diff --git a/bin_files/6502_functional_test.bin b/bin_files/6502_functional_test.bin
new file mode 100644
index 0000000..8a20227
Binary files /dev/null and b/bin_files/6502_functional_test.bin differ
diff --git a/bin_files/6502_functional_test.lst b/bin_files/6502_functional_test.lst
new file mode 100644
index 0000000..9051910
--- /dev/null
+++ b/bin_files/6502_functional_test.lst
@@ -0,0 +1,13999 @@
+AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 1
+---------------------------------------------------- 6502_functional_test.a65 ----------------------------------------------------
+
+5803 lines read, no errors in pass 1.
+ ;
+ ; 6 5 0 2 F U N C T I O N A L T E S T
+ ;
+ ; Copyright (C) 2012-2013 Klaus Dormann
+ ;
+ ; This program is free software: you can redistribute it and/or modify
+ ; it under the terms of the GNU General Public License as published by
+ ; the Free Software Foundation, either version 3 of the License, or
+ ; (at your option) any later version.
+ ;
+ ; This program is distributed in the hope that it will be useful,
+ ; but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ; GNU General Public License for more details.
+ ;
+ ; You should have received a copy of the GNU General Public License
+ ; along with this program. If not, see .
+
+
+ ; This program is designed to test all opcodes of a 6502 emulator using all
+ ; addressing modes with focus on propper setting of the processor status
+ ; register bits.
+ ;
+ ; version 16-aug-2013
+ ; edited to provide a pre-configured bin file loadable at $0000 for full 64k
+ ; contact info at http://2m5.de or email K@2m5.de
+ ;
+ ; assembled with AS65 from http://www.kingswood-consulting.co.uk/assemblers/
+ ; command line switches: -l -m -s2 -w -h0
+ ; | | | | no page headers in listing
+ ; | | | wide listing (133 char/col)
+ ; | | write intel hex file instead of binary
+ ; | expand macros in listing
+ ; generate pass2 listing
+ ;
+ ; No IO - should be run from a monitor with access to registers.
+ ; To run load intel hex image with a load command, than alter PC to 400 hex
+ ; (code_segment) and enter a go command.
+ ; Loop on program counter determines error or successful completion of test.
+ ; Check listing for relevant traps (jump/branch *).
+ ; Please note that in early tests some instructions will have to be used before
+ ; they are actually tested!
+ ;
+ ; RESET, NMI or IRQ should not occur and will be trapped if vectors are enabled.
+ ; Tests documented behavior of the original NMOS 6502 only! No unofficial
+ ; opcodes. Additional opcodes of newer versions of the CPU (65C02, 65816) will
+ ; not be tested. Decimal ops will only be tested with valid BCD operands and
+ ; N V Z flags will be ignored.
+ ;
+ ; Debugging hints:
+ ; Most of the code is written sequentially. if you hit a trap, check the
+ ; immediately preceeding code for the instruction to be tested. Results are
+ ; tested first, flags are checked second by pushing them onto the stack and
+ ; pulling them to the accumulator after the result was checked. The "real"
+ ; flags are no longer valid for the tested instruction at this time!
+ ; If the tested instruction was indexed, the relevant index (X or Y) must
+ ; also be checked. Opposed to the flags, X and Y registers are still valid.
+ ;
+ ; versions:
+ ; 28-jul-2012 1st version distributed for testing
+ ; 29-jul-2012 fixed references to location 0, now #0
+ ; added license - GPLv3
+ ; 30-jul-2012 added configuration options
+ ; 01-aug-2012 added trap macro to allow user to change error handling
+ ; 01-dec-2012 fixed trap in branch field must be a branch
+ ; 02-mar-2013 fixed PLA flags not tested
+ ; 19-jul-2013 allowed ROM vectors to be loaded when load_data_direct = 0
+ ; added test sequence check to detect if tests jump their fence
+ ; 23-jul-2013 added RAM integrity check option
+ ; 16-aug-2013 added error report to standard output option
+
+
+ ; C O N F I G U R A T I O N
+
+ ;ROM_vectors writable (0=no, 1=yes)
+ ;if ROM vectors can not be used interrupts will not be trapped
+ ;as a consequence BRK can not be tested but will be emulated to test RTI
+0001 = ROM_vectors = 1
+
+ ;load_data_direct (0=move from code segment, 1=load directly)
+ ;loading directly is preferred but may not be supported by your platform
+ ;0 produces only consecutive object code, 1 is not suitable for a binary image
+0001 = load_data_direct = 1
+
+ ;I_flag behavior (0=force enabled, 1=force disabled, 2=prohibit change, 3=allow
+ ;change) 2 requires extra code and is not recommended. SEI & CLI can only be
+ ;tested if you allow changing the interrupt status (I_flag = 3)
+0003 = I_flag = 3
+
+ ;configure memory - try to stay away from memory used by the system
+ ;zero_page memory start address, $50 (80) consecutive Bytes required
+ ; add 2 if I_flag = 2
+000a = zero_page = $a
+
+ ;data_segment memory start address, $5B (91) consecutive Bytes required
+0200 = data_segment = $200
+ if (data_segment & $ff) != 0
+ ERROR ERROR ERROR low byte of data_segment MUST be $00 !!
+ endif
+
+ ;code_segment memory start address, 13kB of consecutive space required
+ ; add 2.5 kB if I_flag = 2
+ ;parts of the code are self modifying and must reside in RAM
+0400 = code_segment = $400
+
+ ;report errors through I/O channel (0=use standard self trap loops, 1=include
+ ;report.i65 as I/O channel, add 3.5 kB)
+0000 = report = 0
+
+ ;RAM integrity test option. Checks for undesired RAM writes.
+ ;set lowest non RAM or RAM mirror address page (-1=disable, 0=64k, $40=16k)
+ ;leave disabled if a monitor, OS or background interrupt is allowed to alter RAM
+ffff = ram_top = -1
+
+ noopt ;do not take shortcuts
+
+ ;macros for error & success traps to allow user modification
+ ;example:
+ ;trap macro
+ ; jsr my_error_handler
+ ; endm
+ ;trap_eq macro
+ ; bne skip\?
+ ; trap ;failed equal (zero)
+ ;skip\?
+ ; endm
+ ;
+ ; my_error_handler should pop the calling address from the stack and report it.
+ ; putting larger portions of code (more than 3 bytes) inside the trap macro
+ ; may lead to branch range problems for some tests.
+ if report = 0
+ trap macro
+ jmp * ;failed anyway
+ endm
+ trap_eq macro
+ beq * ;failed equal (zero)
+ endm
+ trap_ne macro
+ bne * ;failed not equal (non zero)
+ endm
+ trap_cs macro
+ bcs * ;failed carry set
+ endm
+ trap_cc macro
+ bcc * ;failed carry clear
+ endm
+ trap_mi macro
+ bmi * ;failed minus (bit 7 set)
+ endm
+ trap_pl macro
+ bpl * ;failed plus (bit 7 clear)
+ endm
+ trap_vs macro
+ bvs * ;failed overflow set
+ endm
+ trap_vc macro
+ bvc * ;failed overflow clear
+ endm
+ ; please observe that during the test the stack gets invalidated
+ ; therefore a RTS inside the success macro is not possible
+ success macro
+ jmp * ;test passed, no errors
+ endm
+ endif
+ if report = 1
+ trap macro
+ jsr report_error
+ endm
+ trap_eq macro
+ bne skip\?
+ trap ;failed equal (zero)
+ skip\?
+ endm
+ trap_ne macro
+ beq skip\?
+ trap ;failed not equal (non zero)
+ skip\?
+ endm
+ trap_cs macro
+ bcc skip\?
+ trap ;failed carry set
+ skip\?
+ endm
+ trap_cc macro
+ bcs skip\?
+ trap ;failed carry clear
+ skip\?
+ endm
+ trap_mi macro
+ bpl skip\?
+ trap ;failed minus (bit 7 set)
+ skip\?
+ endm
+ trap_pl macro
+ bmi skip\?
+ trap ;failed plus (bit 7 clear)
+ skip\?
+ endm
+ trap_vs macro
+ bvc skip\?
+ trap ;failed overflow set
+ skip\?
+ endm
+ trap_vc macro
+ bvs skip\?
+ trap ;failed overflow clear
+ skip\?
+ endm
+ ; please observe that during the test the stack gets invalidated
+ ; therefore a RTS inside the success macro is not possible
+ success macro
+ jsr report_success
+ endm
+ endif
+
+
+0001 = carry equ %00000001 ;flag bits in status
+0002 = zero equ %00000010
+0004 = intdis equ %00000100
+0008 = decmode equ %00001000
+0010 = break equ %00010000
+0020 = reserv equ %00100000
+0040 = overfl equ %01000000
+0080 = minus equ %10000000
+
+0001 = fc equ carry
+0002 = fz equ zero
+0003 = fzc equ carry+zero
+0040 = fv equ overfl
+0042 = fvz equ overfl+zero
+0080 = fn equ minus
+0081 = fnc equ minus+carry
+0082 = fnz equ minus+zero
+0083 = fnzc equ minus+zero+carry
+00c0 = fnv equ minus+overfl
+
+0030 = fao equ break+reserv ;bits always on after PHP, BRK
+0034 = fai equ fao+intdis ;+ forced interrupt disable
+00ff = m8 equ $ff ;8 bit mask
+00fb = m8i equ $ff&~intdis ;8 bit mask - interrupt disable
+
+ ;macros to allow masking of status bits.
+ ;masking of interrupt enable/disable on load and compare
+ ;masking of always on bits after PHP or BRK (unused & break) on compare
+ if I_flag = 0
+ load_flag macro
+ lda #\1&m8i ;force enable interrupts (mask I)
+ endm
+ cmp_flag macro
+ cmp #(\1|fao)&m8i ;I_flag is always enabled + always on bits
+ endm
+ eor_flag macro
+ eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits
+ endm
+ endif
+ if I_flag = 1
+ load_flag macro
+ lda #\1|intdis ;force disable interrupts
+ endm
+ cmp_flag macro
+ cmp #(\1|fai)&m8 ;I_flag is always disabled + always on bits
+ endm
+ eor_flag macro
+ eor #(\1|fai) ;invert expected flags + always on bits + I
+ endm
+ endif
+ if I_flag = 2
+ load_flag macro
+ lda #\1
+ ora flag_I_on ;restore I-flag
+ and flag_I_off
+ endm
+ cmp_flag macro
+ eor flag_I_on ;I_flag is never changed
+ cmp #(\1|fao)&m8i ;expected flags + always on bits, mask I
+ endm
+ eor_flag macro
+ eor flag_I_on ;I_flag is never changed
+ eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits
+ endm
+ endif
+ if I_flag = 3
+ load_flag macro
+ lda #\1 ;allow test to change I-flag (no mask)
+ endm
+ cmp_flag macro
+ cmp #(\1|fao)&m8 ;expected flags + always on bits
+ endm
+ eor_flag macro
+ eor #\1|fao ;invert expected flags + always on bits
+ endm
+ endif
+
+ ;macros to set (register|memory|zeropage) & status
+ set_stat macro ;setting flags in the processor status register
+ load_flag \1
+ pha ;use stack to load status
+ plp
+ endm
+
+ set_a macro ;precharging accu & status
+ load_flag \2
+ pha ;use stack to load status
+ lda #\1 ;precharge accu
+ plp
+ endm
+
+ set_x macro ;precharging index & status
+ load_flag \2
+ pha ;use stack to load status
+ ldx #\1 ;precharge index x
+ plp
+ endm
+
+ set_y macro ;precharging index & status
+ load_flag \2
+ pha ;use stack to load status
+ ldy #\1 ;precharge index y
+ plp
+ endm
+
+ set_ax macro ;precharging indexed accu & immediate status
+ load_flag \2
+ pha ;use stack to load status
+ lda \1,x ;precharge accu
+ plp
+ endm
+
+ set_ay macro ;precharging indexed accu & immediate status
+ load_flag \2
+ pha ;use stack to load status
+ lda \1,y ;precharge accu
+ plp
+ endm
+
+ set_z macro ;precharging indexed zp & immediate status
+ load_flag \2
+ pha ;use stack to load status
+ lda \1,x ;load to zeropage
+ sta zpt
+ plp
+ endm
+
+ set_zx macro ;precharging zp,x & immediate status
+ load_flag \2
+ pha ;use stack to load status
+ lda \1,x ;load to indexed zeropage
+ sta zpt,x
+ plp
+ endm
+
+ set_abs macro ;precharging indexed memory & immediate status
+ load_flag \2
+ pha ;use stack to load status
+ lda \1,x ;load to memory
+ sta abst
+ plp
+ endm
+
+ set_absx macro ;precharging abs,x & immediate status
+ load_flag \2
+ pha ;use stack to load status
+ lda \1,x ;load to indexed memory
+ sta abst,x
+ plp
+ endm
+
+ ;macros to test (register|memory|zeropage) & status & (mask)
+ tst_stat macro ;testing flags in the processor status register
+ php ;save status
+ pla ;use stack to retrieve status
+ pha
+ cmp_flag \1
+ trap_ne
+ plp ;restore status
+ endm
+
+ tst_a macro ;testing result in accu & flags
+ php ;save flags
+ cmp #\1 ;test result
+ trap_ne
+ pla ;load status
+ pha
+ cmp_flag \2
+ trap_ne
+ plp ;restore status
+ endm
+
+ tst_x macro ;testing result in x index & flags
+ php ;save flags
+ cpx #\1 ;test result
+ trap_ne
+ pla ;load status
+ pha
+ cmp_flag \2
+ trap_ne
+ plp ;restore status
+ endm
+
+ tst_y macro ;testing result in y index & flags
+ php ;save flags
+ cpy #\1 ;test result
+ trap_ne
+ pla ;load status
+ pha
+ cmp_flag \2
+ trap_ne
+ plp ;restore status
+ endm
+
+ tst_ax macro ;indexed testing result in accu & flags
+ php ;save flags
+ cmp \1,x ;test result
+ trap_ne
+ pla ;load status
+ eor_flag \3
+ cmp \2,x ;test flags
+ trap_ne ;
+ endm
+
+ tst_ay macro ;indexed testing result in accu & flags
+ php ;save flags
+ cmp \1,y ;test result
+ trap_ne ;
+ pla ;load status
+ eor_flag \3
+ cmp \2,y ;test flags
+ trap_ne
+ endm
+
+ tst_z macro ;indexed testing result in zp & flags
+ php ;save flags
+ lda zpt
+ cmp \1,x ;test result
+ trap_ne
+ pla ;load status
+ eor_flag \3
+ cmp \2,x ;test flags
+ trap_ne
+ endm
+
+ tst_zx macro ;testing result in zp,x & flags
+ php ;save flags
+ lda zpt,x
+ cmp \1,x ;test result
+ trap_ne
+ pla ;load status
+ eor_flag \3
+ cmp \2,x ;test flags
+ trap_ne
+ endm
+
+ tst_abs macro ;indexed testing result in memory & flags
+ php ;save flags
+ lda abst
+ cmp \1,x ;test result
+ trap_ne
+ pla ;load status
+ eor_flag \3
+ cmp \2,x ;test flags
+ trap_ne
+ endm
+
+ tst_absx macro ;testing result in abs,x & flags
+ php ;save flags
+ lda abst,x
+ cmp \1,x ;test result
+ trap_ne
+ pla ;load status
+ eor_flag \3
+ cmp \2,x ;test flags
+ trap_ne
+ endm
+
+ ; RAM integrity test
+ ; verifies that none of the previous tests has altered RAM outside of the
+ ; designated write areas.
+ ; uses zpt word as indirect pointer, zpt+2 word as checksum
+ if ram_top > -1
+ check_ram macro
+ cld
+ lda #0
+ sta zpt ;set low byte of indirect pointer
+ sta zpt+3 ;checksum high byte
+ sta range_adr ;reset self modifying code
+ sta tandi1
+ sta tandi2
+ sta teori1
+ sta teori2
+ sta torai1
+ sta torai2
+ sta chkdadi
+ sta chkdsbi
+ sta chkadi
+ sta chksbi
+ clc
+ ldx #zp_bss-zero_page ;zeropage - write test area
+ ccs3\? adc zero_page,x
+ bcc ccs2\?
+ inc zpt+3 ;carry to high byte
+ clc
+ ccs2\? inx
+ bne ccs3\?
+ ldx #hi(data_segment) ;set high byte of indirect pointer
+ stx zpt+1
+ ldy #lo(data_bss) ;data after write test area
+ ccs5\? adc (zpt),y
+ bcc ccs4\?
+ inc zpt+3 ;carry to high byte
+ clc
+ ccs4\? iny
+ bne ccs5\?
+ inx ;advance RAM high address
+ stx zpt+1
+ cpx #ram_top
+ bne ccs5\?
+ sta zpt+2 ;checksum low is
+ cmp ram_chksm ;checksum low expected
+ trap_ne ;checksum mismatch
+ lda zpt+3 ;checksum high is
+ cmp ram_chksm+1 ;checksum high expected
+ trap_ne ;checksum mismatch
+ endm
+ else
+ check_ram macro
+ ;RAM check disabled - RAM size not set
+ endm
+ endif
+
+ next_test macro ;make sure, tests don't jump the fence
+ lda test_case ;previous test
+ cmp #test_num
+ trap_ne ;test is out of sequence
+ test_num = test_num + 1
+ lda #test_num ;*** next tests' number
+ sta test_case
+ ;check_ram ;uncomment to find altered RAM after each test
+ endm
+
+ if load_data_direct = 1
+ data
+ else
+ bss ;uninitialized segment, copy of data at end of code!
+ endif
+ ; org zero_page
+0000 = org 0 ;edited to provide binaries loading from 0
+0000 : 00000000000000.. ds zero_page
+ ;break test interrupt save
+000a : 00 irq_a ds 1 ;a register
+000b : 00 irq_x ds 1 ;x register
+ if I_flag = 2
+ ;masking for I bit in status
+ flag_I_on ds 1 ;or mask to load flags
+ flag_I_off ds 1 ;and mask to load flags
+ endif
+000c : zpt ;5 bytes store/modify test area
+ ;add/subtract operand generation and result/flag prediction
+000c : 00 adfc ds 1 ;carry flag before op
+000d : 00 ad1 ds 1 ;operand 1 - accumulator
+000e : 00 ad2 ds 1 ;operand 2 - memory / immediate
+000f : 00 adrl ds 1 ;expected result bits 0-7
+0010 : 00 adrh ds 1 ;expected result bit 8 (carry)
+0011 : 00 adrf ds 1 ;expected flags NV0000ZC (only binary mode)
+0012 : 00 sb2 ds 1 ;operand 2 complemented for subtract
+0013 : zp_bss
+0013 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
+0017 : 7f zp7f db $7f ;test pattern for compare
+ ;logical zeropage operands
+0018 : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR
+001c : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND
+0020 : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR
+ ;indirect addressing pointers
+0024 : 0802 ind1 dw abs1 ;indirect pointer to pattern in absolute memory
+0026 : 0902 dw abs1+1
+0028 : 0a02 dw abs1+2
+002a : 0b02 dw abs1+3
+002c : 0c02 dw abs7f
+002e : 1001 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern
+0030 : 0302 indt dw abst ;indirect pointer to store area in absolute memory
+0032 : 0402 dw abst+1
+0034 : 0502 dw abst+2
+0036 : 0602 dw abst+3
+0038 : 0b01 inwt dw abst-$f8 ;indirect pointer for wrap-test store
+003a : 3f02 indAN dw absAN ;indirect pointer to AND pattern in absolute memory
+003c : 4002 dw absAN+1
+003e : 4102 dw absAN+2
+0040 : 4202 dw absAN+3
+0042 : 4302 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory
+0044 : 4402 dw absEO+1
+0046 : 4502 dw absEO+2
+0048 : 4602 dw absEO+3
+004a : 3b02 indOR dw absOR ;indirect pointer to OR pattern in absolute memory
+004c : 3c02 dw absOR+1
+004e : 3d02 dw absOR+2
+0050 : 3e02 dw absOR+3
+ ;add/subtract indirect pointers
+0052 : 0302 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory
+0054 : 0402 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC)
+0056 : 0401 adiy2 dw ada2-$ff ;with offset for indirect indexed
+0058 : 0501 sbiy2 dw sba2-$ff
+005a : zp_bss_end
+
+0200 = org data_segment
+0200 : 00 test_case ds 1 ;current test number
+0201 : 0000 ram_chksm ds 2 ;checksum for RAM integrity test
+ ;add/subtract operand copy - abs tests write area
+0203 : abst ;5 bytes store/modify test area
+0203 : 00 ada2 ds 1 ;operand 2
+0204 : 00 sba2 ds 1 ;operand 2 complemented for subtract
+0205 : 000000 ds 3 ;fill remaining bytes
+0208 : data_bss
+0208 : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
+020c : 7f abs7f db $7f ;test pattern for compare
+ ;loads
+020d : 80800002 fLDx db fn,fn,0,fz ;expected flags for load
+ ;shifts
+0211 : rASL ;expected result ASL & ROL -carry
+0211 : 86048200 rROL db $86,$04,$82,0 ; "
+0215 : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry
+0219 : rLSR ;expected result LSR & ROR -carry
+0219 : 61412000 rROR db $61,$41,$20,0 ; "
+021d : e1c1a080 rRORc db $e1,$c1,$a0,$80 ;expected result ROR +carry
+0221 : fASL ;expected flags for shifts
+0221 : 81018002 fROL db fnc,fc,fn,fz ;no carry in
+0225 : 81018000 fROLc db fnc,fc,fn,0 ;carry in
+0229 : fLSR
+0229 : 01000102 fROR db fc,0,fc,fz ;no carry in
+022d : 81808180 fRORc db fnc,fn,fnc,fn ;carry in
+ ;increments (decrements)
+0231 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC
+0236 : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC
+ ;logical memory operand
+023b : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR
+023f : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND
+0243 : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR
+ ;logical accu operand
+0247 : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR
+024b : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND
+024f : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR
+ ;logical results
+0253 : 00ff7f80 absrlo db 0,$ff,$7f,$80
+0257 : 02800080 absflo db fz,fn,0,fn
+025b : data_bss_end
+
+
+ code
+0400 = org code_segment
+0400 : d8 start cld
+0401 : a2ff ldx #$ff
+0403 : 9a txs
+0404 : a900 lda #0 ;*** test 0 = initialize
+0406 : 8d0002 sta test_case
+0000 = test_num = 0
+
+ ;stop interrupts before initializing BSS
+ if I_flag = 1
+ sei
+ endif
+
+ ;initialize I/O for report channel
+ if report = 1
+ jsr report_init
+ endif
+
+ ;initialize BSS segment
+ if load_data_direct != 1
+ ldx #zp_end-zp_init-1
+ ld_zp lda zp_init,x
+ sta zp_bss,x
+ dex
+ bpl ld_zp
+ ldx #data_end-data_init-1
+ ld_data lda data_init,x
+ sta data_bss,x
+ dex
+ bpl ld_data
+ if ROM_vectors = 1
+ ldx #5
+ ld_vect lda vec_init,x
+ sta vec_bss,x
+ dex
+ bpl ld_vect
+ endif
+ endif
+
+ ;retain status of interrupt flag
+ if I_flag = 2
+ php
+ pla
+ and #4 ;isolate flag
+ sta flag_I_on ;or mask
+ eor #lo(~4) ;reverse
+ sta flag_I_off ;and mask
+ endif
+
+ ;generate checksum for RAM integrity test
+ if ram_top > -1
+ lda #0
+ sta zpt ;set low byte of indirect pointer
+ sta ram_chksm+1 ;checksum high byte
+ sta range_adr ;reset self modifying code
+ sta tandi1
+ sta tandi2
+ sta teori1
+ sta teori2
+ sta torai1
+ sta torai2
+ sta chkdadi
+ sta chkdsbi
+ sta chkadi
+ sta chksbi
+ clc
+ ldx #zp_bss-zero_page ;zeropage - write test area
+ gcs3 adc zero_page,x
+ bcc gcs2
+ inc ram_chksm+1 ;carry to high byte
+ clc
+ gcs2 inx
+ bne gcs3
+ ldx #hi(data_segment) ;set high byte of indirect pointer
+ stx zpt+1
+ ldy #lo(data_bss) ;data after write test area
+ gcs5 adc (zpt),y
+ bcc gcs4
+ inc ram_chksm+1 ;carry to high byte
+ clc
+ gcs4 iny
+ bne gcs5
+ inx ;advance RAM high address
+ stx zpt+1
+ cpx #ram_top
+ bne gcs5
+ sta ram_chksm ;checksum complete
+ endif
+ next_test
+0409 : ad0002 > lda test_case ;previous test
+040c : c900 > cmp #test_num
+ > trap_ne ;test is out of sequence
+040e : d0fe > bne * ;failed not equal (non zero)
+ >
+0001 = >test_num = test_num + 1
+0410 : a901 > lda #test_num ;*** next tests' number
+0412 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ;testing relative addressing with BEQ
+0415 : a0fe ldy #$fe ;testing maximum range, not -1/-2 (invalid/self adr)
+0417 : range_loop
+0417 : 88 dey ;next relative address
+0418 : 98 tya
+0419 : aa tax ;precharge count to end of loop
+041a : 1003 bpl range_fw ;calculate relative address
+041c : 18 clc ;avoid branch self or to relative address of branch
+041d : 6902 adc #2
+041f : range_fw
+041f : 497f eor #$7f ;complement except sign
+0421 : 8da804 sta range_adr ;load into test target
+0424 : a900 lda #0 ;should set zero flag in status register
+0426 : 4ca704 jmp range_op
+
+ ;relative address target field with branch under test in the middle
+0429 : ca dex ;-128 - max backward
+042a : ca dex
+042b : ca dex
+042c : ca dex
+042d : ca dex
+042e : ca dex
+042f : ca dex
+0430 : ca dex
+0431 : ca dex ;-120
+0432 : ca dex
+0433 : ca dex
+0434 : ca dex
+0435 : ca dex
+0436 : ca dex
+0437 : ca dex
+0438 : ca dex
+0439 : ca dex
+043a : ca dex
+043b : ca dex ;-110
+043c : ca dex
+043d : ca dex
+043e : ca dex
+043f : ca dex
+0440 : ca dex
+0441 : ca dex
+0442 : ca dex
+0443 : ca dex
+0444 : ca dex
+0445 : ca dex ;-100
+0446 : ca dex
+0447 : ca dex
+0448 : ca dex
+0449 : ca dex
+044a : ca dex
+044b : ca dex
+044c : ca dex
+044d : ca dex
+044e : ca dex
+044f : ca dex ;-90
+0450 : ca dex
+0451 : ca dex
+0452 : ca dex
+0453 : ca dex
+0454 : ca dex
+0455 : ca dex
+0456 : ca dex
+0457 : ca dex
+0458 : ca dex
+0459 : ca dex ;-80
+045a : ca dex
+045b : ca dex
+045c : ca dex
+045d : ca dex
+045e : ca dex
+045f : ca dex
+0460 : ca dex
+0461 : ca dex
+0462 : ca dex
+0463 : ca dex ;-70
+0464 : ca dex
+0465 : ca dex
+0466 : ca dex
+0467 : ca dex
+0468 : ca dex
+0469 : ca dex
+046a : ca dex
+046b : ca dex
+046c : ca dex
+046d : ca dex ;-60
+046e : ca dex
+046f : ca dex
+0470 : ca dex
+0471 : ca dex
+0472 : ca dex
+0473 : ca dex
+0474 : ca dex
+0475 : ca dex
+0476 : ca dex
+0477 : ca dex ;-50
+0478 : ca dex
+0479 : ca dex
+047a : ca dex
+047b : ca dex
+047c : ca dex
+047d : ca dex
+047e : ca dex
+047f : ca dex
+0480 : ca dex
+0481 : ca dex ;-40
+0482 : ca dex
+0483 : ca dex
+0484 : ca dex
+0485 : ca dex
+0486 : ca dex
+0487 : ca dex
+0488 : ca dex
+0489 : ca dex
+048a : ca dex
+048b : ca dex ;-30
+048c : ca dex
+048d : ca dex
+048e : ca dex
+048f : ca dex
+0490 : ca dex
+0491 : ca dex
+0492 : ca dex
+0493 : ca dex
+0494 : ca dex
+0495 : ca dex ;-20
+0496 : ca dex
+0497 : ca dex
+0498 : ca dex
+0499 : ca dex
+049a : ca dex
+049b : ca dex
+049c : ca dex
+049d : ca dex
+049e : ca dex
+049f : ca dex ;-10
+04a0 : ca dex
+04a1 : ca dex
+04a2 : ca dex
+04a3 : ca dex
+04a4 : ca dex
+04a5 : ca dex
+04a6 : ca dex ;-3
+04a7 : range_op ;test target with zero flag=0, z=1 if previous dex
+04a8 = range_adr = *+1 ;modifiable relative address
+04a7 : f03e beq *+64 ;if called without modification
+04a9 : ca dex ;+0
+04aa : ca dex
+04ab : ca dex
+04ac : ca dex
+04ad : ca dex
+04ae : ca dex
+04af : ca dex
+04b0 : ca dex
+04b1 : ca dex
+04b2 : ca dex
+04b3 : ca dex ;+10
+04b4 : ca dex
+04b5 : ca dex
+04b6 : ca dex
+04b7 : ca dex
+04b8 : ca dex
+04b9 : ca dex
+04ba : ca dex
+04bb : ca dex
+04bc : ca dex
+04bd : ca dex ;+20
+04be : ca dex
+04bf : ca dex
+04c0 : ca dex
+04c1 : ca dex
+04c2 : ca dex
+04c3 : ca dex
+04c4 : ca dex
+04c5 : ca dex
+04c6 : ca dex
+04c7 : ca dex ;+30
+04c8 : ca dex
+04c9 : ca dex
+04ca : ca dex
+04cb : ca dex
+04cc : ca dex
+04cd : ca dex
+04ce : ca dex
+04cf : ca dex
+04d0 : ca dex
+04d1 : ca dex ;+40
+04d2 : ca dex
+04d3 : ca dex
+04d4 : ca dex
+04d5 : ca dex
+04d6 : ca dex
+04d7 : ca dex
+04d8 : ca dex
+04d9 : ca dex
+04da : ca dex
+04db : ca dex ;+50
+04dc : ca dex
+04dd : ca dex
+04de : ca dex
+04df : ca dex
+04e0 : ca dex
+04e1 : ca dex
+04e2 : ca dex
+04e3 : ca dex
+04e4 : ca dex
+04e5 : ca dex ;+60
+04e6 : ca dex
+04e7 : ca dex
+04e8 : ca dex
+04e9 : ca dex
+04ea : ca dex
+04eb : ca dex
+04ec : ca dex
+04ed : ca dex
+04ee : ca dex
+04ef : ca dex ;+70
+04f0 : ca dex
+04f1 : ca dex
+04f2 : ca dex
+04f3 : ca dex
+04f4 : ca dex
+04f5 : ca dex
+04f6 : ca dex
+04f7 : ca dex
+04f8 : ca dex
+04f9 : ca dex ;+80
+04fa : ca dex
+04fb : ca dex
+04fc : ca dex
+04fd : ca dex
+04fe : ca dex
+04ff : ca dex
+0500 : ca dex
+0501 : ca dex
+0502 : ca dex
+0503 : ca dex ;+90
+0504 : ca dex
+0505 : ca dex
+0506 : ca dex
+0507 : ca dex
+0508 : ca dex
+0509 : ca dex
+050a : ca dex
+050b : ca dex
+050c : ca dex
+050d : ca dex ;+100
+050e : ca dex
+050f : ca dex
+0510 : ca dex
+0511 : ca dex
+0512 : ca dex
+0513 : ca dex
+0514 : ca dex
+0515 : ca dex
+0516 : ca dex
+0517 : ca dex ;+110
+0518 : ca dex
+0519 : ca dex
+051a : ca dex
+051b : ca dex
+051c : ca dex
+051d : ca dex
+051e : ca dex
+051f : ca dex
+0520 : ca dex
+0521 : ca dex ;+120
+0522 : ca dex
+0523 : ca dex
+0524 : ca dex
+0525 : ca dex
+0526 : ca dex
+0527 : ca dex
+0528 : f003 beq range_ok ;+127 - max forward
+ trap ; bad range
+052a : 4c2a05 > jmp * ;failed anyway
+
+052d : range_ok
+052d : c000 cpy #0
+052f : f003 beq range_end
+0531 : 4c1704 jmp range_loop
+0534 : range_end ;range test successful
+ next_test
+0534 : ad0002 > lda test_case ;previous test
+0537 : c901 > cmp #test_num
+ > trap_ne ;test is out of sequence
+0539 : d0fe > bne * ;failed not equal (non zero)
+ >
+0002 = >test_num = test_num + 1
+053b : a902 > lda #test_num ;*** next tests' number
+053d : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ;partial test BNE & CMP, CPX, CPY immediate
+0540 : c001 cpy #1 ;testing BNE true
+0542 : d003 bne test_bne
+ trap
+0544 : 4c4405 > jmp * ;failed anyway
+
+0547 : test_bne
+0547 : a900 lda #0
+0549 : c900 cmp #0 ;test compare immediate
+ trap_ne
+054b : d0fe > bne * ;failed not equal (non zero)
+
+ trap_cc
+054d : 90fe > bcc * ;failed carry clear
+
+ trap_mi
+054f : 30fe > bmi * ;failed minus (bit 7 set)
+
+0551 : c901 cmp #1
+ trap_eq
+0553 : f0fe > beq * ;failed equal (zero)
+
+ trap_cs
+0555 : b0fe > bcs * ;failed carry set
+
+ trap_pl
+0557 : 10fe > bpl * ;failed plus (bit 7 clear)
+
+0559 : aa tax
+055a : e000 cpx #0 ;test compare x immediate
+ trap_ne
+055c : d0fe > bne * ;failed not equal (non zero)
+
+ trap_cc
+055e : 90fe > bcc * ;failed carry clear
+
+ trap_mi
+0560 : 30fe > bmi * ;failed minus (bit 7 set)
+
+0562 : e001 cpx #1
+ trap_eq
+0564 : f0fe > beq * ;failed equal (zero)
+
+ trap_cs
+0566 : b0fe > bcs * ;failed carry set
+
+ trap_pl
+0568 : 10fe > bpl * ;failed plus (bit 7 clear)
+
+056a : a8 tay
+056b : c000 cpy #0 ;test compare y immediate
+ trap_ne
+056d : d0fe > bne * ;failed not equal (non zero)
+
+ trap_cc
+056f : 90fe > bcc * ;failed carry clear
+
+ trap_mi
+0571 : 30fe > bmi * ;failed minus (bit 7 set)
+
+0573 : c001 cpy #1
+ trap_eq
+0575 : f0fe > beq * ;failed equal (zero)
+
+ trap_cs
+0577 : b0fe > bcs * ;failed carry set
+
+ trap_pl
+0579 : 10fe > bpl * ;failed plus (bit 7 clear)
+
+ next_test
+057b : ad0002 > lda test_case ;previous test
+057e : c902 > cmp #test_num
+ > trap_ne ;test is out of sequence
+0580 : d0fe > bne * ;failed not equal (non zero)
+ >
+0003 = >test_num = test_num + 1
+0582 : a903 > lda #test_num ;*** next tests' number
+0584 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+ ;testing stack operations PHA PHP PLA PLP
+
+0587 : a2ff ldx #$ff ;initialize stack
+0589 : 9a txs
+058a : a955 lda #$55
+058c : 48 pha
+058d : a9aa lda #$aa
+058f : 48 pha
+0590 : cdfe01 cmp $1fe ;on stack ?
+ trap_ne
+0593 : d0fe > bne * ;failed not equal (non zero)
+
+0595 : ba tsx
+0596 : 8a txa ;overwrite accu
+0597 : c9fd cmp #$fd ;sp decremented?
+ trap_ne
+0599 : d0fe > bne * ;failed not equal (non zero)
+
+059b : 68 pla
+059c : c9aa cmp #$aa ;successful retreived from stack?
+ trap_ne
+059e : d0fe > bne * ;failed not equal (non zero)
+
+05a0 : 68 pla
+05a1 : c955 cmp #$55
+ trap_ne
+05a3 : d0fe > bne * ;failed not equal (non zero)
+
+05a5 : cdff01 cmp $1ff ;remains on stack?
+ trap_ne
+05a8 : d0fe > bne * ;failed not equal (non zero)
+
+05aa : ba tsx
+05ab : e0ff cpx #$ff ;sp incremented?
+ trap_ne
+05ad : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+05af : ad0002 > lda test_case ;previous test
+05b2 : c903 > cmp #test_num
+ > trap_ne ;test is out of sequence
+05b4 : d0fe > bne * ;failed not equal (non zero)
+ >
+0004 = >test_num = test_num + 1
+05b6 : a904 > lda #test_num ;*** next tests' number
+05b8 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ;testing branch decisions BPL BMI BVC BVS BCC BCS BNE BEQ
+ set_stat $ff ;all on
+ > load_flag $ff
+05bb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+05bd : 48 > pha ;use stack to load status
+05be : 28 > plp
+
+05bf : 101a bpl nbr1 ;branches should not be taken
+05c1 : 501b bvc nbr2
+05c3 : 901c bcc nbr3
+05c5 : d01d bne nbr4
+05c7 : 3003 bmi br1 ;branches should be taken
+ trap
+05c9 : 4cc905 > jmp * ;failed anyway
+
+05cc : 7003 br1 bvs br2
+ trap
+05ce : 4cce05 > jmp * ;failed anyway
+
+05d1 : b003 br2 bcs br3
+ trap
+05d3 : 4cd305 > jmp * ;failed anyway
+
+05d6 : f00f br3 beq br4
+ trap
+05d8 : 4cd805 > jmp * ;failed anyway
+
+05db : nbr1
+ trap ;previous bpl taken
+05db : 4cdb05 > jmp * ;failed anyway
+
+05de : nbr2
+ trap ;previous bvc taken
+05de : 4cde05 > jmp * ;failed anyway
+
+05e1 : nbr3
+ trap ;previous bcc taken
+05e1 : 4ce105 > jmp * ;failed anyway
+
+05e4 : nbr4
+ trap ;previous bne taken
+05e4 : 4ce405 > jmp * ;failed anyway
+
+05e7 : 08 br4 php
+05e8 : ba tsx
+05e9 : e0fe cpx #$fe ;sp after php?
+ trap_ne
+05eb : d0fe > bne * ;failed not equal (non zero)
+
+05ed : 68 pla
+ cmp_flag $ff ;returned all flags on?
+05ee : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+05f0 : d0fe > bne * ;failed not equal (non zero)
+
+05f2 : ba tsx
+05f3 : e0ff cpx #$ff ;sp after php?
+ trap_ne
+05f5 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0 ;all off
+ > load_flag 0
+05f7 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+05f9 : 48 > pha ;use stack to load status
+05fa : 28 > plp
+
+05fb : 301a bmi nbr11 ;branches should not be taken
+05fd : 701b bvs nbr12
+05ff : b01c bcs nbr13
+0601 : f01d beq nbr14
+0603 : 1003 bpl br11 ;branches should be taken
+ trap
+0605 : 4c0506 > jmp * ;failed anyway
+
+0608 : 5003 br11 bvc br12
+ trap
+060a : 4c0a06 > jmp * ;failed anyway
+
+060d : 9003 br12 bcc br13
+ trap
+060f : 4c0f06 > jmp * ;failed anyway
+
+0612 : d00f br13 bne br14
+ trap
+0614 : 4c1406 > jmp * ;failed anyway
+
+0617 : nbr11
+ trap ;previous bmi taken
+0617 : 4c1706 > jmp * ;failed anyway
+
+061a : nbr12
+ trap ;previous bvs taken
+061a : 4c1a06 > jmp * ;failed anyway
+
+061d : nbr13
+ trap ;previous bcs taken
+061d : 4c1d06 > jmp * ;failed anyway
+
+0620 : nbr14
+ trap ;previous beq taken
+0620 : 4c2006 > jmp * ;failed anyway
+
+0623 : 08 br14 php
+0624 : 68 pla
+ cmp_flag 0 ;flags off except break (pushed by sw) + reserved?
+0625 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0627 : d0fe > bne * ;failed not equal (non zero)
+
+ ;crosscheck flags
+ set_stat zero
+ > load_flag zero
+0629 : a902 > lda #zero ;allow test to change I-flag (no mask)
+ >
+062b : 48 > pha ;use stack to load status
+062c : 28 > plp
+
+062d : d002 bne brzs1
+062f : f003 beq brzs2
+0631 : brzs1
+ trap ;branch zero/non zero
+0631 : 4c3106 > jmp * ;failed anyway
+
+0634 : b002 brzs2 bcs brzs3
+0636 : 9003 bcc brzs4
+0638 : brzs3
+ trap ;branch carry/no carry
+0638 : 4c3806 > jmp * ;failed anyway
+
+063b : 3002 brzs4 bmi brzs5
+063d : 1003 bpl brzs6
+063f : brzs5
+ trap ;branch minus/plus
+063f : 4c3f06 > jmp * ;failed anyway
+
+0642 : 7002 brzs6 bvs brzs7
+0644 : 5003 bvc brzs8
+0646 : brzs7
+ trap ;branch overflow/no overflow
+0646 : 4c4606 > jmp * ;failed anyway
+
+0649 : brzs8
+ set_stat carry
+ > load_flag carry
+0649 : a901 > lda #carry ;allow test to change I-flag (no mask)
+ >
+064b : 48 > pha ;use stack to load status
+064c : 28 > plp
+
+064d : f002 beq brcs1
+064f : d003 bne brcs2
+0651 : brcs1
+ trap ;branch zero/non zero
+0651 : 4c5106 > jmp * ;failed anyway
+
+0654 : 9002 brcs2 bcc brcs3
+0656 : b003 bcs brcs4
+0658 : brcs3
+ trap ;branch carry/no carry
+0658 : 4c5806 > jmp * ;failed anyway
+
+065b : 3002 brcs4 bmi brcs5
+065d : 1003 bpl brcs6
+065f : brcs5
+ trap ;branch minus/plus
+065f : 4c5f06 > jmp * ;failed anyway
+
+0662 : 7002 brcs6 bvs brcs7
+0664 : 5003 bvc brcs8
+0666 : brcs7
+ trap ;branch overflow/no overflow
+0666 : 4c6606 > jmp * ;failed anyway
+
+
+0669 : brcs8
+ set_stat minus
+ > load_flag minus
+0669 : a980 > lda #minus ;allow test to change I-flag (no mask)
+ >
+066b : 48 > pha ;use stack to load status
+066c : 28 > plp
+
+066d : f002 beq brmi1
+066f : d003 bne brmi2
+0671 : brmi1
+ trap ;branch zero/non zero
+0671 : 4c7106 > jmp * ;failed anyway
+
+0674 : b002 brmi2 bcs brmi3
+0676 : 9003 bcc brmi4
+0678 : brmi3
+ trap ;branch carry/no carry
+0678 : 4c7806 > jmp * ;failed anyway
+
+067b : 1002 brmi4 bpl brmi5
+067d : 3003 bmi brmi6
+067f : brmi5
+ trap ;branch minus/plus
+067f : 4c7f06 > jmp * ;failed anyway
+
+0682 : 7002 brmi6 bvs brmi7
+0684 : 5003 bvc brmi8
+0686 : brmi7
+ trap ;branch overflow/no overflow
+0686 : 4c8606 > jmp * ;failed anyway
+
+0689 : brmi8
+ set_stat overfl
+ > load_flag overfl
+0689 : a940 > lda #overfl ;allow test to change I-flag (no mask)
+ >
+068b : 48 > pha ;use stack to load status
+068c : 28 > plp
+
+068d : f002 beq brvs1
+068f : d003 bne brvs2
+0691 : brvs1
+ trap ;branch zero/non zero
+0691 : 4c9106 > jmp * ;failed anyway
+
+0694 : b002 brvs2 bcs brvs3
+0696 : 9003 bcc brvs4
+0698 : brvs3
+ trap ;branch carry/no carry
+0698 : 4c9806 > jmp * ;failed anyway
+
+069b : 3002 brvs4 bmi brvs5
+069d : 1003 bpl brvs6
+069f : brvs5
+ trap ;branch minus/plus
+069f : 4c9f06 > jmp * ;failed anyway
+
+06a2 : 5002 brvs6 bvc brvs7
+06a4 : 7003 bvs brvs8
+06a6 : brvs7
+ trap ;branch overflow/no overflow
+06a6 : 4ca606 > jmp * ;failed anyway
+
+06a9 : brvs8
+ set_stat $ff-zero
+ > load_flag $ff-zero
+06a9 : a9fd > lda #$ff-zero ;allow test to change I-flag (no mask)
+ >
+06ab : 48 > pha ;use stack to load status
+06ac : 28 > plp
+
+06ad : f002 beq brzc1
+06af : d003 bne brzc2
+06b1 : brzc1
+ trap ;branch zero/non zero
+06b1 : 4cb106 > jmp * ;failed anyway
+
+06b4 : 9002 brzc2 bcc brzc3
+06b6 : b003 bcs brzc4
+06b8 : brzc3
+ trap ;branch carry/no carry
+06b8 : 4cb806 > jmp * ;failed anyway
+
+06bb : 1002 brzc4 bpl brzc5
+06bd : 3003 bmi brzc6
+06bf : brzc5
+ trap ;branch minus/plus
+06bf : 4cbf06 > jmp * ;failed anyway
+
+06c2 : 5002 brzc6 bvc brzc7
+06c4 : 7003 bvs brzc8
+06c6 : brzc7
+ trap ;branch overflow/no overflow
+06c6 : 4cc606 > jmp * ;failed anyway
+
+06c9 : brzc8
+ set_stat $ff-carry
+ > load_flag $ff-carry
+06c9 : a9fe > lda #$ff-carry ;allow test to change I-flag (no mask)
+ >
+06cb : 48 > pha ;use stack to load status
+06cc : 28 > plp
+
+06cd : d002 bne brcc1
+06cf : f003 beq brcc2
+06d1 : brcc1
+ trap ;branch zero/non zero
+06d1 : 4cd106 > jmp * ;failed anyway
+
+06d4 : b002 brcc2 bcs brcc3
+06d6 : 9003 bcc brcc4
+06d8 : brcc3
+ trap ;branch carry/no carry
+06d8 : 4cd806 > jmp * ;failed anyway
+
+06db : 1002 brcc4 bpl brcc5
+06dd : 3003 bmi brcc6
+06df : brcc5
+ trap ;branch minus/plus
+06df : 4cdf06 > jmp * ;failed anyway
+
+06e2 : 5002 brcc6 bvc brcc7
+06e4 : 7003 bvs brcc8
+06e6 : brcc7
+ trap ;branch overflow/no overflow
+06e6 : 4ce606 > jmp * ;failed anyway
+
+06e9 : brcc8
+ set_stat $ff-minus
+ > load_flag $ff-minus
+06e9 : a97f > lda #$ff-minus ;allow test to change I-flag (no mask)
+ >
+06eb : 48 > pha ;use stack to load status
+06ec : 28 > plp
+
+06ed : d002 bne brpl1
+06ef : f003 beq brpl2
+06f1 : brpl1
+ trap ;branch zero/non zero
+06f1 : 4cf106 > jmp * ;failed anyway
+
+06f4 : 9002 brpl2 bcc brpl3
+06f6 : b003 bcs brpl4
+06f8 : brpl3
+ trap ;branch carry/no carry
+06f8 : 4cf806 > jmp * ;failed anyway
+
+06fb : 3002 brpl4 bmi brpl5
+06fd : 1003 bpl brpl6
+06ff : brpl5
+ trap ;branch minus/plus
+06ff : 4cff06 > jmp * ;failed anyway
+
+0702 : 5002 brpl6 bvc brpl7
+0704 : 7003 bvs brpl8
+0706 : brpl7
+ trap ;branch overflow/no overflow
+0706 : 4c0607 > jmp * ;failed anyway
+
+0709 : brpl8
+ set_stat $ff-overfl
+ > load_flag $ff-overfl
+0709 : a9bf > lda #$ff-overfl ;allow test to change I-flag (no mask)
+ >
+070b : 48 > pha ;use stack to load status
+070c : 28 > plp
+
+070d : d002 bne brvc1
+070f : f003 beq brvc2
+0711 : brvc1
+ trap ;branch zero/non zero
+0711 : 4c1107 > jmp * ;failed anyway
+
+0714 : 9002 brvc2 bcc brvc3
+0716 : b003 bcs brvc4
+0718 : brvc3
+ trap ;branch carry/no carry
+0718 : 4c1807 > jmp * ;failed anyway
+
+071b : 1002 brvc4 bpl brvc5
+071d : 3003 bmi brvc6
+071f : brvc5
+ trap ;branch minus/plus
+071f : 4c1f07 > jmp * ;failed anyway
+
+0722 : 7002 brvc6 bvs brvc7
+0724 : 5003 bvc brvc8
+0726 : brvc7
+ trap ;branch overflow/no overflow
+0726 : 4c2607 > jmp * ;failed anyway
+
+0729 : brvc8
+ next_test
+0729 : ad0002 > lda test_case ;previous test
+072c : c904 > cmp #test_num
+ > trap_ne ;test is out of sequence
+072e : d0fe > bne * ;failed not equal (non zero)
+ >
+0005 = >test_num = test_num + 1
+0730 : a905 > lda #test_num ;*** next tests' number
+0732 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; test PHA does not alter flags or accumulator but PLA does
+0735 : a255 ldx #$55 ;x & y protected
+0737 : a0aa ldy #$aa
+ set_a 1,$ff ;push
+ > load_flag $ff
+0739 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+073b : 48 > pha ;use stack to load status
+073c : a901 > lda #1 ;precharge accu
+073e : 28 > plp
+
+073f : 48 pha
+ tst_a 1,$ff
+0740 : 08 > php ;save flags
+0741 : c901 > cmp #1 ;test result
+ > trap_ne
+0743 : d0fe > bne * ;failed not equal (non zero)
+ >
+0745 : 68 > pla ;load status
+0746 : 48 > pha
+ > cmp_flag $ff
+0747 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0749 : d0fe > bne * ;failed not equal (non zero)
+ >
+074b : 28 > plp ;restore status
+
+ set_a 0,0
+ > load_flag 0
+074c : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+074e : 48 > pha ;use stack to load status
+074f : a900 > lda #0 ;precharge accu
+0751 : 28 > plp
+
+0752 : 48 pha
+ tst_a 0,0
+0753 : 08 > php ;save flags
+0754 : c900 > cmp #0 ;test result
+ > trap_ne
+0756 : d0fe > bne * ;failed not equal (non zero)
+ >
+0758 : 68 > pla ;load status
+0759 : 48 > pha
+ > cmp_flag 0
+075a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+075c : d0fe > bne * ;failed not equal (non zero)
+ >
+075e : 28 > plp ;restore status
+
+ set_a $ff,$ff
+ > load_flag $ff
+075f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0761 : 48 > pha ;use stack to load status
+0762 : a9ff > lda #$ff ;precharge accu
+0764 : 28 > plp
+
+0765 : 48 pha
+ tst_a $ff,$ff
+0766 : 08 > php ;save flags
+0767 : c9ff > cmp #$ff ;test result
+ > trap_ne
+0769 : d0fe > bne * ;failed not equal (non zero)
+ >
+076b : 68 > pla ;load status
+076c : 48 > pha
+ > cmp_flag $ff
+076d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+076f : d0fe > bne * ;failed not equal (non zero)
+ >
+0771 : 28 > plp ;restore status
+
+ set_a 1,0
+ > load_flag 0
+0772 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0774 : 48 > pha ;use stack to load status
+0775 : a901 > lda #1 ;precharge accu
+0777 : 28 > plp
+
+0778 : 48 pha
+ tst_a 1,0
+0779 : 08 > php ;save flags
+077a : c901 > cmp #1 ;test result
+ > trap_ne
+077c : d0fe > bne * ;failed not equal (non zero)
+ >
+077e : 68 > pla ;load status
+077f : 48 > pha
+ > cmp_flag 0
+0780 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0782 : d0fe > bne * ;failed not equal (non zero)
+ >
+0784 : 28 > plp ;restore status
+
+ set_a 0,$ff
+ > load_flag $ff
+0785 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0787 : 48 > pha ;use stack to load status
+0788 : a900 > lda #0 ;precharge accu
+078a : 28 > plp
+
+078b : 48 pha
+ tst_a 0,$ff
+078c : 08 > php ;save flags
+078d : c900 > cmp #0 ;test result
+ > trap_ne
+078f : d0fe > bne * ;failed not equal (non zero)
+ >
+0791 : 68 > pla ;load status
+0792 : 48 > pha
+ > cmp_flag $ff
+0793 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0795 : d0fe > bne * ;failed not equal (non zero)
+ >
+0797 : 28 > plp ;restore status
+
+ set_a $ff,0
+ > load_flag 0
+0798 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+079a : 48 > pha ;use stack to load status
+079b : a9ff > lda #$ff ;precharge accu
+079d : 28 > plp
+
+079e : 48 pha
+ tst_a $ff,0
+079f : 08 > php ;save flags
+07a0 : c9ff > cmp #$ff ;test result
+ > trap_ne
+07a2 : d0fe > bne * ;failed not equal (non zero)
+ >
+07a4 : 68 > pla ;load status
+07a5 : 48 > pha
+ > cmp_flag 0
+07a6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+07a8 : d0fe > bne * ;failed not equal (non zero)
+ >
+07aa : 28 > plp ;restore status
+
+ set_a 0,$ff ;pull
+ > load_flag $ff
+07ab : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+07ad : 48 > pha ;use stack to load status
+07ae : a900 > lda #0 ;precharge accu
+07b0 : 28 > plp
+
+07b1 : 68 pla
+ tst_a $ff,$ff-zero
+07b2 : 08 > php ;save flags
+07b3 : c9ff > cmp #$ff ;test result
+ > trap_ne
+07b5 : d0fe > bne * ;failed not equal (non zero)
+ >
+07b7 : 68 > pla ;load status
+07b8 : 48 > pha
+ > cmp_flag $ff-zero
+07b9 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+07bb : d0fe > bne * ;failed not equal (non zero)
+ >
+07bd : 28 > plp ;restore status
+
+ set_a $ff,0
+ > load_flag 0
+07be : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+07c0 : 48 > pha ;use stack to load status
+07c1 : a9ff > lda #$ff ;precharge accu
+07c3 : 28 > plp
+
+07c4 : 68 pla
+ tst_a 0,zero
+07c5 : 08 > php ;save flags
+07c6 : c900 > cmp #0 ;test result
+ > trap_ne
+07c8 : d0fe > bne * ;failed not equal (non zero)
+ >
+07ca : 68 > pla ;load status
+07cb : 48 > pha
+ > cmp_flag zero
+07cc : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+07ce : d0fe > bne * ;failed not equal (non zero)
+ >
+07d0 : 28 > plp ;restore status
+
+ set_a $fe,$ff
+ > load_flag $ff
+07d1 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+07d3 : 48 > pha ;use stack to load status
+07d4 : a9fe > lda #$fe ;precharge accu
+07d6 : 28 > plp
+
+07d7 : 68 pla
+ tst_a 1,$ff-zero-minus
+07d8 : 08 > php ;save flags
+07d9 : c901 > cmp #1 ;test result
+ > trap_ne
+07db : d0fe > bne * ;failed not equal (non zero)
+ >
+07dd : 68 > pla ;load status
+07de : 48 > pha
+ > cmp_flag $ff-zero-minus
+07df : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+07e1 : d0fe > bne * ;failed not equal (non zero)
+ >
+07e3 : 28 > plp ;restore status
+
+ set_a 0,0
+ > load_flag 0
+07e4 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+07e6 : 48 > pha ;use stack to load status
+07e7 : a900 > lda #0 ;precharge accu
+07e9 : 28 > plp
+
+07ea : 68 pla
+ tst_a $ff,minus
+07eb : 08 > php ;save flags
+07ec : c9ff > cmp #$ff ;test result
+ > trap_ne
+07ee : d0fe > bne * ;failed not equal (non zero)
+ >
+07f0 : 68 > pla ;load status
+07f1 : 48 > pha
+ > cmp_flag minus
+07f2 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+07f4 : d0fe > bne * ;failed not equal (non zero)
+ >
+07f6 : 28 > plp ;restore status
+
+ set_a $ff,$ff
+ > load_flag $ff
+07f7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+07f9 : 48 > pha ;use stack to load status
+07fa : a9ff > lda #$ff ;precharge accu
+07fc : 28 > plp
+
+07fd : 68 pla
+ tst_a 0,$ff-minus
+07fe : 08 > php ;save flags
+07ff : c900 > cmp #0 ;test result
+ > trap_ne
+0801 : d0fe > bne * ;failed not equal (non zero)
+ >
+0803 : 68 > pla ;load status
+0804 : 48 > pha
+ > cmp_flag $ff-minus
+0805 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0807 : d0fe > bne * ;failed not equal (non zero)
+ >
+0809 : 28 > plp ;restore status
+
+ set_a $fe,0
+ > load_flag 0
+080a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+080c : 48 > pha ;use stack to load status
+080d : a9fe > lda #$fe ;precharge accu
+080f : 28 > plp
+
+0810 : 68 pla
+ tst_a 1,0
+0811 : 08 > php ;save flags
+0812 : c901 > cmp #1 ;test result
+ > trap_ne
+0814 : d0fe > bne * ;failed not equal (non zero)
+ >
+0816 : 68 > pla ;load status
+0817 : 48 > pha
+ > cmp_flag 0
+0818 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+081a : d0fe > bne * ;failed not equal (non zero)
+ >
+081c : 28 > plp ;restore status
+
+081d : e055 cpx #$55 ;x & y unchanged?
+ trap_ne
+081f : d0fe > bne * ;failed not equal (non zero)
+
+0821 : c0aa cpy #$aa
+ trap_ne
+0823 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+0825 : ad0002 > lda test_case ;previous test
+0828 : c905 > cmp #test_num
+ > trap_ne ;test is out of sequence
+082a : d0fe > bne * ;failed not equal (non zero)
+ >
+0006 = >test_num = test_num + 1
+082c : a906 > lda #test_num ;*** next tests' number
+082e : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; partial pretest EOR #
+ set_a $3c,0
+ > load_flag 0
+0831 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0833 : 48 > pha ;use stack to load status
+0834 : a93c > lda #$3c ;precharge accu
+0836 : 28 > plp
+
+0837 : 49c3 eor #$c3
+ tst_a $ff,fn
+0839 : 08 > php ;save flags
+083a : c9ff > cmp #$ff ;test result
+ > trap_ne
+083c : d0fe > bne * ;failed not equal (non zero)
+ >
+083e : 68 > pla ;load status
+083f : 48 > pha
+ > cmp_flag fn
+0840 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0842 : d0fe > bne * ;failed not equal (non zero)
+ >
+0844 : 28 > plp ;restore status
+
+ set_a $c3,0
+ > load_flag 0
+0845 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0847 : 48 > pha ;use stack to load status
+0848 : a9c3 > lda #$c3 ;precharge accu
+084a : 28 > plp
+
+084b : 49c3 eor #$c3
+ tst_a 0,fz
+084d : 08 > php ;save flags
+084e : c900 > cmp #0 ;test result
+ > trap_ne
+0850 : d0fe > bne * ;failed not equal (non zero)
+ >
+0852 : 68 > pla ;load status
+0853 : 48 > pha
+ > cmp_flag fz
+0854 : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0856 : d0fe > bne * ;failed not equal (non zero)
+ >
+0858 : 28 > plp ;restore status
+
+ next_test
+0859 : ad0002 > lda test_case ;previous test
+085c : c906 > cmp #test_num
+ > trap_ne ;test is out of sequence
+085e : d0fe > bne * ;failed not equal (non zero)
+ >
+0007 = >test_num = test_num + 1
+0860 : a907 > lda #test_num ;*** next tests' number
+0862 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; PC modifying instructions except branches (NOP, JMP, JSR, RTS, BRK, RTI)
+ ; testing NOP
+0865 : a224 ldx #$24
+0867 : a042 ldy #$42
+ set_a $18,0
+ > load_flag 0
+0869 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+086b : 48 > pha ;use stack to load status
+086c : a918 > lda #$18 ;precharge accu
+086e : 28 > plp
+
+086f : ea nop
+ tst_a $18,0
+0870 : 08 > php ;save flags
+0871 : c918 > cmp #$18 ;test result
+ > trap_ne
+0873 : d0fe > bne * ;failed not equal (non zero)
+ >
+0875 : 68 > pla ;load status
+0876 : 48 > pha
+ > cmp_flag 0
+0877 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0879 : d0fe > bne * ;failed not equal (non zero)
+ >
+087b : 28 > plp ;restore status
+
+087c : e024 cpx #$24
+ trap_ne
+087e : d0fe > bne * ;failed not equal (non zero)
+
+0880 : c042 cpy #$42
+ trap_ne
+0882 : d0fe > bne * ;failed not equal (non zero)
+
+0884 : a2db ldx #$db
+0886 : a0bd ldy #$bd
+ set_a $e7,$ff
+ > load_flag $ff
+0888 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+088a : 48 > pha ;use stack to load status
+088b : a9e7 > lda #$e7 ;precharge accu
+088d : 28 > plp
+
+088e : ea nop
+ tst_a $e7,$ff
+088f : 08 > php ;save flags
+0890 : c9e7 > cmp #$e7 ;test result
+ > trap_ne
+0892 : d0fe > bne * ;failed not equal (non zero)
+ >
+0894 : 68 > pla ;load status
+0895 : 48 > pha
+ > cmp_flag $ff
+0896 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0898 : d0fe > bne * ;failed not equal (non zero)
+ >
+089a : 28 > plp ;restore status
+
+089b : e0db cpx #$db
+ trap_ne
+089d : d0fe > bne * ;failed not equal (non zero)
+
+089f : c0bd cpy #$bd
+ trap_ne
+08a1 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+08a3 : ad0002 > lda test_case ;previous test
+08a6 : c907 > cmp #test_num
+ > trap_ne ;test is out of sequence
+08a8 : d0fe > bne * ;failed not equal (non zero)
+ >
+0008 = >test_num = test_num + 1
+08aa : a908 > lda #test_num ;*** next tests' number
+08ac : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; jump absolute
+ set_stat $0
+ > load_flag $0
+08af : a900 > lda #$0 ;allow test to change I-flag (no mask)
+ >
+08b1 : 48 > pha ;use stack to load status
+08b2 : 28 > plp
+
+08b3 : a946 lda #'F'
+08b5 : a241 ldx #'A'
+08b7 : a052 ldy #'R' ;N=0, V=0, Z=0, C=0
+08b9 : 4c1b36 jmp test_far
+08bc : ea nop
+08bd : ea nop
+ trap_ne ;runover protection
+08be : d0fe > bne * ;failed not equal (non zero)
+
+08c0 : e8 inx
+08c1 : e8 inx
+08c2 : far_ret
+ trap_eq ;returned flags OK?
+08c2 : f0fe > beq * ;failed equal (zero)
+
+ trap_pl
+08c4 : 10fe > bpl * ;failed plus (bit 7 clear)
+
+ trap_cc
+08c6 : 90fe > bcc * ;failed carry clear
+
+ trap_vc
+08c8 : 50fe > bvc * ;failed overflow clear
+
+08ca : c9ec cmp #('F'^$aa) ;returned registers OK?
+ trap_ne
+08cc : d0fe > bne * ;failed not equal (non zero)
+
+08ce : e042 cpx #('A'+1)
+ trap_ne
+08d0 : d0fe > bne * ;failed not equal (non zero)
+
+08d2 : c04f cpy #('R'-3)
+ trap_ne
+08d4 : d0fe > bne * ;failed not equal (non zero)
+
+08d6 : ca dex
+08d7 : c8 iny
+08d8 : c8 iny
+08d9 : c8 iny
+08da : 49aa eor #$aa ;N=0, V=1, Z=0, C=1
+08dc : 4ce508 jmp test_near
+08df : ea nop
+08e0 : ea nop
+ trap_ne ;runover protection
+08e1 : d0fe > bne * ;failed not equal (non zero)
+
+08e3 : e8 inx
+08e4 : e8 inx
+08e5 : test_near
+ trap_eq ;passed flags OK?
+08e5 : f0fe > beq * ;failed equal (zero)
+
+ trap_mi
+08e7 : 30fe > bmi * ;failed minus (bit 7 set)
+
+ trap_cc
+08e9 : 90fe > bcc * ;failed carry clear
+
+ trap_vc
+08eb : 50fe > bvc * ;failed overflow clear
+
+08ed : c946 cmp #'F' ;passed registers OK?
+ trap_ne
+08ef : d0fe > bne * ;failed not equal (non zero)
+
+08f1 : e041 cpx #'A'
+ trap_ne
+08f3 : d0fe > bne * ;failed not equal (non zero)
+
+08f5 : c052 cpy #'R'
+ trap_ne
+08f7 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+08f9 : ad0002 > lda test_case ;previous test
+08fc : c908 > cmp #test_num
+ > trap_ne ;test is out of sequence
+08fe : d0fe > bne * ;failed not equal (non zero)
+ >
+0009 = >test_num = test_num + 1
+0900 : a909 > lda #test_num ;*** next tests' number
+0902 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; jump indirect
+ set_stat 0
+ > load_flag 0
+0905 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0907 : 48 > pha ;use stack to load status
+0908 : 28 > plp
+
+0909 : a949 lda #'I'
+090b : a24e ldx #'N'
+090d : a044 ldy #'D' ;N=0, V=0, Z=0, C=0
+090f : 6c4a36 jmp (ptr_tst_ind)
+0912 : ea nop
+ trap_ne ;runover protection
+0913 : d0fe > bne * ;failed not equal (non zero)
+
+0915 : 88 dey
+0916 : 88 dey
+0917 : ind_ret
+0917 : 08 php ;either SP or Y count will fail, if we do not hit
+0918 : 88 dey
+0919 : 88 dey
+091a : 88 dey
+091b : 28 plp
+ trap_eq ;returned flags OK?
+091c : f0fe > beq * ;failed equal (zero)
+
+ trap_pl
+091e : 10fe > bpl * ;failed plus (bit 7 clear)
+
+ trap_cc
+0920 : 90fe > bcc * ;failed carry clear
+
+ trap_vc
+0922 : 50fe > bvc * ;failed overflow clear
+
+0924 : c9e3 cmp #('I'^$aa) ;returned registers OK?
+ trap_ne
+0926 : d0fe > bne * ;failed not equal (non zero)
+
+0928 : e04f cpx #('N'+1)
+ trap_ne
+092a : d0fe > bne * ;failed not equal (non zero)
+
+092c : c03e cpy #('D'-6)
+ trap_ne
+092e : d0fe > bne * ;failed not equal (non zero)
+
+0930 : ba tsx ;SP check
+0931 : e0ff cpx #$ff
+ trap_ne
+0933 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+0935 : ad0002 > lda test_case ;previous test
+0938 : c909 > cmp #test_num
+ > trap_ne ;test is out of sequence
+093a : d0fe > bne * ;failed not equal (non zero)
+ >
+000a = >test_num = test_num + 1
+093c : a90a > lda #test_num ;*** next tests' number
+093e : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; jump subroutine & return from subroutine
+ set_stat 0
+ > load_flag 0
+0941 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0943 : 48 > pha ;use stack to load status
+0944 : 28 > plp
+
+0945 : a94a lda #'J'
+0947 : a253 ldx #'S'
+0949 : a052 ldy #'R' ;N=0, V=0, Z=0, C=0
+094b : 208636 jsr test_jsr
+094d = jsr_ret = *-1 ;last address of jsr = return address
+094e : 08 php ;either SP or Y count will fail, if we do not hit
+094f : 88 dey
+0950 : 88 dey
+0951 : 88 dey
+0952 : 28 plp
+ trap_eq ;returned flags OK?
+0953 : f0fe > beq * ;failed equal (zero)
+
+ trap_pl
+0955 : 10fe > bpl * ;failed plus (bit 7 clear)
+
+ trap_cc
+0957 : 90fe > bcc * ;failed carry clear
+
+ trap_vc
+0959 : 50fe > bvc * ;failed overflow clear
+
+095b : c9e0 cmp #('J'^$aa) ;returned registers OK?
+ trap_ne
+095d : d0fe > bne * ;failed not equal (non zero)
+
+095f : e054 cpx #('S'+1)
+ trap_ne
+0961 : d0fe > bne * ;failed not equal (non zero)
+
+0963 : c04c cpy #('R'-6)
+ trap_ne
+0965 : d0fe > bne * ;failed not equal (non zero)
+
+0967 : ba tsx ;sp?
+0968 : e0ff cpx #$ff
+ trap_ne
+096a : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+096c : ad0002 > lda test_case ;previous test
+096f : c90a > cmp #test_num
+ > trap_ne ;test is out of sequence
+0971 : d0fe > bne * ;failed not equal (non zero)
+ >
+000b = >test_num = test_num + 1
+0973 : a90b > lda #test_num ;*** next tests' number
+0975 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; break & return from interrupt
+ if ROM_vectors = 1
+ set_stat 0
+ > load_flag 0
+0978 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+097a : 48 > pha ;use stack to load status
+097b : 28 > plp
+
+097c : a942 lda #'B'
+097e : a252 ldx #'R'
+0980 : a04b ldy #'K' ;N=0, V=0, Z=0, C=0
+0982 : 00 brk
+ else
+ lda #hi brk_ret ;emulated break
+ pha
+ lda #lo brk_ret
+ pha
+ lda #fao ;set break & unused on stack
+ pha
+ set_stat intdis
+ lda #'B'
+ ldx #'R'
+ ldy #'K' ;N=0, V=0, Z=0, C=0
+ jmp irq_trap
+ endif
+0983 : 88 dey ;should not be executed
+0984 : brk_ret ;address of break return
+0984 : 08 php ;either SP or Y count will fail, if we do not hit
+0985 : 88 dey
+0986 : 88 dey
+0987 : 88 dey
+0988 : c9e8 cmp #('B'^$aa) ;returned registers OK?
+ trap_ne
+098a : d0fe > bne * ;failed not equal (non zero)
+
+098c : e053 cpx #('R'+1)
+ trap_ne
+098e : d0fe > bne * ;failed not equal (non zero)
+
+0990 : c045 cpy #('K'-6)
+ trap_ne
+0992 : d0fe > bne * ;failed not equal (non zero)
+
+0994 : 68 pla ;returned flags OK (unchanged)?
+ cmp_flag 0
+0995 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0997 : d0fe > bne * ;failed not equal (non zero)
+
+0999 : ba tsx ;sp?
+099a : e0ff cpx #$ff
+ trap_ne
+099c : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+099e : ad0002 > lda test_case ;previous test
+09a1 : c90b > cmp #test_num
+ > trap_ne ;test is out of sequence
+09a3 : d0fe > bne * ;failed not equal (non zero)
+ >
+000c = >test_num = test_num + 1
+09a5 : a90c > lda #test_num ;*** next tests' number
+09a7 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; test set and clear flags CLC CLI CLD CLV SEC SEI SED
+ set_stat $ff
+ > load_flag $ff
+09aa : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+09ac : 48 > pha ;use stack to load status
+09ad : 28 > plp
+
+09ae : 18 clc
+ tst_stat $ff-carry
+09af : 08 > php ;save status
+09b0 : 68 > pla ;use stack to retrieve status
+09b1 : 48 > pha
+ > cmp_flag $ff-carry
+09b2 : c9fe > cmp #($ff-carry|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+09b4 : d0fe > bne * ;failed not equal (non zero)
+ >
+09b6 : 28 > plp ;restore status
+
+09b7 : 38 sec
+ tst_stat $ff
+09b8 : 08 > php ;save status
+09b9 : 68 > pla ;use stack to retrieve status
+09ba : 48 > pha
+ > cmp_flag $ff
+09bb : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+09bd : d0fe > bne * ;failed not equal (non zero)
+ >
+09bf : 28 > plp ;restore status
+
+ if I_flag = 3
+09c0 : 58 cli
+ tst_stat $ff-intdis
+09c1 : 08 > php ;save status
+09c2 : 68 > pla ;use stack to retrieve status
+09c3 : 48 > pha
+ > cmp_flag $ff-intdis
+09c4 : c9fb > cmp #($ff-intdis|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+09c6 : d0fe > bne * ;failed not equal (non zero)
+ >
+09c8 : 28 > plp ;restore status
+
+09c9 : 78 sei
+ tst_stat $ff
+09ca : 08 > php ;save status
+09cb : 68 > pla ;use stack to retrieve status
+09cc : 48 > pha
+ > cmp_flag $ff
+09cd : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+09cf : d0fe > bne * ;failed not equal (non zero)
+ >
+09d1 : 28 > plp ;restore status
+
+ endif
+09d2 : d8 cld
+ tst_stat $ff-decmode
+09d3 : 08 > php ;save status
+09d4 : 68 > pla ;use stack to retrieve status
+09d5 : 48 > pha
+ > cmp_flag $ff-decmode
+09d6 : c9f7 > cmp #($ff-decmode|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+09d8 : d0fe > bne * ;failed not equal (non zero)
+ >
+09da : 28 > plp ;restore status
+
+09db : f8 sed
+ tst_stat $ff
+09dc : 08 > php ;save status
+09dd : 68 > pla ;use stack to retrieve status
+09de : 48 > pha
+ > cmp_flag $ff
+09df : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+09e1 : d0fe > bne * ;failed not equal (non zero)
+ >
+09e3 : 28 > plp ;restore status
+
+09e4 : b8 clv
+ tst_stat $ff-overfl
+09e5 : 08 > php ;save status
+09e6 : 68 > pla ;use stack to retrieve status
+09e7 : 48 > pha
+ > cmp_flag $ff-overfl
+09e8 : c9bf > cmp #($ff-overfl|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+09ea : d0fe > bne * ;failed not equal (non zero)
+ >
+09ec : 28 > plp ;restore status
+
+ set_stat 0
+ > load_flag 0
+09ed : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+09ef : 48 > pha ;use stack to load status
+09f0 : 28 > plp
+
+ tst_stat 0
+09f1 : 08 > php ;save status
+09f2 : 68 > pla ;use stack to retrieve status
+09f3 : 48 > pha
+ > cmp_flag 0
+09f4 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+09f6 : d0fe > bne * ;failed not equal (non zero)
+ >
+09f8 : 28 > plp ;restore status
+
+09f9 : 38 sec
+ tst_stat carry
+09fa : 08 > php ;save status
+09fb : 68 > pla ;use stack to retrieve status
+09fc : 48 > pha
+ > cmp_flag carry
+09fd : c931 > cmp #(carry|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+09ff : d0fe > bne * ;failed not equal (non zero)
+ >
+0a01 : 28 > plp ;restore status
+
+0a02 : 18 clc
+ tst_stat 0
+0a03 : 08 > php ;save status
+0a04 : 68 > pla ;use stack to retrieve status
+0a05 : 48 > pha
+ > cmp_flag 0
+0a06 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a08 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a0a : 28 > plp ;restore status
+
+ if I_flag = 3
+0a0b : 78 sei
+ tst_stat intdis
+0a0c : 08 > php ;save status
+0a0d : 68 > pla ;use stack to retrieve status
+0a0e : 48 > pha
+ > cmp_flag intdis
+0a0f : c934 > cmp #(intdis|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a11 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a13 : 28 > plp ;restore status
+
+0a14 : 58 cli
+ tst_stat 0
+0a15 : 08 > php ;save status
+0a16 : 68 > pla ;use stack to retrieve status
+0a17 : 48 > pha
+ > cmp_flag 0
+0a18 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a1a : d0fe > bne * ;failed not equal (non zero)
+ >
+0a1c : 28 > plp ;restore status
+
+ endif
+0a1d : f8 sed
+ tst_stat decmode
+0a1e : 08 > php ;save status
+0a1f : 68 > pla ;use stack to retrieve status
+0a20 : 48 > pha
+ > cmp_flag decmode
+0a21 : c938 > cmp #(decmode|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a23 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a25 : 28 > plp ;restore status
+
+0a26 : d8 cld
+ tst_stat 0
+0a27 : 08 > php ;save status
+0a28 : 68 > pla ;use stack to retrieve status
+0a29 : 48 > pha
+ > cmp_flag 0
+0a2a : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a2c : d0fe > bne * ;failed not equal (non zero)
+ >
+0a2e : 28 > plp ;restore status
+
+ set_stat overfl
+ > load_flag overfl
+0a2f : a940 > lda #overfl ;allow test to change I-flag (no mask)
+ >
+0a31 : 48 > pha ;use stack to load status
+0a32 : 28 > plp
+
+ tst_stat overfl
+0a33 : 08 > php ;save status
+0a34 : 68 > pla ;use stack to retrieve status
+0a35 : 48 > pha
+ > cmp_flag overfl
+0a36 : c970 > cmp #(overfl|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a38 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a3a : 28 > plp ;restore status
+
+0a3b : b8 clv
+ tst_stat 0
+0a3c : 08 > php ;save status
+0a3d : 68 > pla ;use stack to retrieve status
+0a3e : 48 > pha
+ > cmp_flag 0
+0a3f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a41 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a43 : 28 > plp ;restore status
+
+ next_test
+0a44 : ad0002 > lda test_case ;previous test
+0a47 : c90c > cmp #test_num
+ > trap_ne ;test is out of sequence
+0a49 : d0fe > bne * ;failed not equal (non zero)
+ >
+000d = >test_num = test_num + 1
+0a4b : a90d > lda #test_num ;*** next tests' number
+0a4d : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+ ; testing index register increment/decrement and transfer
+ ; INX INY DEX DEY TAX TXA TAY TYA
+0a50 : a2fe ldx #$fe
+ set_stat $ff
+ > load_flag $ff
+0a52 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0a54 : 48 > pha ;use stack to load status
+0a55 : 28 > plp
+
+0a56 : e8 inx ;ff
+ tst_x $ff,$ff-zero
+0a57 : 08 > php ;save flags
+0a58 : e0ff > cpx #$ff ;test result
+ > trap_ne
+0a5a : d0fe > bne * ;failed not equal (non zero)
+ >
+0a5c : 68 > pla ;load status
+0a5d : 48 > pha
+ > cmp_flag $ff-zero
+0a5e : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a60 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a62 : 28 > plp ;restore status
+
+0a63 : e8 inx ;00
+ tst_x 0,$ff-minus
+0a64 : 08 > php ;save flags
+0a65 : e000 > cpx #0 ;test result
+ > trap_ne
+0a67 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a69 : 68 > pla ;load status
+0a6a : 48 > pha
+ > cmp_flag $ff-minus
+0a6b : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a6d : d0fe > bne * ;failed not equal (non zero)
+ >
+0a6f : 28 > plp ;restore status
+
+0a70 : e8 inx ;01
+ tst_x 1,$ff-minus-zero
+0a71 : 08 > php ;save flags
+0a72 : e001 > cpx #1 ;test result
+ > trap_ne
+0a74 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a76 : 68 > pla ;load status
+0a77 : 48 > pha
+ > cmp_flag $ff-minus-zero
+0a78 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a7a : d0fe > bne * ;failed not equal (non zero)
+ >
+0a7c : 28 > plp ;restore status
+
+0a7d : ca dex ;00
+ tst_x 0,$ff-minus
+0a7e : 08 > php ;save flags
+0a7f : e000 > cpx #0 ;test result
+ > trap_ne
+0a81 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a83 : 68 > pla ;load status
+0a84 : 48 > pha
+ > cmp_flag $ff-minus
+0a85 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a87 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a89 : 28 > plp ;restore status
+
+0a8a : ca dex ;ff
+ tst_x $ff,$ff-zero
+0a8b : 08 > php ;save flags
+0a8c : e0ff > cpx #$ff ;test result
+ > trap_ne
+0a8e : d0fe > bne * ;failed not equal (non zero)
+ >
+0a90 : 68 > pla ;load status
+0a91 : 48 > pha
+ > cmp_flag $ff-zero
+0a92 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a94 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a96 : 28 > plp ;restore status
+
+0a97 : ca dex ;fe
+ set_stat 0
+ > load_flag 0
+0a98 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0a9a : 48 > pha ;use stack to load status
+0a9b : 28 > plp
+
+0a9c : e8 inx ;ff
+ tst_x $ff,minus
+0a9d : 08 > php ;save flags
+0a9e : e0ff > cpx #$ff ;test result
+ > trap_ne
+0aa0 : d0fe > bne * ;failed not equal (non zero)
+ >
+0aa2 : 68 > pla ;load status
+0aa3 : 48 > pha
+ > cmp_flag minus
+0aa4 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0aa6 : d0fe > bne * ;failed not equal (non zero)
+ >
+0aa8 : 28 > plp ;restore status
+
+0aa9 : e8 inx ;00
+ tst_x 0,zero
+0aaa : 08 > php ;save flags
+0aab : e000 > cpx #0 ;test result
+ > trap_ne
+0aad : d0fe > bne * ;failed not equal (non zero)
+ >
+0aaf : 68 > pla ;load status
+0ab0 : 48 > pha
+ > cmp_flag zero
+0ab1 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0ab3 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ab5 : 28 > plp ;restore status
+
+0ab6 : e8 inx ;01
+ tst_x 1,0
+0ab7 : 08 > php ;save flags
+0ab8 : e001 > cpx #1 ;test result
+ > trap_ne
+0aba : d0fe > bne * ;failed not equal (non zero)
+ >
+0abc : 68 > pla ;load status
+0abd : 48 > pha
+ > cmp_flag 0
+0abe : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0ac0 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ac2 : 28 > plp ;restore status
+
+0ac3 : ca dex ;00
+ tst_x 0,zero
+0ac4 : 08 > php ;save flags
+0ac5 : e000 > cpx #0 ;test result
+ > trap_ne
+0ac7 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ac9 : 68 > pla ;load status
+0aca : 48 > pha
+ > cmp_flag zero
+0acb : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0acd : d0fe > bne * ;failed not equal (non zero)
+ >
+0acf : 28 > plp ;restore status
+
+0ad0 : ca dex ;ff
+ tst_x $ff,minus
+0ad1 : 08 > php ;save flags
+0ad2 : e0ff > cpx #$ff ;test result
+ > trap_ne
+0ad4 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ad6 : 68 > pla ;load status
+0ad7 : 48 > pha
+ > cmp_flag minus
+0ad8 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0ada : d0fe > bne * ;failed not equal (non zero)
+ >
+0adc : 28 > plp ;restore status
+
+
+0add : a0fe ldy #$fe
+ set_stat $ff
+ > load_flag $ff
+0adf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0ae1 : 48 > pha ;use stack to load status
+0ae2 : 28 > plp
+
+0ae3 : c8 iny ;ff
+ tst_y $ff,$ff-zero
+0ae4 : 08 > php ;save flags
+0ae5 : c0ff > cpy #$ff ;test result
+ > trap_ne
+0ae7 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ae9 : 68 > pla ;load status
+0aea : 48 > pha
+ > cmp_flag $ff-zero
+0aeb : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0aed : d0fe > bne * ;failed not equal (non zero)
+ >
+0aef : 28 > plp ;restore status
+
+0af0 : c8 iny ;00
+ tst_y 0,$ff-minus
+0af1 : 08 > php ;save flags
+0af2 : c000 > cpy #0 ;test result
+ > trap_ne
+0af4 : d0fe > bne * ;failed not equal (non zero)
+ >
+0af6 : 68 > pla ;load status
+0af7 : 48 > pha
+ > cmp_flag $ff-minus
+0af8 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0afa : d0fe > bne * ;failed not equal (non zero)
+ >
+0afc : 28 > plp ;restore status
+
+0afd : c8 iny ;01
+ tst_y 1,$ff-minus-zero
+0afe : 08 > php ;save flags
+0aff : c001 > cpy #1 ;test result
+ > trap_ne
+0b01 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b03 : 68 > pla ;load status
+0b04 : 48 > pha
+ > cmp_flag $ff-minus-zero
+0b05 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b07 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b09 : 28 > plp ;restore status
+
+0b0a : 88 dey ;00
+ tst_y 0,$ff-minus
+0b0b : 08 > php ;save flags
+0b0c : c000 > cpy #0 ;test result
+ > trap_ne
+0b0e : d0fe > bne * ;failed not equal (non zero)
+ >
+0b10 : 68 > pla ;load status
+0b11 : 48 > pha
+ > cmp_flag $ff-minus
+0b12 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b14 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b16 : 28 > plp ;restore status
+
+0b17 : 88 dey ;ff
+ tst_y $ff,$ff-zero
+0b18 : 08 > php ;save flags
+0b19 : c0ff > cpy #$ff ;test result
+ > trap_ne
+0b1b : d0fe > bne * ;failed not equal (non zero)
+ >
+0b1d : 68 > pla ;load status
+0b1e : 48 > pha
+ > cmp_flag $ff-zero
+0b1f : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b21 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b23 : 28 > plp ;restore status
+
+0b24 : 88 dey ;fe
+ set_stat 0
+ > load_flag 0
+0b25 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0b27 : 48 > pha ;use stack to load status
+0b28 : 28 > plp
+
+0b29 : c8 iny ;ff
+ tst_y $ff,0+minus
+0b2a : 08 > php ;save flags
+0b2b : c0ff > cpy #$ff ;test result
+ > trap_ne
+0b2d : d0fe > bne * ;failed not equal (non zero)
+ >
+0b2f : 68 > pla ;load status
+0b30 : 48 > pha
+ > cmp_flag 0+minus
+0b31 : c9b0 > cmp #(0+minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b33 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b35 : 28 > plp ;restore status
+
+0b36 : c8 iny ;00
+ tst_y 0,zero
+0b37 : 08 > php ;save flags
+0b38 : c000 > cpy #0 ;test result
+ > trap_ne
+0b3a : d0fe > bne * ;failed not equal (non zero)
+ >
+0b3c : 68 > pla ;load status
+0b3d : 48 > pha
+ > cmp_flag zero
+0b3e : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b40 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b42 : 28 > plp ;restore status
+
+0b43 : c8 iny ;01
+ tst_y 1,0
+0b44 : 08 > php ;save flags
+0b45 : c001 > cpy #1 ;test result
+ > trap_ne
+0b47 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b49 : 68 > pla ;load status
+0b4a : 48 > pha
+ > cmp_flag 0
+0b4b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b4d : d0fe > bne * ;failed not equal (non zero)
+ >
+0b4f : 28 > plp ;restore status
+
+0b50 : 88 dey ;00
+ tst_y 0,zero
+0b51 : 08 > php ;save flags
+0b52 : c000 > cpy #0 ;test result
+ > trap_ne
+0b54 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b56 : 68 > pla ;load status
+0b57 : 48 > pha
+ > cmp_flag zero
+0b58 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b5a : d0fe > bne * ;failed not equal (non zero)
+ >
+0b5c : 28 > plp ;restore status
+
+0b5d : 88 dey ;ff
+ tst_y $ff,minus
+0b5e : 08 > php ;save flags
+0b5f : c0ff > cpy #$ff ;test result
+ > trap_ne
+0b61 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b63 : 68 > pla ;load status
+0b64 : 48 > pha
+ > cmp_flag minus
+0b65 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b67 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b69 : 28 > plp ;restore status
+
+
+0b6a : a2ff ldx #$ff
+ set_stat $ff
+ > load_flag $ff
+0b6c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0b6e : 48 > pha ;use stack to load status
+0b6f : 28 > plp
+
+0b70 : 8a txa
+ tst_a $ff,$ff-zero
+0b71 : 08 > php ;save flags
+0b72 : c9ff > cmp #$ff ;test result
+ > trap_ne
+0b74 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b76 : 68 > pla ;load status
+0b77 : 48 > pha
+ > cmp_flag $ff-zero
+0b78 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b7a : d0fe > bne * ;failed not equal (non zero)
+ >
+0b7c : 28 > plp ;restore status
+
+0b7d : 08 php
+0b7e : e8 inx ;00
+0b7f : 28 plp
+0b80 : 8a txa
+ tst_a 0,$ff-minus
+0b81 : 08 > php ;save flags
+0b82 : c900 > cmp #0 ;test result
+ > trap_ne
+0b84 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b86 : 68 > pla ;load status
+0b87 : 48 > pha
+ > cmp_flag $ff-minus
+0b88 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b8a : d0fe > bne * ;failed not equal (non zero)
+ >
+0b8c : 28 > plp ;restore status
+
+0b8d : 08 php
+0b8e : e8 inx ;01
+0b8f : 28 plp
+0b90 : 8a txa
+ tst_a 1,$ff-minus-zero
+0b91 : 08 > php ;save flags
+0b92 : c901 > cmp #1 ;test result
+ > trap_ne
+0b94 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b96 : 68 > pla ;load status
+0b97 : 48 > pha
+ > cmp_flag $ff-minus-zero
+0b98 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b9a : d0fe > bne * ;failed not equal (non zero)
+ >
+0b9c : 28 > plp ;restore status
+
+ set_stat 0
+ > load_flag 0
+0b9d : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0b9f : 48 > pha ;use stack to load status
+0ba0 : 28 > plp
+
+0ba1 : 8a txa
+ tst_a 1,0
+0ba2 : 08 > php ;save flags
+0ba3 : c901 > cmp #1 ;test result
+ > trap_ne
+0ba5 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ba7 : 68 > pla ;load status
+0ba8 : 48 > pha
+ > cmp_flag 0
+0ba9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0bab : d0fe > bne * ;failed not equal (non zero)
+ >
+0bad : 28 > plp ;restore status
+
+0bae : 08 php
+0baf : ca dex ;00
+0bb0 : 28 plp
+0bb1 : 8a txa
+ tst_a 0,zero
+0bb2 : 08 > php ;save flags
+0bb3 : c900 > cmp #0 ;test result
+ > trap_ne
+0bb5 : d0fe > bne * ;failed not equal (non zero)
+ >
+0bb7 : 68 > pla ;load status
+0bb8 : 48 > pha
+ > cmp_flag zero
+0bb9 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0bbb : d0fe > bne * ;failed not equal (non zero)
+ >
+0bbd : 28 > plp ;restore status
+
+0bbe : 08 php
+0bbf : ca dex ;ff
+0bc0 : 28 plp
+0bc1 : 8a txa
+ tst_a $ff,minus
+0bc2 : 08 > php ;save flags
+0bc3 : c9ff > cmp #$ff ;test result
+ > trap_ne
+0bc5 : d0fe > bne * ;failed not equal (non zero)
+ >
+0bc7 : 68 > pla ;load status
+0bc8 : 48 > pha
+ > cmp_flag minus
+0bc9 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0bcb : d0fe > bne * ;failed not equal (non zero)
+ >
+0bcd : 28 > plp ;restore status
+
+
+0bce : a0ff ldy #$ff
+ set_stat $ff
+ > load_flag $ff
+0bd0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0bd2 : 48 > pha ;use stack to load status
+0bd3 : 28 > plp
+
+0bd4 : 98 tya
+ tst_a $ff,$ff-zero
+0bd5 : 08 > php ;save flags
+0bd6 : c9ff > cmp #$ff ;test result
+ > trap_ne
+0bd8 : d0fe > bne * ;failed not equal (non zero)
+ >
+0bda : 68 > pla ;load status
+0bdb : 48 > pha
+ > cmp_flag $ff-zero
+0bdc : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0bde : d0fe > bne * ;failed not equal (non zero)
+ >
+0be0 : 28 > plp ;restore status
+
+0be1 : 08 php
+0be2 : c8 iny ;00
+0be3 : 28 plp
+0be4 : 98 tya
+ tst_a 0,$ff-minus
+0be5 : 08 > php ;save flags
+0be6 : c900 > cmp #0 ;test result
+ > trap_ne
+0be8 : d0fe > bne * ;failed not equal (non zero)
+ >
+0bea : 68 > pla ;load status
+0beb : 48 > pha
+ > cmp_flag $ff-minus
+0bec : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0bee : d0fe > bne * ;failed not equal (non zero)
+ >
+0bf0 : 28 > plp ;restore status
+
+0bf1 : 08 php
+0bf2 : c8 iny ;01
+0bf3 : 28 plp
+0bf4 : 98 tya
+ tst_a 1,$ff-minus-zero
+0bf5 : 08 > php ;save flags
+0bf6 : c901 > cmp #1 ;test result
+ > trap_ne
+0bf8 : d0fe > bne * ;failed not equal (non zero)
+ >
+0bfa : 68 > pla ;load status
+0bfb : 48 > pha
+ > cmp_flag $ff-minus-zero
+0bfc : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0bfe : d0fe > bne * ;failed not equal (non zero)
+ >
+0c00 : 28 > plp ;restore status
+
+ set_stat 0
+ > load_flag 0
+0c01 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0c03 : 48 > pha ;use stack to load status
+0c04 : 28 > plp
+
+0c05 : 98 tya
+ tst_a 1,0
+0c06 : 08 > php ;save flags
+0c07 : c901 > cmp #1 ;test result
+ > trap_ne
+0c09 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c0b : 68 > pla ;load status
+0c0c : 48 > pha
+ > cmp_flag 0
+0c0d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c0f : d0fe > bne * ;failed not equal (non zero)
+ >
+0c11 : 28 > plp ;restore status
+
+0c12 : 08 php
+0c13 : 88 dey ;00
+0c14 : 28 plp
+0c15 : 98 tya
+ tst_a 0,zero
+0c16 : 08 > php ;save flags
+0c17 : c900 > cmp #0 ;test result
+ > trap_ne
+0c19 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c1b : 68 > pla ;load status
+0c1c : 48 > pha
+ > cmp_flag zero
+0c1d : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c1f : d0fe > bne * ;failed not equal (non zero)
+ >
+0c21 : 28 > plp ;restore status
+
+0c22 : 08 php
+0c23 : 88 dey ;ff
+0c24 : 28 plp
+0c25 : 98 tya
+ tst_a $ff,minus
+0c26 : 08 > php ;save flags
+0c27 : c9ff > cmp #$ff ;test result
+ > trap_ne
+0c29 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c2b : 68 > pla ;load status
+0c2c : 48 > pha
+ > cmp_flag minus
+0c2d : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c2f : d0fe > bne * ;failed not equal (non zero)
+ >
+0c31 : 28 > plp ;restore status
+
+
+ load_flag $ff
+0c32 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+
+0c34 : 48 pha
+0c35 : a2ff ldx #$ff ;ff
+0c37 : 8a txa
+0c38 : 28 plp
+0c39 : a8 tay
+ tst_y $ff,$ff-zero
+0c3a : 08 > php ;save flags
+0c3b : c0ff > cpy #$ff ;test result
+ > trap_ne
+0c3d : d0fe > bne * ;failed not equal (non zero)
+ >
+0c3f : 68 > pla ;load status
+0c40 : 48 > pha
+ > cmp_flag $ff-zero
+0c41 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c43 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c45 : 28 > plp ;restore status
+
+0c46 : 08 php
+0c47 : e8 inx ;00
+0c48 : 8a txa
+0c49 : 28 plp
+0c4a : a8 tay
+ tst_y 0,$ff-minus
+0c4b : 08 > php ;save flags
+0c4c : c000 > cpy #0 ;test result
+ > trap_ne
+0c4e : d0fe > bne * ;failed not equal (non zero)
+ >
+0c50 : 68 > pla ;load status
+0c51 : 48 > pha
+ > cmp_flag $ff-minus
+0c52 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c54 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c56 : 28 > plp ;restore status
+
+0c57 : 08 php
+0c58 : e8 inx ;01
+0c59 : 8a txa
+0c5a : 28 plp
+0c5b : a8 tay
+ tst_y 1,$ff-minus-zero
+0c5c : 08 > php ;save flags
+0c5d : c001 > cpy #1 ;test result
+ > trap_ne
+0c5f : d0fe > bne * ;failed not equal (non zero)
+ >
+0c61 : 68 > pla ;load status
+0c62 : 48 > pha
+ > cmp_flag $ff-minus-zero
+0c63 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c65 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c67 : 28 > plp ;restore status
+
+ load_flag 0
+0c68 : a900 > lda #0 ;allow test to change I-flag (no mask)
+
+0c6a : 48 pha
+0c6b : a900 lda #0
+0c6d : 8a txa
+0c6e : 28 plp
+0c6f : a8 tay
+ tst_y 1,0
+0c70 : 08 > php ;save flags
+0c71 : c001 > cpy #1 ;test result
+ > trap_ne
+0c73 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c75 : 68 > pla ;load status
+0c76 : 48 > pha
+ > cmp_flag 0
+0c77 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c79 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c7b : 28 > plp ;restore status
+
+0c7c : 08 php
+0c7d : ca dex ;00
+0c7e : 8a txa
+0c7f : 28 plp
+0c80 : a8 tay
+ tst_y 0,zero
+0c81 : 08 > php ;save flags
+0c82 : c000 > cpy #0 ;test result
+ > trap_ne
+0c84 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c86 : 68 > pla ;load status
+0c87 : 48 > pha
+ > cmp_flag zero
+0c88 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c8a : d0fe > bne * ;failed not equal (non zero)
+ >
+0c8c : 28 > plp ;restore status
+
+0c8d : 08 php
+0c8e : ca dex ;ff
+0c8f : 8a txa
+0c90 : 28 plp
+0c91 : a8 tay
+ tst_y $ff,minus
+0c92 : 08 > php ;save flags
+0c93 : c0ff > cpy #$ff ;test result
+ > trap_ne
+0c95 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c97 : 68 > pla ;load status
+0c98 : 48 > pha
+ > cmp_flag minus
+0c99 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c9b : d0fe > bne * ;failed not equal (non zero)
+ >
+0c9d : 28 > plp ;restore status
+
+
+
+ load_flag $ff
+0c9e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+
+0ca0 : 48 pha
+0ca1 : a0ff ldy #$ff ;ff
+0ca3 : 98 tya
+0ca4 : 28 plp
+0ca5 : aa tax
+ tst_x $ff,$ff-zero
+0ca6 : 08 > php ;save flags
+0ca7 : e0ff > cpx #$ff ;test result
+ > trap_ne
+0ca9 : d0fe > bne * ;failed not equal (non zero)
+ >
+0cab : 68 > pla ;load status
+0cac : 48 > pha
+ > cmp_flag $ff-zero
+0cad : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0caf : d0fe > bne * ;failed not equal (non zero)
+ >
+0cb1 : 28 > plp ;restore status
+
+0cb2 : 08 php
+0cb3 : c8 iny ;00
+0cb4 : 98 tya
+0cb5 : 28 plp
+0cb6 : aa tax
+ tst_x 0,$ff-minus
+0cb7 : 08 > php ;save flags
+0cb8 : e000 > cpx #0 ;test result
+ > trap_ne
+0cba : d0fe > bne * ;failed not equal (non zero)
+ >
+0cbc : 68 > pla ;load status
+0cbd : 48 > pha
+ > cmp_flag $ff-minus
+0cbe : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0cc0 : d0fe > bne * ;failed not equal (non zero)
+ >
+0cc2 : 28 > plp ;restore status
+
+0cc3 : 08 php
+0cc4 : c8 iny ;01
+0cc5 : 98 tya
+0cc6 : 28 plp
+0cc7 : aa tax
+ tst_x 1,$ff-minus-zero
+0cc8 : 08 > php ;save flags
+0cc9 : e001 > cpx #1 ;test result
+ > trap_ne
+0ccb : d0fe > bne * ;failed not equal (non zero)
+ >
+0ccd : 68 > pla ;load status
+0cce : 48 > pha
+ > cmp_flag $ff-minus-zero
+0ccf : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0cd1 : d0fe > bne * ;failed not equal (non zero)
+ >
+0cd3 : 28 > plp ;restore status
+
+ load_flag 0
+0cd4 : a900 > lda #0 ;allow test to change I-flag (no mask)
+
+0cd6 : 48 pha
+0cd7 : a900 lda #0 ;preset status
+0cd9 : 98 tya
+0cda : 28 plp
+0cdb : aa tax
+ tst_x 1,0
+0cdc : 08 > php ;save flags
+0cdd : e001 > cpx #1 ;test result
+ > trap_ne
+0cdf : d0fe > bne * ;failed not equal (non zero)
+ >
+0ce1 : 68 > pla ;load status
+0ce2 : 48 > pha
+ > cmp_flag 0
+0ce3 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0ce5 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ce7 : 28 > plp ;restore status
+
+0ce8 : 08 php
+0ce9 : 88 dey ;00
+0cea : 98 tya
+0ceb : 28 plp
+0cec : aa tax
+ tst_x 0,zero
+0ced : 08 > php ;save flags
+0cee : e000 > cpx #0 ;test result
+ > trap_ne
+0cf0 : d0fe > bne * ;failed not equal (non zero)
+ >
+0cf2 : 68 > pla ;load status
+0cf3 : 48 > pha
+ > cmp_flag zero
+0cf4 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0cf6 : d0fe > bne * ;failed not equal (non zero)
+ >
+0cf8 : 28 > plp ;restore status
+
+0cf9 : 08 php
+0cfa : 88 dey ;ff
+0cfb : 98 tya
+0cfc : 28 plp
+0cfd : aa tax
+ tst_x $ff,minus
+0cfe : 08 > php ;save flags
+0cff : e0ff > cpx #$ff ;test result
+ > trap_ne
+0d01 : d0fe > bne * ;failed not equal (non zero)
+ >
+0d03 : 68 > pla ;load status
+0d04 : 48 > pha
+ > cmp_flag minus
+0d05 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0d07 : d0fe > bne * ;failed not equal (non zero)
+ >
+0d09 : 28 > plp ;restore status
+
+ next_test
+0d0a : ad0002 > lda test_case ;previous test
+0d0d : c90d > cmp #test_num
+ > trap_ne ;test is out of sequence
+0d0f : d0fe > bne * ;failed not equal (non zero)
+ >
+000e = >test_num = test_num + 1
+0d11 : a90e > lda #test_num ;*** next tests' number
+0d13 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ;TSX sets NZ - TXS does not
+0d16 : a201 ldx #1 ;01
+ set_stat $ff
+ > load_flag $ff
+0d18 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0d1a : 48 > pha ;use stack to load status
+0d1b : 28 > plp
+
+0d1c : 9a txs
+0d1d : 08 php
+0d1e : ad0101 lda $101
+ cmp_flag $ff
+0d21 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0d23 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+0d25 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0d27 : 48 > pha ;use stack to load status
+0d28 : 28 > plp
+
+0d29 : 9a txs
+0d2a : 08 php
+0d2b : ad0101 lda $101
+ cmp_flag 0
+0d2e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0d30 : d0fe > bne * ;failed not equal (non zero)
+
+0d32 : ca dex ;00
+ set_stat $ff
+ > load_flag $ff
+0d33 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0d35 : 48 > pha ;use stack to load status
+0d36 : 28 > plp
+
+0d37 : 9a txs
+0d38 : 08 php
+0d39 : ad0001 lda $100
+ cmp_flag $ff
+0d3c : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0d3e : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+0d40 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0d42 : 48 > pha ;use stack to load status
+0d43 : 28 > plp
+
+0d44 : 9a txs
+0d45 : 08 php
+0d46 : ad0001 lda $100
+ cmp_flag 0
+0d49 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0d4b : d0fe > bne * ;failed not equal (non zero)
+
+0d4d : ca dex ;ff
+ set_stat $ff
+ > load_flag $ff
+0d4e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0d50 : 48 > pha ;use stack to load status
+0d51 : 28 > plp
+
+0d52 : 9a txs
+0d53 : 08 php
+0d54 : adff01 lda $1ff
+ cmp_flag $ff
+0d57 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0d59 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+0d5b : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0d5d : 48 > pha ;use stack to load status
+0d5e : 28 > plp
+
+0d5f : 9a txs
+0d60 : 08 php
+0d61 : adff01 lda $1ff
+ cmp_flag 0
+0d64 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+
+
+0d66 : a201 ldx #1
+0d68 : 9a txs ;sp=01
+ set_stat $ff
+ > load_flag $ff
+0d69 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0d6b : 48 > pha ;use stack to load status
+0d6c : 28 > plp
+
+0d6d : ba tsx ;clears Z, N
+0d6e : 08 php ;sp=00
+0d6f : e001 cpx #1
+ trap_ne
+0d71 : d0fe > bne * ;failed not equal (non zero)
+
+0d73 : ad0101 lda $101
+ cmp_flag $ff-minus-zero
+0d76 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0d78 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+0d7a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0d7c : 48 > pha ;use stack to load status
+0d7d : 28 > plp
+
+0d7e : ba tsx ;clears N, sets Z
+0d7f : 08 php ;sp=ff
+0d80 : e000 cpx #0
+ trap_ne
+0d82 : d0fe > bne * ;failed not equal (non zero)
+
+0d84 : ad0001 lda $100
+ cmp_flag $ff-minus
+0d87 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0d89 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+0d8b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0d8d : 48 > pha ;use stack to load status
+0d8e : 28 > plp
+
+0d8f : ba tsx ;clears N, sets Z
+0d90 : 08 php ;sp=fe
+0d91 : e0ff cpx #$ff
+ trap_ne
+0d93 : d0fe > bne * ;failed not equal (non zero)
+
+0d95 : adff01 lda $1ff
+ cmp_flag $ff-zero
+0d98 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0d9a : d0fe > bne * ;failed not equal (non zero)
+
+
+0d9c : a201 ldx #1
+0d9e : 9a txs ;sp=01
+ set_stat 0
+ > load_flag 0
+0d9f : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0da1 : 48 > pha ;use stack to load status
+0da2 : 28 > plp
+
+0da3 : ba tsx ;clears Z, N
+0da4 : 08 php ;sp=00
+0da5 : e001 cpx #1
+ trap_ne
+0da7 : d0fe > bne * ;failed not equal (non zero)
+
+0da9 : ad0101 lda $101
+ cmp_flag 0
+0dac : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0dae : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+0db0 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0db2 : 48 > pha ;use stack to load status
+0db3 : 28 > plp
+
+0db4 : ba tsx ;clears N, sets Z
+0db5 : 08 php ;sp=ff
+0db6 : e000 cpx #0
+ trap_ne
+0db8 : d0fe > bne * ;failed not equal (non zero)
+
+0dba : ad0001 lda $100
+ cmp_flag zero
+0dbd : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0dbf : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+0dc1 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0dc3 : 48 > pha ;use stack to load status
+0dc4 : 28 > plp
+
+0dc5 : ba tsx ;clears N, sets Z
+0dc6 : 08 php ;sp=fe
+0dc7 : e0ff cpx #$ff
+ trap_ne
+0dc9 : d0fe > bne * ;failed not equal (non zero)
+
+0dcb : adff01 lda $1ff
+ cmp_flag minus
+0dce : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+
+ trap_ne
+0dd0 : d0fe > bne * ;failed not equal (non zero)
+
+0dd2 : 68 pla ;sp=ff
+ next_test
+0dd3 : ad0002 > lda test_case ;previous test
+0dd6 : c90e > cmp #test_num
+ > trap_ne ;test is out of sequence
+0dd8 : d0fe > bne * ;failed not equal (non zero)
+ >
+000f = >test_num = test_num + 1
+0dda : a90f > lda #test_num ;*** next tests' number
+0ddc : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; testing index register load & store LDY LDX STY STX all addressing modes
+ ; LDX / STX - zp,y / abs,y
+0ddf : a003 ldy #3
+0de1 : tldx
+ set_stat 0
+ > load_flag 0
+0de1 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0de3 : 48 > pha ;use stack to load status
+0de4 : 28 > plp
+
+0de5 : b613 ldx zp1,y
+0de7 : 08 php ;test stores do not alter flags
+0de8 : 8a txa
+0de9 : 49c3 eor #$c3
+0deb : 28 plp
+0dec : 990302 sta abst,y
+0def : 08 php ;flags after load/store sequence
+0df0 : 49c3 eor #$c3
+0df2 : d90802 cmp abs1,y ;test result
+ trap_ne
+0df5 : d0fe > bne * ;failed not equal (non zero)
+
+0df7 : 68 pla ;load status
+ eor_flag 0
+0df8 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+0dfa : d90d02 cmp fLDx,y ;test flags
+ trap_ne
+0dfd : d0fe > bne * ;failed not equal (non zero)
+
+0dff : 88 dey
+0e00 : 10df bpl tldx
+
+0e02 : a003 ldy #3
+0e04 : tldx1
+ set_stat $ff
+ > load_flag $ff
+0e04 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0e06 : 48 > pha ;use stack to load status
+0e07 : 28 > plp
+
+0e08 : b613 ldx zp1,y
+0e0a : 08 php ;test stores do not alter flags
+0e0b : 8a txa
+0e0c : 49c3 eor #$c3
+0e0e : 28 plp
+0e0f : 990302 sta abst,y
+0e12 : 08 php ;flags after load/store sequence
+0e13 : 49c3 eor #$c3
+0e15 : d90802 cmp abs1,y ;test result
+ trap_ne
+0e18 : d0fe > bne * ;failed not equal (non zero)
+
+0e1a : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+0e1b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+0e1d : d90d02 cmp fLDx,y ;test flags
+ trap_ne
+0e20 : d0fe > bne * ;failed not equal (non zero)
+
+0e22 : 88 dey
+0e23 : 10df bpl tldx1
+
+0e25 : a003 ldy #3
+0e27 : tldx2
+ set_stat 0
+ > load_flag 0
+0e27 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0e29 : 48 > pha ;use stack to load status
+0e2a : 28 > plp
+
+0e2b : be0802 ldx abs1,y
+0e2e : 08 php ;test stores do not alter flags
+0e2f : 8a txa
+0e30 : 49c3 eor #$c3
+0e32 : aa tax
+0e33 : 28 plp
+0e34 : 960c stx zpt,y
+0e36 : 08 php ;flags after load/store sequence
+0e37 : 49c3 eor #$c3
+0e39 : d91300 cmp zp1,y ;test result
+ trap_ne
+0e3c : d0fe > bne * ;failed not equal (non zero)
+
+0e3e : 68 pla ;load status
+ eor_flag 0
+0e3f : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+0e41 : d90d02 cmp fLDx,y ;test flags
+ trap_ne
+0e44 : d0fe > bne * ;failed not equal (non zero)
+
+0e46 : 88 dey
+0e47 : 10de bpl tldx2
+
+0e49 : a003 ldy #3
+0e4b : tldx3
+ set_stat $ff
+ > load_flag $ff
+0e4b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0e4d : 48 > pha ;use stack to load status
+0e4e : 28 > plp
+
+0e4f : be0802 ldx abs1,y
+0e52 : 08 php ;test stores do not alter flags
+0e53 : 8a txa
+0e54 : 49c3 eor #$c3
+0e56 : aa tax
+0e57 : 28 plp
+0e58 : 960c stx zpt,y
+0e5a : 08 php ;flags after load/store sequence
+0e5b : 49c3 eor #$c3
+0e5d : d91300 cmp zp1,y ;test result
+ trap_ne
+0e60 : d0fe > bne * ;failed not equal (non zero)
+
+0e62 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+0e63 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+0e65 : d90d02 cmp fLDx,y ;test flags
+ trap_ne
+0e68 : d0fe > bne * ;failed not equal (non zero)
+
+0e6a : 88 dey
+0e6b : 10de bpl tldx3
+
+0e6d : a003 ldy #3 ;testing store result
+0e6f : a200 ldx #0
+0e71 : b90c00 tstx lda zpt,y
+0e74 : 49c3 eor #$c3
+0e76 : d91300 cmp zp1,y
+ trap_ne ;store to zp data
+0e79 : d0fe > bne * ;failed not equal (non zero)
+
+0e7b : 960c stx zpt,y ;clear
+0e7d : b90302 lda abst,y
+0e80 : 49c3 eor #$c3
+0e82 : d90802 cmp abs1,y
+ trap_ne ;store to abs data
+0e85 : d0fe > bne * ;failed not equal (non zero)
+
+0e87 : 8a txa
+0e88 : 990302 sta abst,y ;clear
+0e8b : 88 dey
+0e8c : 10e3 bpl tstx
+ next_test
+0e8e : ad0002 > lda test_case ;previous test
+0e91 : c90f > cmp #test_num
+ > trap_ne ;test is out of sequence
+0e93 : d0fe > bne * ;failed not equal (non zero)
+ >
+0010 = >test_num = test_num + 1
+0e95 : a910 > lda #test_num ;*** next tests' number
+0e97 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; indexed wraparound test (only zp should wrap)
+0e9a : a0fd ldy #3+$fa
+0e9c : b619 tldx4 ldx zp1-$fa&$ff,y ;wrap on indexed zp
+0e9e : 8a txa
+0e9f : 990901 sta abst-$fa,y ;no STX abs,y!
+0ea2 : 88 dey
+0ea3 : c0fa cpy #$fa
+0ea5 : b0f5 bcs tldx4
+0ea7 : a0fd ldy #3+$fa
+0ea9 : be0e01 tldx5 ldx abs1-$fa,y ;no wrap on indexed abs
+0eac : 9612 stx zpt-$fa&$ff,y
+0eae : 88 dey
+0eaf : c0fa cpy #$fa
+0eb1 : b0f6 bcs tldx5
+0eb3 : a003 ldy #3 ;testing wraparound result
+0eb5 : a200 ldx #0
+0eb7 : b90c00 tstx1 lda zpt,y
+0eba : d91300 cmp zp1,y
+ trap_ne ;store to zp data
+0ebd : d0fe > bne * ;failed not equal (non zero)
+
+0ebf : 960c stx zpt,y ;clear
+0ec1 : b90302 lda abst,y
+0ec4 : d90802 cmp abs1,y
+ trap_ne ;store to abs data
+0ec7 : d0fe > bne * ;failed not equal (non zero)
+
+0ec9 : 8a txa
+0eca : 990302 sta abst,y ;clear
+0ecd : 88 dey
+0ece : 10e7 bpl tstx1
+ next_test
+0ed0 : ad0002 > lda test_case ;previous test
+0ed3 : c910 > cmp #test_num
+ > trap_ne ;test is out of sequence
+0ed5 : d0fe > bne * ;failed not equal (non zero)
+ >
+0011 = >test_num = test_num + 1
+0ed7 : a911 > lda #test_num ;*** next tests' number
+0ed9 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; LDY / STY - zp,x / abs,x
+0edc : a203 ldx #3
+0ede : tldy
+ set_stat 0
+ > load_flag 0
+0ede : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0ee0 : 48 > pha ;use stack to load status
+0ee1 : 28 > plp
+
+0ee2 : b413 ldy zp1,x
+0ee4 : 08 php ;test stores do not alter flags
+0ee5 : 98 tya
+0ee6 : 49c3 eor #$c3
+0ee8 : 28 plp
+0ee9 : 9d0302 sta abst,x
+0eec : 08 php ;flags after load/store sequence
+0eed : 49c3 eor #$c3
+0eef : dd0802 cmp abs1,x ;test result
+ trap_ne
+0ef2 : d0fe > bne * ;failed not equal (non zero)
+
+0ef4 : 68 pla ;load status
+ eor_flag 0
+0ef5 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+0ef7 : dd0d02 cmp fLDx,x ;test flags
+ trap_ne
+0efa : d0fe > bne * ;failed not equal (non zero)
+
+0efc : ca dex
+0efd : 10df bpl tldy
+
+0eff : a203 ldx #3
+0f01 : tldy1
+ set_stat $ff
+ > load_flag $ff
+0f01 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0f03 : 48 > pha ;use stack to load status
+0f04 : 28 > plp
+
+0f05 : b413 ldy zp1,x
+0f07 : 08 php ;test stores do not alter flags
+0f08 : 98 tya
+0f09 : 49c3 eor #$c3
+0f0b : 28 plp
+0f0c : 9d0302 sta abst,x
+0f0f : 08 php ;flags after load/store sequence
+0f10 : 49c3 eor #$c3
+0f12 : dd0802 cmp abs1,x ;test result
+ trap_ne
+0f15 : d0fe > bne * ;failed not equal (non zero)
+
+0f17 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+0f18 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+0f1a : dd0d02 cmp fLDx,x ;test flags
+ trap_ne
+0f1d : d0fe > bne * ;failed not equal (non zero)
+
+0f1f : ca dex
+0f20 : 10df bpl tldy1
+
+0f22 : a203 ldx #3
+0f24 : tldy2
+ set_stat 0
+ > load_flag 0
+0f24 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0f26 : 48 > pha ;use stack to load status
+0f27 : 28 > plp
+
+0f28 : bc0802 ldy abs1,x
+0f2b : 08 php ;test stores do not alter flags
+0f2c : 98 tya
+0f2d : 49c3 eor #$c3
+0f2f : a8 tay
+0f30 : 28 plp
+0f31 : 940c sty zpt,x
+0f33 : 08 php ;flags after load/store sequence
+0f34 : 49c3 eor #$c3
+0f36 : d513 cmp zp1,x ;test result
+ trap_ne
+0f38 : d0fe > bne * ;failed not equal (non zero)
+
+0f3a : 68 pla ;load status
+ eor_flag 0
+0f3b : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+0f3d : dd0d02 cmp fLDx,x ;test flags
+ trap_ne
+0f40 : d0fe > bne * ;failed not equal (non zero)
+
+0f42 : ca dex
+0f43 : 10df bpl tldy2
+
+0f45 : a203 ldx #3
+0f47 : tldy3
+ set_stat $ff
+ > load_flag $ff
+0f47 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0f49 : 48 > pha ;use stack to load status
+0f4a : 28 > plp
+
+0f4b : bc0802 ldy abs1,x
+0f4e : 08 php ;test stores do not alter flags
+0f4f : 98 tya
+0f50 : 49c3 eor #$c3
+0f52 : a8 tay
+0f53 : 28 plp
+0f54 : 940c sty zpt,x
+0f56 : 08 php ;flags after load/store sequence
+0f57 : 49c3 eor #$c3
+0f59 : d513 cmp zp1,x ;test result
+ trap_ne
+0f5b : d0fe > bne * ;failed not equal (non zero)
+
+0f5d : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+0f5e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+0f60 : dd0d02 cmp fLDx,x ;test flags
+ trap_ne
+0f63 : d0fe > bne * ;failed not equal (non zero)
+
+0f65 : ca dex
+0f66 : 10df bpl tldy3
+
+0f68 : a203 ldx #3 ;testing store result
+0f6a : a000 ldy #0
+0f6c : b50c tsty lda zpt,x
+0f6e : 49c3 eor #$c3
+0f70 : d513 cmp zp1,x
+ trap_ne ;store to zp,x data
+0f72 : d0fe > bne * ;failed not equal (non zero)
+
+0f74 : 940c sty zpt,x ;clear
+0f76 : bd0302 lda abst,x
+0f79 : 49c3 eor #$c3
+0f7b : dd0802 cmp abs1,x
+ trap_ne ;store to abs,x data
+0f7e : d0fe > bne * ;failed not equal (non zero)
+
+0f80 : 8a txa
+0f81 : 9d0302 sta abst,x ;clear
+0f84 : ca dex
+0f85 : 10e5 bpl tsty
+ next_test
+0f87 : ad0002 > lda test_case ;previous test
+0f8a : c911 > cmp #test_num
+ > trap_ne ;test is out of sequence
+0f8c : d0fe > bne * ;failed not equal (non zero)
+ >
+0012 = >test_num = test_num + 1
+0f8e : a912 > lda #test_num ;*** next tests' number
+0f90 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; indexed wraparound test (only zp should wrap)
+0f93 : a2fd ldx #3+$fa
+0f95 : b419 tldy4 ldy zp1-$fa&$ff,x ;wrap on indexed zp
+0f97 : 98 tya
+0f98 : 9d0901 sta abst-$fa,x ;no STX abs,x!
+0f9b : ca dex
+0f9c : e0fa cpx #$fa
+0f9e : b0f5 bcs tldy4
+0fa0 : a2fd ldx #3+$fa
+0fa2 : bc0e01 tldy5 ldy abs1-$fa,x ;no wrap on indexed abs
+0fa5 : 9412 sty zpt-$fa&$ff,x
+0fa7 : ca dex
+0fa8 : e0fa cpx #$fa
+0faa : b0f6 bcs tldy5
+0fac : a203 ldx #3 ;testing wraparound result
+0fae : a000 ldy #0
+0fb0 : b50c tsty1 lda zpt,x
+0fb2 : d513 cmp zp1,x
+ trap_ne ;store to zp,x data
+0fb4 : d0fe > bne * ;failed not equal (non zero)
+
+0fb6 : 940c sty zpt,x ;clear
+0fb8 : bd0302 lda abst,x
+0fbb : dd0802 cmp abs1,x
+ trap_ne ;store to abs,x data
+0fbe : d0fe > bne * ;failed not equal (non zero)
+
+0fc0 : 8a txa
+0fc1 : 9d0302 sta abst,x ;clear
+0fc4 : ca dex
+0fc5 : 10e9 bpl tsty1
+ next_test
+0fc7 : ad0002 > lda test_case ;previous test
+0fca : c912 > cmp #test_num
+ > trap_ne ;test is out of sequence
+0fcc : d0fe > bne * ;failed not equal (non zero)
+ >
+0013 = >test_num = test_num + 1
+0fce : a913 > lda #test_num ;*** next tests' number
+0fd0 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; LDX / STX - zp / abs / #
+ set_stat 0
+ > load_flag 0
+0fd3 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0fd5 : 48 > pha ;use stack to load status
+0fd6 : 28 > plp
+
+0fd7 : a613 ldx zp1
+0fd9 : 08 php ;test stores do not alter flags
+0fda : 8a txa
+0fdb : 49c3 eor #$c3
+0fdd : aa tax
+0fde : 28 plp
+0fdf : 8e0302 stx abst
+0fe2 : 08 php ;flags after load/store sequence
+0fe3 : 49c3 eor #$c3
+0fe5 : aa tax
+0fe6 : e0c3 cpx #$c3 ;test result
+ trap_ne
+0fe8 : d0fe > bne * ;failed not equal (non zero)
+
+0fea : 68 pla ;load status
+ eor_flag 0
+0feb : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+0fed : cd0d02 cmp fLDx ;test flags
+ trap_ne
+0ff0 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+0ff2 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0ff4 : 48 > pha ;use stack to load status
+0ff5 : 28 > plp
+
+0ff6 : a614 ldx zp1+1
+0ff8 : 08 php ;test stores do not alter flags
+0ff9 : 8a txa
+0ffa : 49c3 eor #$c3
+0ffc : aa tax
+0ffd : 28 plp
+0ffe : 8e0402 stx abst+1
+1001 : 08 php ;flags after load/store sequence
+1002 : 49c3 eor #$c3
+1004 : aa tax
+1005 : e082 cpx #$82 ;test result
+ trap_ne
+1007 : d0fe > bne * ;failed not equal (non zero)
+
+1009 : 68 pla ;load status
+ eor_flag 0
+100a : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+100c : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+100f : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1011 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1013 : 48 > pha ;use stack to load status
+1014 : 28 > plp
+
+1015 : a615 ldx zp1+2
+1017 : 08 php ;test stores do not alter flags
+1018 : 8a txa
+1019 : 49c3 eor #$c3
+101b : aa tax
+101c : 28 plp
+101d : 8e0502 stx abst+2
+1020 : 08 php ;flags after load/store sequence
+1021 : 49c3 eor #$c3
+1023 : aa tax
+1024 : e041 cpx #$41 ;test result
+ trap_ne
+1026 : d0fe > bne * ;failed not equal (non zero)
+
+1028 : 68 pla ;load status
+ eor_flag 0
+1029 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+102b : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+102e : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1030 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1032 : 48 > pha ;use stack to load status
+1033 : 28 > plp
+
+1034 : a616 ldx zp1+3
+1036 : 08 php ;test stores do not alter flags
+1037 : 8a txa
+1038 : 49c3 eor #$c3
+103a : aa tax
+103b : 28 plp
+103c : 8e0602 stx abst+3
+103f : 08 php ;flags after load/store sequence
+1040 : 49c3 eor #$c3
+1042 : aa tax
+1043 : e000 cpx #0 ;test result
+ trap_ne
+1045 : d0fe > bne * ;failed not equal (non zero)
+
+1047 : 68 pla ;load status
+ eor_flag 0
+1048 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+104a : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+104d : d0fe > bne * ;failed not equal (non zero)
+
+
+ set_stat $ff
+ > load_flag $ff
+104f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1051 : 48 > pha ;use stack to load status
+1052 : 28 > plp
+
+1053 : a613 ldx zp1
+1055 : 08 php ;test stores do not alter flags
+1056 : 8a txa
+1057 : 49c3 eor #$c3
+1059 : aa tax
+105a : 28 plp
+105b : 8e0302 stx abst
+105e : 08 php ;flags after load/store sequence
+105f : 49c3 eor #$c3
+1061 : aa tax
+1062 : e0c3 cpx #$c3 ;test result
+ trap_ne ;
+1064 : d0fe > bne * ;failed not equal (non zero)
+
+1066 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1067 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1069 : cd0d02 cmp fLDx ;test flags
+ trap_ne
+106c : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+106e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1070 : 48 > pha ;use stack to load status
+1071 : 28 > plp
+
+1072 : a614 ldx zp1+1
+1074 : 08 php ;test stores do not alter flags
+1075 : 8a txa
+1076 : 49c3 eor #$c3
+1078 : aa tax
+1079 : 28 plp
+107a : 8e0402 stx abst+1
+107d : 08 php ;flags after load/store sequence
+107e : 49c3 eor #$c3
+1080 : aa tax
+1081 : e082 cpx #$82 ;test result
+ trap_ne
+1083 : d0fe > bne * ;failed not equal (non zero)
+
+1085 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1086 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1088 : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+108b : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+108d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+108f : 48 > pha ;use stack to load status
+1090 : 28 > plp
+
+1091 : a615 ldx zp1+2
+1093 : 08 php ;test stores do not alter flags
+1094 : 8a txa
+1095 : 49c3 eor #$c3
+1097 : aa tax
+1098 : 28 plp
+1099 : 8e0502 stx abst+2
+109c : 08 php ;flags after load/store sequence
+109d : 49c3 eor #$c3
+109f : aa tax
+10a0 : e041 cpx #$41 ;test result
+ trap_ne ;
+10a2 : d0fe > bne * ;failed not equal (non zero)
+
+10a4 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+10a5 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+10a7 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+10aa : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+10ac : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+10ae : 48 > pha ;use stack to load status
+10af : 28 > plp
+
+10b0 : a616 ldx zp1+3
+10b2 : 08 php ;test stores do not alter flags
+10b3 : 8a txa
+10b4 : 49c3 eor #$c3
+10b6 : aa tax
+10b7 : 28 plp
+10b8 : 8e0602 stx abst+3
+10bb : 08 php ;flags after load/store sequence
+10bc : 49c3 eor #$c3
+10be : aa tax
+10bf : e000 cpx #0 ;test result
+ trap_ne
+10c1 : d0fe > bne * ;failed not equal (non zero)
+
+10c3 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+10c4 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+10c6 : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+10c9 : d0fe > bne * ;failed not equal (non zero)
+
+
+ set_stat 0
+ > load_flag 0
+10cb : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+10cd : 48 > pha ;use stack to load status
+10ce : 28 > plp
+
+10cf : ae0802 ldx abs1
+10d2 : 08 php ;test stores do not alter flags
+10d3 : 8a txa
+10d4 : 49c3 eor #$c3
+10d6 : aa tax
+10d7 : 28 plp
+10d8 : 860c stx zpt
+10da : 08 php ;flags after load/store sequence
+10db : 49c3 eor #$c3
+10dd : c513 cmp zp1 ;test result
+ trap_ne
+10df : d0fe > bne * ;failed not equal (non zero)
+
+10e1 : 68 pla ;load status
+ eor_flag 0
+10e2 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+10e4 : cd0d02 cmp fLDx ;test flags
+ trap_ne
+10e7 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+10e9 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+10eb : 48 > pha ;use stack to load status
+10ec : 28 > plp
+
+10ed : ae0902 ldx abs1+1
+10f0 : 08 php ;test stores do not alter flags
+10f1 : 8a txa
+10f2 : 49c3 eor #$c3
+10f4 : aa tax
+10f5 : 28 plp
+10f6 : 860d stx zpt+1
+10f8 : 08 php ;flags after load/store sequence
+10f9 : 49c3 eor #$c3
+10fb : c514 cmp zp1+1 ;test result
+ trap_ne
+10fd : d0fe > bne * ;failed not equal (non zero)
+
+10ff : 68 pla ;load status
+ eor_flag 0
+1100 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1102 : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+1105 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1107 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1109 : 48 > pha ;use stack to load status
+110a : 28 > plp
+
+110b : ae0a02 ldx abs1+2
+110e : 08 php ;test stores do not alter flags
+110f : 8a txa
+1110 : 49c3 eor #$c3
+1112 : aa tax
+1113 : 28 plp
+1114 : 860e stx zpt+2
+1116 : 08 php ;flags after load/store sequence
+1117 : 49c3 eor #$c3
+1119 : c515 cmp zp1+2 ;test result
+ trap_ne
+111b : d0fe > bne * ;failed not equal (non zero)
+
+111d : 68 pla ;load status
+ eor_flag 0
+111e : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1120 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+1123 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1125 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1127 : 48 > pha ;use stack to load status
+1128 : 28 > plp
+
+1129 : ae0b02 ldx abs1+3
+112c : 08 php ;test stores do not alter flags
+112d : 8a txa
+112e : 49c3 eor #$c3
+1130 : aa tax
+1131 : 28 plp
+1132 : 860f stx zpt+3
+1134 : 08 php ;flags after load/store sequence
+1135 : 49c3 eor #$c3
+1137 : c516 cmp zp1+3 ;test result
+ trap_ne
+1139 : d0fe > bne * ;failed not equal (non zero)
+
+113b : 68 pla ;load status
+ eor_flag 0
+113c : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+113e : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+1141 : d0fe > bne * ;failed not equal (non zero)
+
+
+ set_stat $ff
+ > load_flag $ff
+1143 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1145 : 48 > pha ;use stack to load status
+1146 : 28 > plp
+
+1147 : ae0802 ldx abs1
+114a : 08 php ;test stores do not alter flags
+114b : 8a txa
+114c : 49c3 eor #$c3
+114e : aa tax
+114f : 28 plp
+1150 : 860c stx zpt
+1152 : 08 php ;flags after load/store sequence
+1153 : 49c3 eor #$c3
+1155 : aa tax
+1156 : e413 cpx zp1 ;test result
+ trap_ne
+1158 : d0fe > bne * ;failed not equal (non zero)
+
+115a : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+115b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+115d : cd0d02 cmp fLDx ;test flags
+ trap_ne
+1160 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+1162 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1164 : 48 > pha ;use stack to load status
+1165 : 28 > plp
+
+1166 : ae0902 ldx abs1+1
+1169 : 08 php ;test stores do not alter flags
+116a : 8a txa
+116b : 49c3 eor #$c3
+116d : aa tax
+116e : 28 plp
+116f : 860d stx zpt+1
+1171 : 08 php ;flags after load/store sequence
+1172 : 49c3 eor #$c3
+1174 : aa tax
+1175 : e414 cpx zp1+1 ;test result
+ trap_ne
+1177 : d0fe > bne * ;failed not equal (non zero)
+
+1179 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+117a : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+117c : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+117f : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+1181 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1183 : 48 > pha ;use stack to load status
+1184 : 28 > plp
+
+1185 : ae0a02 ldx abs1+2
+1188 : 08 php ;test stores do not alter flags
+1189 : 8a txa
+118a : 49c3 eor #$c3
+118c : aa tax
+118d : 28 plp
+118e : 860e stx zpt+2
+1190 : 08 php ;flags after load/store sequence
+1191 : 49c3 eor #$c3
+1193 : aa tax
+1194 : e415 cpx zp1+2 ;test result
+ trap_ne
+1196 : d0fe > bne * ;failed not equal (non zero)
+
+1198 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1199 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+119b : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+119e : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+11a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+11a2 : 48 > pha ;use stack to load status
+11a3 : 28 > plp
+
+11a4 : ae0b02 ldx abs1+3
+11a7 : 08 php ;test stores do not alter flags
+11a8 : 8a txa
+11a9 : 49c3 eor #$c3
+11ab : aa tax
+11ac : 28 plp
+11ad : 860f stx zpt+3
+11af : 08 php ;flags after load/store sequence
+11b0 : 49c3 eor #$c3
+11b2 : aa tax
+11b3 : e416 cpx zp1+3 ;test result
+ trap_ne
+11b5 : d0fe > bne * ;failed not equal (non zero)
+
+11b7 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+11b8 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+11ba : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+11bd : d0fe > bne * ;failed not equal (non zero)
+
+
+ set_stat 0
+ > load_flag 0
+11bf : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+11c1 : 48 > pha ;use stack to load status
+11c2 : 28 > plp
+
+11c3 : a2c3 ldx #$c3
+11c5 : 08 php
+11c6 : ec0802 cpx abs1 ;test result
+ trap_ne
+11c9 : d0fe > bne * ;failed not equal (non zero)
+
+11cb : 68 pla ;load status
+ eor_flag 0
+11cc : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+11ce : cd0d02 cmp fLDx ;test flags
+ trap_ne
+11d1 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+11d3 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+11d5 : 48 > pha ;use stack to load status
+11d6 : 28 > plp
+
+11d7 : a282 ldx #$82
+11d9 : 08 php
+11da : ec0902 cpx abs1+1 ;test result
+ trap_ne
+11dd : d0fe > bne * ;failed not equal (non zero)
+
+11df : 68 pla ;load status
+ eor_flag 0
+11e0 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+11e2 : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+11e5 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+11e7 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+11e9 : 48 > pha ;use stack to load status
+11ea : 28 > plp
+
+11eb : a241 ldx #$41
+11ed : 08 php
+11ee : ec0a02 cpx abs1+2 ;test result
+ trap_ne
+11f1 : d0fe > bne * ;failed not equal (non zero)
+
+11f3 : 68 pla ;load status
+ eor_flag 0
+11f4 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+11f6 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+11f9 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+11fb : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+11fd : 48 > pha ;use stack to load status
+11fe : 28 > plp
+
+11ff : a200 ldx #0
+1201 : 08 php
+1202 : ec0b02 cpx abs1+3 ;test result
+ trap_ne
+1205 : d0fe > bne * ;failed not equal (non zero)
+
+1207 : 68 pla ;load status
+ eor_flag 0
+1208 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+120a : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+120d : d0fe > bne * ;failed not equal (non zero)
+
+
+ set_stat $ff
+ > load_flag $ff
+120f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1211 : 48 > pha ;use stack to load status
+1212 : 28 > plp
+
+1213 : a2c3 ldx #$c3
+1215 : 08 php
+1216 : ec0802 cpx abs1 ;test result
+ trap_ne
+1219 : d0fe > bne * ;failed not equal (non zero)
+
+121b : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+121c : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+121e : cd0d02 cmp fLDx ;test flags
+ trap_ne
+1221 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+1223 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1225 : 48 > pha ;use stack to load status
+1226 : 28 > plp
+
+1227 : a282 ldx #$82
+1229 : 08 php
+122a : ec0902 cpx abs1+1 ;test result
+ trap_ne
+122d : d0fe > bne * ;failed not equal (non zero)
+
+122f : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1230 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1232 : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+1235 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+1237 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1239 : 48 > pha ;use stack to load status
+123a : 28 > plp
+
+123b : a241 ldx #$41
+123d : 08 php
+123e : ec0a02 cpx abs1+2 ;test result
+ trap_ne
+1241 : d0fe > bne * ;failed not equal (non zero)
+
+1243 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1244 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1246 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+1249 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+124b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+124d : 48 > pha ;use stack to load status
+124e : 28 > plp
+
+124f : a200 ldx #0
+1251 : 08 php
+1252 : ec0b02 cpx abs1+3 ;test result
+ trap_ne
+1255 : d0fe > bne * ;failed not equal (non zero)
+
+1257 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1258 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+125a : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+125d : d0fe > bne * ;failed not equal (non zero)
+
+
+125f : a200 ldx #0
+1261 : a50c lda zpt
+1263 : 49c3 eor #$c3
+1265 : c513 cmp zp1
+ trap_ne ;store to zp data
+1267 : d0fe > bne * ;failed not equal (non zero)
+
+1269 : 860c stx zpt ;clear
+126b : ad0302 lda abst
+126e : 49c3 eor #$c3
+1270 : cd0802 cmp abs1
+ trap_ne ;store to abs data
+1273 : d0fe > bne * ;failed not equal (non zero)
+
+1275 : 8e0302 stx abst ;clear
+1278 : a50d lda zpt+1
+127a : 49c3 eor #$c3
+127c : c514 cmp zp1+1
+ trap_ne ;store to zp data
+127e : d0fe > bne * ;failed not equal (non zero)
+
+1280 : 860d stx zpt+1 ;clear
+1282 : ad0402 lda abst+1
+1285 : 49c3 eor #$c3
+1287 : cd0902 cmp abs1+1
+ trap_ne ;store to abs data
+128a : d0fe > bne * ;failed not equal (non zero)
+
+128c : 8e0402 stx abst+1 ;clear
+128f : a50e lda zpt+2
+1291 : 49c3 eor #$c3
+1293 : c515 cmp zp1+2
+ trap_ne ;store to zp data
+1295 : d0fe > bne * ;failed not equal (non zero)
+
+1297 : 860e stx zpt+2 ;clear
+1299 : ad0502 lda abst+2
+129c : 49c3 eor #$c3
+129e : cd0a02 cmp abs1+2
+ trap_ne ;store to abs data
+12a1 : d0fe > bne * ;failed not equal (non zero)
+
+12a3 : 8e0502 stx abst+2 ;clear
+12a6 : a50f lda zpt+3
+12a8 : 49c3 eor #$c3
+12aa : c516 cmp zp1+3
+ trap_ne ;store to zp data
+12ac : d0fe > bne * ;failed not equal (non zero)
+
+12ae : 860f stx zpt+3 ;clear
+12b0 : ad0602 lda abst+3
+12b3 : 49c3 eor #$c3
+12b5 : cd0b02 cmp abs1+3
+ trap_ne ;store to abs data
+12b8 : d0fe > bne * ;failed not equal (non zero)
+
+12ba : 8e0602 stx abst+3 ;clear
+ next_test
+12bd : ad0002 > lda test_case ;previous test
+12c0 : c913 > cmp #test_num
+ > trap_ne ;test is out of sequence
+12c2 : d0fe > bne * ;failed not equal (non zero)
+ >
+0014 = >test_num = test_num + 1
+12c4 : a914 > lda #test_num ;*** next tests' number
+12c6 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; LDY / STY - zp / abs / #
+ set_stat 0
+ > load_flag 0
+12c9 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+12cb : 48 > pha ;use stack to load status
+12cc : 28 > plp
+
+12cd : a413 ldy zp1
+12cf : 08 php ;test stores do not alter flags
+12d0 : 98 tya
+12d1 : 49c3 eor #$c3
+12d3 : a8 tay
+12d4 : 28 plp
+12d5 : 8c0302 sty abst
+12d8 : 08 php ;flags after load/store sequence
+12d9 : 49c3 eor #$c3
+12db : a8 tay
+12dc : c0c3 cpy #$c3 ;test result
+ trap_ne
+12de : d0fe > bne * ;failed not equal (non zero)
+
+12e0 : 68 pla ;load status
+ eor_flag 0
+12e1 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+12e3 : cd0d02 cmp fLDx ;test flags
+ trap_ne
+12e6 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+12e8 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+12ea : 48 > pha ;use stack to load status
+12eb : 28 > plp
+
+12ec : a414 ldy zp1+1
+12ee : 08 php ;test stores do not alter flags
+12ef : 98 tya
+12f0 : 49c3 eor #$c3
+12f2 : a8 tay
+12f3 : 28 plp
+12f4 : 8c0402 sty abst+1
+12f7 : 08 php ;flags after load/store sequence
+12f8 : 49c3 eor #$c3
+12fa : a8 tay
+12fb : c082 cpy #$82 ;test result
+ trap_ne
+12fd : d0fe > bne * ;failed not equal (non zero)
+
+12ff : 68 pla ;load status
+ eor_flag 0
+1300 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1302 : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+1305 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1307 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1309 : 48 > pha ;use stack to load status
+130a : 28 > plp
+
+130b : a415 ldy zp1+2
+130d : 08 php ;test stores do not alter flags
+130e : 98 tya
+130f : 49c3 eor #$c3
+1311 : a8 tay
+1312 : 28 plp
+1313 : 8c0502 sty abst+2
+1316 : 08 php ;flags after load/store sequence
+1317 : 49c3 eor #$c3
+1319 : a8 tay
+131a : c041 cpy #$41 ;test result
+ trap_ne
+131c : d0fe > bne * ;failed not equal (non zero)
+
+131e : 68 pla ;load status
+ eor_flag 0
+131f : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1321 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+1324 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1326 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1328 : 48 > pha ;use stack to load status
+1329 : 28 > plp
+
+132a : a416 ldy zp1+3
+132c : 08 php ;test stores do not alter flags
+132d : 98 tya
+132e : 49c3 eor #$c3
+1330 : a8 tay
+1331 : 28 plp
+1332 : 8c0602 sty abst+3
+1335 : 08 php ;flags after load/store sequence
+1336 : 49c3 eor #$c3
+1338 : a8 tay
+1339 : c000 cpy #0 ;test result
+ trap_ne
+133b : d0fe > bne * ;failed not equal (non zero)
+
+133d : 68 pla ;load status
+ eor_flag 0
+133e : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1340 : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+1343 : d0fe > bne * ;failed not equal (non zero)
+
+
+ set_stat $ff
+ > load_flag $ff
+1345 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1347 : 48 > pha ;use stack to load status
+1348 : 28 > plp
+
+1349 : a413 ldy zp1
+134b : 08 php ;test stores do not alter flags
+134c : 98 tya
+134d : 49c3 eor #$c3
+134f : a8 tay
+1350 : 28 plp
+1351 : 8c0302 sty abst
+1354 : 08 php ;flags after load/store sequence
+1355 : 49c3 eor #$c3
+1357 : a8 tay
+1358 : c0c3 cpy #$c3 ;test result
+ trap_ne
+135a : d0fe > bne * ;failed not equal (non zero)
+
+135c : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+135d : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+135f : cd0d02 cmp fLDx ;test flags
+ trap_ne
+1362 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+1364 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1366 : 48 > pha ;use stack to load status
+1367 : 28 > plp
+
+1368 : a414 ldy zp1+1
+136a : 08 php ;test stores do not alter flags
+136b : 98 tya
+136c : 49c3 eor #$c3
+136e : a8 tay
+136f : 28 plp
+1370 : 8c0402 sty abst+1
+1373 : 08 php ;flags after load/store sequence
+1374 : 49c3 eor #$c3
+1376 : a8 tay
+1377 : c082 cpy #$82 ;test result
+ trap_ne
+1379 : d0fe > bne * ;failed not equal (non zero)
+
+137b : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+137c : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+137e : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+1381 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+1383 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1385 : 48 > pha ;use stack to load status
+1386 : 28 > plp
+
+1387 : a415 ldy zp1+2
+1389 : 08 php ;test stores do not alter flags
+138a : 98 tya
+138b : 49c3 eor #$c3
+138d : a8 tay
+138e : 28 plp
+138f : 8c0502 sty abst+2
+1392 : 08 php ;flags after load/store sequence
+1393 : 49c3 eor #$c3
+1395 : a8 tay
+1396 : c041 cpy #$41 ;test result
+ trap_ne
+1398 : d0fe > bne * ;failed not equal (non zero)
+
+139a : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+139b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+139d : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+13a0 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+13a2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+13a4 : 48 > pha ;use stack to load status
+13a5 : 28 > plp
+
+13a6 : a416 ldy zp1+3
+13a8 : 08 php ;test stores do not alter flags
+13a9 : 98 tya
+13aa : 49c3 eor #$c3
+13ac : a8 tay
+13ad : 28 plp
+13ae : 8c0602 sty abst+3
+13b1 : 08 php ;flags after load/store sequence
+13b2 : 49c3 eor #$c3
+13b4 : a8 tay
+13b5 : c000 cpy #0 ;test result
+ trap_ne
+13b7 : d0fe > bne * ;failed not equal (non zero)
+
+13b9 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+13ba : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+13bc : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+13bf : d0fe > bne * ;failed not equal (non zero)
+
+
+ set_stat 0
+ > load_flag 0
+13c1 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+13c3 : 48 > pha ;use stack to load status
+13c4 : 28 > plp
+
+13c5 : ac0802 ldy abs1
+13c8 : 08 php ;test stores do not alter flags
+13c9 : 98 tya
+13ca : 49c3 eor #$c3
+13cc : a8 tay
+13cd : 28 plp
+13ce : 840c sty zpt
+13d0 : 08 php ;flags after load/store sequence
+13d1 : 49c3 eor #$c3
+13d3 : a8 tay
+13d4 : c413 cpy zp1 ;test result
+ trap_ne
+13d6 : d0fe > bne * ;failed not equal (non zero)
+
+13d8 : 68 pla ;load status
+ eor_flag 0
+13d9 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+13db : cd0d02 cmp fLDx ;test flags
+ trap_ne
+13de : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+13e0 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+13e2 : 48 > pha ;use stack to load status
+13e3 : 28 > plp
+
+13e4 : ac0902 ldy abs1+1
+13e7 : 08 php ;test stores do not alter flags
+13e8 : 98 tya
+13e9 : 49c3 eor #$c3
+13eb : a8 tay
+13ec : 28 plp
+13ed : 840d sty zpt+1
+13ef : 08 php ;flags after load/store sequence
+13f0 : 49c3 eor #$c3
+13f2 : a8 tay
+13f3 : c414 cpy zp1+1 ;test result
+ trap_ne
+13f5 : d0fe > bne * ;failed not equal (non zero)
+
+13f7 : 68 pla ;load status
+ eor_flag 0
+13f8 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+13fa : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+13fd : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+13ff : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1401 : 48 > pha ;use stack to load status
+1402 : 28 > plp
+
+1403 : ac0a02 ldy abs1+2
+1406 : 08 php ;test stores do not alter flags
+1407 : 98 tya
+1408 : 49c3 eor #$c3
+140a : a8 tay
+140b : 28 plp
+140c : 840e sty zpt+2
+140e : 08 php ;flags after load/store sequence
+140f : 49c3 eor #$c3
+1411 : a8 tay
+1412 : c415 cpy zp1+2 ;test result
+ trap_ne
+1414 : d0fe > bne * ;failed not equal (non zero)
+
+1416 : 68 pla ;load status
+ eor_flag 0
+1417 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1419 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+141c : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+141e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1420 : 48 > pha ;use stack to load status
+1421 : 28 > plp
+
+1422 : ac0b02 ldy abs1+3
+1425 : 08 php ;test stores do not alter flags
+1426 : 98 tya
+1427 : 49c3 eor #$c3
+1429 : a8 tay
+142a : 28 plp
+142b : 840f sty zpt+3
+142d : 08 php ;flags after load/store sequence
+142e : 49c3 eor #$c3
+1430 : a8 tay
+1431 : c416 cpy zp1+3 ;test result
+ trap_ne
+1433 : d0fe > bne * ;failed not equal (non zero)
+
+1435 : 68 pla ;load status
+ eor_flag 0
+1436 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1438 : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+143b : d0fe > bne * ;failed not equal (non zero)
+
+
+ set_stat $ff
+ > load_flag $ff
+143d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+143f : 48 > pha ;use stack to load status
+1440 : 28 > plp
+
+1441 : ac0802 ldy abs1
+1444 : 08 php ;test stores do not alter flags
+1445 : 98 tya
+1446 : 49c3 eor #$c3
+1448 : a8 tay
+1449 : 28 plp
+144a : 840c sty zpt
+144c : 08 php ;flags after load/store sequence
+144d : 49c3 eor #$c3
+144f : a8 tay
+1450 : c513 cmp zp1 ;test result
+ trap_ne
+1452 : d0fe > bne * ;failed not equal (non zero)
+
+1454 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1455 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1457 : cd0d02 cmp fLDx ;test flags
+ trap_ne
+145a : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+145c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+145e : 48 > pha ;use stack to load status
+145f : 28 > plp
+
+1460 : ac0902 ldy abs1+1
+1463 : 08 php ;test stores do not alter flags
+1464 : 98 tya
+1465 : 49c3 eor #$c3
+1467 : a8 tay
+1468 : 28 plp
+1469 : 840d sty zpt+1
+146b : 08 php ;flags after load/store sequence
+146c : 49c3 eor #$c3
+146e : a8 tay
+146f : c514 cmp zp1+1 ;test result
+ trap_ne
+1471 : d0fe > bne * ;failed not equal (non zero)
+
+1473 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1474 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1476 : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+1479 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+147b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+147d : 48 > pha ;use stack to load status
+147e : 28 > plp
+
+147f : ac0a02 ldy abs1+2
+1482 : 08 php ;test stores do not alter flags
+1483 : 98 tya
+1484 : 49c3 eor #$c3
+1486 : a8 tay
+1487 : 28 plp
+1488 : 840e sty zpt+2
+148a : 08 php ;flags after load/store sequence
+148b : 49c3 eor #$c3
+148d : a8 tay
+148e : c515 cmp zp1+2 ;test result
+ trap_ne
+1490 : d0fe > bne * ;failed not equal (non zero)
+
+1492 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1493 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1495 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+1498 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+149a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+149c : 48 > pha ;use stack to load status
+149d : 28 > plp
+
+149e : ac0b02 ldy abs1+3
+14a1 : 08 php ;test stores do not alter flags
+14a2 : 98 tya
+14a3 : 49c3 eor #$c3
+14a5 : a8 tay
+14a6 : 28 plp
+14a7 : 840f sty zpt+3
+14a9 : 08 php ;flags after load/store sequence
+14aa : 49c3 eor #$c3
+14ac : a8 tay
+14ad : c516 cmp zp1+3 ;test result
+ trap_ne
+14af : d0fe > bne * ;failed not equal (non zero)
+
+14b1 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+14b2 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+14b4 : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+14b7 : d0fe > bne * ;failed not equal (non zero)
+
+
+
+ set_stat 0
+ > load_flag 0
+14b9 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+14bb : 48 > pha ;use stack to load status
+14bc : 28 > plp
+
+14bd : a0c3 ldy #$c3
+14bf : 08 php
+14c0 : cc0802 cpy abs1 ;test result
+ trap_ne
+14c3 : d0fe > bne * ;failed not equal (non zero)
+
+14c5 : 68 pla ;load status
+ eor_flag 0
+14c6 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+14c8 : cd0d02 cmp fLDx ;test flags
+ trap_ne
+14cb : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+14cd : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+14cf : 48 > pha ;use stack to load status
+14d0 : 28 > plp
+
+14d1 : a082 ldy #$82
+14d3 : 08 php
+14d4 : cc0902 cpy abs1+1 ;test result
+ trap_ne
+14d7 : d0fe > bne * ;failed not equal (non zero)
+
+14d9 : 68 pla ;load status
+ eor_flag 0
+14da : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+14dc : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+14df : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+14e1 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+14e3 : 48 > pha ;use stack to load status
+14e4 : 28 > plp
+
+14e5 : a041 ldy #$41
+14e7 : 08 php
+14e8 : cc0a02 cpy abs1+2 ;test result
+ trap_ne
+14eb : d0fe > bne * ;failed not equal (non zero)
+
+14ed : 68 pla ;load status
+ eor_flag 0
+14ee : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+14f0 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+14f3 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+14f5 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+14f7 : 48 > pha ;use stack to load status
+14f8 : 28 > plp
+
+14f9 : a000 ldy #0
+14fb : 08 php
+14fc : cc0b02 cpy abs1+3 ;test result
+ trap_ne
+14ff : d0fe > bne * ;failed not equal (non zero)
+
+1501 : 68 pla ;load status
+ eor_flag 0
+1502 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1504 : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+1507 : d0fe > bne * ;failed not equal (non zero)
+
+
+ set_stat $ff
+ > load_flag $ff
+1509 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+150b : 48 > pha ;use stack to load status
+150c : 28 > plp
+
+150d : a0c3 ldy #$c3
+150f : 08 php
+1510 : cc0802 cpy abs1 ;test result
+ trap_ne
+1513 : d0fe > bne * ;failed not equal (non zero)
+
+1515 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1516 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1518 : cd0d02 cmp fLDx ;test flags
+ trap_ne
+151b : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+151d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+151f : 48 > pha ;use stack to load status
+1520 : 28 > plp
+
+1521 : a082 ldy #$82
+1523 : 08 php
+1524 : cc0902 cpy abs1+1 ;test result
+ trap_ne
+1527 : d0fe > bne * ;failed not equal (non zero)
+
+1529 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+152a : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+152c : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+152f : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+1531 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1533 : 48 > pha ;use stack to load status
+1534 : 28 > plp
+
+1535 : a041 ldy #$41
+1537 : 08 php
+1538 : cc0a02 cpy abs1+2 ;test result
+ trap_ne
+153b : d0fe > bne * ;failed not equal (non zero)
+
+153d : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+153e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1540 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+1543 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+1545 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1547 : 48 > pha ;use stack to load status
+1548 : 28 > plp
+
+1549 : a000 ldy #0
+154b : 08 php
+154c : cc0b02 cpy abs1+3 ;test result
+ trap_ne
+154f : d0fe > bne * ;failed not equal (non zero)
+
+1551 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1552 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1554 : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+1557 : d0fe > bne * ;failed not equal (non zero)
+
+
+1559 : a000 ldy #0
+155b : a50c lda zpt
+155d : 49c3 eor #$c3
+155f : c513 cmp zp1
+ trap_ne ;store to zp data
+1561 : d0fe > bne * ;failed not equal (non zero)
+
+1563 : 840c sty zpt ;clear
+1565 : ad0302 lda abst
+1568 : 49c3 eor #$c3
+156a : cd0802 cmp abs1
+ trap_ne ;store to abs data
+156d : d0fe > bne * ;failed not equal (non zero)
+
+156f : 8c0302 sty abst ;clear
+1572 : a50d lda zpt+1
+1574 : 49c3 eor #$c3
+1576 : c514 cmp zp1+1
+ trap_ne ;store to zp+1 data
+1578 : d0fe > bne * ;failed not equal (non zero)
+
+157a : 840d sty zpt+1 ;clear
+157c : ad0402 lda abst+1
+157f : 49c3 eor #$c3
+1581 : cd0902 cmp abs1+1
+ trap_ne ;store to abs+1 data
+1584 : d0fe > bne * ;failed not equal (non zero)
+
+1586 : 8c0402 sty abst+1 ;clear
+1589 : a50e lda zpt+2
+158b : 49c3 eor #$c3
+158d : c515 cmp zp1+2
+ trap_ne ;store to zp+2 data
+158f : d0fe > bne * ;failed not equal (non zero)
+
+1591 : 840e sty zpt+2 ;clear
+1593 : ad0502 lda abst+2
+1596 : 49c3 eor #$c3
+1598 : cd0a02 cmp abs1+2
+ trap_ne ;store to abs+2 data
+159b : d0fe > bne * ;failed not equal (non zero)
+
+159d : 8c0502 sty abst+2 ;clear
+15a0 : a50f lda zpt+3
+15a2 : 49c3 eor #$c3
+15a4 : c516 cmp zp1+3
+ trap_ne ;store to zp+3 data
+15a6 : d0fe > bne * ;failed not equal (non zero)
+
+15a8 : 840f sty zpt+3 ;clear
+15aa : ad0602 lda abst+3
+15ad : 49c3 eor #$c3
+15af : cd0b02 cmp abs1+3
+ trap_ne ;store to abs+3 data
+15b2 : d0fe > bne * ;failed not equal (non zero)
+
+15b4 : 8c0602 sty abst+3 ;clear
+ next_test
+15b7 : ad0002 > lda test_case ;previous test
+15ba : c914 > cmp #test_num
+ > trap_ne ;test is out of sequence
+15bc : d0fe > bne * ;failed not equal (non zero)
+ >
+0015 = >test_num = test_num + 1
+15be : a915 > lda #test_num ;*** next tests' number
+15c0 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; testing load / store accumulator LDA / STA all addressing modes
+ ; LDA / STA - zp,x / abs,x
+15c3 : a203 ldx #3
+15c5 : tldax
+ set_stat 0
+ > load_flag 0
+15c5 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+15c7 : 48 > pha ;use stack to load status
+15c8 : 28 > plp
+
+15c9 : b513 lda zp1,x
+15cb : 08 php ;test stores do not alter flags
+15cc : 49c3 eor #$c3
+15ce : 28 plp
+15cf : 9d0302 sta abst,x
+15d2 : 08 php ;flags after load/store sequence
+15d3 : 49c3 eor #$c3
+15d5 : dd0802 cmp abs1,x ;test result
+ trap_ne
+15d8 : d0fe > bne * ;failed not equal (non zero)
+
+15da : 68 pla ;load status
+ eor_flag 0
+15db : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+15dd : dd0d02 cmp fLDx,x ;test flags
+ trap_ne
+15e0 : d0fe > bne * ;failed not equal (non zero)
+
+15e2 : ca dex
+15e3 : 10e0 bpl tldax
+
+15e5 : a203 ldx #3
+15e7 : tldax1
+ set_stat $ff
+ > load_flag $ff
+15e7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+15e9 : 48 > pha ;use stack to load status
+15ea : 28 > plp
+
+15eb : b513 lda zp1,x
+15ed : 08 php ;test stores do not alter flags
+15ee : 49c3 eor #$c3
+15f0 : 28 plp
+15f1 : 9d0302 sta abst,x
+15f4 : 08 php ;flags after load/store sequence
+15f5 : 49c3 eor #$c3
+15f7 : dd0802 cmp abs1,x ;test result
+ trap_ne
+15fa : d0fe > bne * ;failed not equal (non zero)
+
+15fc : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+15fd : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+15ff : dd0d02 cmp fLDx,x ;test flags
+ trap_ne
+1602 : d0fe > bne * ;failed not equal (non zero)
+
+1604 : ca dex
+1605 : 10e0 bpl tldax1
+
+1607 : a203 ldx #3
+1609 : tldax2
+ set_stat 0
+ > load_flag 0
+1609 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+160b : 48 > pha ;use stack to load status
+160c : 28 > plp
+
+160d : bd0802 lda abs1,x
+1610 : 08 php ;test stores do not alter flags
+1611 : 49c3 eor #$c3
+1613 : 28 plp
+1614 : 950c sta zpt,x
+1616 : 08 php ;flags after load/store sequence
+1617 : 49c3 eor #$c3
+1619 : d513 cmp zp1,x ;test result
+ trap_ne
+161b : d0fe > bne * ;failed not equal (non zero)
+
+161d : 68 pla ;load status
+ eor_flag 0
+161e : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1620 : dd0d02 cmp fLDx,x ;test flags
+ trap_ne
+1623 : d0fe > bne * ;failed not equal (non zero)
+
+1625 : ca dex
+1626 : 10e1 bpl tldax2
+
+1628 : a203 ldx #3
+162a : tldax3
+ set_stat $ff
+ > load_flag $ff
+162a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+162c : 48 > pha ;use stack to load status
+162d : 28 > plp
+
+162e : bd0802 lda abs1,x
+1631 : 08 php ;test stores do not alter flags
+1632 : 49c3 eor #$c3
+1634 : 28 plp
+1635 : 950c sta zpt,x
+1637 : 08 php ;flags after load/store sequence
+1638 : 49c3 eor #$c3
+163a : d513 cmp zp1,x ;test result
+ trap_ne
+163c : d0fe > bne * ;failed not equal (non zero)
+
+163e : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+163f : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1641 : dd0d02 cmp fLDx,x ;test flags
+ trap_ne
+1644 : d0fe > bne * ;failed not equal (non zero)
+
+1646 : ca dex
+1647 : 10e1 bpl tldax3
+
+1649 : a203 ldx #3 ;testing store result
+164b : a000 ldy #0
+164d : b50c tstax lda zpt,x
+164f : 49c3 eor #$c3
+1651 : d513 cmp zp1,x
+ trap_ne ;store to zp,x data
+1653 : d0fe > bne * ;failed not equal (non zero)
+
+1655 : 940c sty zpt,x ;clear
+1657 : bd0302 lda abst,x
+165a : 49c3 eor #$c3
+165c : dd0802 cmp abs1,x
+ trap_ne ;store to abs,x data
+165f : d0fe > bne * ;failed not equal (non zero)
+
+1661 : 8a txa
+1662 : 9d0302 sta abst,x ;clear
+1665 : ca dex
+1666 : 10e5 bpl tstax
+ next_test
+1668 : ad0002 > lda test_case ;previous test
+166b : c915 > cmp #test_num
+ > trap_ne ;test is out of sequence
+166d : d0fe > bne * ;failed not equal (non zero)
+ >
+0016 = >test_num = test_num + 1
+166f : a916 > lda #test_num ;*** next tests' number
+1671 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; LDA / STA - (zp),y / abs,y / (zp,x)
+1674 : a003 ldy #3
+1676 : tlday
+ set_stat 0
+ > load_flag 0
+1676 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1678 : 48 > pha ;use stack to load status
+1679 : 28 > plp
+
+167a : b124 lda (ind1),y
+167c : 08 php ;test stores do not alter flags
+167d : 49c3 eor #$c3
+167f : 28 plp
+1680 : 990302 sta abst,y
+1683 : 08 php ;flags after load/store sequence
+1684 : 49c3 eor #$c3
+1686 : d90802 cmp abs1,y ;test result
+ trap_ne
+1689 : d0fe > bne * ;failed not equal (non zero)
+
+168b : 68 pla ;load status
+ eor_flag 0
+168c : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+168e : d90d02 cmp fLDx,y ;test flags
+ trap_ne
+1691 : d0fe > bne * ;failed not equal (non zero)
+
+1693 : 88 dey
+1694 : 10e0 bpl tlday
+
+1696 : a003 ldy #3
+1698 : tlday1
+ set_stat $ff
+ > load_flag $ff
+1698 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+169a : 48 > pha ;use stack to load status
+169b : 28 > plp
+
+169c : b124 lda (ind1),y
+169e : 08 php ;test stores do not alter flags
+169f : 49c3 eor #$c3
+16a1 : 28 plp
+16a2 : 990302 sta abst,y
+16a5 : 08 php ;flags after load/store sequence
+16a6 : 49c3 eor #$c3
+16a8 : d90802 cmp abs1,y ;test result
+ trap_ne
+16ab : d0fe > bne * ;failed not equal (non zero)
+
+16ad : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+16ae : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+16b0 : d90d02 cmp fLDx,y ;test flags
+ trap_ne
+16b3 : d0fe > bne * ;failed not equal (non zero)
+
+16b5 : 88 dey
+16b6 : 10e0 bpl tlday1
+
+16b8 : a003 ldy #3 ;testing store result
+16ba : a200 ldx #0
+16bc : b90302 tstay lda abst,y
+16bf : 49c3 eor #$c3
+16c1 : d90802 cmp abs1,y
+ trap_ne ;store to abs data
+16c4 : d0fe > bne * ;failed not equal (non zero)
+
+16c6 : 8a txa
+16c7 : 990302 sta abst,y ;clear
+16ca : 88 dey
+16cb : 10ef bpl tstay
+
+16cd : a003 ldy #3
+16cf : tlday2
+ set_stat 0
+ > load_flag 0
+16cf : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+16d1 : 48 > pha ;use stack to load status
+16d2 : 28 > plp
+
+16d3 : b90802 lda abs1,y
+16d6 : 08 php ;test stores do not alter flags
+16d7 : 49c3 eor #$c3
+16d9 : 28 plp
+16da : 9130 sta (indt),y
+16dc : 08 php ;flags after load/store sequence
+16dd : 49c3 eor #$c3
+16df : d124 cmp (ind1),y ;test result
+ trap_ne
+16e1 : d0fe > bne * ;failed not equal (non zero)
+
+16e3 : 68 pla ;load status
+ eor_flag 0
+16e4 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+16e6 : d90d02 cmp fLDx,y ;test flags
+ trap_ne
+16e9 : d0fe > bne * ;failed not equal (non zero)
+
+16eb : 88 dey
+16ec : 10e1 bpl tlday2
+
+16ee : a003 ldy #3
+16f0 : tlday3
+ set_stat $ff
+ > load_flag $ff
+16f0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+16f2 : 48 > pha ;use stack to load status
+16f3 : 28 > plp
+
+16f4 : b90802 lda abs1,y
+16f7 : 08 php ;test stores do not alter flags
+16f8 : 49c3 eor #$c3
+16fa : 28 plp
+16fb : 9130 sta (indt),y
+16fd : 08 php ;flags after load/store sequence
+16fe : 49c3 eor #$c3
+1700 : d124 cmp (ind1),y ;test result
+ trap_ne
+1702 : d0fe > bne * ;failed not equal (non zero)
+
+1704 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1705 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1707 : d90d02 cmp fLDx,y ;test flags
+ trap_ne
+170a : d0fe > bne * ;failed not equal (non zero)
+
+170c : 88 dey
+170d : 10e1 bpl tlday3
+
+170f : a003 ldy #3 ;testing store result
+1711 : a200 ldx #0
+1713 : b90302 tstay1 lda abst,y
+1716 : 49c3 eor #$c3
+1718 : d90802 cmp abs1,y
+ trap_ne ;store to abs data
+171b : d0fe > bne * ;failed not equal (non zero)
+
+171d : 8a txa
+171e : 990302 sta abst,y ;clear
+1721 : 88 dey
+1722 : 10ef bpl tstay1
+
+1724 : a206 ldx #6
+1726 : a003 ldy #3
+1728 : tldax4
+ set_stat 0
+ > load_flag 0
+1728 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+172a : 48 > pha ;use stack to load status
+172b : 28 > plp
+
+172c : a124 lda (ind1,x)
+172e : 08 php ;test stores do not alter flags
+172f : 49c3 eor #$c3
+1731 : 28 plp
+1732 : 8130 sta (indt,x)
+1734 : 08 php ;flags after load/store sequence
+1735 : 49c3 eor #$c3
+1737 : d90802 cmp abs1,y ;test result
+ trap_ne
+173a : d0fe > bne * ;failed not equal (non zero)
+
+173c : 68 pla ;load status
+ eor_flag 0
+173d : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+173f : d90d02 cmp fLDx,y ;test flags
+ trap_ne
+1742 : d0fe > bne * ;failed not equal (non zero)
+
+1744 : ca dex
+1745 : ca dex
+1746 : 88 dey
+1747 : 10df bpl tldax4
+
+1749 : a206 ldx #6
+174b : a003 ldy #3
+174d : tldax5
+ set_stat $ff
+ > load_flag $ff
+174d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+174f : 48 > pha ;use stack to load status
+1750 : 28 > plp
+
+1751 : a124 lda (ind1,x)
+1753 : 08 php ;test stores do not alter flags
+1754 : 49c3 eor #$c3
+1756 : 28 plp
+1757 : 8130 sta (indt,x)
+1759 : 08 php ;flags after load/store sequence
+175a : 49c3 eor #$c3
+175c : d90802 cmp abs1,y ;test result
+ trap_ne
+175f : d0fe > bne * ;failed not equal (non zero)
+
+1761 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1762 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1764 : d90d02 cmp fLDx,y ;test flags
+ trap_ne
+1767 : d0fe > bne * ;failed not equal (non zero)
+
+1769 : ca dex
+176a : ca dex
+176b : 88 dey
+176c : 10df bpl tldax5
+
+176e : a003 ldy #3 ;testing store result
+1770 : a200 ldx #0
+1772 : b90302 tstay2 lda abst,y
+1775 : 49c3 eor #$c3
+1777 : d90802 cmp abs1,y
+ trap_ne ;store to abs data
+177a : d0fe > bne * ;failed not equal (non zero)
+
+177c : 8a txa
+177d : 990302 sta abst,y ;clear
+1780 : 88 dey
+1781 : 10ef bpl tstay2
+ next_test
+1783 : ad0002 > lda test_case ;previous test
+1786 : c916 > cmp #test_num
+ > trap_ne ;test is out of sequence
+1788 : d0fe > bne * ;failed not equal (non zero)
+ >
+0017 = >test_num = test_num + 1
+178a : a917 > lda #test_num ;*** next tests' number
+178c : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; indexed wraparound test (only zp should wrap)
+178f : a2fd ldx #3+$fa
+1791 : b519 tldax6 lda zp1-$fa&$ff,x ;wrap on indexed zp
+1793 : 9d0901 sta abst-$fa,x ;no STX abs,x!
+1796 : ca dex
+1797 : e0fa cpx #$fa
+1799 : b0f6 bcs tldax6
+179b : a2fd ldx #3+$fa
+179d : bd0e01 tldax7 lda abs1-$fa,x ;no wrap on indexed abs
+17a0 : 9512 sta zpt-$fa&$ff,x
+17a2 : ca dex
+17a3 : e0fa cpx #$fa
+17a5 : b0f6 bcs tldax7
+
+17a7 : a203 ldx #3 ;testing wraparound result
+17a9 : a000 ldy #0
+17ab : b50c tstax1 lda zpt,x
+17ad : d513 cmp zp1,x
+ trap_ne ;store to zp,x data
+17af : d0fe > bne * ;failed not equal (non zero)
+
+17b1 : 940c sty zpt,x ;clear
+17b3 : bd0302 lda abst,x
+17b6 : dd0802 cmp abs1,x
+ trap_ne ;store to abs,x data
+17b9 : d0fe > bne * ;failed not equal (non zero)
+
+17bb : 8a txa
+17bc : 9d0302 sta abst,x ;clear
+17bf : ca dex
+17c0 : 10e9 bpl tstax1
+
+17c2 : a0fb ldy #3+$f8
+17c4 : a2fe ldx #6+$f8
+17c6 : a12c tlday4 lda (ind1-$f8&$ff,x) ;wrap on indexed zp indirect
+17c8 : 990b01 sta abst-$f8,y
+17cb : ca dex
+17cc : ca dex
+17cd : 88 dey
+17ce : c0f8 cpy #$f8
+17d0 : b0f4 bcs tlday4
+17d2 : a003 ldy #3 ;testing wraparound result
+17d4 : a200 ldx #0
+17d6 : b90302 tstay4 lda abst,y
+17d9 : d90802 cmp abs1,y
+ trap_ne ;store to abs data
+17dc : d0fe > bne * ;failed not equal (non zero)
+
+17de : 8a txa
+17df : 990302 sta abst,y ;clear
+17e2 : 88 dey
+17e3 : 10f1 bpl tstay4
+
+17e5 : a0fb ldy #3+$f8
+17e7 : b91001 tlday5 lda abs1-$f8,y ;no wrap on indexed abs
+17ea : 9138 sta (inwt),y
+17ec : 88 dey
+17ed : c0f8 cpy #$f8
+17ef : b0f6 bcs tlday5
+17f1 : a003 ldy #3 ;testing wraparound result
+17f3 : a200 ldx #0
+17f5 : b90302 tstay5 lda abst,y
+17f8 : d90802 cmp abs1,y
+ trap_ne ;store to abs data
+17fb : d0fe > bne * ;failed not equal (non zero)
+
+17fd : 8a txa
+17fe : 990302 sta abst,y ;clear
+1801 : 88 dey
+1802 : 10f1 bpl tstay5
+
+1804 : a0fb ldy #3+$f8
+1806 : a2fe ldx #6+$f8
+1808 : b12e tlday6 lda (inw1),y ;no wrap on zp indirect indexed
+180a : 8138 sta (indt-$f8&$ff,x)
+180c : ca dex
+180d : ca dex
+180e : 88 dey
+180f : c0f8 cpy #$f8
+1811 : b0f5 bcs tlday6
+1813 : a003 ldy #3 ;testing wraparound result
+1815 : a200 ldx #0
+1817 : b90302 tstay6 lda abst,y
+181a : d90802 cmp abs1,y
+ trap_ne ;store to abs data
+181d : d0fe > bne * ;failed not equal (non zero)
+
+181f : 8a txa
+1820 : 990302 sta abst,y ;clear
+1823 : 88 dey
+1824 : 10f1 bpl tstay6
+ next_test
+1826 : ad0002 > lda test_case ;previous test
+1829 : c917 > cmp #test_num
+ > trap_ne ;test is out of sequence
+182b : d0fe > bne * ;failed not equal (non zero)
+ >
+0018 = >test_num = test_num + 1
+182d : a918 > lda #test_num ;*** next tests' number
+182f : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; LDA / STA - zp / abs / #
+ set_stat 0
+ > load_flag 0
+1832 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1834 : 48 > pha ;use stack to load status
+1835 : 28 > plp
+
+1836 : a513 lda zp1
+1838 : 08 php ;test stores do not alter flags
+1839 : 49c3 eor #$c3
+183b : 28 plp
+183c : 8d0302 sta abst
+183f : 08 php ;flags after load/store sequence
+1840 : 49c3 eor #$c3
+1842 : c9c3 cmp #$c3 ;test result
+ trap_ne
+1844 : d0fe > bne * ;failed not equal (non zero)
+
+1846 : 68 pla ;load status
+ eor_flag 0
+1847 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1849 : cd0d02 cmp fLDx ;test flags
+ trap_ne
+184c : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+184e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1850 : 48 > pha ;use stack to load status
+1851 : 28 > plp
+
+1852 : a514 lda zp1+1
+1854 : 08 php ;test stores do not alter flags
+1855 : 49c3 eor #$c3
+1857 : 28 plp
+1858 : 8d0402 sta abst+1
+185b : 08 php ;flags after load/store sequence
+185c : 49c3 eor #$c3
+185e : c982 cmp #$82 ;test result
+ trap_ne
+1860 : d0fe > bne * ;failed not equal (non zero)
+
+1862 : 68 pla ;load status
+ eor_flag 0
+1863 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1865 : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+1868 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+186a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+186c : 48 > pha ;use stack to load status
+186d : 28 > plp
+
+186e : a515 lda zp1+2
+1870 : 08 php ;test stores do not alter flags
+1871 : 49c3 eor #$c3
+1873 : 28 plp
+1874 : 8d0502 sta abst+2
+1877 : 08 php ;flags after load/store sequence
+1878 : 49c3 eor #$c3
+187a : c941 cmp #$41 ;test result
+ trap_ne
+187c : d0fe > bne * ;failed not equal (non zero)
+
+187e : 68 pla ;load status
+ eor_flag 0
+187f : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1881 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+1884 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1886 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1888 : 48 > pha ;use stack to load status
+1889 : 28 > plp
+
+188a : a516 lda zp1+3
+188c : 08 php ;test stores do not alter flags
+188d : 49c3 eor #$c3
+188f : 28 plp
+1890 : 8d0602 sta abst+3
+1893 : 08 php ;flags after load/store sequence
+1894 : 49c3 eor #$c3
+1896 : c900 cmp #0 ;test result
+ trap_ne
+1898 : d0fe > bne * ;failed not equal (non zero)
+
+189a : 68 pla ;load status
+ eor_flag 0
+189b : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+189d : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+18a0 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+18a2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+18a4 : 48 > pha ;use stack to load status
+18a5 : 28 > plp
+
+18a6 : a513 lda zp1
+18a8 : 08 php ;test stores do not alter flags
+18a9 : 49c3 eor #$c3
+18ab : 28 plp
+18ac : 8d0302 sta abst
+18af : 08 php ;flags after load/store sequence
+18b0 : 49c3 eor #$c3
+18b2 : c9c3 cmp #$c3 ;test result
+ trap_ne
+18b4 : d0fe > bne * ;failed not equal (non zero)
+
+18b6 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+18b7 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+18b9 : cd0d02 cmp fLDx ;test flags
+ trap_ne
+18bc : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+18be : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+18c0 : 48 > pha ;use stack to load status
+18c1 : 28 > plp
+
+18c2 : a514 lda zp1+1
+18c4 : 08 php ;test stores do not alter flags
+18c5 : 49c3 eor #$c3
+18c7 : 28 plp
+18c8 : 8d0402 sta abst+1
+18cb : 08 php ;flags after load/store sequence
+18cc : 49c3 eor #$c3
+18ce : c982 cmp #$82 ;test result
+ trap_ne
+18d0 : d0fe > bne * ;failed not equal (non zero)
+
+18d2 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+18d3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+18d5 : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+18d8 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+18da : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+18dc : 48 > pha ;use stack to load status
+18dd : 28 > plp
+
+18de : a515 lda zp1+2
+18e0 : 08 php ;test stores do not alter flags
+18e1 : 49c3 eor #$c3
+18e3 : 28 plp
+18e4 : 8d0502 sta abst+2
+18e7 : 08 php ;flags after load/store sequence
+18e8 : 49c3 eor #$c3
+18ea : c941 cmp #$41 ;test result
+ trap_ne
+18ec : d0fe > bne * ;failed not equal (non zero)
+
+18ee : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+18ef : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+18f1 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+18f4 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+18f6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+18f8 : 48 > pha ;use stack to load status
+18f9 : 28 > plp
+
+18fa : a516 lda zp1+3
+18fc : 08 php ;test stores do not alter flags
+18fd : 49c3 eor #$c3
+18ff : 28 plp
+1900 : 8d0602 sta abst+3
+1903 : 08 php ;flags after load/store sequence
+1904 : 49c3 eor #$c3
+1906 : c900 cmp #0 ;test result
+ trap_ne
+1908 : d0fe > bne * ;failed not equal (non zero)
+
+190a : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+190b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+190d : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+1910 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1912 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1914 : 48 > pha ;use stack to load status
+1915 : 28 > plp
+
+1916 : ad0802 lda abs1
+1919 : 08 php ;test stores do not alter flags
+191a : 49c3 eor #$c3
+191c : 28 plp
+191d : 850c sta zpt
+191f : 08 php ;flags after load/store sequence
+1920 : 49c3 eor #$c3
+1922 : c513 cmp zp1 ;test result
+ trap_ne
+1924 : d0fe > bne * ;failed not equal (non zero)
+
+1926 : 68 pla ;load status
+ eor_flag 0
+1927 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1929 : cd0d02 cmp fLDx ;test flags
+ trap_ne
+192c : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+192e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1930 : 48 > pha ;use stack to load status
+1931 : 28 > plp
+
+1932 : ad0902 lda abs1+1
+1935 : 08 php ;test stores do not alter flags
+1936 : 49c3 eor #$c3
+1938 : 28 plp
+1939 : 850d sta zpt+1
+193b : 08 php ;flags after load/store sequence
+193c : 49c3 eor #$c3
+193e : c514 cmp zp1+1 ;test result
+ trap_ne
+1940 : d0fe > bne * ;failed not equal (non zero)
+
+1942 : 68 pla ;load status
+ eor_flag 0
+1943 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1945 : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+1948 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+194a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+194c : 48 > pha ;use stack to load status
+194d : 28 > plp
+
+194e : ad0a02 lda abs1+2
+1951 : 08 php ;test stores do not alter flags
+1952 : 49c3 eor #$c3
+1954 : 28 plp
+1955 : 850e sta zpt+2
+1957 : 08 php ;flags after load/store sequence
+1958 : 49c3 eor #$c3
+195a : c515 cmp zp1+2 ;test result
+ trap_ne
+195c : d0fe > bne * ;failed not equal (non zero)
+
+195e : 68 pla ;load status
+ eor_flag 0
+195f : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1961 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+1964 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1966 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1968 : 48 > pha ;use stack to load status
+1969 : 28 > plp
+
+196a : ad0b02 lda abs1+3
+196d : 08 php ;test stores do not alter flags
+196e : 49c3 eor #$c3
+1970 : 28 plp
+1971 : 850f sta zpt+3
+1973 : 08 php ;flags after load/store sequence
+1974 : 49c3 eor #$c3
+1976 : c516 cmp zp1+3 ;test result
+ trap_ne
+1978 : d0fe > bne * ;failed not equal (non zero)
+
+197a : 68 pla ;load status
+ eor_flag 0
+197b : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+197d : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+1980 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+1982 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1984 : 48 > pha ;use stack to load status
+1985 : 28 > plp
+
+1986 : ad0802 lda abs1
+1989 : 08 php ;test stores do not alter flags
+198a : 49c3 eor #$c3
+198c : 28 plp
+198d : 850c sta zpt
+198f : 08 php ;flags after load/store sequence
+1990 : 49c3 eor #$c3
+1992 : c513 cmp zp1 ;test result
+ trap_ne
+1994 : d0fe > bne * ;failed not equal (non zero)
+
+1996 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1997 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1999 : cd0d02 cmp fLDx ;test flags
+ trap_ne
+199c : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+199e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+19a0 : 48 > pha ;use stack to load status
+19a1 : 28 > plp
+
+19a2 : ad0902 lda abs1+1
+19a5 : 08 php ;test stores do not alter flags
+19a6 : 49c3 eor #$c3
+19a8 : 28 plp
+19a9 : 850d sta zpt+1
+19ab : 08 php ;flags after load/store sequence
+19ac : 49c3 eor #$c3
+19ae : c514 cmp zp1+1 ;test result
+ trap_ne
+19b0 : d0fe > bne * ;failed not equal (non zero)
+
+19b2 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+19b3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+19b5 : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+19b8 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+19ba : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+19bc : 48 > pha ;use stack to load status
+19bd : 28 > plp
+
+19be : ad0a02 lda abs1+2
+19c1 : 08 php ;test stores do not alter flags
+19c2 : 49c3 eor #$c3
+19c4 : 28 plp
+19c5 : 850e sta zpt+2
+19c7 : 08 php ;flags after load/store sequence
+19c8 : 49c3 eor #$c3
+19ca : c515 cmp zp1+2 ;test result
+ trap_ne
+19cc : d0fe > bne * ;failed not equal (non zero)
+
+19ce : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+19cf : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+19d1 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+19d4 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+19d6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+19d8 : 48 > pha ;use stack to load status
+19d9 : 28 > plp
+
+19da : ad0b02 lda abs1+3
+19dd : 08 php ;test stores do not alter flags
+19de : 49c3 eor #$c3
+19e0 : 28 plp
+19e1 : 850f sta zpt+3
+19e3 : 08 php ;flags after load/store sequence
+19e4 : 49c3 eor #$c3
+19e6 : c516 cmp zp1+3 ;test result
+ trap_ne
+19e8 : d0fe > bne * ;failed not equal (non zero)
+
+19ea : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+19eb : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+19ed : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+19f0 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+19f2 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+19f4 : 48 > pha ;use stack to load status
+19f5 : 28 > plp
+
+19f6 : a9c3 lda #$c3
+19f8 : 08 php
+19f9 : cd0802 cmp abs1 ;test result
+ trap_ne
+19fc : d0fe > bne * ;failed not equal (non zero)
+
+19fe : 68 pla ;load status
+ eor_flag 0
+19ff : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1a01 : cd0d02 cmp fLDx ;test flags
+ trap_ne
+1a04 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1a06 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1a08 : 48 > pha ;use stack to load status
+1a09 : 28 > plp
+
+1a0a : a982 lda #$82
+1a0c : 08 php
+1a0d : cd0902 cmp abs1+1 ;test result
+ trap_ne
+1a10 : d0fe > bne * ;failed not equal (non zero)
+
+1a12 : 68 pla ;load status
+ eor_flag 0
+1a13 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1a15 : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+1a18 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1a1a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1a1c : 48 > pha ;use stack to load status
+1a1d : 28 > plp
+
+1a1e : a941 lda #$41
+1a20 : 08 php
+1a21 : cd0a02 cmp abs1+2 ;test result
+ trap_ne
+1a24 : d0fe > bne * ;failed not equal (non zero)
+
+1a26 : 68 pla ;load status
+ eor_flag 0
+1a27 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1a29 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+1a2c : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1a2e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1a30 : 48 > pha ;use stack to load status
+1a31 : 28 > plp
+
+1a32 : a900 lda #0
+1a34 : 08 php
+1a35 : cd0b02 cmp abs1+3 ;test result
+ trap_ne
+1a38 : d0fe > bne * ;failed not equal (non zero)
+
+1a3a : 68 pla ;load status
+ eor_flag 0
+1a3b : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1a3d : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+1a40 : d0fe > bne * ;failed not equal (non zero)
+
+
+ set_stat $ff
+ > load_flag $ff
+1a42 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1a44 : 48 > pha ;use stack to load status
+1a45 : 28 > plp
+
+1a46 : a9c3 lda #$c3
+1a48 : 08 php
+1a49 : cd0802 cmp abs1 ;test result
+ trap_ne
+1a4c : d0fe > bne * ;failed not equal (non zero)
+
+1a4e : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1a4f : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1a51 : cd0d02 cmp fLDx ;test flags
+ trap_ne
+1a54 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+1a56 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1a58 : 48 > pha ;use stack to load status
+1a59 : 28 > plp
+
+1a5a : a982 lda #$82
+1a5c : 08 php
+1a5d : cd0902 cmp abs1+1 ;test result
+ trap_ne
+1a60 : d0fe > bne * ;failed not equal (non zero)
+
+1a62 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1a63 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1a65 : cd0e02 cmp fLDx+1 ;test flags
+ trap_ne
+1a68 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+1a6a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1a6c : 48 > pha ;use stack to load status
+1a6d : 28 > plp
+
+1a6e : a941 lda #$41
+1a70 : 08 php
+1a71 : cd0a02 cmp abs1+2 ;test result
+ trap_ne
+1a74 : d0fe > bne * ;failed not equal (non zero)
+
+1a76 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1a77 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1a79 : cd0f02 cmp fLDx+2 ;test flags
+ trap_ne
+1a7c : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+1a7e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1a80 : 48 > pha ;use stack to load status
+1a81 : 28 > plp
+
+1a82 : a900 lda #0
+1a84 : 08 php
+1a85 : cd0b02 cmp abs1+3 ;test result
+ trap_ne
+1a88 : d0fe > bne * ;failed not equal (non zero)
+
+1a8a : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1a8b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+1a8d : cd1002 cmp fLDx+3 ;test flags
+ trap_ne
+1a90 : d0fe > bne * ;failed not equal (non zero)
+
+
+1a92 : a200 ldx #0
+1a94 : a50c lda zpt
+1a96 : 49c3 eor #$c3
+1a98 : c513 cmp zp1
+ trap_ne ;store to zp data
+1a9a : d0fe > bne * ;failed not equal (non zero)
+
+1a9c : 860c stx zpt ;clear
+1a9e : ad0302 lda abst
+1aa1 : 49c3 eor #$c3
+1aa3 : cd0802 cmp abs1
+ trap_ne ;store to abs data
+1aa6 : d0fe > bne * ;failed not equal (non zero)
+
+1aa8 : 8e0302 stx abst ;clear
+1aab : a50d lda zpt+1
+1aad : 49c3 eor #$c3
+1aaf : c514 cmp zp1+1
+ trap_ne ;store to zp data
+1ab1 : d0fe > bne * ;failed not equal (non zero)
+
+1ab3 : 860d stx zpt+1 ;clear
+1ab5 : ad0402 lda abst+1
+1ab8 : 49c3 eor #$c3
+1aba : cd0902 cmp abs1+1
+ trap_ne ;store to abs data
+1abd : d0fe > bne * ;failed not equal (non zero)
+
+1abf : 8e0402 stx abst+1 ;clear
+1ac2 : a50e lda zpt+2
+1ac4 : 49c3 eor #$c3
+1ac6 : c515 cmp zp1+2
+ trap_ne ;store to zp data
+1ac8 : d0fe > bne * ;failed not equal (non zero)
+
+1aca : 860e stx zpt+2 ;clear
+1acc : ad0502 lda abst+2
+1acf : 49c3 eor #$c3
+1ad1 : cd0a02 cmp abs1+2
+ trap_ne ;store to abs data
+1ad4 : d0fe > bne * ;failed not equal (non zero)
+
+1ad6 : 8e0502 stx abst+2 ;clear
+1ad9 : a50f lda zpt+3
+1adb : 49c3 eor #$c3
+1add : c516 cmp zp1+3
+ trap_ne ;store to zp data
+1adf : d0fe > bne * ;failed not equal (non zero)
+
+1ae1 : 860f stx zpt+3 ;clear
+1ae3 : ad0602 lda abst+3
+1ae6 : 49c3 eor #$c3
+1ae8 : cd0b02 cmp abs1+3
+ trap_ne ;store to abs data
+1aeb : d0fe > bne * ;failed not equal (non zero)
+
+1aed : 8e0602 stx abst+3 ;clear
+ next_test
+1af0 : ad0002 > lda test_case ;previous test
+1af3 : c918 > cmp #test_num
+ > trap_ne ;test is out of sequence
+1af5 : d0fe > bne * ;failed not equal (non zero)
+ >
+0019 = >test_num = test_num + 1
+1af7 : a919 > lda #test_num ;*** next tests' number
+1af9 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; testing bit test & compares BIT CPX CPY CMP all addressing modes
+ ; BIT - zp / abs
+ set_a $ff,0
+ > load_flag 0
+1afc : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1afe : 48 > pha ;use stack to load status
+1aff : a9ff > lda #$ff ;precharge accu
+1b01 : 28 > plp
+
+1b02 : 2416 bit zp1+3 ;00 - should set Z / clear NV
+ tst_a $ff,fz
+1b04 : 08 > php ;save flags
+1b05 : c9ff > cmp #$ff ;test result
+ > trap_ne
+1b07 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b09 : 68 > pla ;load status
+1b0a : 48 > pha
+ > cmp_flag fz
+1b0b : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b0d : d0fe > bne * ;failed not equal (non zero)
+ >
+1b0f : 28 > plp ;restore status
+
+ set_a 1,0
+ > load_flag 0
+1b10 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1b12 : 48 > pha ;use stack to load status
+1b13 : a901 > lda #1 ;precharge accu
+1b15 : 28 > plp
+
+1b16 : 2415 bit zp1+2 ;41 - should set V (M6) / clear NZ
+ tst_a 1,fv
+1b18 : 08 > php ;save flags
+1b19 : c901 > cmp #1 ;test result
+ > trap_ne
+1b1b : d0fe > bne * ;failed not equal (non zero)
+ >
+1b1d : 68 > pla ;load status
+1b1e : 48 > pha
+ > cmp_flag fv
+1b1f : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b21 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b23 : 28 > plp ;restore status
+
+ set_a 1,0
+ > load_flag 0
+1b24 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1b26 : 48 > pha ;use stack to load status
+1b27 : a901 > lda #1 ;precharge accu
+1b29 : 28 > plp
+
+1b2a : 2414 bit zp1+1 ;82 - should set N (M7) & Z / clear V
+ tst_a 1,fnz
+1b2c : 08 > php ;save flags
+1b2d : c901 > cmp #1 ;test result
+ > trap_ne
+1b2f : d0fe > bne * ;failed not equal (non zero)
+ >
+1b31 : 68 > pla ;load status
+1b32 : 48 > pha
+ > cmp_flag fnz
+1b33 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b35 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b37 : 28 > plp ;restore status
+
+ set_a 1,0
+ > load_flag 0
+1b38 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1b3a : 48 > pha ;use stack to load status
+1b3b : a901 > lda #1 ;precharge accu
+1b3d : 28 > plp
+
+1b3e : 2413 bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z
+ tst_a 1,fnv
+1b40 : 08 > php ;save flags
+1b41 : c901 > cmp #1 ;test result
+ > trap_ne
+1b43 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b45 : 68 > pla ;load status
+1b46 : 48 > pha
+ > cmp_flag fnv
+1b47 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b49 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b4b : 28 > plp ;restore status
+
+
+ set_a $ff,$ff
+ > load_flag $ff
+1b4c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1b4e : 48 > pha ;use stack to load status
+1b4f : a9ff > lda #$ff ;precharge accu
+1b51 : 28 > plp
+
+1b52 : 2416 bit zp1+3 ;00 - should set Z / clear NV
+ tst_a $ff,~fnv
+1b54 : 08 > php ;save flags
+1b55 : c9ff > cmp #$ff ;test result
+ > trap_ne
+1b57 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b59 : 68 > pla ;load status
+1b5a : 48 > pha
+ > cmp_flag ~fnv
+1b5b : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b5d : d0fe > bne * ;failed not equal (non zero)
+ >
+1b5f : 28 > plp ;restore status
+
+ set_a 1,$ff
+ > load_flag $ff
+1b60 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1b62 : 48 > pha ;use stack to load status
+1b63 : a901 > lda #1 ;precharge accu
+1b65 : 28 > plp
+
+1b66 : 2415 bit zp1+2 ;41 - should set V (M6) / clear NZ
+ tst_a 1,~fnz
+1b68 : 08 > php ;save flags
+1b69 : c901 > cmp #1 ;test result
+ > trap_ne
+1b6b : d0fe > bne * ;failed not equal (non zero)
+ >
+1b6d : 68 > pla ;load status
+1b6e : 48 > pha
+ > cmp_flag ~fnz
+1b6f : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b71 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b73 : 28 > plp ;restore status
+
+ set_a 1,$ff
+ > load_flag $ff
+1b74 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1b76 : 48 > pha ;use stack to load status
+1b77 : a901 > lda #1 ;precharge accu
+1b79 : 28 > plp
+
+1b7a : 2414 bit zp1+1 ;82 - should set N (M7) & Z / clear V
+ tst_a 1,~fv
+1b7c : 08 > php ;save flags
+1b7d : c901 > cmp #1 ;test result
+ > trap_ne
+1b7f : d0fe > bne * ;failed not equal (non zero)
+ >
+1b81 : 68 > pla ;load status
+1b82 : 48 > pha
+ > cmp_flag ~fv
+1b83 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b85 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b87 : 28 > plp ;restore status
+
+ set_a 1,$ff
+ > load_flag $ff
+1b88 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1b8a : 48 > pha ;use stack to load status
+1b8b : a901 > lda #1 ;precharge accu
+1b8d : 28 > plp
+
+1b8e : 2413 bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z
+ tst_a 1,~fz
+1b90 : 08 > php ;save flags
+1b91 : c901 > cmp #1 ;test result
+ > trap_ne
+1b93 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b95 : 68 > pla ;load status
+1b96 : 48 > pha
+ > cmp_flag ~fz
+1b97 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b99 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b9b : 28 > plp ;restore status
+
+
+ set_a $ff,0
+ > load_flag 0
+1b9c : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1b9e : 48 > pha ;use stack to load status
+1b9f : a9ff > lda #$ff ;precharge accu
+1ba1 : 28 > plp
+
+1ba2 : 2c0b02 bit abs1+3 ;00 - should set Z / clear NV
+ tst_a $ff,fz
+1ba5 : 08 > php ;save flags
+1ba6 : c9ff > cmp #$ff ;test result
+ > trap_ne
+1ba8 : d0fe > bne * ;failed not equal (non zero)
+ >
+1baa : 68 > pla ;load status
+1bab : 48 > pha
+ > cmp_flag fz
+1bac : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1bae : d0fe > bne * ;failed not equal (non zero)
+ >
+1bb0 : 28 > plp ;restore status
+
+ set_a 1,0
+ > load_flag 0
+1bb1 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1bb3 : 48 > pha ;use stack to load status
+1bb4 : a901 > lda #1 ;precharge accu
+1bb6 : 28 > plp
+
+1bb7 : 2c0a02 bit abs1+2 ;41 - should set V (M6) / clear NZ
+ tst_a 1,fv
+1bba : 08 > php ;save flags
+1bbb : c901 > cmp #1 ;test result
+ > trap_ne
+1bbd : d0fe > bne * ;failed not equal (non zero)
+ >
+1bbf : 68 > pla ;load status
+1bc0 : 48 > pha
+ > cmp_flag fv
+1bc1 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1bc3 : d0fe > bne * ;failed not equal (non zero)
+ >
+1bc5 : 28 > plp ;restore status
+
+ set_a 1,0
+ > load_flag 0
+1bc6 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1bc8 : 48 > pha ;use stack to load status
+1bc9 : a901 > lda #1 ;precharge accu
+1bcb : 28 > plp
+
+1bcc : 2c0902 bit abs1+1 ;82 - should set N (M7) & Z / clear V
+ tst_a 1,fnz
+1bcf : 08 > php ;save flags
+1bd0 : c901 > cmp #1 ;test result
+ > trap_ne
+1bd2 : d0fe > bne * ;failed not equal (non zero)
+ >
+1bd4 : 68 > pla ;load status
+1bd5 : 48 > pha
+ > cmp_flag fnz
+1bd6 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1bd8 : d0fe > bne * ;failed not equal (non zero)
+ >
+1bda : 28 > plp ;restore status
+
+ set_a 1,0
+ > load_flag 0
+1bdb : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1bdd : 48 > pha ;use stack to load status
+1bde : a901 > lda #1 ;precharge accu
+1be0 : 28 > plp
+
+1be1 : 2c0802 bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z
+ tst_a 1,fnv
+1be4 : 08 > php ;save flags
+1be5 : c901 > cmp #1 ;test result
+ > trap_ne
+1be7 : d0fe > bne * ;failed not equal (non zero)
+ >
+1be9 : 68 > pla ;load status
+1bea : 48 > pha
+ > cmp_flag fnv
+1beb : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1bed : d0fe > bne * ;failed not equal (non zero)
+ >
+1bef : 28 > plp ;restore status
+
+
+ set_a $ff,$ff
+ > load_flag $ff
+1bf0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1bf2 : 48 > pha ;use stack to load status
+1bf3 : a9ff > lda #$ff ;precharge accu
+1bf5 : 28 > plp
+
+1bf6 : 2c0b02 bit abs1+3 ;00 - should set Z / clear NV
+ tst_a $ff,~fnv
+1bf9 : 08 > php ;save flags
+1bfa : c9ff > cmp #$ff ;test result
+ > trap_ne
+1bfc : d0fe > bne * ;failed not equal (non zero)
+ >
+1bfe : 68 > pla ;load status
+1bff : 48 > pha
+ > cmp_flag ~fnv
+1c00 : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c02 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c04 : 28 > plp ;restore status
+
+ set_a 1,$ff
+ > load_flag $ff
+1c05 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1c07 : 48 > pha ;use stack to load status
+1c08 : a901 > lda #1 ;precharge accu
+1c0a : 28 > plp
+
+1c0b : 2c0a02 bit abs1+2 ;41 - should set V (M6) / clear NZ
+ tst_a 1,~fnz
+1c0e : 08 > php ;save flags
+1c0f : c901 > cmp #1 ;test result
+ > trap_ne
+1c11 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c13 : 68 > pla ;load status
+1c14 : 48 > pha
+ > cmp_flag ~fnz
+1c15 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c17 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c19 : 28 > plp ;restore status
+
+ set_a 1,$ff
+ > load_flag $ff
+1c1a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1c1c : 48 > pha ;use stack to load status
+1c1d : a901 > lda #1 ;precharge accu
+1c1f : 28 > plp
+
+1c20 : 2c0902 bit abs1+1 ;82 - should set N (M7) & Z / clear V
+ tst_a 1,~fv
+1c23 : 08 > php ;save flags
+1c24 : c901 > cmp #1 ;test result
+ > trap_ne
+1c26 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c28 : 68 > pla ;load status
+1c29 : 48 > pha
+ > cmp_flag ~fv
+1c2a : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c2c : d0fe > bne * ;failed not equal (non zero)
+ >
+1c2e : 28 > plp ;restore status
+
+ set_a 1,$ff
+ > load_flag $ff
+1c2f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1c31 : 48 > pha ;use stack to load status
+1c32 : a901 > lda #1 ;precharge accu
+1c34 : 28 > plp
+
+1c35 : 2c0802 bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z
+ tst_a 1,~fz
+1c38 : 08 > php ;save flags
+1c39 : c901 > cmp #1 ;test result
+ > trap_ne
+1c3b : d0fe > bne * ;failed not equal (non zero)
+ >
+1c3d : 68 > pla ;load status
+1c3e : 48 > pha
+ > cmp_flag ~fz
+1c3f : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c41 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c43 : 28 > plp ;restore status
+
+ next_test
+1c44 : ad0002 > lda test_case ;previous test
+1c47 : c919 > cmp #test_num
+ > trap_ne ;test is out of sequence
+1c49 : d0fe > bne * ;failed not equal (non zero)
+ >
+001a = >test_num = test_num + 1
+1c4b : a91a > lda #test_num ;*** next tests' number
+1c4d : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; CPX - zp / abs / #
+ set_x $80,0
+ > load_flag 0
+1c50 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1c52 : 48 > pha ;use stack to load status
+1c53 : a280 > ldx #$80 ;precharge index x
+1c55 : 28 > plp
+
+1c56 : e417 cpx zp7f
+ tst_stat fc
+1c58 : 08 > php ;save status
+1c59 : 68 > pla ;use stack to retrieve status
+1c5a : 48 > pha
+ > cmp_flag fc
+1c5b : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c5d : d0fe > bne * ;failed not equal (non zero)
+ >
+1c5f : 28 > plp ;restore status
+
+1c60 : ca dex
+1c61 : e417 cpx zp7f
+ tst_stat fzc
+1c63 : 08 > php ;save status
+1c64 : 68 > pla ;use stack to retrieve status
+1c65 : 48 > pha
+ > cmp_flag fzc
+1c66 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c68 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c6a : 28 > plp ;restore status
+
+1c6b : ca dex
+1c6c : e417 cpx zp7f
+ tst_x $7e,fn
+1c6e : 08 > php ;save flags
+1c6f : e07e > cpx #$7e ;test result
+ > trap_ne
+1c71 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c73 : 68 > pla ;load status
+1c74 : 48 > pha
+ > cmp_flag fn
+1c75 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c77 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c79 : 28 > plp ;restore status
+
+ set_x $80,$ff
+ > load_flag $ff
+1c7a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1c7c : 48 > pha ;use stack to load status
+1c7d : a280 > ldx #$80 ;precharge index x
+1c7f : 28 > plp
+
+1c80 : e417 cpx zp7f
+ tst_stat ~fnz
+1c82 : 08 > php ;save status
+1c83 : 68 > pla ;use stack to retrieve status
+1c84 : 48 > pha
+ > cmp_flag ~fnz
+1c85 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c87 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c89 : 28 > plp ;restore status
+
+1c8a : ca dex
+1c8b : e417 cpx zp7f
+ tst_stat ~fn
+1c8d : 08 > php ;save status
+1c8e : 68 > pla ;use stack to retrieve status
+1c8f : 48 > pha
+ > cmp_flag ~fn
+1c90 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c92 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c94 : 28 > plp ;restore status
+
+1c95 : ca dex
+1c96 : e417 cpx zp7f
+ tst_x $7e,~fzc
+1c98 : 08 > php ;save flags
+1c99 : e07e > cpx #$7e ;test result
+ > trap_ne
+1c9b : d0fe > bne * ;failed not equal (non zero)
+ >
+1c9d : 68 > pla ;load status
+1c9e : 48 > pha
+ > cmp_flag ~fzc
+1c9f : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ca1 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ca3 : 28 > plp ;restore status
+
+
+ set_x $80,0
+ > load_flag 0
+1ca4 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1ca6 : 48 > pha ;use stack to load status
+1ca7 : a280 > ldx #$80 ;precharge index x
+1ca9 : 28 > plp
+
+1caa : ec0c02 cpx abs7f
+ tst_stat fc
+1cad : 08 > php ;save status
+1cae : 68 > pla ;use stack to retrieve status
+1caf : 48 > pha
+ > cmp_flag fc
+1cb0 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1cb2 : d0fe > bne * ;failed not equal (non zero)
+ >
+1cb4 : 28 > plp ;restore status
+
+1cb5 : ca dex
+1cb6 : ec0c02 cpx abs7f
+ tst_stat fzc
+1cb9 : 08 > php ;save status
+1cba : 68 > pla ;use stack to retrieve status
+1cbb : 48 > pha
+ > cmp_flag fzc
+1cbc : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1cbe : d0fe > bne * ;failed not equal (non zero)
+ >
+1cc0 : 28 > plp ;restore status
+
+1cc1 : ca dex
+1cc2 : ec0c02 cpx abs7f
+ tst_x $7e,fn
+1cc5 : 08 > php ;save flags
+1cc6 : e07e > cpx #$7e ;test result
+ > trap_ne
+1cc8 : d0fe > bne * ;failed not equal (non zero)
+ >
+1cca : 68 > pla ;load status
+1ccb : 48 > pha
+ > cmp_flag fn
+1ccc : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1cce : d0fe > bne * ;failed not equal (non zero)
+ >
+1cd0 : 28 > plp ;restore status
+
+ set_x $80,$ff
+ > load_flag $ff
+1cd1 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1cd3 : 48 > pha ;use stack to load status
+1cd4 : a280 > ldx #$80 ;precharge index x
+1cd6 : 28 > plp
+
+1cd7 : ec0c02 cpx abs7f
+ tst_stat ~fnz
+1cda : 08 > php ;save status
+1cdb : 68 > pla ;use stack to retrieve status
+1cdc : 48 > pha
+ > cmp_flag ~fnz
+1cdd : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1cdf : d0fe > bne * ;failed not equal (non zero)
+ >
+1ce1 : 28 > plp ;restore status
+
+1ce2 : ca dex
+1ce3 : ec0c02 cpx abs7f
+ tst_stat ~fn
+1ce6 : 08 > php ;save status
+1ce7 : 68 > pla ;use stack to retrieve status
+1ce8 : 48 > pha
+ > cmp_flag ~fn
+1ce9 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ceb : d0fe > bne * ;failed not equal (non zero)
+ >
+1ced : 28 > plp ;restore status
+
+1cee : ca dex
+1cef : ec0c02 cpx abs7f
+ tst_x $7e,~fzc
+1cf2 : 08 > php ;save flags
+1cf3 : e07e > cpx #$7e ;test result
+ > trap_ne
+1cf5 : d0fe > bne * ;failed not equal (non zero)
+ >
+1cf7 : 68 > pla ;load status
+1cf8 : 48 > pha
+ > cmp_flag ~fzc
+1cf9 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1cfb : d0fe > bne * ;failed not equal (non zero)
+ >
+1cfd : 28 > plp ;restore status
+
+
+ set_x $80,0
+ > load_flag 0
+1cfe : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1d00 : 48 > pha ;use stack to load status
+1d01 : a280 > ldx #$80 ;precharge index x
+1d03 : 28 > plp
+
+1d04 : e07f cpx #$7f
+ tst_stat fc
+1d06 : 08 > php ;save status
+1d07 : 68 > pla ;use stack to retrieve status
+1d08 : 48 > pha
+ > cmp_flag fc
+1d09 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1d0b : d0fe > bne * ;failed not equal (non zero)
+ >
+1d0d : 28 > plp ;restore status
+
+1d0e : ca dex
+1d0f : e07f cpx #$7f
+ tst_stat fzc
+1d11 : 08 > php ;save status
+1d12 : 68 > pla ;use stack to retrieve status
+1d13 : 48 > pha
+ > cmp_flag fzc
+1d14 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1d16 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d18 : 28 > plp ;restore status
+
+1d19 : ca dex
+1d1a : e07f cpx #$7f
+ tst_x $7e,fn
+1d1c : 08 > php ;save flags
+1d1d : e07e > cpx #$7e ;test result
+ > trap_ne
+1d1f : d0fe > bne * ;failed not equal (non zero)
+ >
+1d21 : 68 > pla ;load status
+1d22 : 48 > pha
+ > cmp_flag fn
+1d23 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1d25 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d27 : 28 > plp ;restore status
+
+ set_x $80,$ff
+ > load_flag $ff
+1d28 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1d2a : 48 > pha ;use stack to load status
+1d2b : a280 > ldx #$80 ;precharge index x
+1d2d : 28 > plp
+
+1d2e : e07f cpx #$7f
+ tst_stat ~fnz
+1d30 : 08 > php ;save status
+1d31 : 68 > pla ;use stack to retrieve status
+1d32 : 48 > pha
+ > cmp_flag ~fnz
+1d33 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1d35 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d37 : 28 > plp ;restore status
+
+1d38 : ca dex
+1d39 : e07f cpx #$7f
+ tst_stat ~fn
+1d3b : 08 > php ;save status
+1d3c : 68 > pla ;use stack to retrieve status
+1d3d : 48 > pha
+ > cmp_flag ~fn
+1d3e : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1d40 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d42 : 28 > plp ;restore status
+
+1d43 : ca dex
+1d44 : e07f cpx #$7f
+ tst_x $7e,~fzc
+1d46 : 08 > php ;save flags
+1d47 : e07e > cpx #$7e ;test result
+ > trap_ne
+1d49 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d4b : 68 > pla ;load status
+1d4c : 48 > pha
+ > cmp_flag ~fzc
+1d4d : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1d4f : d0fe > bne * ;failed not equal (non zero)
+ >
+1d51 : 28 > plp ;restore status
+
+ next_test
+1d52 : ad0002 > lda test_case ;previous test
+1d55 : c91a > cmp #test_num
+ > trap_ne ;test is out of sequence
+1d57 : d0fe > bne * ;failed not equal (non zero)
+ >
+001b = >test_num = test_num + 1
+1d59 : a91b > lda #test_num ;*** next tests' number
+1d5b : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; CPY - zp / abs / #
+ set_y $80,0
+ > load_flag 0
+1d5e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1d60 : 48 > pha ;use stack to load status
+1d61 : a080 > ldy #$80 ;precharge index y
+1d63 : 28 > plp
+
+1d64 : c417 cpy zp7f
+ tst_stat fc
+1d66 : 08 > php ;save status
+1d67 : 68 > pla ;use stack to retrieve status
+1d68 : 48 > pha
+ > cmp_flag fc
+1d69 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1d6b : d0fe > bne * ;failed not equal (non zero)
+ >
+1d6d : 28 > plp ;restore status
+
+1d6e : 88 dey
+1d6f : c417 cpy zp7f
+ tst_stat fzc
+1d71 : 08 > php ;save status
+1d72 : 68 > pla ;use stack to retrieve status
+1d73 : 48 > pha
+ > cmp_flag fzc
+1d74 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1d76 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d78 : 28 > plp ;restore status
+
+1d79 : 88 dey
+1d7a : c417 cpy zp7f
+ tst_y $7e,fn
+1d7c : 08 > php ;save flags
+1d7d : c07e > cpy #$7e ;test result
+ > trap_ne
+1d7f : d0fe > bne * ;failed not equal (non zero)
+ >
+1d81 : 68 > pla ;load status
+1d82 : 48 > pha
+ > cmp_flag fn
+1d83 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1d85 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d87 : 28 > plp ;restore status
+
+ set_y $80,$ff
+ > load_flag $ff
+1d88 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1d8a : 48 > pha ;use stack to load status
+1d8b : a080 > ldy #$80 ;precharge index y
+1d8d : 28 > plp
+
+1d8e : c417 cpy zp7f
+ tst_stat ~fnz
+1d90 : 08 > php ;save status
+1d91 : 68 > pla ;use stack to retrieve status
+1d92 : 48 > pha
+ > cmp_flag ~fnz
+1d93 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1d95 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d97 : 28 > plp ;restore status
+
+1d98 : 88 dey
+1d99 : c417 cpy zp7f
+ tst_stat ~fn
+1d9b : 08 > php ;save status
+1d9c : 68 > pla ;use stack to retrieve status
+1d9d : 48 > pha
+ > cmp_flag ~fn
+1d9e : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1da0 : d0fe > bne * ;failed not equal (non zero)
+ >
+1da2 : 28 > plp ;restore status
+
+1da3 : 88 dey
+1da4 : c417 cpy zp7f
+ tst_y $7e,~fzc
+1da6 : 08 > php ;save flags
+1da7 : c07e > cpy #$7e ;test result
+ > trap_ne
+1da9 : d0fe > bne * ;failed not equal (non zero)
+ >
+1dab : 68 > pla ;load status
+1dac : 48 > pha
+ > cmp_flag ~fzc
+1dad : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1daf : d0fe > bne * ;failed not equal (non zero)
+ >
+1db1 : 28 > plp ;restore status
+
+
+ set_y $80,0
+ > load_flag 0
+1db2 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1db4 : 48 > pha ;use stack to load status
+1db5 : a080 > ldy #$80 ;precharge index y
+1db7 : 28 > plp
+
+1db8 : cc0c02 cpy abs7f
+ tst_stat fc
+1dbb : 08 > php ;save status
+1dbc : 68 > pla ;use stack to retrieve status
+1dbd : 48 > pha
+ > cmp_flag fc
+1dbe : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1dc0 : d0fe > bne * ;failed not equal (non zero)
+ >
+1dc2 : 28 > plp ;restore status
+
+1dc3 : 88 dey
+1dc4 : cc0c02 cpy abs7f
+ tst_stat fzc
+1dc7 : 08 > php ;save status
+1dc8 : 68 > pla ;use stack to retrieve status
+1dc9 : 48 > pha
+ > cmp_flag fzc
+1dca : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1dcc : d0fe > bne * ;failed not equal (non zero)
+ >
+1dce : 28 > plp ;restore status
+
+1dcf : 88 dey
+1dd0 : cc0c02 cpy abs7f
+ tst_y $7e,fn
+1dd3 : 08 > php ;save flags
+1dd4 : c07e > cpy #$7e ;test result
+ > trap_ne
+1dd6 : d0fe > bne * ;failed not equal (non zero)
+ >
+1dd8 : 68 > pla ;load status
+1dd9 : 48 > pha
+ > cmp_flag fn
+1dda : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ddc : d0fe > bne * ;failed not equal (non zero)
+ >
+1dde : 28 > plp ;restore status
+
+ set_y $80,$ff
+ > load_flag $ff
+1ddf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1de1 : 48 > pha ;use stack to load status
+1de2 : a080 > ldy #$80 ;precharge index y
+1de4 : 28 > plp
+
+1de5 : cc0c02 cpy abs7f
+ tst_stat ~fnz
+1de8 : 08 > php ;save status
+1de9 : 68 > pla ;use stack to retrieve status
+1dea : 48 > pha
+ > cmp_flag ~fnz
+1deb : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ded : d0fe > bne * ;failed not equal (non zero)
+ >
+1def : 28 > plp ;restore status
+
+1df0 : 88 dey
+1df1 : cc0c02 cpy abs7f
+ tst_stat ~fn
+1df4 : 08 > php ;save status
+1df5 : 68 > pla ;use stack to retrieve status
+1df6 : 48 > pha
+ > cmp_flag ~fn
+1df7 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1df9 : d0fe > bne * ;failed not equal (non zero)
+ >
+1dfb : 28 > plp ;restore status
+
+1dfc : 88 dey
+1dfd : cc0c02 cpy abs7f
+ tst_y $7e,~fzc
+1e00 : 08 > php ;save flags
+1e01 : c07e > cpy #$7e ;test result
+ > trap_ne
+1e03 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e05 : 68 > pla ;load status
+1e06 : 48 > pha
+ > cmp_flag ~fzc
+1e07 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e09 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e0b : 28 > plp ;restore status
+
+
+ set_y $80,0
+ > load_flag 0
+1e0c : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1e0e : 48 > pha ;use stack to load status
+1e0f : a080 > ldy #$80 ;precharge index y
+1e11 : 28 > plp
+
+1e12 : c07f cpy #$7f
+ tst_stat fc
+1e14 : 08 > php ;save status
+1e15 : 68 > pla ;use stack to retrieve status
+1e16 : 48 > pha
+ > cmp_flag fc
+1e17 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e19 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e1b : 28 > plp ;restore status
+
+1e1c : 88 dey
+1e1d : c07f cpy #$7f
+ tst_stat fzc
+1e1f : 08 > php ;save status
+1e20 : 68 > pla ;use stack to retrieve status
+1e21 : 48 > pha
+ > cmp_flag fzc
+1e22 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e24 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e26 : 28 > plp ;restore status
+
+1e27 : 88 dey
+1e28 : c07f cpy #$7f
+ tst_y $7e,fn
+1e2a : 08 > php ;save flags
+1e2b : c07e > cpy #$7e ;test result
+ > trap_ne
+1e2d : d0fe > bne * ;failed not equal (non zero)
+ >
+1e2f : 68 > pla ;load status
+1e30 : 48 > pha
+ > cmp_flag fn
+1e31 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e33 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e35 : 28 > plp ;restore status
+
+ set_y $80,$ff
+ > load_flag $ff
+1e36 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1e38 : 48 > pha ;use stack to load status
+1e39 : a080 > ldy #$80 ;precharge index y
+1e3b : 28 > plp
+
+1e3c : c07f cpy #$7f
+ tst_stat ~fnz
+1e3e : 08 > php ;save status
+1e3f : 68 > pla ;use stack to retrieve status
+1e40 : 48 > pha
+ > cmp_flag ~fnz
+1e41 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e43 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e45 : 28 > plp ;restore status
+
+1e46 : 88 dey
+1e47 : c07f cpy #$7f
+ tst_stat ~fn
+1e49 : 08 > php ;save status
+1e4a : 68 > pla ;use stack to retrieve status
+1e4b : 48 > pha
+ > cmp_flag ~fn
+1e4c : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e4e : d0fe > bne * ;failed not equal (non zero)
+ >
+1e50 : 28 > plp ;restore status
+
+1e51 : 88 dey
+1e52 : c07f cpy #$7f
+ tst_y $7e,~fzc
+1e54 : 08 > php ;save flags
+1e55 : c07e > cpy #$7e ;test result
+ > trap_ne
+1e57 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e59 : 68 > pla ;load status
+1e5a : 48 > pha
+ > cmp_flag ~fzc
+1e5b : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e5d : d0fe > bne * ;failed not equal (non zero)
+ >
+1e5f : 28 > plp ;restore status
+
+ next_test
+1e60 : ad0002 > lda test_case ;previous test
+1e63 : c91b > cmp #test_num
+ > trap_ne ;test is out of sequence
+1e65 : d0fe > bne * ;failed not equal (non zero)
+ >
+001c = >test_num = test_num + 1
+1e67 : a91c > lda #test_num ;*** next tests' number
+1e69 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; CMP - zp / abs / #
+ set_a $80,0
+ > load_flag 0
+1e6c : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1e6e : 48 > pha ;use stack to load status
+1e6f : a980 > lda #$80 ;precharge accu
+1e71 : 28 > plp
+
+1e72 : c517 cmp zp7f
+ tst_a $80,fc
+1e74 : 08 > php ;save flags
+1e75 : c980 > cmp #$80 ;test result
+ > trap_ne
+1e77 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e79 : 68 > pla ;load status
+1e7a : 48 > pha
+ > cmp_flag fc
+1e7b : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e7d : d0fe > bne * ;failed not equal (non zero)
+ >
+1e7f : 28 > plp ;restore status
+
+ set_a $7f,0
+ > load_flag 0
+1e80 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1e82 : 48 > pha ;use stack to load status
+1e83 : a97f > lda #$7f ;precharge accu
+1e85 : 28 > plp
+
+1e86 : c517 cmp zp7f
+ tst_a $7f,fzc
+1e88 : 08 > php ;save flags
+1e89 : c97f > cmp #$7f ;test result
+ > trap_ne
+1e8b : d0fe > bne * ;failed not equal (non zero)
+ >
+1e8d : 68 > pla ;load status
+1e8e : 48 > pha
+ > cmp_flag fzc
+1e8f : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e91 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e93 : 28 > plp ;restore status
+
+ set_a $7e,0
+ > load_flag 0
+1e94 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1e96 : 48 > pha ;use stack to load status
+1e97 : a97e > lda #$7e ;precharge accu
+1e99 : 28 > plp
+
+1e9a : c517 cmp zp7f
+ tst_a $7e,fn
+1e9c : 08 > php ;save flags
+1e9d : c97e > cmp #$7e ;test result
+ > trap_ne
+1e9f : d0fe > bne * ;failed not equal (non zero)
+ >
+1ea1 : 68 > pla ;load status
+1ea2 : 48 > pha
+ > cmp_flag fn
+1ea3 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ea5 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ea7 : 28 > plp ;restore status
+
+ set_a $80,$ff
+ > load_flag $ff
+1ea8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1eaa : 48 > pha ;use stack to load status
+1eab : a980 > lda #$80 ;precharge accu
+1ead : 28 > plp
+
+1eae : c517 cmp zp7f
+ tst_a $80,~fnz
+1eb0 : 08 > php ;save flags
+1eb1 : c980 > cmp #$80 ;test result
+ > trap_ne
+1eb3 : d0fe > bne * ;failed not equal (non zero)
+ >
+1eb5 : 68 > pla ;load status
+1eb6 : 48 > pha
+ > cmp_flag ~fnz
+1eb7 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1eb9 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ebb : 28 > plp ;restore status
+
+ set_a $7f,$ff
+ > load_flag $ff
+1ebc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1ebe : 48 > pha ;use stack to load status
+1ebf : a97f > lda #$7f ;precharge accu
+1ec1 : 28 > plp
+
+1ec2 : c517 cmp zp7f
+ tst_a $7f,~fn
+1ec4 : 08 > php ;save flags
+1ec5 : c97f > cmp #$7f ;test result
+ > trap_ne
+1ec7 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ec9 : 68 > pla ;load status
+1eca : 48 > pha
+ > cmp_flag ~fn
+1ecb : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ecd : d0fe > bne * ;failed not equal (non zero)
+ >
+1ecf : 28 > plp ;restore status
+
+ set_a $7e,$ff
+ > load_flag $ff
+1ed0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1ed2 : 48 > pha ;use stack to load status
+1ed3 : a97e > lda #$7e ;precharge accu
+1ed5 : 28 > plp
+
+1ed6 : c517 cmp zp7f
+ tst_a $7e,~fzc
+1ed8 : 08 > php ;save flags
+1ed9 : c97e > cmp #$7e ;test result
+ > trap_ne
+1edb : d0fe > bne * ;failed not equal (non zero)
+ >
+1edd : 68 > pla ;load status
+1ede : 48 > pha
+ > cmp_flag ~fzc
+1edf : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ee1 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ee3 : 28 > plp ;restore status
+
+
+ set_a $80,0
+ > load_flag 0
+1ee4 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1ee6 : 48 > pha ;use stack to load status
+1ee7 : a980 > lda #$80 ;precharge accu
+1ee9 : 28 > plp
+
+1eea : cd0c02 cmp abs7f
+ tst_a $80,fc
+1eed : 08 > php ;save flags
+1eee : c980 > cmp #$80 ;test result
+ > trap_ne
+1ef0 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ef2 : 68 > pla ;load status
+1ef3 : 48 > pha
+ > cmp_flag fc
+1ef4 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ef6 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ef8 : 28 > plp ;restore status
+
+ set_a $7f,0
+ > load_flag 0
+1ef9 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1efb : 48 > pha ;use stack to load status
+1efc : a97f > lda #$7f ;precharge accu
+1efe : 28 > plp
+
+1eff : cd0c02 cmp abs7f
+ tst_a $7f,fzc
+1f02 : 08 > php ;save flags
+1f03 : c97f > cmp #$7f ;test result
+ > trap_ne
+1f05 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f07 : 68 > pla ;load status
+1f08 : 48 > pha
+ > cmp_flag fzc
+1f09 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f0b : d0fe > bne * ;failed not equal (non zero)
+ >
+1f0d : 28 > plp ;restore status
+
+ set_a $7e,0
+ > load_flag 0
+1f0e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1f10 : 48 > pha ;use stack to load status
+1f11 : a97e > lda #$7e ;precharge accu
+1f13 : 28 > plp
+
+1f14 : cd0c02 cmp abs7f
+ tst_a $7e,fn
+1f17 : 08 > php ;save flags
+1f18 : c97e > cmp #$7e ;test result
+ > trap_ne
+1f1a : d0fe > bne * ;failed not equal (non zero)
+ >
+1f1c : 68 > pla ;load status
+1f1d : 48 > pha
+ > cmp_flag fn
+1f1e : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f20 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f22 : 28 > plp ;restore status
+
+ set_a $80,$ff
+ > load_flag $ff
+1f23 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1f25 : 48 > pha ;use stack to load status
+1f26 : a980 > lda #$80 ;precharge accu
+1f28 : 28 > plp
+
+1f29 : cd0c02 cmp abs7f
+ tst_a $80,~fnz
+1f2c : 08 > php ;save flags
+1f2d : c980 > cmp #$80 ;test result
+ > trap_ne
+1f2f : d0fe > bne * ;failed not equal (non zero)
+ >
+1f31 : 68 > pla ;load status
+1f32 : 48 > pha
+ > cmp_flag ~fnz
+1f33 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f35 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f37 : 28 > plp ;restore status
+
+ set_a $7f,$ff
+ > load_flag $ff
+1f38 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1f3a : 48 > pha ;use stack to load status
+1f3b : a97f > lda #$7f ;precharge accu
+1f3d : 28 > plp
+
+1f3e : cd0c02 cmp abs7f
+ tst_a $7f,~fn
+1f41 : 08 > php ;save flags
+1f42 : c97f > cmp #$7f ;test result
+ > trap_ne
+1f44 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f46 : 68 > pla ;load status
+1f47 : 48 > pha
+ > cmp_flag ~fn
+1f48 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f4a : d0fe > bne * ;failed not equal (non zero)
+ >
+1f4c : 28 > plp ;restore status
+
+ set_a $7e,$ff
+ > load_flag $ff
+1f4d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1f4f : 48 > pha ;use stack to load status
+1f50 : a97e > lda #$7e ;precharge accu
+1f52 : 28 > plp
+
+1f53 : cd0c02 cmp abs7f
+ tst_a $7e,~fzc
+1f56 : 08 > php ;save flags
+1f57 : c97e > cmp #$7e ;test result
+ > trap_ne
+1f59 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f5b : 68 > pla ;load status
+1f5c : 48 > pha
+ > cmp_flag ~fzc
+1f5d : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f5f : d0fe > bne * ;failed not equal (non zero)
+ >
+1f61 : 28 > plp ;restore status
+
+
+ set_a $80,0
+ > load_flag 0
+1f62 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1f64 : 48 > pha ;use stack to load status
+1f65 : a980 > lda #$80 ;precharge accu
+1f67 : 28 > plp
+
+1f68 : c97f cmp #$7f
+ tst_a $80,fc
+1f6a : 08 > php ;save flags
+1f6b : c980 > cmp #$80 ;test result
+ > trap_ne
+1f6d : d0fe > bne * ;failed not equal (non zero)
+ >
+1f6f : 68 > pla ;load status
+1f70 : 48 > pha
+ > cmp_flag fc
+1f71 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f73 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f75 : 28 > plp ;restore status
+
+ set_a $7f,0
+ > load_flag 0
+1f76 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1f78 : 48 > pha ;use stack to load status
+1f79 : a97f > lda #$7f ;precharge accu
+1f7b : 28 > plp
+
+1f7c : c97f cmp #$7f
+ tst_a $7f,fzc
+1f7e : 08 > php ;save flags
+1f7f : c97f > cmp #$7f ;test result
+ > trap_ne
+1f81 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f83 : 68 > pla ;load status
+1f84 : 48 > pha
+ > cmp_flag fzc
+1f85 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f87 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f89 : 28 > plp ;restore status
+
+ set_a $7e,0
+ > load_flag 0
+1f8a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1f8c : 48 > pha ;use stack to load status
+1f8d : a97e > lda #$7e ;precharge accu
+1f8f : 28 > plp
+
+1f90 : c97f cmp #$7f
+ tst_a $7e,fn
+1f92 : 08 > php ;save flags
+1f93 : c97e > cmp #$7e ;test result
+ > trap_ne
+1f95 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f97 : 68 > pla ;load status
+1f98 : 48 > pha
+ > cmp_flag fn
+1f99 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f9b : d0fe > bne * ;failed not equal (non zero)
+ >
+1f9d : 28 > plp ;restore status
+
+ set_a $80,$ff
+ > load_flag $ff
+1f9e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1fa0 : 48 > pha ;use stack to load status
+1fa1 : a980 > lda #$80 ;precharge accu
+1fa3 : 28 > plp
+
+1fa4 : c97f cmp #$7f
+ tst_a $80,~fnz
+1fa6 : 08 > php ;save flags
+1fa7 : c980 > cmp #$80 ;test result
+ > trap_ne
+1fa9 : d0fe > bne * ;failed not equal (non zero)
+ >
+1fab : 68 > pla ;load status
+1fac : 48 > pha
+ > cmp_flag ~fnz
+1fad : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1faf : d0fe > bne * ;failed not equal (non zero)
+ >
+1fb1 : 28 > plp ;restore status
+
+ set_a $7f,$ff
+ > load_flag $ff
+1fb2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1fb4 : 48 > pha ;use stack to load status
+1fb5 : a97f > lda #$7f ;precharge accu
+1fb7 : 28 > plp
+
+1fb8 : c97f cmp #$7f
+ tst_a $7f,~fn
+1fba : 08 > php ;save flags
+1fbb : c97f > cmp #$7f ;test result
+ > trap_ne
+1fbd : d0fe > bne * ;failed not equal (non zero)
+ >
+1fbf : 68 > pla ;load status
+1fc0 : 48 > pha
+ > cmp_flag ~fn
+1fc1 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1fc3 : d0fe > bne * ;failed not equal (non zero)
+ >
+1fc5 : 28 > plp ;restore status
+
+ set_a $7e,$ff
+ > load_flag $ff
+1fc6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1fc8 : 48 > pha ;use stack to load status
+1fc9 : a97e > lda #$7e ;precharge accu
+1fcb : 28 > plp
+
+1fcc : c97f cmp #$7f
+ tst_a $7e,~fzc
+1fce : 08 > php ;save flags
+1fcf : c97e > cmp #$7e ;test result
+ > trap_ne
+1fd1 : d0fe > bne * ;failed not equal (non zero)
+ >
+1fd3 : 68 > pla ;load status
+1fd4 : 48 > pha
+ > cmp_flag ~fzc
+1fd5 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1fd7 : d0fe > bne * ;failed not equal (non zero)
+ >
+1fd9 : 28 > plp ;restore status
+
+
+1fda : a204 ldx #4 ;with indexing by X
+ set_a $80,0
+ > load_flag 0
+1fdc : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1fde : 48 > pha ;use stack to load status
+1fdf : a980 > lda #$80 ;precharge accu
+1fe1 : 28 > plp
+
+1fe2 : d513 cmp zp1,x
+ tst_a $80,fc
+1fe4 : 08 > php ;save flags
+1fe5 : c980 > cmp #$80 ;test result
+ > trap_ne
+1fe7 : d0fe > bne * ;failed not equal (non zero)
+ >
+1fe9 : 68 > pla ;load status
+1fea : 48 > pha
+ > cmp_flag fc
+1feb : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1fed : d0fe > bne * ;failed not equal (non zero)
+ >
+1fef : 28 > plp ;restore status
+
+ set_a $7f,0
+ > load_flag 0
+1ff0 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1ff2 : 48 > pha ;use stack to load status
+1ff3 : a97f > lda #$7f ;precharge accu
+1ff5 : 28 > plp
+
+1ff6 : d513 cmp zp1,x
+ tst_a $7f,fzc
+1ff8 : 08 > php ;save flags
+1ff9 : c97f > cmp #$7f ;test result
+ > trap_ne
+1ffb : d0fe > bne * ;failed not equal (non zero)
+ >
+1ffd : 68 > pla ;load status
+1ffe : 48 > pha
+ > cmp_flag fzc
+1fff : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2001 : d0fe > bne * ;failed not equal (non zero)
+ >
+2003 : 28 > plp ;restore status
+
+ set_a $7e,0
+ > load_flag 0
+2004 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2006 : 48 > pha ;use stack to load status
+2007 : a97e > lda #$7e ;precharge accu
+2009 : 28 > plp
+
+200a : d513 cmp zp1,x
+ tst_a $7e,fn
+200c : 08 > php ;save flags
+200d : c97e > cmp #$7e ;test result
+ > trap_ne
+200f : d0fe > bne * ;failed not equal (non zero)
+ >
+2011 : 68 > pla ;load status
+2012 : 48 > pha
+ > cmp_flag fn
+2013 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2015 : d0fe > bne * ;failed not equal (non zero)
+ >
+2017 : 28 > plp ;restore status
+
+ set_a $80,$ff
+ > load_flag $ff
+2018 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+201a : 48 > pha ;use stack to load status
+201b : a980 > lda #$80 ;precharge accu
+201d : 28 > plp
+
+201e : d513 cmp zp1,x
+ tst_a $80,~fnz
+2020 : 08 > php ;save flags
+2021 : c980 > cmp #$80 ;test result
+ > trap_ne
+2023 : d0fe > bne * ;failed not equal (non zero)
+ >
+2025 : 68 > pla ;load status
+2026 : 48 > pha
+ > cmp_flag ~fnz
+2027 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2029 : d0fe > bne * ;failed not equal (non zero)
+ >
+202b : 28 > plp ;restore status
+
+ set_a $7f,$ff
+ > load_flag $ff
+202c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+202e : 48 > pha ;use stack to load status
+202f : a97f > lda #$7f ;precharge accu
+2031 : 28 > plp
+
+2032 : d513 cmp zp1,x
+ tst_a $7f,~fn
+2034 : 08 > php ;save flags
+2035 : c97f > cmp #$7f ;test result
+ > trap_ne
+2037 : d0fe > bne * ;failed not equal (non zero)
+ >
+2039 : 68 > pla ;load status
+203a : 48 > pha
+ > cmp_flag ~fn
+203b : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+203d : d0fe > bne * ;failed not equal (non zero)
+ >
+203f : 28 > plp ;restore status
+
+ set_a $7e,$ff
+ > load_flag $ff
+2040 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2042 : 48 > pha ;use stack to load status
+2043 : a97e > lda #$7e ;precharge accu
+2045 : 28 > plp
+
+2046 : d513 cmp zp1,x
+ tst_a $7e,~fzc
+2048 : 08 > php ;save flags
+2049 : c97e > cmp #$7e ;test result
+ > trap_ne
+204b : d0fe > bne * ;failed not equal (non zero)
+ >
+204d : 68 > pla ;load status
+204e : 48 > pha
+ > cmp_flag ~fzc
+204f : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2051 : d0fe > bne * ;failed not equal (non zero)
+ >
+2053 : 28 > plp ;restore status
+
+
+ set_a $80,0
+ > load_flag 0
+2054 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2056 : 48 > pha ;use stack to load status
+2057 : a980 > lda #$80 ;precharge accu
+2059 : 28 > plp
+
+205a : dd0802 cmp abs1,x
+ tst_a $80,fc
+205d : 08 > php ;save flags
+205e : c980 > cmp #$80 ;test result
+ > trap_ne
+2060 : d0fe > bne * ;failed not equal (non zero)
+ >
+2062 : 68 > pla ;load status
+2063 : 48 > pha
+ > cmp_flag fc
+2064 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2066 : d0fe > bne * ;failed not equal (non zero)
+ >
+2068 : 28 > plp ;restore status
+
+ set_a $7f,0
+ > load_flag 0
+2069 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+206b : 48 > pha ;use stack to load status
+206c : a97f > lda #$7f ;precharge accu
+206e : 28 > plp
+
+206f : dd0802 cmp abs1,x
+ tst_a $7f,fzc
+2072 : 08 > php ;save flags
+2073 : c97f > cmp #$7f ;test result
+ > trap_ne
+2075 : d0fe > bne * ;failed not equal (non zero)
+ >
+2077 : 68 > pla ;load status
+2078 : 48 > pha
+ > cmp_flag fzc
+2079 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+207b : d0fe > bne * ;failed not equal (non zero)
+ >
+207d : 28 > plp ;restore status
+
+ set_a $7e,0
+ > load_flag 0
+207e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2080 : 48 > pha ;use stack to load status
+2081 : a97e > lda #$7e ;precharge accu
+2083 : 28 > plp
+
+2084 : dd0802 cmp abs1,x
+ tst_a $7e,fn
+2087 : 08 > php ;save flags
+2088 : c97e > cmp #$7e ;test result
+ > trap_ne
+208a : d0fe > bne * ;failed not equal (non zero)
+ >
+208c : 68 > pla ;load status
+208d : 48 > pha
+ > cmp_flag fn
+208e : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2090 : d0fe > bne * ;failed not equal (non zero)
+ >
+2092 : 28 > plp ;restore status
+
+ set_a $80,$ff
+ > load_flag $ff
+2093 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2095 : 48 > pha ;use stack to load status
+2096 : a980 > lda #$80 ;precharge accu
+2098 : 28 > plp
+
+2099 : dd0802 cmp abs1,x
+ tst_a $80,~fnz
+209c : 08 > php ;save flags
+209d : c980 > cmp #$80 ;test result
+ > trap_ne
+209f : d0fe > bne * ;failed not equal (non zero)
+ >
+20a1 : 68 > pla ;load status
+20a2 : 48 > pha
+ > cmp_flag ~fnz
+20a3 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+20a5 : d0fe > bne * ;failed not equal (non zero)
+ >
+20a7 : 28 > plp ;restore status
+
+ set_a $7f,$ff
+ > load_flag $ff
+20a8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+20aa : 48 > pha ;use stack to load status
+20ab : a97f > lda #$7f ;precharge accu
+20ad : 28 > plp
+
+20ae : dd0802 cmp abs1,x
+ tst_a $7f,~fn
+20b1 : 08 > php ;save flags
+20b2 : c97f > cmp #$7f ;test result
+ > trap_ne
+20b4 : d0fe > bne * ;failed not equal (non zero)
+ >
+20b6 : 68 > pla ;load status
+20b7 : 48 > pha
+ > cmp_flag ~fn
+20b8 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+20ba : d0fe > bne * ;failed not equal (non zero)
+ >
+20bc : 28 > plp ;restore status
+
+ set_a $7e,$ff
+ > load_flag $ff
+20bd : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+20bf : 48 > pha ;use stack to load status
+20c0 : a97e > lda #$7e ;precharge accu
+20c2 : 28 > plp
+
+20c3 : dd0802 cmp abs1,x
+ tst_a $7e,~fzc
+20c6 : 08 > php ;save flags
+20c7 : c97e > cmp #$7e ;test result
+ > trap_ne
+20c9 : d0fe > bne * ;failed not equal (non zero)
+ >
+20cb : 68 > pla ;load status
+20cc : 48 > pha
+ > cmp_flag ~fzc
+20cd : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+20cf : d0fe > bne * ;failed not equal (non zero)
+ >
+20d1 : 28 > plp ;restore status
+
+
+20d2 : a004 ldy #4 ;with indexing by Y
+20d4 : a208 ldx #8 ;with indexed indirect
+ set_a $80,0
+ > load_flag 0
+20d6 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+20d8 : 48 > pha ;use stack to load status
+20d9 : a980 > lda #$80 ;precharge accu
+20db : 28 > plp
+
+20dc : d90802 cmp abs1,y
+ tst_a $80,fc
+20df : 08 > php ;save flags
+20e0 : c980 > cmp #$80 ;test result
+ > trap_ne
+20e2 : d0fe > bne * ;failed not equal (non zero)
+ >
+20e4 : 68 > pla ;load status
+20e5 : 48 > pha
+ > cmp_flag fc
+20e6 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+20e8 : d0fe > bne * ;failed not equal (non zero)
+ >
+20ea : 28 > plp ;restore status
+
+ set_a $7f,0
+ > load_flag 0
+20eb : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+20ed : 48 > pha ;use stack to load status
+20ee : a97f > lda #$7f ;precharge accu
+20f0 : 28 > plp
+
+20f1 : d90802 cmp abs1,y
+ tst_a $7f,fzc
+20f4 : 08 > php ;save flags
+20f5 : c97f > cmp #$7f ;test result
+ > trap_ne
+20f7 : d0fe > bne * ;failed not equal (non zero)
+ >
+20f9 : 68 > pla ;load status
+20fa : 48 > pha
+ > cmp_flag fzc
+20fb : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+20fd : d0fe > bne * ;failed not equal (non zero)
+ >
+20ff : 28 > plp ;restore status
+
+ set_a $7e,0
+ > load_flag 0
+2100 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2102 : 48 > pha ;use stack to load status
+2103 : a97e > lda #$7e ;precharge accu
+2105 : 28 > plp
+
+2106 : d90802 cmp abs1,y
+ tst_a $7e,fn
+2109 : 08 > php ;save flags
+210a : c97e > cmp #$7e ;test result
+ > trap_ne
+210c : d0fe > bne * ;failed not equal (non zero)
+ >
+210e : 68 > pla ;load status
+210f : 48 > pha
+ > cmp_flag fn
+2110 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2112 : d0fe > bne * ;failed not equal (non zero)
+ >
+2114 : 28 > plp ;restore status
+
+ set_a $80,$ff
+ > load_flag $ff
+2115 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2117 : 48 > pha ;use stack to load status
+2118 : a980 > lda #$80 ;precharge accu
+211a : 28 > plp
+
+211b : d90802 cmp abs1,y
+ tst_a $80,~fnz
+211e : 08 > php ;save flags
+211f : c980 > cmp #$80 ;test result
+ > trap_ne
+2121 : d0fe > bne * ;failed not equal (non zero)
+ >
+2123 : 68 > pla ;load status
+2124 : 48 > pha
+ > cmp_flag ~fnz
+2125 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2127 : d0fe > bne * ;failed not equal (non zero)
+ >
+2129 : 28 > plp ;restore status
+
+ set_a $7f,$ff
+ > load_flag $ff
+212a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+212c : 48 > pha ;use stack to load status
+212d : a97f > lda #$7f ;precharge accu
+212f : 28 > plp
+
+2130 : d90802 cmp abs1,y
+ tst_a $7f,~fn
+2133 : 08 > php ;save flags
+2134 : c97f > cmp #$7f ;test result
+ > trap_ne
+2136 : d0fe > bne * ;failed not equal (non zero)
+ >
+2138 : 68 > pla ;load status
+2139 : 48 > pha
+ > cmp_flag ~fn
+213a : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+213c : d0fe > bne * ;failed not equal (non zero)
+ >
+213e : 28 > plp ;restore status
+
+ set_a $7e,$ff
+ > load_flag $ff
+213f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2141 : 48 > pha ;use stack to load status
+2142 : a97e > lda #$7e ;precharge accu
+2144 : 28 > plp
+
+2145 : d90802 cmp abs1,y
+ tst_a $7e,~fzc
+2148 : 08 > php ;save flags
+2149 : c97e > cmp #$7e ;test result
+ > trap_ne
+214b : d0fe > bne * ;failed not equal (non zero)
+ >
+214d : 68 > pla ;load status
+214e : 48 > pha
+ > cmp_flag ~fzc
+214f : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2151 : d0fe > bne * ;failed not equal (non zero)
+ >
+2153 : 28 > plp ;restore status
+
+
+ set_a $80,0
+ > load_flag 0
+2154 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2156 : 48 > pha ;use stack to load status
+2157 : a980 > lda #$80 ;precharge accu
+2159 : 28 > plp
+
+215a : c124 cmp (ind1,x)
+ tst_a $80,fc
+215c : 08 > php ;save flags
+215d : c980 > cmp #$80 ;test result
+ > trap_ne
+215f : d0fe > bne * ;failed not equal (non zero)
+ >
+2161 : 68 > pla ;load status
+2162 : 48 > pha
+ > cmp_flag fc
+2163 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2165 : d0fe > bne * ;failed not equal (non zero)
+ >
+2167 : 28 > plp ;restore status
+
+ set_a $7f,0
+ > load_flag 0
+2168 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+216a : 48 > pha ;use stack to load status
+216b : a97f > lda #$7f ;precharge accu
+216d : 28 > plp
+
+216e : c124 cmp (ind1,x)
+ tst_a $7f,fzc
+2170 : 08 > php ;save flags
+2171 : c97f > cmp #$7f ;test result
+ > trap_ne
+2173 : d0fe > bne * ;failed not equal (non zero)
+ >
+2175 : 68 > pla ;load status
+2176 : 48 > pha
+ > cmp_flag fzc
+2177 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2179 : d0fe > bne * ;failed not equal (non zero)
+ >
+217b : 28 > plp ;restore status
+
+ set_a $7e,0
+ > load_flag 0
+217c : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+217e : 48 > pha ;use stack to load status
+217f : a97e > lda #$7e ;precharge accu
+2181 : 28 > plp
+
+2182 : c124 cmp (ind1,x)
+ tst_a $7e,fn
+2184 : 08 > php ;save flags
+2185 : c97e > cmp #$7e ;test result
+ > trap_ne
+2187 : d0fe > bne * ;failed not equal (non zero)
+ >
+2189 : 68 > pla ;load status
+218a : 48 > pha
+ > cmp_flag fn
+218b : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+218d : d0fe > bne * ;failed not equal (non zero)
+ >
+218f : 28 > plp ;restore status
+
+ set_a $80,$ff
+ > load_flag $ff
+2190 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2192 : 48 > pha ;use stack to load status
+2193 : a980 > lda #$80 ;precharge accu
+2195 : 28 > plp
+
+2196 : c124 cmp (ind1,x)
+ tst_a $80,~fnz
+2198 : 08 > php ;save flags
+2199 : c980 > cmp #$80 ;test result
+ > trap_ne
+219b : d0fe > bne * ;failed not equal (non zero)
+ >
+219d : 68 > pla ;load status
+219e : 48 > pha
+ > cmp_flag ~fnz
+219f : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+21a1 : d0fe > bne * ;failed not equal (non zero)
+ >
+21a3 : 28 > plp ;restore status
+
+ set_a $7f,$ff
+ > load_flag $ff
+21a4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+21a6 : 48 > pha ;use stack to load status
+21a7 : a97f > lda #$7f ;precharge accu
+21a9 : 28 > plp
+
+21aa : c124 cmp (ind1,x)
+ tst_a $7f,~fn
+21ac : 08 > php ;save flags
+21ad : c97f > cmp #$7f ;test result
+ > trap_ne
+21af : d0fe > bne * ;failed not equal (non zero)
+ >
+21b1 : 68 > pla ;load status
+21b2 : 48 > pha
+ > cmp_flag ~fn
+21b3 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+21b5 : d0fe > bne * ;failed not equal (non zero)
+ >
+21b7 : 28 > plp ;restore status
+
+ set_a $7e,$ff
+ > load_flag $ff
+21b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+21ba : 48 > pha ;use stack to load status
+21bb : a97e > lda #$7e ;precharge accu
+21bd : 28 > plp
+
+21be : c124 cmp (ind1,x)
+ tst_a $7e,~fzc
+21c0 : 08 > php ;save flags
+21c1 : c97e > cmp #$7e ;test result
+ > trap_ne
+21c3 : d0fe > bne * ;failed not equal (non zero)
+ >
+21c5 : 68 > pla ;load status
+21c6 : 48 > pha
+ > cmp_flag ~fzc
+21c7 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+21c9 : d0fe > bne * ;failed not equal (non zero)
+ >
+21cb : 28 > plp ;restore status
+
+
+ set_a $80,0
+ > load_flag 0
+21cc : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+21ce : 48 > pha ;use stack to load status
+21cf : a980 > lda #$80 ;precharge accu
+21d1 : 28 > plp
+
+21d2 : d124 cmp (ind1),y
+ tst_a $80,fc
+21d4 : 08 > php ;save flags
+21d5 : c980 > cmp #$80 ;test result
+ > trap_ne
+21d7 : d0fe > bne * ;failed not equal (non zero)
+ >
+21d9 : 68 > pla ;load status
+21da : 48 > pha
+ > cmp_flag fc
+21db : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+21dd : d0fe > bne * ;failed not equal (non zero)
+ >
+21df : 28 > plp ;restore status
+
+ set_a $7f,0
+ > load_flag 0
+21e0 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+21e2 : 48 > pha ;use stack to load status
+21e3 : a97f > lda #$7f ;precharge accu
+21e5 : 28 > plp
+
+21e6 : d124 cmp (ind1),y
+ tst_a $7f,fzc
+21e8 : 08 > php ;save flags
+21e9 : c97f > cmp #$7f ;test result
+ > trap_ne
+21eb : d0fe > bne * ;failed not equal (non zero)
+ >
+21ed : 68 > pla ;load status
+21ee : 48 > pha
+ > cmp_flag fzc
+21ef : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+21f1 : d0fe > bne * ;failed not equal (non zero)
+ >
+21f3 : 28 > plp ;restore status
+
+ set_a $7e,0
+ > load_flag 0
+21f4 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+21f6 : 48 > pha ;use stack to load status
+21f7 : a97e > lda #$7e ;precharge accu
+21f9 : 28 > plp
+
+21fa : d124 cmp (ind1),y
+ tst_a $7e,fn
+21fc : 08 > php ;save flags
+21fd : c97e > cmp #$7e ;test result
+ > trap_ne
+21ff : d0fe > bne * ;failed not equal (non zero)
+ >
+2201 : 68 > pla ;load status
+2202 : 48 > pha
+ > cmp_flag fn
+2203 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2205 : d0fe > bne * ;failed not equal (non zero)
+ >
+2207 : 28 > plp ;restore status
+
+ set_a $80,$ff
+ > load_flag $ff
+2208 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+220a : 48 > pha ;use stack to load status
+220b : a980 > lda #$80 ;precharge accu
+220d : 28 > plp
+
+220e : d124 cmp (ind1),y
+ tst_a $80,~fnz
+2210 : 08 > php ;save flags
+2211 : c980 > cmp #$80 ;test result
+ > trap_ne
+2213 : d0fe > bne * ;failed not equal (non zero)
+ >
+2215 : 68 > pla ;load status
+2216 : 48 > pha
+ > cmp_flag ~fnz
+2217 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2219 : d0fe > bne * ;failed not equal (non zero)
+ >
+221b : 28 > plp ;restore status
+
+ set_a $7f,$ff
+ > load_flag $ff
+221c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+221e : 48 > pha ;use stack to load status
+221f : a97f > lda #$7f ;precharge accu
+2221 : 28 > plp
+
+2222 : d124 cmp (ind1),y
+ tst_a $7f,~fn
+2224 : 08 > php ;save flags
+2225 : c97f > cmp #$7f ;test result
+ > trap_ne
+2227 : d0fe > bne * ;failed not equal (non zero)
+ >
+2229 : 68 > pla ;load status
+222a : 48 > pha
+ > cmp_flag ~fn
+222b : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+222d : d0fe > bne * ;failed not equal (non zero)
+ >
+222f : 28 > plp ;restore status
+
+ set_a $7e,$ff
+ > load_flag $ff
+2230 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2232 : 48 > pha ;use stack to load status
+2233 : a97e > lda #$7e ;precharge accu
+2235 : 28 > plp
+
+2236 : d124 cmp (ind1),y
+ tst_a $7e,~fzc
+2238 : 08 > php ;save flags
+2239 : c97e > cmp #$7e ;test result
+ > trap_ne
+223b : d0fe > bne * ;failed not equal (non zero)
+ >
+223d : 68 > pla ;load status
+223e : 48 > pha
+ > cmp_flag ~fzc
+223f : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2241 : d0fe > bne * ;failed not equal (non zero)
+ >
+2243 : 28 > plp ;restore status
+
+ next_test
+2244 : ad0002 > lda test_case ;previous test
+2247 : c91c > cmp #test_num
+ > trap_ne ;test is out of sequence
+2249 : d0fe > bne * ;failed not equal (non zero)
+ >
+001d = >test_num = test_num + 1
+224b : a91d > lda #test_num ;*** next tests' number
+224d : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; testing shifts - ASL LSR ROL ROR all addressing modes
+ ; shifts - accumulator
+2250 : a203 ldx #3
+2252 : tasl
+ set_ax zp1,0
+ > load_flag 0
+2252 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2254 : 48 > pha ;use stack to load status
+2255 : b513 > lda zp1,x ;precharge accu
+2257 : 28 > plp
+
+2258 : 0a asl a
+ tst_ax rASL,fASL,0
+2259 : 08 > php ;save flags
+225a : dd1102 > cmp rASL,x ;test result
+ > trap_ne
+225d : d0fe > bne * ;failed not equal (non zero)
+ >
+225f : 68 > pla ;load status
+ > eor_flag 0
+2260 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2262 : dd2102 > cmp fASL,x ;test flags
+ > trap_ne ;
+2265 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2267 : ca dex
+2268 : 10e8 bpl tasl
+226a : a203 ldx #3
+226c : tasl1
+ set_ax zp1,$ff
+ > load_flag $ff
+226c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+226e : 48 > pha ;use stack to load status
+226f : b513 > lda zp1,x ;precharge accu
+2271 : 28 > plp
+
+2272 : 0a asl a
+ tst_ax rASL,fASL,$ff-fnzc
+2273 : 08 > php ;save flags
+2274 : dd1102 > cmp rASL,x ;test result
+ > trap_ne
+2277 : d0fe > bne * ;failed not equal (non zero)
+ >
+2279 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+227a : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+227c : dd2102 > cmp fASL,x ;test flags
+ > trap_ne ;
+227f : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2281 : ca dex
+2282 : 10e8 bpl tasl1
+
+2284 : a203 ldx #3
+2286 : tlsr
+ set_ax zp1,0
+ > load_flag 0
+2286 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2288 : 48 > pha ;use stack to load status
+2289 : b513 > lda zp1,x ;precharge accu
+228b : 28 > plp
+
+228c : 4a lsr a
+ tst_ax rLSR,fLSR,0
+228d : 08 > php ;save flags
+228e : dd1902 > cmp rLSR,x ;test result
+ > trap_ne
+2291 : d0fe > bne * ;failed not equal (non zero)
+ >
+2293 : 68 > pla ;load status
+ > eor_flag 0
+2294 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2296 : dd2902 > cmp fLSR,x ;test flags
+ > trap_ne ;
+2299 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+229b : ca dex
+229c : 10e8 bpl tlsr
+229e : a203 ldx #3
+22a0 : tlsr1
+ set_ax zp1,$ff
+ > load_flag $ff
+22a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+22a2 : 48 > pha ;use stack to load status
+22a3 : b513 > lda zp1,x ;precharge accu
+22a5 : 28 > plp
+
+22a6 : 4a lsr a
+ tst_ax rLSR,fLSR,$ff-fnzc
+22a7 : 08 > php ;save flags
+22a8 : dd1902 > cmp rLSR,x ;test result
+ > trap_ne
+22ab : d0fe > bne * ;failed not equal (non zero)
+ >
+22ad : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+22ae : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+22b0 : dd2902 > cmp fLSR,x ;test flags
+ > trap_ne ;
+22b3 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+22b5 : ca dex
+22b6 : 10e8 bpl tlsr1
+
+22b8 : a203 ldx #3
+22ba : trol
+ set_ax zp1,0
+ > load_flag 0
+22ba : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+22bc : 48 > pha ;use stack to load status
+22bd : b513 > lda zp1,x ;precharge accu
+22bf : 28 > plp
+
+22c0 : 2a rol a
+ tst_ax rROL,fROL,0
+22c1 : 08 > php ;save flags
+22c2 : dd1102 > cmp rROL,x ;test result
+ > trap_ne
+22c5 : d0fe > bne * ;failed not equal (non zero)
+ >
+22c7 : 68 > pla ;load status
+ > eor_flag 0
+22c8 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+22ca : dd2102 > cmp fROL,x ;test flags
+ > trap_ne ;
+22cd : d0fe > bne * ;failed not equal (non zero)
+ >
+
+22cf : ca dex
+22d0 : 10e8 bpl trol
+22d2 : a203 ldx #3
+22d4 : trol1
+ set_ax zp1,$ff-fc
+ > load_flag $ff-fc
+22d4 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
+ >
+22d6 : 48 > pha ;use stack to load status
+22d7 : b513 > lda zp1,x ;precharge accu
+22d9 : 28 > plp
+
+22da : 2a rol a
+ tst_ax rROL,fROL,$ff-fnzc
+22db : 08 > php ;save flags
+22dc : dd1102 > cmp rROL,x ;test result
+ > trap_ne
+22df : d0fe > bne * ;failed not equal (non zero)
+ >
+22e1 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+22e2 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+22e4 : dd2102 > cmp fROL,x ;test flags
+ > trap_ne ;
+22e7 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+22e9 : ca dex
+22ea : 10e8 bpl trol1
+
+22ec : a203 ldx #3
+22ee : trolc
+ set_ax zp1,fc
+ > load_flag fc
+22ee : a901 > lda #fc ;allow test to change I-flag (no mask)
+ >
+22f0 : 48 > pha ;use stack to load status
+22f1 : b513 > lda zp1,x ;precharge accu
+22f3 : 28 > plp
+
+22f4 : 2a rol a
+ tst_ax rROLc,fROLc,0
+22f5 : 08 > php ;save flags
+22f6 : dd1502 > cmp rROLc,x ;test result
+ > trap_ne
+22f9 : d0fe > bne * ;failed not equal (non zero)
+ >
+22fb : 68 > pla ;load status
+ > eor_flag 0
+22fc : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+22fe : dd2502 > cmp fROLc,x ;test flags
+ > trap_ne ;
+2301 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2303 : ca dex
+2304 : 10e8 bpl trolc
+2306 : a203 ldx #3
+2308 : trolc1
+ set_ax zp1,$ff
+ > load_flag $ff
+2308 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+230a : 48 > pha ;use stack to load status
+230b : b513 > lda zp1,x ;precharge accu
+230d : 28 > plp
+
+230e : 2a rol a
+ tst_ax rROLc,fROLc,$ff-fnzc
+230f : 08 > php ;save flags
+2310 : dd1502 > cmp rROLc,x ;test result
+ > trap_ne
+2313 : d0fe > bne * ;failed not equal (non zero)
+ >
+2315 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+2316 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2318 : dd2502 > cmp fROLc,x ;test flags
+ > trap_ne ;
+231b : d0fe > bne * ;failed not equal (non zero)
+ >
+
+231d : ca dex
+231e : 10e8 bpl trolc1
+
+2320 : a203 ldx #3
+2322 : tror
+ set_ax zp1,0
+ > load_flag 0
+2322 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2324 : 48 > pha ;use stack to load status
+2325 : b513 > lda zp1,x ;precharge accu
+2327 : 28 > plp
+
+2328 : 6a ror a
+ tst_ax rROR,fROR,0
+2329 : 08 > php ;save flags
+232a : dd1902 > cmp rROR,x ;test result
+ > trap_ne
+232d : d0fe > bne * ;failed not equal (non zero)
+ >
+232f : 68 > pla ;load status
+ > eor_flag 0
+2330 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2332 : dd2902 > cmp fROR,x ;test flags
+ > trap_ne ;
+2335 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2337 : ca dex
+2338 : 10e8 bpl tror
+233a : a203 ldx #3
+233c : tror1
+ set_ax zp1,$ff-fc
+ > load_flag $ff-fc
+233c : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
+ >
+233e : 48 > pha ;use stack to load status
+233f : b513 > lda zp1,x ;precharge accu
+2341 : 28 > plp
+
+2342 : 6a ror a
+ tst_ax rROR,fROR,$ff-fnzc
+2343 : 08 > php ;save flags
+2344 : dd1902 > cmp rROR,x ;test result
+ > trap_ne
+2347 : d0fe > bne * ;failed not equal (non zero)
+ >
+2349 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+234a : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+234c : dd2902 > cmp fROR,x ;test flags
+ > trap_ne ;
+234f : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2351 : ca dex
+2352 : 10e8 bpl tror1
+
+2354 : a203 ldx #3
+2356 : trorc
+ set_ax zp1,fc
+ > load_flag fc
+2356 : a901 > lda #fc ;allow test to change I-flag (no mask)
+ >
+2358 : 48 > pha ;use stack to load status
+2359 : b513 > lda zp1,x ;precharge accu
+235b : 28 > plp
+
+235c : 6a ror a
+ tst_ax rRORc,fRORc,0
+235d : 08 > php ;save flags
+235e : dd1d02 > cmp rRORc,x ;test result
+ > trap_ne
+2361 : d0fe > bne * ;failed not equal (non zero)
+ >
+2363 : 68 > pla ;load status
+ > eor_flag 0
+2364 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2366 : dd2d02 > cmp fRORc,x ;test flags
+ > trap_ne ;
+2369 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+236b : ca dex
+236c : 10e8 bpl trorc
+236e : a203 ldx #3
+2370 : trorc1
+ set_ax zp1,$ff
+ > load_flag $ff
+2370 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2372 : 48 > pha ;use stack to load status
+2373 : b513 > lda zp1,x ;precharge accu
+2375 : 28 > plp
+
+2376 : 6a ror a
+ tst_ax rRORc,fRORc,$ff-fnzc
+2377 : 08 > php ;save flags
+2378 : dd1d02 > cmp rRORc,x ;test result
+ > trap_ne
+237b : d0fe > bne * ;failed not equal (non zero)
+ >
+237d : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+237e : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2380 : dd2d02 > cmp fRORc,x ;test flags
+ > trap_ne ;
+2383 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2385 : ca dex
+2386 : 10e8 bpl trorc1
+ next_test
+2388 : ad0002 > lda test_case ;previous test
+238b : c91d > cmp #test_num
+ > trap_ne ;test is out of sequence
+238d : d0fe > bne * ;failed not equal (non zero)
+ >
+001e = >test_num = test_num + 1
+238f : a91e > lda #test_num ;*** next tests' number
+2391 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; shifts - zeropage
+2394 : a203 ldx #3
+2396 : tasl2
+ set_z zp1,0
+ > load_flag 0
+2396 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2398 : 48 > pha ;use stack to load status
+2399 : b513 > lda zp1,x ;load to zeropage
+239b : 850c > sta zpt
+239d : 28 > plp
+
+239e : 060c asl zpt
+ tst_z rASL,fASL,0
+23a0 : 08 > php ;save flags
+23a1 : a50c > lda zpt
+23a3 : dd1102 > cmp rASL,x ;test result
+ > trap_ne
+23a6 : d0fe > bne * ;failed not equal (non zero)
+ >
+23a8 : 68 > pla ;load status
+ > eor_flag 0
+23a9 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+23ab : dd2102 > cmp fASL,x ;test flags
+ > trap_ne
+23ae : d0fe > bne * ;failed not equal (non zero)
+ >
+
+23b0 : ca dex
+23b1 : 10e3 bpl tasl2
+23b3 : a203 ldx #3
+23b5 : tasl3
+ set_z zp1,$ff
+ > load_flag $ff
+23b5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+23b7 : 48 > pha ;use stack to load status
+23b8 : b513 > lda zp1,x ;load to zeropage
+23ba : 850c > sta zpt
+23bc : 28 > plp
+
+23bd : 060c asl zpt
+ tst_z rASL,fASL,$ff-fnzc
+23bf : 08 > php ;save flags
+23c0 : a50c > lda zpt
+23c2 : dd1102 > cmp rASL,x ;test result
+ > trap_ne
+23c5 : d0fe > bne * ;failed not equal (non zero)
+ >
+23c7 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+23c8 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+23ca : dd2102 > cmp fASL,x ;test flags
+ > trap_ne
+23cd : d0fe > bne * ;failed not equal (non zero)
+ >
+
+23cf : ca dex
+23d0 : 10e3 bpl tasl3
+
+23d2 : a203 ldx #3
+23d4 : tlsr2
+ set_z zp1,0
+ > load_flag 0
+23d4 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+23d6 : 48 > pha ;use stack to load status
+23d7 : b513 > lda zp1,x ;load to zeropage
+23d9 : 850c > sta zpt
+23db : 28 > plp
+
+23dc : 460c lsr zpt
+ tst_z rLSR,fLSR,0
+23de : 08 > php ;save flags
+23df : a50c > lda zpt
+23e1 : dd1902 > cmp rLSR,x ;test result
+ > trap_ne
+23e4 : d0fe > bne * ;failed not equal (non zero)
+ >
+23e6 : 68 > pla ;load status
+ > eor_flag 0
+23e7 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+23e9 : dd2902 > cmp fLSR,x ;test flags
+ > trap_ne
+23ec : d0fe > bne * ;failed not equal (non zero)
+ >
+
+23ee : ca dex
+23ef : 10e3 bpl tlsr2
+23f1 : a203 ldx #3
+23f3 : tlsr3
+ set_z zp1,$ff
+ > load_flag $ff
+23f3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+23f5 : 48 > pha ;use stack to load status
+23f6 : b513 > lda zp1,x ;load to zeropage
+23f8 : 850c > sta zpt
+23fa : 28 > plp
+
+23fb : 460c lsr zpt
+ tst_z rLSR,fLSR,$ff-fnzc
+23fd : 08 > php ;save flags
+23fe : a50c > lda zpt
+2400 : dd1902 > cmp rLSR,x ;test result
+ > trap_ne
+2403 : d0fe > bne * ;failed not equal (non zero)
+ >
+2405 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+2406 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2408 : dd2902 > cmp fLSR,x ;test flags
+ > trap_ne
+240b : d0fe > bne * ;failed not equal (non zero)
+ >
+
+240d : ca dex
+240e : 10e3 bpl tlsr3
+
+2410 : a203 ldx #3
+2412 : trol2
+ set_z zp1,0
+ > load_flag 0
+2412 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2414 : 48 > pha ;use stack to load status
+2415 : b513 > lda zp1,x ;load to zeropage
+2417 : 850c > sta zpt
+2419 : 28 > plp
+
+241a : 260c rol zpt
+ tst_z rROL,fROL,0
+241c : 08 > php ;save flags
+241d : a50c > lda zpt
+241f : dd1102 > cmp rROL,x ;test result
+ > trap_ne
+2422 : d0fe > bne * ;failed not equal (non zero)
+ >
+2424 : 68 > pla ;load status
+ > eor_flag 0
+2425 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2427 : dd2102 > cmp fROL,x ;test flags
+ > trap_ne
+242a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+242c : ca dex
+242d : 10e3 bpl trol2
+242f : a203 ldx #3
+2431 : trol3
+ set_z zp1,$ff-fc
+ > load_flag $ff-fc
+2431 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
+ >
+2433 : 48 > pha ;use stack to load status
+2434 : b513 > lda zp1,x ;load to zeropage
+2436 : 850c > sta zpt
+2438 : 28 > plp
+
+2439 : 260c rol zpt
+ tst_z rROL,fROL,$ff-fnzc
+243b : 08 > php ;save flags
+243c : a50c > lda zpt
+243e : dd1102 > cmp rROL,x ;test result
+ > trap_ne
+2441 : d0fe > bne * ;failed not equal (non zero)
+ >
+2443 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+2444 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2446 : dd2102 > cmp fROL,x ;test flags
+ > trap_ne
+2449 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+244b : ca dex
+244c : 10e3 bpl trol3
+
+244e : a203 ldx #3
+2450 : trolc2
+ set_z zp1,fc
+ > load_flag fc
+2450 : a901 > lda #fc ;allow test to change I-flag (no mask)
+ >
+2452 : 48 > pha ;use stack to load status
+2453 : b513 > lda zp1,x ;load to zeropage
+2455 : 850c > sta zpt
+2457 : 28 > plp
+
+2458 : 260c rol zpt
+ tst_z rROLc,fROLc,0
+245a : 08 > php ;save flags
+245b : a50c > lda zpt
+245d : dd1502 > cmp rROLc,x ;test result
+ > trap_ne
+2460 : d0fe > bne * ;failed not equal (non zero)
+ >
+2462 : 68 > pla ;load status
+ > eor_flag 0
+2463 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2465 : dd2502 > cmp fROLc,x ;test flags
+ > trap_ne
+2468 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+246a : ca dex
+246b : 10e3 bpl trolc2
+246d : a203 ldx #3
+246f : trolc3
+ set_z zp1,$ff
+ > load_flag $ff
+246f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2471 : 48 > pha ;use stack to load status
+2472 : b513 > lda zp1,x ;load to zeropage
+2474 : 850c > sta zpt
+2476 : 28 > plp
+
+2477 : 260c rol zpt
+ tst_z rROLc,fROLc,$ff-fnzc
+2479 : 08 > php ;save flags
+247a : a50c > lda zpt
+247c : dd1502 > cmp rROLc,x ;test result
+ > trap_ne
+247f : d0fe > bne * ;failed not equal (non zero)
+ >
+2481 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+2482 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2484 : dd2502 > cmp fROLc,x ;test flags
+ > trap_ne
+2487 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2489 : ca dex
+248a : 10e3 bpl trolc3
+
+248c : a203 ldx #3
+248e : tror2
+ set_z zp1,0
+ > load_flag 0
+248e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2490 : 48 > pha ;use stack to load status
+2491 : b513 > lda zp1,x ;load to zeropage
+2493 : 850c > sta zpt
+2495 : 28 > plp
+
+2496 : 660c ror zpt
+ tst_z rROR,fROR,0
+2498 : 08 > php ;save flags
+2499 : a50c > lda zpt
+249b : dd1902 > cmp rROR,x ;test result
+ > trap_ne
+249e : d0fe > bne * ;failed not equal (non zero)
+ >
+24a0 : 68 > pla ;load status
+ > eor_flag 0
+24a1 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+24a3 : dd2902 > cmp fROR,x ;test flags
+ > trap_ne
+24a6 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+24a8 : ca dex
+24a9 : 10e3 bpl tror2
+24ab : a203 ldx #3
+24ad : tror3
+ set_z zp1,$ff-fc
+ > load_flag $ff-fc
+24ad : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
+ >
+24af : 48 > pha ;use stack to load status
+24b0 : b513 > lda zp1,x ;load to zeropage
+24b2 : 850c > sta zpt
+24b4 : 28 > plp
+
+24b5 : 660c ror zpt
+ tst_z rROR,fROR,$ff-fnzc
+24b7 : 08 > php ;save flags
+24b8 : a50c > lda zpt
+24ba : dd1902 > cmp rROR,x ;test result
+ > trap_ne
+24bd : d0fe > bne * ;failed not equal (non zero)
+ >
+24bf : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+24c0 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+24c2 : dd2902 > cmp fROR,x ;test flags
+ > trap_ne
+24c5 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+24c7 : ca dex
+24c8 : 10e3 bpl tror3
+
+24ca : a203 ldx #3
+24cc : trorc2
+ set_z zp1,fc
+ > load_flag fc
+24cc : a901 > lda #fc ;allow test to change I-flag (no mask)
+ >
+24ce : 48 > pha ;use stack to load status
+24cf : b513 > lda zp1,x ;load to zeropage
+24d1 : 850c > sta zpt
+24d3 : 28 > plp
+
+24d4 : 660c ror zpt
+ tst_z rRORc,fRORc,0
+24d6 : 08 > php ;save flags
+24d7 : a50c > lda zpt
+24d9 : dd1d02 > cmp rRORc,x ;test result
+ > trap_ne
+24dc : d0fe > bne * ;failed not equal (non zero)
+ >
+24de : 68 > pla ;load status
+ > eor_flag 0
+24df : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+24e1 : dd2d02 > cmp fRORc,x ;test flags
+ > trap_ne
+24e4 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+24e6 : ca dex
+24e7 : 10e3 bpl trorc2
+24e9 : a203 ldx #3
+24eb : trorc3
+ set_z zp1,$ff
+ > load_flag $ff
+24eb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+24ed : 48 > pha ;use stack to load status
+24ee : b513 > lda zp1,x ;load to zeropage
+24f0 : 850c > sta zpt
+24f2 : 28 > plp
+
+24f3 : 660c ror zpt
+ tst_z rRORc,fRORc,$ff-fnzc
+24f5 : 08 > php ;save flags
+24f6 : a50c > lda zpt
+24f8 : dd1d02 > cmp rRORc,x ;test result
+ > trap_ne
+24fb : d0fe > bne * ;failed not equal (non zero)
+ >
+24fd : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+24fe : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2500 : dd2d02 > cmp fRORc,x ;test flags
+ > trap_ne
+2503 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2505 : ca dex
+2506 : 10e3 bpl trorc3
+ next_test
+2508 : ad0002 > lda test_case ;previous test
+250b : c91e > cmp #test_num
+ > trap_ne ;test is out of sequence
+250d : d0fe > bne * ;failed not equal (non zero)
+ >
+001f = >test_num = test_num + 1
+250f : a91f > lda #test_num ;*** next tests' number
+2511 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; shifts - absolute
+2514 : a203 ldx #3
+2516 : tasl4
+ set_abs zp1,0
+ > load_flag 0
+2516 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2518 : 48 > pha ;use stack to load status
+2519 : b513 > lda zp1,x ;load to memory
+251b : 8d0302 > sta abst
+251e : 28 > plp
+
+251f : 0e0302 asl abst
+ tst_abs rASL,fASL,0
+2522 : 08 > php ;save flags
+2523 : ad0302 > lda abst
+2526 : dd1102 > cmp rASL,x ;test result
+ > trap_ne
+2529 : d0fe > bne * ;failed not equal (non zero)
+ >
+252b : 68 > pla ;load status
+ > eor_flag 0
+252c : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+252e : dd2102 > cmp fASL,x ;test flags
+ > trap_ne
+2531 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2533 : ca dex
+2534 : 10e0 bpl tasl4
+2536 : a203 ldx #3
+2538 : tasl5
+ set_abs zp1,$ff
+ > load_flag $ff
+2538 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+253a : 48 > pha ;use stack to load status
+253b : b513 > lda zp1,x ;load to memory
+253d : 8d0302 > sta abst
+2540 : 28 > plp
+
+2541 : 0e0302 asl abst
+ tst_abs rASL,fASL,$ff-fnzc
+2544 : 08 > php ;save flags
+2545 : ad0302 > lda abst
+2548 : dd1102 > cmp rASL,x ;test result
+ > trap_ne
+254b : d0fe > bne * ;failed not equal (non zero)
+ >
+254d : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+254e : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2550 : dd2102 > cmp fASL,x ;test flags
+ > trap_ne
+2553 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2555 : ca dex
+2556 : 10e0 bpl tasl5
+
+2558 : a203 ldx #3
+255a : tlsr4
+ set_abs zp1,0
+ > load_flag 0
+255a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+255c : 48 > pha ;use stack to load status
+255d : b513 > lda zp1,x ;load to memory
+255f : 8d0302 > sta abst
+2562 : 28 > plp
+
+2563 : 4e0302 lsr abst
+ tst_abs rLSR,fLSR,0
+2566 : 08 > php ;save flags
+2567 : ad0302 > lda abst
+256a : dd1902 > cmp rLSR,x ;test result
+ > trap_ne
+256d : d0fe > bne * ;failed not equal (non zero)
+ >
+256f : 68 > pla ;load status
+ > eor_flag 0
+2570 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2572 : dd2902 > cmp fLSR,x ;test flags
+ > trap_ne
+2575 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2577 : ca dex
+2578 : 10e0 bpl tlsr4
+257a : a203 ldx #3
+257c : tlsr5
+ set_abs zp1,$ff
+ > load_flag $ff
+257c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+257e : 48 > pha ;use stack to load status
+257f : b513 > lda zp1,x ;load to memory
+2581 : 8d0302 > sta abst
+2584 : 28 > plp
+
+2585 : 4e0302 lsr abst
+ tst_abs rLSR,fLSR,$ff-fnzc
+2588 : 08 > php ;save flags
+2589 : ad0302 > lda abst
+258c : dd1902 > cmp rLSR,x ;test result
+ > trap_ne
+258f : d0fe > bne * ;failed not equal (non zero)
+ >
+2591 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+2592 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2594 : dd2902 > cmp fLSR,x ;test flags
+ > trap_ne
+2597 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2599 : ca dex
+259a : 10e0 bpl tlsr5
+
+259c : a203 ldx #3
+259e : trol4
+ set_abs zp1,0
+ > load_flag 0
+259e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+25a0 : 48 > pha ;use stack to load status
+25a1 : b513 > lda zp1,x ;load to memory
+25a3 : 8d0302 > sta abst
+25a6 : 28 > plp
+
+25a7 : 2e0302 rol abst
+ tst_abs rROL,fROL,0
+25aa : 08 > php ;save flags
+25ab : ad0302 > lda abst
+25ae : dd1102 > cmp rROL,x ;test result
+ > trap_ne
+25b1 : d0fe > bne * ;failed not equal (non zero)
+ >
+25b3 : 68 > pla ;load status
+ > eor_flag 0
+25b4 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+25b6 : dd2102 > cmp fROL,x ;test flags
+ > trap_ne
+25b9 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+25bb : ca dex
+25bc : 10e0 bpl trol4
+25be : a203 ldx #3
+25c0 : trol5
+ set_abs zp1,$ff-fc
+ > load_flag $ff-fc
+25c0 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
+ >
+25c2 : 48 > pha ;use stack to load status
+25c3 : b513 > lda zp1,x ;load to memory
+25c5 : 8d0302 > sta abst
+25c8 : 28 > plp
+
+25c9 : 2e0302 rol abst
+ tst_abs rROL,fROL,$ff-fnzc
+25cc : 08 > php ;save flags
+25cd : ad0302 > lda abst
+25d0 : dd1102 > cmp rROL,x ;test result
+ > trap_ne
+25d3 : d0fe > bne * ;failed not equal (non zero)
+ >
+25d5 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+25d6 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+25d8 : dd2102 > cmp fROL,x ;test flags
+ > trap_ne
+25db : d0fe > bne * ;failed not equal (non zero)
+ >
+
+25dd : ca dex
+25de : 10e0 bpl trol5
+
+25e0 : a203 ldx #3
+25e2 : trolc4
+ set_abs zp1,fc
+ > load_flag fc
+25e2 : a901 > lda #fc ;allow test to change I-flag (no mask)
+ >
+25e4 : 48 > pha ;use stack to load status
+25e5 : b513 > lda zp1,x ;load to memory
+25e7 : 8d0302 > sta abst
+25ea : 28 > plp
+
+25eb : 2e0302 rol abst
+ tst_abs rROLc,fROLc,0
+25ee : 08 > php ;save flags
+25ef : ad0302 > lda abst
+25f2 : dd1502 > cmp rROLc,x ;test result
+ > trap_ne
+25f5 : d0fe > bne * ;failed not equal (non zero)
+ >
+25f7 : 68 > pla ;load status
+ > eor_flag 0
+25f8 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+25fa : dd2502 > cmp fROLc,x ;test flags
+ > trap_ne
+25fd : d0fe > bne * ;failed not equal (non zero)
+ >
+
+25ff : ca dex
+2600 : 10e0 bpl trolc4
+2602 : a203 ldx #3
+2604 : trolc5
+ set_abs zp1,$ff
+ > load_flag $ff
+2604 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2606 : 48 > pha ;use stack to load status
+2607 : b513 > lda zp1,x ;load to memory
+2609 : 8d0302 > sta abst
+260c : 28 > plp
+
+260d : 2e0302 rol abst
+ tst_abs rROLc,fROLc,$ff-fnzc
+2610 : 08 > php ;save flags
+2611 : ad0302 > lda abst
+2614 : dd1502 > cmp rROLc,x ;test result
+ > trap_ne
+2617 : d0fe > bne * ;failed not equal (non zero)
+ >
+2619 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+261a : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+261c : dd2502 > cmp fROLc,x ;test flags
+ > trap_ne
+261f : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2621 : ca dex
+2622 : 10e0 bpl trolc5
+
+2624 : a203 ldx #3
+2626 : tror4
+ set_abs zp1,0
+ > load_flag 0
+2626 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2628 : 48 > pha ;use stack to load status
+2629 : b513 > lda zp1,x ;load to memory
+262b : 8d0302 > sta abst
+262e : 28 > plp
+
+262f : 6e0302 ror abst
+ tst_abs rROR,fROR,0
+2632 : 08 > php ;save flags
+2633 : ad0302 > lda abst
+2636 : dd1902 > cmp rROR,x ;test result
+ > trap_ne
+2639 : d0fe > bne * ;failed not equal (non zero)
+ >
+263b : 68 > pla ;load status
+ > eor_flag 0
+263c : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+263e : dd2902 > cmp fROR,x ;test flags
+ > trap_ne
+2641 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2643 : ca dex
+2644 : 10e0 bpl tror4
+2646 : a203 ldx #3
+2648 : tror5
+ set_abs zp1,$ff-fc
+ > load_flag $ff-fc
+2648 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
+ >
+264a : 48 > pha ;use stack to load status
+264b : b513 > lda zp1,x ;load to memory
+264d : 8d0302 > sta abst
+2650 : 28 > plp
+
+2651 : 6e0302 ror abst
+ tst_abs rROR,fROR,$ff-fnzc
+2654 : 08 > php ;save flags
+2655 : ad0302 > lda abst
+2658 : dd1902 > cmp rROR,x ;test result
+ > trap_ne
+265b : d0fe > bne * ;failed not equal (non zero)
+ >
+265d : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+265e : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2660 : dd2902 > cmp fROR,x ;test flags
+ > trap_ne
+2663 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2665 : ca dex
+2666 : 10e0 bpl tror5
+
+2668 : a203 ldx #3
+266a : trorc4
+ set_abs zp1,fc
+ > load_flag fc
+266a : a901 > lda #fc ;allow test to change I-flag (no mask)
+ >
+266c : 48 > pha ;use stack to load status
+266d : b513 > lda zp1,x ;load to memory
+266f : 8d0302 > sta abst
+2672 : 28 > plp
+
+2673 : 6e0302 ror abst
+ tst_abs rRORc,fRORc,0
+2676 : 08 > php ;save flags
+2677 : ad0302 > lda abst
+267a : dd1d02 > cmp rRORc,x ;test result
+ > trap_ne
+267d : d0fe > bne * ;failed not equal (non zero)
+ >
+267f : 68 > pla ;load status
+ > eor_flag 0
+2680 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2682 : dd2d02 > cmp fRORc,x ;test flags
+ > trap_ne
+2685 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2687 : ca dex
+2688 : 10e0 bpl trorc4
+268a : a203 ldx #3
+268c : trorc5
+ set_abs zp1,$ff
+ > load_flag $ff
+268c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+268e : 48 > pha ;use stack to load status
+268f : b513 > lda zp1,x ;load to memory
+2691 : 8d0302 > sta abst
+2694 : 28 > plp
+
+2695 : 6e0302 ror abst
+ tst_abs rRORc,fRORc,$ff-fnzc
+2698 : 08 > php ;save flags
+2699 : ad0302 > lda abst
+269c : dd1d02 > cmp rRORc,x ;test result
+ > trap_ne
+269f : d0fe > bne * ;failed not equal (non zero)
+ >
+26a1 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+26a2 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+26a4 : dd2d02 > cmp fRORc,x ;test flags
+ > trap_ne
+26a7 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+26a9 : ca dex
+26aa : 10e0 bpl trorc5
+ next_test
+26ac : ad0002 > lda test_case ;previous test
+26af : c91f > cmp #test_num
+ > trap_ne ;test is out of sequence
+26b1 : d0fe > bne * ;failed not equal (non zero)
+ >
+0020 = >test_num = test_num + 1
+26b3 : a920 > lda #test_num ;*** next tests' number
+26b5 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; shifts - zp indexed
+26b8 : a203 ldx #3
+26ba : tasl6
+ set_zx zp1,0
+ > load_flag 0
+26ba : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+26bc : 48 > pha ;use stack to load status
+26bd : b513 > lda zp1,x ;load to indexed zeropage
+26bf : 950c > sta zpt,x
+26c1 : 28 > plp
+
+26c2 : 160c asl zpt,x
+ tst_zx rASL,fASL,0
+26c4 : 08 > php ;save flags
+26c5 : b50c > lda zpt,x
+26c7 : dd1102 > cmp rASL,x ;test result
+ > trap_ne
+26ca : d0fe > bne * ;failed not equal (non zero)
+ >
+26cc : 68 > pla ;load status
+ > eor_flag 0
+26cd : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+26cf : dd2102 > cmp fASL,x ;test flags
+ > trap_ne
+26d2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+26d4 : ca dex
+26d5 : 10e3 bpl tasl6
+26d7 : a203 ldx #3
+26d9 : tasl7
+ set_zx zp1,$ff
+ > load_flag $ff
+26d9 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+26db : 48 > pha ;use stack to load status
+26dc : b513 > lda zp1,x ;load to indexed zeropage
+26de : 950c > sta zpt,x
+26e0 : 28 > plp
+
+26e1 : 160c asl zpt,x
+ tst_zx rASL,fASL,$ff-fnzc
+26e3 : 08 > php ;save flags
+26e4 : b50c > lda zpt,x
+26e6 : dd1102 > cmp rASL,x ;test result
+ > trap_ne
+26e9 : d0fe > bne * ;failed not equal (non zero)
+ >
+26eb : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+26ec : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+26ee : dd2102 > cmp fASL,x ;test flags
+ > trap_ne
+26f1 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+26f3 : ca dex
+26f4 : 10e3 bpl tasl7
+
+26f6 : a203 ldx #3
+26f8 : tlsr6
+ set_zx zp1,0
+ > load_flag 0
+26f8 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+26fa : 48 > pha ;use stack to load status
+26fb : b513 > lda zp1,x ;load to indexed zeropage
+26fd : 950c > sta zpt,x
+26ff : 28 > plp
+
+2700 : 560c lsr zpt,x
+ tst_zx rLSR,fLSR,0
+2702 : 08 > php ;save flags
+2703 : b50c > lda zpt,x
+2705 : dd1902 > cmp rLSR,x ;test result
+ > trap_ne
+2708 : d0fe > bne * ;failed not equal (non zero)
+ >
+270a : 68 > pla ;load status
+ > eor_flag 0
+270b : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+270d : dd2902 > cmp fLSR,x ;test flags
+ > trap_ne
+2710 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2712 : ca dex
+2713 : 10e3 bpl tlsr6
+2715 : a203 ldx #3
+2717 : tlsr7
+ set_zx zp1,$ff
+ > load_flag $ff
+2717 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2719 : 48 > pha ;use stack to load status
+271a : b513 > lda zp1,x ;load to indexed zeropage
+271c : 950c > sta zpt,x
+271e : 28 > plp
+
+271f : 560c lsr zpt,x
+ tst_zx rLSR,fLSR,$ff-fnzc
+2721 : 08 > php ;save flags
+2722 : b50c > lda zpt,x
+2724 : dd1902 > cmp rLSR,x ;test result
+ > trap_ne
+2727 : d0fe > bne * ;failed not equal (non zero)
+ >
+2729 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+272a : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+272c : dd2902 > cmp fLSR,x ;test flags
+ > trap_ne
+272f : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2731 : ca dex
+2732 : 10e3 bpl tlsr7
+
+2734 : a203 ldx #3
+2736 : trol6
+ set_zx zp1,0
+ > load_flag 0
+2736 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2738 : 48 > pha ;use stack to load status
+2739 : b513 > lda zp1,x ;load to indexed zeropage
+273b : 950c > sta zpt,x
+273d : 28 > plp
+
+273e : 360c rol zpt,x
+ tst_zx rROL,fROL,0
+2740 : 08 > php ;save flags
+2741 : b50c > lda zpt,x
+2743 : dd1102 > cmp rROL,x ;test result
+ > trap_ne
+2746 : d0fe > bne * ;failed not equal (non zero)
+ >
+2748 : 68 > pla ;load status
+ > eor_flag 0
+2749 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+274b : dd2102 > cmp fROL,x ;test flags
+ > trap_ne
+274e : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2750 : ca dex
+2751 : 10e3 bpl trol6
+2753 : a203 ldx #3
+2755 : trol7
+ set_zx zp1,$ff-fc
+ > load_flag $ff-fc
+2755 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
+ >
+2757 : 48 > pha ;use stack to load status
+2758 : b513 > lda zp1,x ;load to indexed zeropage
+275a : 950c > sta zpt,x
+275c : 28 > plp
+
+275d : 360c rol zpt,x
+ tst_zx rROL,fROL,$ff-fnzc
+275f : 08 > php ;save flags
+2760 : b50c > lda zpt,x
+2762 : dd1102 > cmp rROL,x ;test result
+ > trap_ne
+2765 : d0fe > bne * ;failed not equal (non zero)
+ >
+2767 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+2768 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+276a : dd2102 > cmp fROL,x ;test flags
+ > trap_ne
+276d : d0fe > bne * ;failed not equal (non zero)
+ >
+
+276f : ca dex
+2770 : 10e3 bpl trol7
+
+2772 : a203 ldx #3
+2774 : trolc6
+ set_zx zp1,fc
+ > load_flag fc
+2774 : a901 > lda #fc ;allow test to change I-flag (no mask)
+ >
+2776 : 48 > pha ;use stack to load status
+2777 : b513 > lda zp1,x ;load to indexed zeropage
+2779 : 950c > sta zpt,x
+277b : 28 > plp
+
+277c : 360c rol zpt,x
+ tst_zx rROLc,fROLc,0
+277e : 08 > php ;save flags
+277f : b50c > lda zpt,x
+2781 : dd1502 > cmp rROLc,x ;test result
+ > trap_ne
+2784 : d0fe > bne * ;failed not equal (non zero)
+ >
+2786 : 68 > pla ;load status
+ > eor_flag 0
+2787 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2789 : dd2502 > cmp fROLc,x ;test flags
+ > trap_ne
+278c : d0fe > bne * ;failed not equal (non zero)
+ >
+
+278e : ca dex
+278f : 10e3 bpl trolc6
+2791 : a203 ldx #3
+2793 : trolc7
+ set_zx zp1,$ff
+ > load_flag $ff
+2793 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2795 : 48 > pha ;use stack to load status
+2796 : b513 > lda zp1,x ;load to indexed zeropage
+2798 : 950c > sta zpt,x
+279a : 28 > plp
+
+279b : 360c rol zpt,x
+ tst_zx rROLc,fROLc,$ff-fnzc
+279d : 08 > php ;save flags
+279e : b50c > lda zpt,x
+27a0 : dd1502 > cmp rROLc,x ;test result
+ > trap_ne
+27a3 : d0fe > bne * ;failed not equal (non zero)
+ >
+27a5 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+27a6 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+27a8 : dd2502 > cmp fROLc,x ;test flags
+ > trap_ne
+27ab : d0fe > bne * ;failed not equal (non zero)
+ >
+
+27ad : ca dex
+27ae : 10e3 bpl trolc7
+
+27b0 : a203 ldx #3
+27b2 : tror6
+ set_zx zp1,0
+ > load_flag 0
+27b2 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+27b4 : 48 > pha ;use stack to load status
+27b5 : b513 > lda zp1,x ;load to indexed zeropage
+27b7 : 950c > sta zpt,x
+27b9 : 28 > plp
+
+27ba : 760c ror zpt,x
+ tst_zx rROR,fROR,0
+27bc : 08 > php ;save flags
+27bd : b50c > lda zpt,x
+27bf : dd1902 > cmp rROR,x ;test result
+ > trap_ne
+27c2 : d0fe > bne * ;failed not equal (non zero)
+ >
+27c4 : 68 > pla ;load status
+ > eor_flag 0
+27c5 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+27c7 : dd2902 > cmp fROR,x ;test flags
+ > trap_ne
+27ca : d0fe > bne * ;failed not equal (non zero)
+ >
+
+27cc : ca dex
+27cd : 10e3 bpl tror6
+27cf : a203 ldx #3
+27d1 : tror7
+ set_zx zp1,$ff-fc
+ > load_flag $ff-fc
+27d1 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
+ >
+27d3 : 48 > pha ;use stack to load status
+27d4 : b513 > lda zp1,x ;load to indexed zeropage
+27d6 : 950c > sta zpt,x
+27d8 : 28 > plp
+
+27d9 : 760c ror zpt,x
+ tst_zx rROR,fROR,$ff-fnzc
+27db : 08 > php ;save flags
+27dc : b50c > lda zpt,x
+27de : dd1902 > cmp rROR,x ;test result
+ > trap_ne
+27e1 : d0fe > bne * ;failed not equal (non zero)
+ >
+27e3 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+27e4 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+27e6 : dd2902 > cmp fROR,x ;test flags
+ > trap_ne
+27e9 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+27eb : ca dex
+27ec : 10e3 bpl tror7
+
+27ee : a203 ldx #3
+27f0 : trorc6
+ set_zx zp1,fc
+ > load_flag fc
+27f0 : a901 > lda #fc ;allow test to change I-flag (no mask)
+ >
+27f2 : 48 > pha ;use stack to load status
+27f3 : b513 > lda zp1,x ;load to indexed zeropage
+27f5 : 950c > sta zpt,x
+27f7 : 28 > plp
+
+27f8 : 760c ror zpt,x
+ tst_zx rRORc,fRORc,0
+27fa : 08 > php ;save flags
+27fb : b50c > lda zpt,x
+27fd : dd1d02 > cmp rRORc,x ;test result
+ > trap_ne
+2800 : d0fe > bne * ;failed not equal (non zero)
+ >
+2802 : 68 > pla ;load status
+ > eor_flag 0
+2803 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2805 : dd2d02 > cmp fRORc,x ;test flags
+ > trap_ne
+2808 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+280a : ca dex
+280b : 10e3 bpl trorc6
+280d : a203 ldx #3
+280f : trorc7
+ set_zx zp1,$ff
+ > load_flag $ff
+280f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2811 : 48 > pha ;use stack to load status
+2812 : b513 > lda zp1,x ;load to indexed zeropage
+2814 : 950c > sta zpt,x
+2816 : 28 > plp
+
+2817 : 760c ror zpt,x
+ tst_zx rRORc,fRORc,$ff-fnzc
+2819 : 08 > php ;save flags
+281a : b50c > lda zpt,x
+281c : dd1d02 > cmp rRORc,x ;test result
+ > trap_ne
+281f : d0fe > bne * ;failed not equal (non zero)
+ >
+2821 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+2822 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2824 : dd2d02 > cmp fRORc,x ;test flags
+ > trap_ne
+2827 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2829 : ca dex
+282a : 10e3 bpl trorc7
+ next_test
+282c : ad0002 > lda test_case ;previous test
+282f : c920 > cmp #test_num
+ > trap_ne ;test is out of sequence
+2831 : d0fe > bne * ;failed not equal (non zero)
+ >
+0021 = >test_num = test_num + 1
+2833 : a921 > lda #test_num ;*** next tests' number
+2835 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; shifts - abs indexed
+2838 : a203 ldx #3
+283a : tasl8
+ set_absx zp1,0
+ > load_flag 0
+283a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+283c : 48 > pha ;use stack to load status
+283d : b513 > lda zp1,x ;load to indexed memory
+283f : 9d0302 > sta abst,x
+2842 : 28 > plp
+
+2843 : 1e0302 asl abst,x
+ tst_absx rASL,fASL,0
+2846 : 08 > php ;save flags
+2847 : bd0302 > lda abst,x
+284a : dd1102 > cmp rASL,x ;test result
+ > trap_ne
+284d : d0fe > bne * ;failed not equal (non zero)
+ >
+284f : 68 > pla ;load status
+ > eor_flag 0
+2850 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2852 : dd2102 > cmp fASL,x ;test flags
+ > trap_ne
+2855 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2857 : ca dex
+2858 : 10e0 bpl tasl8
+285a : a203 ldx #3
+285c : tasl9
+ set_absx zp1,$ff
+ > load_flag $ff
+285c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+285e : 48 > pha ;use stack to load status
+285f : b513 > lda zp1,x ;load to indexed memory
+2861 : 9d0302 > sta abst,x
+2864 : 28 > plp
+
+2865 : 1e0302 asl abst,x
+ tst_absx rASL,fASL,$ff-fnzc
+2868 : 08 > php ;save flags
+2869 : bd0302 > lda abst,x
+286c : dd1102 > cmp rASL,x ;test result
+ > trap_ne
+286f : d0fe > bne * ;failed not equal (non zero)
+ >
+2871 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+2872 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2874 : dd2102 > cmp fASL,x ;test flags
+ > trap_ne
+2877 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2879 : ca dex
+287a : 10e0 bpl tasl9
+
+287c : a203 ldx #3
+287e : tlsr8
+ set_absx zp1,0
+ > load_flag 0
+287e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2880 : 48 > pha ;use stack to load status
+2881 : b513 > lda zp1,x ;load to indexed memory
+2883 : 9d0302 > sta abst,x
+2886 : 28 > plp
+
+2887 : 5e0302 lsr abst,x
+ tst_absx rLSR,fLSR,0
+288a : 08 > php ;save flags
+288b : bd0302 > lda abst,x
+288e : dd1902 > cmp rLSR,x ;test result
+ > trap_ne
+2891 : d0fe > bne * ;failed not equal (non zero)
+ >
+2893 : 68 > pla ;load status
+ > eor_flag 0
+2894 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2896 : dd2902 > cmp fLSR,x ;test flags
+ > trap_ne
+2899 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+289b : ca dex
+289c : 10e0 bpl tlsr8
+289e : a203 ldx #3
+28a0 : tlsr9
+ set_absx zp1,$ff
+ > load_flag $ff
+28a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+28a2 : 48 > pha ;use stack to load status
+28a3 : b513 > lda zp1,x ;load to indexed memory
+28a5 : 9d0302 > sta abst,x
+28a8 : 28 > plp
+
+28a9 : 5e0302 lsr abst,x
+ tst_absx rLSR,fLSR,$ff-fnzc
+28ac : 08 > php ;save flags
+28ad : bd0302 > lda abst,x
+28b0 : dd1902 > cmp rLSR,x ;test result
+ > trap_ne
+28b3 : d0fe > bne * ;failed not equal (non zero)
+ >
+28b5 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+28b6 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+28b8 : dd2902 > cmp fLSR,x ;test flags
+ > trap_ne
+28bb : d0fe > bne * ;failed not equal (non zero)
+ >
+
+28bd : ca dex
+28be : 10e0 bpl tlsr9
+
+28c0 : a203 ldx #3
+28c2 : trol8
+ set_absx zp1,0
+ > load_flag 0
+28c2 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+28c4 : 48 > pha ;use stack to load status
+28c5 : b513 > lda zp1,x ;load to indexed memory
+28c7 : 9d0302 > sta abst,x
+28ca : 28 > plp
+
+28cb : 3e0302 rol abst,x
+ tst_absx rROL,fROL,0
+28ce : 08 > php ;save flags
+28cf : bd0302 > lda abst,x
+28d2 : dd1102 > cmp rROL,x ;test result
+ > trap_ne
+28d5 : d0fe > bne * ;failed not equal (non zero)
+ >
+28d7 : 68 > pla ;load status
+ > eor_flag 0
+28d8 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+28da : dd2102 > cmp fROL,x ;test flags
+ > trap_ne
+28dd : d0fe > bne * ;failed not equal (non zero)
+ >
+
+28df : ca dex
+28e0 : 10e0 bpl trol8
+28e2 : a203 ldx #3
+28e4 : trol9
+ set_absx zp1,$ff-fc
+ > load_flag $ff-fc
+28e4 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
+ >
+28e6 : 48 > pha ;use stack to load status
+28e7 : b513 > lda zp1,x ;load to indexed memory
+28e9 : 9d0302 > sta abst,x
+28ec : 28 > plp
+
+28ed : 3e0302 rol abst,x
+ tst_absx rROL,fROL,$ff-fnzc
+28f0 : 08 > php ;save flags
+28f1 : bd0302 > lda abst,x
+28f4 : dd1102 > cmp rROL,x ;test result
+ > trap_ne
+28f7 : d0fe > bne * ;failed not equal (non zero)
+ >
+28f9 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+28fa : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+28fc : dd2102 > cmp fROL,x ;test flags
+ > trap_ne
+28ff : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2901 : ca dex
+2902 : 10e0 bpl trol9
+
+2904 : a203 ldx #3
+2906 : trolc8
+ set_absx zp1,fc
+ > load_flag fc
+2906 : a901 > lda #fc ;allow test to change I-flag (no mask)
+ >
+2908 : 48 > pha ;use stack to load status
+2909 : b513 > lda zp1,x ;load to indexed memory
+290b : 9d0302 > sta abst,x
+290e : 28 > plp
+
+290f : 3e0302 rol abst,x
+ tst_absx rROLc,fROLc,0
+2912 : 08 > php ;save flags
+2913 : bd0302 > lda abst,x
+2916 : dd1502 > cmp rROLc,x ;test result
+ > trap_ne
+2919 : d0fe > bne * ;failed not equal (non zero)
+ >
+291b : 68 > pla ;load status
+ > eor_flag 0
+291c : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+291e : dd2502 > cmp fROLc,x ;test flags
+ > trap_ne
+2921 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2923 : ca dex
+2924 : 10e0 bpl trolc8
+2926 : a203 ldx #3
+2928 : trolc9
+ set_absx zp1,$ff
+ > load_flag $ff
+2928 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+292a : 48 > pha ;use stack to load status
+292b : b513 > lda zp1,x ;load to indexed memory
+292d : 9d0302 > sta abst,x
+2930 : 28 > plp
+
+2931 : 3e0302 rol abst,x
+ tst_absx rROLc,fROLc,$ff-fnzc
+2934 : 08 > php ;save flags
+2935 : bd0302 > lda abst,x
+2938 : dd1502 > cmp rROLc,x ;test result
+ > trap_ne
+293b : d0fe > bne * ;failed not equal (non zero)
+ >
+293d : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+293e : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2940 : dd2502 > cmp fROLc,x ;test flags
+ > trap_ne
+2943 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2945 : ca dex
+2946 : 10e0 bpl trolc9
+
+2948 : a203 ldx #3
+294a : tror8
+ set_absx zp1,0
+ > load_flag 0
+294a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+294c : 48 > pha ;use stack to load status
+294d : b513 > lda zp1,x ;load to indexed memory
+294f : 9d0302 > sta abst,x
+2952 : 28 > plp
+
+2953 : 7e0302 ror abst,x
+ tst_absx rROR,fROR,0
+2956 : 08 > php ;save flags
+2957 : bd0302 > lda abst,x
+295a : dd1902 > cmp rROR,x ;test result
+ > trap_ne
+295d : d0fe > bne * ;failed not equal (non zero)
+ >
+295f : 68 > pla ;load status
+ > eor_flag 0
+2960 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2962 : dd2902 > cmp fROR,x ;test flags
+ > trap_ne
+2965 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2967 : ca dex
+2968 : 10e0 bpl tror8
+296a : a203 ldx #3
+296c : tror9
+ set_absx zp1,$ff-fc
+ > load_flag $ff-fc
+296c : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
+ >
+296e : 48 > pha ;use stack to load status
+296f : b513 > lda zp1,x ;load to indexed memory
+2971 : 9d0302 > sta abst,x
+2974 : 28 > plp
+
+2975 : 7e0302 ror abst,x
+ tst_absx rROR,fROR,$ff-fnzc
+2978 : 08 > php ;save flags
+2979 : bd0302 > lda abst,x
+297c : dd1902 > cmp rROR,x ;test result
+ > trap_ne
+297f : d0fe > bne * ;failed not equal (non zero)
+ >
+2981 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+2982 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+2984 : dd2902 > cmp fROR,x ;test flags
+ > trap_ne
+2987 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2989 : ca dex
+298a : 10e0 bpl tror9
+
+298c : a203 ldx #3
+298e : trorc8
+ set_absx zp1,fc
+ > load_flag fc
+298e : a901 > lda #fc ;allow test to change I-flag (no mask)
+ >
+2990 : 48 > pha ;use stack to load status
+2991 : b513 > lda zp1,x ;load to indexed memory
+2993 : 9d0302 > sta abst,x
+2996 : 28 > plp
+
+2997 : 7e0302 ror abst,x
+ tst_absx rRORc,fRORc,0
+299a : 08 > php ;save flags
+299b : bd0302 > lda abst,x
+299e : dd1d02 > cmp rRORc,x ;test result
+ > trap_ne
+29a1 : d0fe > bne * ;failed not equal (non zero)
+ >
+29a3 : 68 > pla ;load status
+ > eor_flag 0
+29a4 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+29a6 : dd2d02 > cmp fRORc,x ;test flags
+ > trap_ne
+29a9 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+29ab : ca dex
+29ac : 10e0 bpl trorc8
+29ae : a203 ldx #3
+29b0 : trorc9
+ set_absx zp1,$ff
+ > load_flag $ff
+29b0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+29b2 : 48 > pha ;use stack to load status
+29b3 : b513 > lda zp1,x ;load to indexed memory
+29b5 : 9d0302 > sta abst,x
+29b8 : 28 > plp
+
+29b9 : 7e0302 ror abst,x
+ tst_absx rRORc,fRORc,$ff-fnzc
+29bc : 08 > php ;save flags
+29bd : bd0302 > lda abst,x
+29c0 : dd1d02 > cmp rRORc,x ;test result
+ > trap_ne
+29c3 : d0fe > bne * ;failed not equal (non zero)
+ >
+29c5 : 68 > pla ;load status
+ > eor_flag $ff-fnzc
+29c6 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
+ >
+29c8 : dd2d02 > cmp fRORc,x ;test flags
+ > trap_ne
+29cb : d0fe > bne * ;failed not equal (non zero)
+ >
+
+29cd : ca dex
+29ce : 10e0 bpl trorc9
+ next_test
+29d0 : ad0002 > lda test_case ;previous test
+29d3 : c921 > cmp #test_num
+ > trap_ne ;test is out of sequence
+29d5 : d0fe > bne * ;failed not equal (non zero)
+ >
+0022 = >test_num = test_num + 1
+29d7 : a922 > lda #test_num ;*** next tests' number
+29d9 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; testing memory increment/decrement - INC DEC all addressing modes
+ ; zeropage
+29dc : a200 ldx #0
+29de : a97e lda #$7e
+29e0 : 850c sta zpt
+29e2 : tinc
+ set_stat 0
+ > load_flag 0
+29e2 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+29e4 : 48 > pha ;use stack to load status
+29e5 : 28 > plp
+
+29e6 : e60c inc zpt
+ tst_z rINC,fINC,0
+29e8 : 08 > php ;save flags
+29e9 : a50c > lda zpt
+29eb : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+29ee : d0fe > bne * ;failed not equal (non zero)
+ >
+29f0 : 68 > pla ;load status
+ > eor_flag 0
+29f1 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+29f3 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+29f6 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+29f8 : e8 inx
+29f9 : e002 cpx #2
+29fb : d004 bne tinc1
+29fd : a9fe lda #$fe
+29ff : 850c sta zpt
+2a01 : e005 tinc1 cpx #5
+2a03 : d0dd bne tinc
+2a05 : ca dex
+2a06 : e60c inc zpt
+2a08 : tdec
+ set_stat 0
+ > load_flag 0
+2a08 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2a0a : 48 > pha ;use stack to load status
+2a0b : 28 > plp
+
+2a0c : c60c dec zpt
+ tst_z rINC,fINC,0
+2a0e : 08 > php ;save flags
+2a0f : a50c > lda zpt
+2a11 : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2a14 : d0fe > bne * ;failed not equal (non zero)
+ >
+2a16 : 68 > pla ;load status
+ > eor_flag 0
+2a17 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2a19 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2a1c : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2a1e : ca dex
+2a1f : 300a bmi tdec1
+2a21 : e001 cpx #1
+2a23 : d0e3 bne tdec
+2a25 : a981 lda #$81
+2a27 : 850c sta zpt
+2a29 : d0dd bne tdec
+2a2b : tdec1
+2a2b : a200 ldx #0
+2a2d : a97e lda #$7e
+2a2f : 850c sta zpt
+2a31 : tinc10
+ set_stat $ff
+ > load_flag $ff
+2a31 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2a33 : 48 > pha ;use stack to load status
+2a34 : 28 > plp
+
+2a35 : e60c inc zpt
+ tst_z rINC,fINC,$ff-fnz
+2a37 : 08 > php ;save flags
+2a38 : a50c > lda zpt
+2a3a : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2a3d : d0fe > bne * ;failed not equal (non zero)
+ >
+2a3f : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2a40 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2a42 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2a45 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2a47 : e8 inx
+2a48 : e002 cpx #2
+2a4a : d004 bne tinc11
+2a4c : a9fe lda #$fe
+2a4e : 850c sta zpt
+2a50 : e005 tinc11 cpx #5
+2a52 : d0dd bne tinc10
+2a54 : ca dex
+2a55 : e60c inc zpt
+2a57 : tdec10
+ set_stat $ff
+ > load_flag $ff
+2a57 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2a59 : 48 > pha ;use stack to load status
+2a5a : 28 > plp
+
+2a5b : c60c dec zpt
+ tst_z rINC,fINC,$ff-fnz
+2a5d : 08 > php ;save flags
+2a5e : a50c > lda zpt
+2a60 : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2a63 : d0fe > bne * ;failed not equal (non zero)
+ >
+2a65 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2a66 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2a68 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2a6b : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2a6d : ca dex
+2a6e : 300a bmi tdec11
+2a70 : e001 cpx #1
+2a72 : d0e3 bne tdec10
+2a74 : a981 lda #$81
+2a76 : 850c sta zpt
+2a78 : d0dd bne tdec10
+2a7a : tdec11
+ next_test
+2a7a : ad0002 > lda test_case ;previous test
+2a7d : c922 > cmp #test_num
+ > trap_ne ;test is out of sequence
+2a7f : d0fe > bne * ;failed not equal (non zero)
+ >
+0023 = >test_num = test_num + 1
+2a81 : a923 > lda #test_num ;*** next tests' number
+2a83 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; absolute memory
+2a86 : a200 ldx #0
+2a88 : a97e lda #$7e
+2a8a : 8d0302 sta abst
+2a8d : tinc2
+ set_stat 0
+ > load_flag 0
+2a8d : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2a8f : 48 > pha ;use stack to load status
+2a90 : 28 > plp
+
+2a91 : ee0302 inc abst
+ tst_abs rINC,fINC,0
+2a94 : 08 > php ;save flags
+2a95 : ad0302 > lda abst
+2a98 : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2a9b : d0fe > bne * ;failed not equal (non zero)
+ >
+2a9d : 68 > pla ;load status
+ > eor_flag 0
+2a9e : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2aa0 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2aa3 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2aa5 : e8 inx
+2aa6 : e002 cpx #2
+2aa8 : d005 bne tinc3
+2aaa : a9fe lda #$fe
+2aac : 8d0302 sta abst
+2aaf : e005 tinc3 cpx #5
+2ab1 : d0da bne tinc2
+2ab3 : ca dex
+2ab4 : ee0302 inc abst
+2ab7 : tdec2
+ set_stat 0
+ > load_flag 0
+2ab7 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2ab9 : 48 > pha ;use stack to load status
+2aba : 28 > plp
+
+2abb : ce0302 dec abst
+ tst_abs rINC,fINC,0
+2abe : 08 > php ;save flags
+2abf : ad0302 > lda abst
+2ac2 : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2ac5 : d0fe > bne * ;failed not equal (non zero)
+ >
+2ac7 : 68 > pla ;load status
+ > eor_flag 0
+2ac8 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2aca : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2acd : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2acf : ca dex
+2ad0 : 300b bmi tdec3
+2ad2 : e001 cpx #1
+2ad4 : d0e1 bne tdec2
+2ad6 : a981 lda #$81
+2ad8 : 8d0302 sta abst
+2adb : d0da bne tdec2
+2add : tdec3
+2add : a200 ldx #0
+2adf : a97e lda #$7e
+2ae1 : 8d0302 sta abst
+2ae4 : tinc12
+ set_stat $ff
+ > load_flag $ff
+2ae4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2ae6 : 48 > pha ;use stack to load status
+2ae7 : 28 > plp
+
+2ae8 : ee0302 inc abst
+ tst_abs rINC,fINC,$ff-fnz
+2aeb : 08 > php ;save flags
+2aec : ad0302 > lda abst
+2aef : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2af2 : d0fe > bne * ;failed not equal (non zero)
+ >
+2af4 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2af5 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2af7 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2afa : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2afc : e8 inx
+2afd : e002 cpx #2
+2aff : d005 bne tinc13
+2b01 : a9fe lda #$fe
+2b03 : 8d0302 sta abst
+2b06 : e005 tinc13 cpx #5
+2b08 : d0da bne tinc12
+2b0a : ca dex
+2b0b : ee0302 inc abst
+2b0e : tdec12
+ set_stat $ff
+ > load_flag $ff
+2b0e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2b10 : 48 > pha ;use stack to load status
+2b11 : 28 > plp
+
+2b12 : ce0302 dec abst
+ tst_abs rINC,fINC,$ff-fnz
+2b15 : 08 > php ;save flags
+2b16 : ad0302 > lda abst
+2b19 : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2b1c : d0fe > bne * ;failed not equal (non zero)
+ >
+2b1e : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2b1f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2b21 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2b24 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2b26 : ca dex
+2b27 : 300b bmi tdec13
+2b29 : e001 cpx #1
+2b2b : d0e1 bne tdec12
+2b2d : a981 lda #$81
+2b2f : 8d0302 sta abst
+2b32 : d0da bne tdec12
+2b34 : tdec13
+ next_test
+2b34 : ad0002 > lda test_case ;previous test
+2b37 : c923 > cmp #test_num
+ > trap_ne ;test is out of sequence
+2b39 : d0fe > bne * ;failed not equal (non zero)
+ >
+0024 = >test_num = test_num + 1
+2b3b : a924 > lda #test_num ;*** next tests' number
+2b3d : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; zeropage indexed
+2b40 : a200 ldx #0
+2b42 : a97e lda #$7e
+2b44 : 950c tinc4 sta zpt,x
+ set_stat 0
+ > load_flag 0
+2b46 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2b48 : 48 > pha ;use stack to load status
+2b49 : 28 > plp
+
+2b4a : f60c inc zpt,x
+ tst_zx rINC,fINC,0
+2b4c : 08 > php ;save flags
+2b4d : b50c > lda zpt,x
+2b4f : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2b52 : d0fe > bne * ;failed not equal (non zero)
+ >
+2b54 : 68 > pla ;load status
+ > eor_flag 0
+2b55 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2b57 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2b5a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2b5c : b50c lda zpt,x
+2b5e : e8 inx
+2b5f : e002 cpx #2
+2b61 : d002 bne tinc5
+2b63 : a9fe lda #$fe
+2b65 : e005 tinc5 cpx #5
+2b67 : d0db bne tinc4
+2b69 : ca dex
+2b6a : a902 lda #2
+2b6c : 950c tdec4 sta zpt,x
+ set_stat 0
+ > load_flag 0
+2b6e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2b70 : 48 > pha ;use stack to load status
+2b71 : 28 > plp
+
+2b72 : d60c dec zpt,x
+ tst_zx rINC,fINC,0
+2b74 : 08 > php ;save flags
+2b75 : b50c > lda zpt,x
+2b77 : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2b7a : d0fe > bne * ;failed not equal (non zero)
+ >
+2b7c : 68 > pla ;load status
+ > eor_flag 0
+2b7d : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2b7f : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2b82 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2b84 : b50c lda zpt,x
+2b86 : ca dex
+2b87 : 3008 bmi tdec5
+2b89 : e001 cpx #1
+2b8b : d0df bne tdec4
+2b8d : a981 lda #$81
+2b8f : d0db bne tdec4
+2b91 : tdec5
+2b91 : a200 ldx #0
+2b93 : a97e lda #$7e
+2b95 : 950c tinc14 sta zpt,x
+ set_stat $ff
+ > load_flag $ff
+2b97 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2b99 : 48 > pha ;use stack to load status
+2b9a : 28 > plp
+
+2b9b : f60c inc zpt,x
+ tst_zx rINC,fINC,$ff-fnz
+2b9d : 08 > php ;save flags
+2b9e : b50c > lda zpt,x
+2ba0 : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2ba3 : d0fe > bne * ;failed not equal (non zero)
+ >
+2ba5 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2ba6 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2ba8 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2bab : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2bad : b50c lda zpt,x
+2baf : e8 inx
+2bb0 : e002 cpx #2
+2bb2 : d002 bne tinc15
+2bb4 : a9fe lda #$fe
+2bb6 : e005 tinc15 cpx #5
+2bb8 : d0db bne tinc14
+2bba : ca dex
+2bbb : a902 lda #2
+2bbd : 950c tdec14 sta zpt,x
+ set_stat $ff
+ > load_flag $ff
+2bbf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2bc1 : 48 > pha ;use stack to load status
+2bc2 : 28 > plp
+
+2bc3 : d60c dec zpt,x
+ tst_zx rINC,fINC,$ff-fnz
+2bc5 : 08 > php ;save flags
+2bc6 : b50c > lda zpt,x
+2bc8 : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2bcb : d0fe > bne * ;failed not equal (non zero)
+ >
+2bcd : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2bce : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2bd0 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2bd3 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2bd5 : b50c lda zpt,x
+2bd7 : ca dex
+2bd8 : 3008 bmi tdec15
+2bda : e001 cpx #1
+2bdc : d0df bne tdec14
+2bde : a981 lda #$81
+2be0 : d0db bne tdec14
+2be2 : tdec15
+ next_test
+2be2 : ad0002 > lda test_case ;previous test
+2be5 : c924 > cmp #test_num
+ > trap_ne ;test is out of sequence
+2be7 : d0fe > bne * ;failed not equal (non zero)
+ >
+0025 = >test_num = test_num + 1
+2be9 : a925 > lda #test_num ;*** next tests' number
+2beb : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; memory indexed
+2bee : a200 ldx #0
+2bf0 : a97e lda #$7e
+2bf2 : 9d0302 tinc6 sta abst,x
+ set_stat 0
+ > load_flag 0
+2bf5 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2bf7 : 48 > pha ;use stack to load status
+2bf8 : 28 > plp
+
+2bf9 : fe0302 inc abst,x
+ tst_absx rINC,fINC,0
+2bfc : 08 > php ;save flags
+2bfd : bd0302 > lda abst,x
+2c00 : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2c03 : d0fe > bne * ;failed not equal (non zero)
+ >
+2c05 : 68 > pla ;load status
+ > eor_flag 0
+2c06 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2c08 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2c0b : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2c0d : bd0302 lda abst,x
+2c10 : e8 inx
+2c11 : e002 cpx #2
+2c13 : d002 bne tinc7
+2c15 : a9fe lda #$fe
+2c17 : e005 tinc7 cpx #5
+2c19 : d0d7 bne tinc6
+2c1b : ca dex
+2c1c : a902 lda #2
+2c1e : 9d0302 tdec6 sta abst,x
+ set_stat 0
+ > load_flag 0
+2c21 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2c23 : 48 > pha ;use stack to load status
+2c24 : 28 > plp
+
+2c25 : de0302 dec abst,x
+ tst_absx rINC,fINC,0
+2c28 : 08 > php ;save flags
+2c29 : bd0302 > lda abst,x
+2c2c : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2c2f : d0fe > bne * ;failed not equal (non zero)
+ >
+2c31 : 68 > pla ;load status
+ > eor_flag 0
+2c32 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2c34 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2c37 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2c39 : bd0302 lda abst,x
+2c3c : ca dex
+2c3d : 3008 bmi tdec7
+2c3f : e001 cpx #1
+2c41 : d0db bne tdec6
+2c43 : a981 lda #$81
+2c45 : d0d7 bne tdec6
+2c47 : tdec7
+2c47 : a200 ldx #0
+2c49 : a97e lda #$7e
+2c4b : 9d0302 tinc16 sta abst,x
+ set_stat $ff
+ > load_flag $ff
+2c4e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2c50 : 48 > pha ;use stack to load status
+2c51 : 28 > plp
+
+2c52 : fe0302 inc abst,x
+ tst_absx rINC,fINC,$ff-fnz
+2c55 : 08 > php ;save flags
+2c56 : bd0302 > lda abst,x
+2c59 : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2c5c : d0fe > bne * ;failed not equal (non zero)
+ >
+2c5e : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2c5f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2c61 : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2c64 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2c66 : bd0302 lda abst,x
+2c69 : e8 inx
+2c6a : e002 cpx #2
+2c6c : d002 bne tinc17
+2c6e : a9fe lda #$fe
+2c70 : e005 tinc17 cpx #5
+2c72 : d0d7 bne tinc16
+2c74 : ca dex
+2c75 : a902 lda #2
+2c77 : 9d0302 tdec16 sta abst,x
+ set_stat $ff
+ > load_flag $ff
+2c7a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2c7c : 48 > pha ;use stack to load status
+2c7d : 28 > plp
+
+2c7e : de0302 dec abst,x
+ tst_absx rINC,fINC,$ff-fnz
+2c81 : 08 > php ;save flags
+2c82 : bd0302 > lda abst,x
+2c85 : dd3102 > cmp rINC,x ;test result
+ > trap_ne
+2c88 : d0fe > bne * ;failed not equal (non zero)
+ >
+2c8a : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2c8b : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2c8d : dd3602 > cmp fINC,x ;test flags
+ > trap_ne
+2c90 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2c92 : bd0302 lda abst,x
+2c95 : ca dex
+2c96 : 3008 bmi tdec17
+2c98 : e001 cpx #1
+2c9a : d0db bne tdec16
+2c9c : a981 lda #$81
+2c9e : d0d7 bne tdec16
+2ca0 : tdec17
+ next_test
+2ca0 : ad0002 > lda test_case ;previous test
+2ca3 : c925 > cmp #test_num
+ > trap_ne ;test is out of sequence
+2ca5 : d0fe > bne * ;failed not equal (non zero)
+ >
+0026 = >test_num = test_num + 1
+2ca7 : a926 > lda #test_num ;*** next tests' number
+2ca9 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; testing logical instructions - AND EOR ORA all addressing modes
+ ; AND
+2cac : a203 ldx #3 ;immediate - self modifying code
+2cae : b51c tand lda zpAN,x
+2cb0 : 8dbb2c sta tandi1
+ set_ax absANa,0
+ > load_flag 0
+2cb3 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2cb5 : 48 > pha ;use stack to load status
+2cb6 : bd4b02 > lda absANa,x ;precharge accu
+2cb9 : 28 > plp
+
+2cbb = tandi1 equ *+1 ;target for immediate operand
+2cba : 2963 and #99
+ tst_ax absrlo,absflo,0
+2cbc : 08 > php ;save flags
+2cbd : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2cc0 : d0fe > bne * ;failed not equal (non zero)
+ >
+2cc2 : 68 > pla ;load status
+ > eor_flag 0
+2cc3 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2cc5 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2cc8 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2cca : ca dex
+2ccb : 10e1 bpl tand
+2ccd : a203 ldx #3
+2ccf : b51c tand1 lda zpAN,x
+2cd1 : 8ddc2c sta tandi2
+ set_ax absANa,$ff
+ > load_flag $ff
+2cd4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2cd6 : 48 > pha ;use stack to load status
+2cd7 : bd4b02 > lda absANa,x ;precharge accu
+2cda : 28 > plp
+
+2cdc = tandi2 equ *+1 ;target for immediate operand
+2cdb : 2963 and #99
+ tst_ax absrlo,absflo,$ff-fnz
+2cdd : 08 > php ;save flags
+2cde : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2ce1 : d0fe > bne * ;failed not equal (non zero)
+ >
+2ce3 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2ce4 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2ce6 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2ce9 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2ceb : ca dex
+2cec : 10e1 bpl tand1
+
+2cee : a203 ldx #3 ;zp
+2cf0 : b51c tand2 lda zpAN,x
+2cf2 : 850c sta zpt
+ set_ax absANa,0
+ > load_flag 0
+2cf4 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2cf6 : 48 > pha ;use stack to load status
+2cf7 : bd4b02 > lda absANa,x ;precharge accu
+2cfa : 28 > plp
+
+2cfb : 250c and zpt
+ tst_ax absrlo,absflo,0
+2cfd : 08 > php ;save flags
+2cfe : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2d01 : d0fe > bne * ;failed not equal (non zero)
+ >
+2d03 : 68 > pla ;load status
+ > eor_flag 0
+2d04 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2d06 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2d09 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2d0b : ca dex
+2d0c : 10e2 bpl tand2
+2d0e : a203 ldx #3
+2d10 : b51c tand3 lda zpAN,x
+2d12 : 850c sta zpt
+ set_ax absANa,$ff
+ > load_flag $ff
+2d14 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2d16 : 48 > pha ;use stack to load status
+2d17 : bd4b02 > lda absANa,x ;precharge accu
+2d1a : 28 > plp
+
+2d1b : 250c and zpt
+ tst_ax absrlo,absflo,$ff-fnz
+2d1d : 08 > php ;save flags
+2d1e : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2d21 : d0fe > bne * ;failed not equal (non zero)
+ >
+2d23 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2d24 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2d26 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2d29 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2d2b : ca dex
+2d2c : 10e2 bpl tand3
+
+2d2e : a203 ldx #3 ;abs
+2d30 : b51c tand4 lda zpAN,x
+2d32 : 8d0302 sta abst
+ set_ax absANa,0
+ > load_flag 0
+2d35 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2d37 : 48 > pha ;use stack to load status
+2d38 : bd4b02 > lda absANa,x ;precharge accu
+2d3b : 28 > plp
+
+2d3c : 2d0302 and abst
+ tst_ax absrlo,absflo,0
+2d3f : 08 > php ;save flags
+2d40 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2d43 : d0fe > bne * ;failed not equal (non zero)
+ >
+2d45 : 68 > pla ;load status
+ > eor_flag 0
+2d46 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2d48 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2d4b : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2d4d : ca dex
+2d4e : 10e0 bpl tand4
+2d50 : a203 ldx #3
+2d52 : b51c tand5 lda zpAN,x
+2d54 : 8d0302 sta abst
+ set_ax absANa,$ff
+ > load_flag $ff
+2d57 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2d59 : 48 > pha ;use stack to load status
+2d5a : bd4b02 > lda absANa,x ;precharge accu
+2d5d : 28 > plp
+
+2d5e : 2d0302 and abst
+ tst_ax absrlo,absflo,$ff-fnz
+2d61 : 08 > php ;save flags
+2d62 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2d65 : d0fe > bne * ;failed not equal (non zero)
+ >
+2d67 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2d68 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2d6a : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2d6d : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2d6f : ca dex
+2d70 : 1002 bpl tand6
+
+2d72 : a203 ldx #3 ;zp,x
+2d74 : tand6
+ set_ax absANa,0
+ > load_flag 0
+2d74 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2d76 : 48 > pha ;use stack to load status
+2d77 : bd4b02 > lda absANa,x ;precharge accu
+2d7a : 28 > plp
+
+2d7b : 351c and zpAN,x
+ tst_ax absrlo,absflo,0
+2d7d : 08 > php ;save flags
+2d7e : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2d81 : d0fe > bne * ;failed not equal (non zero)
+ >
+2d83 : 68 > pla ;load status
+ > eor_flag 0
+2d84 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2d86 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2d89 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2d8b : ca dex
+2d8c : 10e6 bpl tand6
+2d8e : a203 ldx #3
+2d90 : tand7
+ set_ax absANa,$ff
+ > load_flag $ff
+2d90 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2d92 : 48 > pha ;use stack to load status
+2d93 : bd4b02 > lda absANa,x ;precharge accu
+2d96 : 28 > plp
+
+2d97 : 351c and zpAN,x
+ tst_ax absrlo,absflo,$ff-fnz
+2d99 : 08 > php ;save flags
+2d9a : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2d9d : d0fe > bne * ;failed not equal (non zero)
+ >
+2d9f : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2da0 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2da2 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2da5 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2da7 : ca dex
+2da8 : 10e6 bpl tand7
+
+2daa : a203 ldx #3 ;abs,x
+2dac : tand8
+ set_ax absANa,0
+ > load_flag 0
+2dac : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2dae : 48 > pha ;use stack to load status
+2daf : bd4b02 > lda absANa,x ;precharge accu
+2db2 : 28 > plp
+
+2db3 : 3d3f02 and absAN,x
+ tst_ax absrlo,absflo,0
+2db6 : 08 > php ;save flags
+2db7 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2dba : d0fe > bne * ;failed not equal (non zero)
+ >
+2dbc : 68 > pla ;load status
+ > eor_flag 0
+2dbd : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2dbf : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2dc2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2dc4 : ca dex
+2dc5 : 10e5 bpl tand8
+2dc7 : a203 ldx #3
+2dc9 : tand9
+ set_ax absANa,$ff
+ > load_flag $ff
+2dc9 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2dcb : 48 > pha ;use stack to load status
+2dcc : bd4b02 > lda absANa,x ;precharge accu
+2dcf : 28 > plp
+
+2dd0 : 3d3f02 and absAN,x
+ tst_ax absrlo,absflo,$ff-fnz
+2dd3 : 08 > php ;save flags
+2dd4 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2dd7 : d0fe > bne * ;failed not equal (non zero)
+ >
+2dd9 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2dda : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2ddc : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2ddf : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2de1 : ca dex
+2de2 : 10e5 bpl tand9
+
+2de4 : a003 ldy #3 ;abs,y
+2de6 : tand10
+ set_ay absANa,0
+ > load_flag 0
+2de6 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2de8 : 48 > pha ;use stack to load status
+2de9 : b94b02 > lda absANa,y ;precharge accu
+2dec : 28 > plp
+
+2ded : 393f02 and absAN,y
+ tst_ay absrlo,absflo,0
+2df0 : 08 > php ;save flags
+2df1 : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+2df4 : d0fe > bne * ;failed not equal (non zero)
+ >
+2df6 : 68 > pla ;load status
+ > eor_flag 0
+2df7 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2df9 : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+2dfc : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2dfe : 88 dey
+2dff : 10e5 bpl tand10
+2e01 : a003 ldy #3
+2e03 : tand11
+ set_ay absANa,$ff
+ > load_flag $ff
+2e03 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2e05 : 48 > pha ;use stack to load status
+2e06 : b94b02 > lda absANa,y ;precharge accu
+2e09 : 28 > plp
+
+2e0a : 393f02 and absAN,y
+ tst_ay absrlo,absflo,$ff-fnz
+2e0d : 08 > php ;save flags
+2e0e : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+2e11 : d0fe > bne * ;failed not equal (non zero)
+ >
+2e13 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2e14 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2e16 : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+2e19 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2e1b : 88 dey
+2e1c : 10e5 bpl tand11
+
+2e1e : a206 ldx #6 ;(zp,x)
+2e20 : a003 ldy #3
+2e22 : tand12
+ set_ay absANa,0
+ > load_flag 0
+2e22 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2e24 : 48 > pha ;use stack to load status
+2e25 : b94b02 > lda absANa,y ;precharge accu
+2e28 : 28 > plp
+
+2e29 : 213a and (indAN,x)
+ tst_ay absrlo,absflo,0
+2e2b : 08 > php ;save flags
+2e2c : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+2e2f : d0fe > bne * ;failed not equal (non zero)
+ >
+2e31 : 68 > pla ;load status
+ > eor_flag 0
+2e32 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2e34 : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+2e37 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2e39 : ca dex
+2e3a : ca dex
+2e3b : 88 dey
+2e3c : 10e4 bpl tand12
+2e3e : a206 ldx #6
+2e40 : a003 ldy #3
+2e42 : tand13
+ set_ay absANa,$ff
+ > load_flag $ff
+2e42 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2e44 : 48 > pha ;use stack to load status
+2e45 : b94b02 > lda absANa,y ;precharge accu
+2e48 : 28 > plp
+
+2e49 : 213a and (indAN,x)
+ tst_ay absrlo,absflo,$ff-fnz
+2e4b : 08 > php ;save flags
+2e4c : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+2e4f : d0fe > bne * ;failed not equal (non zero)
+ >
+2e51 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2e52 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2e54 : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+2e57 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2e59 : ca dex
+2e5a : ca dex
+2e5b : 88 dey
+2e5c : 10e4 bpl tand13
+
+2e5e : a003 ldy #3 ;(zp),y
+2e60 : tand14
+ set_ay absANa,0
+ > load_flag 0
+2e60 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2e62 : 48 > pha ;use stack to load status
+2e63 : b94b02 > lda absANa,y ;precharge accu
+2e66 : 28 > plp
+
+2e67 : 313a and (indAN),y
+ tst_ay absrlo,absflo,0
+2e69 : 08 > php ;save flags
+2e6a : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+2e6d : d0fe > bne * ;failed not equal (non zero)
+ >
+2e6f : 68 > pla ;load status
+ > eor_flag 0
+2e70 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2e72 : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+2e75 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2e77 : 88 dey
+2e78 : 10e6 bpl tand14
+2e7a : a003 ldy #3
+2e7c : tand15
+ set_ay absANa,$ff
+ > load_flag $ff
+2e7c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2e7e : 48 > pha ;use stack to load status
+2e7f : b94b02 > lda absANa,y ;precharge accu
+2e82 : 28 > plp
+
+2e83 : 313a and (indAN),y
+ tst_ay absrlo,absflo,$ff-fnz
+2e85 : 08 > php ;save flags
+2e86 : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+2e89 : d0fe > bne * ;failed not equal (non zero)
+ >
+2e8b : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2e8c : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2e8e : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+2e91 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2e93 : 88 dey
+2e94 : 10e6 bpl tand15
+ next_test
+2e96 : ad0002 > lda test_case ;previous test
+2e99 : c926 > cmp #test_num
+ > trap_ne ;test is out of sequence
+2e9b : d0fe > bne * ;failed not equal (non zero)
+ >
+0027 = >test_num = test_num + 1
+2e9d : a927 > lda #test_num ;*** next tests' number
+2e9f : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; EOR
+2ea2 : a203 ldx #3 ;immediate - self modifying code
+2ea4 : b520 teor lda zpEO,x
+2ea6 : 8db12e sta teori1
+ set_ax absEOa,0
+ > load_flag 0
+2ea9 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2eab : 48 > pha ;use stack to load status
+2eac : bd4f02 > lda absEOa,x ;precharge accu
+2eaf : 28 > plp
+
+2eb1 = teori1 equ *+1 ;target for immediate operand
+2eb0 : 4963 eor #99
+ tst_ax absrlo,absflo,0
+2eb2 : 08 > php ;save flags
+2eb3 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2eb6 : d0fe > bne * ;failed not equal (non zero)
+ >
+2eb8 : 68 > pla ;load status
+ > eor_flag 0
+2eb9 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2ebb : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2ebe : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2ec0 : ca dex
+2ec1 : 10e1 bpl teor
+2ec3 : a203 ldx #3
+2ec5 : b520 teor1 lda zpEO,x
+2ec7 : 8dd22e sta teori2
+ set_ax absEOa,$ff
+ > load_flag $ff
+2eca : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2ecc : 48 > pha ;use stack to load status
+2ecd : bd4f02 > lda absEOa,x ;precharge accu
+2ed0 : 28 > plp
+
+2ed2 = teori2 equ *+1 ;target for immediate operand
+2ed1 : 4963 eor #99
+ tst_ax absrlo,absflo,$ff-fnz
+2ed3 : 08 > php ;save flags
+2ed4 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2ed7 : d0fe > bne * ;failed not equal (non zero)
+ >
+2ed9 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2eda : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2edc : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2edf : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2ee1 : ca dex
+2ee2 : 10e1 bpl teor1
+
+2ee4 : a203 ldx #3 ;zp
+2ee6 : b520 teor2 lda zpEO,x
+2ee8 : 850c sta zpt
+ set_ax absEOa,0
+ > load_flag 0
+2eea : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2eec : 48 > pha ;use stack to load status
+2eed : bd4f02 > lda absEOa,x ;precharge accu
+2ef0 : 28 > plp
+
+2ef1 : 450c eor zpt
+ tst_ax absrlo,absflo,0
+2ef3 : 08 > php ;save flags
+2ef4 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2ef7 : d0fe > bne * ;failed not equal (non zero)
+ >
+2ef9 : 68 > pla ;load status
+ > eor_flag 0
+2efa : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2efc : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2eff : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2f01 : ca dex
+2f02 : 10e2 bpl teor2
+2f04 : a203 ldx #3
+2f06 : b520 teor3 lda zpEO,x
+2f08 : 850c sta zpt
+ set_ax absEOa,$ff
+ > load_flag $ff
+2f0a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2f0c : 48 > pha ;use stack to load status
+2f0d : bd4f02 > lda absEOa,x ;precharge accu
+2f10 : 28 > plp
+
+2f11 : 450c eor zpt
+ tst_ax absrlo,absflo,$ff-fnz
+2f13 : 08 > php ;save flags
+2f14 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2f17 : d0fe > bne * ;failed not equal (non zero)
+ >
+2f19 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2f1a : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2f1c : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2f1f : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2f21 : ca dex
+2f22 : 10e2 bpl teor3
+
+2f24 : a203 ldx #3 ;abs
+2f26 : b520 teor4 lda zpEO,x
+2f28 : 8d0302 sta abst
+ set_ax absEOa,0
+ > load_flag 0
+2f2b : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2f2d : 48 > pha ;use stack to load status
+2f2e : bd4f02 > lda absEOa,x ;precharge accu
+2f31 : 28 > plp
+
+2f32 : 4d0302 eor abst
+ tst_ax absrlo,absflo,0
+2f35 : 08 > php ;save flags
+2f36 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2f39 : d0fe > bne * ;failed not equal (non zero)
+ >
+2f3b : 68 > pla ;load status
+ > eor_flag 0
+2f3c : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2f3e : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2f41 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2f43 : ca dex
+2f44 : 10e0 bpl teor4
+2f46 : a203 ldx #3
+2f48 : b520 teor5 lda zpEO,x
+2f4a : 8d0302 sta abst
+ set_ax absEOa,$ff
+ > load_flag $ff
+2f4d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2f4f : 48 > pha ;use stack to load status
+2f50 : bd4f02 > lda absEOa,x ;precharge accu
+2f53 : 28 > plp
+
+2f54 : 4d0302 eor abst
+ tst_ax absrlo,absflo,$ff-fnz
+2f57 : 08 > php ;save flags
+2f58 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2f5b : d0fe > bne * ;failed not equal (non zero)
+ >
+2f5d : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2f5e : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2f60 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2f63 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2f65 : ca dex
+2f66 : 1002 bpl teor6
+
+2f68 : a203 ldx #3 ;zp,x
+2f6a : teor6
+ set_ax absEOa,0
+ > load_flag 0
+2f6a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2f6c : 48 > pha ;use stack to load status
+2f6d : bd4f02 > lda absEOa,x ;precharge accu
+2f70 : 28 > plp
+
+2f71 : 5520 eor zpEO,x
+ tst_ax absrlo,absflo,0
+2f73 : 08 > php ;save flags
+2f74 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2f77 : d0fe > bne * ;failed not equal (non zero)
+ >
+2f79 : 68 > pla ;load status
+ > eor_flag 0
+2f7a : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2f7c : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2f7f : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2f81 : ca dex
+2f82 : 10e6 bpl teor6
+2f84 : a203 ldx #3
+2f86 : teor7
+ set_ax absEOa,$ff
+ > load_flag $ff
+2f86 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2f88 : 48 > pha ;use stack to load status
+2f89 : bd4f02 > lda absEOa,x ;precharge accu
+2f8c : 28 > plp
+
+2f8d : 5520 eor zpEO,x
+ tst_ax absrlo,absflo,$ff-fnz
+2f8f : 08 > php ;save flags
+2f90 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2f93 : d0fe > bne * ;failed not equal (non zero)
+ >
+2f95 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2f96 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2f98 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2f9b : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2f9d : ca dex
+2f9e : 10e6 bpl teor7
+
+2fa0 : a203 ldx #3 ;abs,x
+2fa2 : teor8
+ set_ax absEOa,0
+ > load_flag 0
+2fa2 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2fa4 : 48 > pha ;use stack to load status
+2fa5 : bd4f02 > lda absEOa,x ;precharge accu
+2fa8 : 28 > plp
+
+2fa9 : 5d4302 eor absEO,x
+ tst_ax absrlo,absflo,0
+2fac : 08 > php ;save flags
+2fad : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2fb0 : d0fe > bne * ;failed not equal (non zero)
+ >
+2fb2 : 68 > pla ;load status
+ > eor_flag 0
+2fb3 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2fb5 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2fb8 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2fba : ca dex
+2fbb : 10e5 bpl teor8
+2fbd : a203 ldx #3
+2fbf : teor9
+ set_ax absEOa,$ff
+ > load_flag $ff
+2fbf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2fc1 : 48 > pha ;use stack to load status
+2fc2 : bd4f02 > lda absEOa,x ;precharge accu
+2fc5 : 28 > plp
+
+2fc6 : 5d4302 eor absEO,x
+ tst_ax absrlo,absflo,$ff-fnz
+2fc9 : 08 > php ;save flags
+2fca : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+2fcd : d0fe > bne * ;failed not equal (non zero)
+ >
+2fcf : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2fd0 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2fd2 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+2fd5 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2fd7 : ca dex
+2fd8 : 10e5 bpl teor9
+
+2fda : a003 ldy #3 ;abs,y
+2fdc : teor10
+ set_ay absEOa,0
+ > load_flag 0
+2fdc : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2fde : 48 > pha ;use stack to load status
+2fdf : b94f02 > lda absEOa,y ;precharge accu
+2fe2 : 28 > plp
+
+2fe3 : 594302 eor absEO,y
+ tst_ay absrlo,absflo,0
+2fe6 : 08 > php ;save flags
+2fe7 : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+2fea : d0fe > bne * ;failed not equal (non zero)
+ >
+2fec : 68 > pla ;load status
+ > eor_flag 0
+2fed : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+2fef : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+2ff2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2ff4 : 88 dey
+2ff5 : 10e5 bpl teor10
+2ff7 : a003 ldy #3
+2ff9 : teor11
+ set_ay absEOa,$ff
+ > load_flag $ff
+2ff9 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2ffb : 48 > pha ;use stack to load status
+2ffc : b94f02 > lda absEOa,y ;precharge accu
+2fff : 28 > plp
+
+3000 : 594302 eor absEO,y
+ tst_ay absrlo,absflo,$ff-fnz
+3003 : 08 > php ;save flags
+3004 : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+3007 : d0fe > bne * ;failed not equal (non zero)
+ >
+3009 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+300a : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+300c : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+300f : d0fe > bne * ;failed not equal (non zero)
+ >
+
+3011 : 88 dey
+3012 : 10e5 bpl teor11
+
+3014 : a206 ldx #6 ;(zp,x)
+3016 : a003 ldy #3
+3018 : teor12
+ set_ay absEOa,0
+ > load_flag 0
+3018 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+301a : 48 > pha ;use stack to load status
+301b : b94f02 > lda absEOa,y ;precharge accu
+301e : 28 > plp
+
+301f : 4142 eor (indEO,x)
+ tst_ay absrlo,absflo,0
+3021 : 08 > php ;save flags
+3022 : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+3025 : d0fe > bne * ;failed not equal (non zero)
+ >
+3027 : 68 > pla ;load status
+ > eor_flag 0
+3028 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+302a : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+302d : d0fe > bne * ;failed not equal (non zero)
+ >
+
+302f : ca dex
+3030 : ca dex
+3031 : 88 dey
+3032 : 10e4 bpl teor12
+3034 : a206 ldx #6
+3036 : a003 ldy #3
+3038 : teor13
+ set_ay absEOa,$ff
+ > load_flag $ff
+3038 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+303a : 48 > pha ;use stack to load status
+303b : b94f02 > lda absEOa,y ;precharge accu
+303e : 28 > plp
+
+303f : 4142 eor (indEO,x)
+ tst_ay absrlo,absflo,$ff-fnz
+3041 : 08 > php ;save flags
+3042 : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+3045 : d0fe > bne * ;failed not equal (non zero)
+ >
+3047 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+3048 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+304a : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+304d : d0fe > bne * ;failed not equal (non zero)
+ >
+
+304f : ca dex
+3050 : ca dex
+3051 : 88 dey
+3052 : 10e4 bpl teor13
+
+3054 : a003 ldy #3 ;(zp),y
+3056 : teor14
+ set_ay absEOa,0
+ > load_flag 0
+3056 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+3058 : 48 > pha ;use stack to load status
+3059 : b94f02 > lda absEOa,y ;precharge accu
+305c : 28 > plp
+
+305d : 5142 eor (indEO),y
+ tst_ay absrlo,absflo,0
+305f : 08 > php ;save flags
+3060 : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+3063 : d0fe > bne * ;failed not equal (non zero)
+ >
+3065 : 68 > pla ;load status
+ > eor_flag 0
+3066 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+3068 : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+306b : d0fe > bne * ;failed not equal (non zero)
+ >
+
+306d : 88 dey
+306e : 10e6 bpl teor14
+3070 : a003 ldy #3
+3072 : teor15
+ set_ay absEOa,$ff
+ > load_flag $ff
+3072 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+3074 : 48 > pha ;use stack to load status
+3075 : b94f02 > lda absEOa,y ;precharge accu
+3078 : 28 > plp
+
+3079 : 5142 eor (indEO),y
+ tst_ay absrlo,absflo,$ff-fnz
+307b : 08 > php ;save flags
+307c : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+307f : d0fe > bne * ;failed not equal (non zero)
+ >
+3081 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+3082 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+3084 : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+3087 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+3089 : 88 dey
+308a : 10e6 bpl teor15
+ next_test
+308c : ad0002 > lda test_case ;previous test
+308f : c927 > cmp #test_num
+ > trap_ne ;test is out of sequence
+3091 : d0fe > bne * ;failed not equal (non zero)
+ >
+0028 = >test_num = test_num + 1
+3093 : a928 > lda #test_num ;*** next tests' number
+3095 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; OR
+3098 : a203 ldx #3 ;immediate - self modifying code
+309a : b518 tora lda zpOR,x
+309c : 8da730 sta torai1
+ set_ax absORa,0
+ > load_flag 0
+309f : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+30a1 : 48 > pha ;use stack to load status
+30a2 : bd4702 > lda absORa,x ;precharge accu
+30a5 : 28 > plp
+
+30a7 = torai1 equ *+1 ;target for immediate operand
+30a6 : 0963 ora #99
+ tst_ax absrlo,absflo,0
+30a8 : 08 > php ;save flags
+30a9 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+30ac : d0fe > bne * ;failed not equal (non zero)
+ >
+30ae : 68 > pla ;load status
+ > eor_flag 0
+30af : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+30b1 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+30b4 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+30b6 : ca dex
+30b7 : 10e1 bpl tora
+30b9 : a203 ldx #3
+30bb : b518 tora1 lda zpOR,x
+30bd : 8dc830 sta torai2
+ set_ax absORa,$ff
+ > load_flag $ff
+30c0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+30c2 : 48 > pha ;use stack to load status
+30c3 : bd4702 > lda absORa,x ;precharge accu
+30c6 : 28 > plp
+
+30c8 = torai2 equ *+1 ;target for immediate operand
+30c7 : 0963 ora #99
+ tst_ax absrlo,absflo,$ff-fnz
+30c9 : 08 > php ;save flags
+30ca : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+30cd : d0fe > bne * ;failed not equal (non zero)
+ >
+30cf : 68 > pla ;load status
+ > eor_flag $ff-fnz
+30d0 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+30d2 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+30d5 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+30d7 : ca dex
+30d8 : 10e1 bpl tora1
+
+30da : a203 ldx #3 ;zp
+30dc : b518 tora2 lda zpOR,x
+30de : 850c sta zpt
+ set_ax absORa,0
+ > load_flag 0
+30e0 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+30e2 : 48 > pha ;use stack to load status
+30e3 : bd4702 > lda absORa,x ;precharge accu
+30e6 : 28 > plp
+
+30e7 : 050c ora zpt
+ tst_ax absrlo,absflo,0
+30e9 : 08 > php ;save flags
+30ea : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+30ed : d0fe > bne * ;failed not equal (non zero)
+ >
+30ef : 68 > pla ;load status
+ > eor_flag 0
+30f0 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+30f2 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+30f5 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+30f7 : ca dex
+30f8 : 10e2 bpl tora2
+30fa : a203 ldx #3
+30fc : b518 tora3 lda zpOR,x
+30fe : 850c sta zpt
+ set_ax absORa,$ff
+ > load_flag $ff
+3100 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+3102 : 48 > pha ;use stack to load status
+3103 : bd4702 > lda absORa,x ;precharge accu
+3106 : 28 > plp
+
+3107 : 050c ora zpt
+ tst_ax absrlo,absflo,$ff-fnz
+3109 : 08 > php ;save flags
+310a : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+310d : d0fe > bne * ;failed not equal (non zero)
+ >
+310f : 68 > pla ;load status
+ > eor_flag $ff-fnz
+3110 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+3112 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+3115 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+3117 : ca dex
+3118 : 10e2 bpl tora3
+
+311a : a203 ldx #3 ;abs
+311c : b518 tora4 lda zpOR,x
+311e : 8d0302 sta abst
+ set_ax absORa,0
+ > load_flag 0
+3121 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+3123 : 48 > pha ;use stack to load status
+3124 : bd4702 > lda absORa,x ;precharge accu
+3127 : 28 > plp
+
+3128 : 0d0302 ora abst
+ tst_ax absrlo,absflo,0
+312b : 08 > php ;save flags
+312c : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+312f : d0fe > bne * ;failed not equal (non zero)
+ >
+3131 : 68 > pla ;load status
+ > eor_flag 0
+3132 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+3134 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+3137 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+3139 : ca dex
+313a : 10e0 bpl tora4
+313c : a203 ldx #3
+313e : b518 tora5 lda zpOR,x
+3140 : 8d0302 sta abst
+ set_ax absORa,$ff
+ > load_flag $ff
+3143 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+3145 : 48 > pha ;use stack to load status
+3146 : bd4702 > lda absORa,x ;precharge accu
+3149 : 28 > plp
+
+314a : 0d0302 ora abst
+ tst_ax absrlo,absflo,$ff-fnz
+314d : 08 > php ;save flags
+314e : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+3151 : d0fe > bne * ;failed not equal (non zero)
+ >
+3153 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+3154 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+3156 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+3159 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+315b : ca dex
+315c : 1002 bpl tora6
+
+315e : a203 ldx #3 ;zp,x
+3160 : tora6
+ set_ax absORa,0
+ > load_flag 0
+3160 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+3162 : 48 > pha ;use stack to load status
+3163 : bd4702 > lda absORa,x ;precharge accu
+3166 : 28 > plp
+
+3167 : 1518 ora zpOR,x
+ tst_ax absrlo,absflo,0
+3169 : 08 > php ;save flags
+316a : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+316d : d0fe > bne * ;failed not equal (non zero)
+ >
+316f : 68 > pla ;load status
+ > eor_flag 0
+3170 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+3172 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+3175 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+3177 : ca dex
+3178 : 10e6 bpl tora6
+317a : a203 ldx #3
+317c : tora7
+ set_ax absORa,$ff
+ > load_flag $ff
+317c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+317e : 48 > pha ;use stack to load status
+317f : bd4702 > lda absORa,x ;precharge accu
+3182 : 28 > plp
+
+3183 : 1518 ora zpOR,x
+ tst_ax absrlo,absflo,$ff-fnz
+3185 : 08 > php ;save flags
+3186 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+3189 : d0fe > bne * ;failed not equal (non zero)
+ >
+318b : 68 > pla ;load status
+ > eor_flag $ff-fnz
+318c : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+318e : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+3191 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+3193 : ca dex
+3194 : 10e6 bpl tora7
+
+3196 : a203 ldx #3 ;abs,x
+3198 : tora8
+ set_ax absORa,0
+ > load_flag 0
+3198 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+319a : 48 > pha ;use stack to load status
+319b : bd4702 > lda absORa,x ;precharge accu
+319e : 28 > plp
+
+319f : 1d3b02 ora absOR,x
+ tst_ax absrlo,absflo,0
+31a2 : 08 > php ;save flags
+31a3 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+31a6 : d0fe > bne * ;failed not equal (non zero)
+ >
+31a8 : 68 > pla ;load status
+ > eor_flag 0
+31a9 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+31ab : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+31ae : d0fe > bne * ;failed not equal (non zero)
+ >
+
+31b0 : ca dex
+31b1 : 10e5 bpl tora8
+31b3 : a203 ldx #3
+31b5 : tora9
+ set_ax absORa,$ff
+ > load_flag $ff
+31b5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+31b7 : 48 > pha ;use stack to load status
+31b8 : bd4702 > lda absORa,x ;precharge accu
+31bb : 28 > plp
+
+31bc : 1d3b02 ora absOR,x
+ tst_ax absrlo,absflo,$ff-fnz
+31bf : 08 > php ;save flags
+31c0 : dd5302 > cmp absrlo,x ;test result
+ > trap_ne
+31c3 : d0fe > bne * ;failed not equal (non zero)
+ >
+31c5 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+31c6 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+31c8 : dd5702 > cmp absflo,x ;test flags
+ > trap_ne ;
+31cb : d0fe > bne * ;failed not equal (non zero)
+ >
+
+31cd : ca dex
+31ce : 10e5 bpl tora9
+
+31d0 : a003 ldy #3 ;abs,y
+31d2 : tora10
+ set_ay absORa,0
+ > load_flag 0
+31d2 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+31d4 : 48 > pha ;use stack to load status
+31d5 : b94702 > lda absORa,y ;precharge accu
+31d8 : 28 > plp
+
+31d9 : 193b02 ora absOR,y
+ tst_ay absrlo,absflo,0
+31dc : 08 > php ;save flags
+31dd : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+31e0 : d0fe > bne * ;failed not equal (non zero)
+ >
+31e2 : 68 > pla ;load status
+ > eor_flag 0
+31e3 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+31e5 : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+31e8 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+31ea : 88 dey
+31eb : 10e5 bpl tora10
+31ed : a003 ldy #3
+31ef : tora11
+ set_ay absORa,$ff
+ > load_flag $ff
+31ef : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+31f1 : 48 > pha ;use stack to load status
+31f2 : b94702 > lda absORa,y ;precharge accu
+31f5 : 28 > plp
+
+31f6 : 193b02 ora absOR,y
+ tst_ay absrlo,absflo,$ff-fnz
+31f9 : 08 > php ;save flags
+31fa : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+31fd : d0fe > bne * ;failed not equal (non zero)
+ >
+31ff : 68 > pla ;load status
+ > eor_flag $ff-fnz
+3200 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+3202 : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+3205 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+3207 : 88 dey
+3208 : 10e5 bpl tora11
+
+320a : a206 ldx #6 ;(zp,x)
+320c : a003 ldy #3
+320e : tora12
+ set_ay absORa,0
+ > load_flag 0
+320e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+3210 : 48 > pha ;use stack to load status
+3211 : b94702 > lda absORa,y ;precharge accu
+3214 : 28 > plp
+
+3215 : 014a ora (indOR,x)
+ tst_ay absrlo,absflo,0
+3217 : 08 > php ;save flags
+3218 : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+321b : d0fe > bne * ;failed not equal (non zero)
+ >
+321d : 68 > pla ;load status
+ > eor_flag 0
+321e : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+3220 : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+3223 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+3225 : ca dex
+3226 : ca dex
+3227 : 88 dey
+3228 : 10e4 bpl tora12
+322a : a206 ldx #6
+322c : a003 ldy #3
+322e : tora13
+ set_ay absORa,$ff
+ > load_flag $ff
+322e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+3230 : 48 > pha ;use stack to load status
+3231 : b94702 > lda absORa,y ;precharge accu
+3234 : 28 > plp
+
+3235 : 014a ora (indOR,x)
+ tst_ay absrlo,absflo,$ff-fnz
+3237 : 08 > php ;save flags
+3238 : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+323b : d0fe > bne * ;failed not equal (non zero)
+ >
+323d : 68 > pla ;load status
+ > eor_flag $ff-fnz
+323e : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+3240 : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+3243 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+3245 : ca dex
+3246 : ca dex
+3247 : 88 dey
+3248 : 10e4 bpl tora13
+
+324a : a003 ldy #3 ;(zp),y
+324c : tora14
+ set_ay absORa,0
+ > load_flag 0
+324c : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+324e : 48 > pha ;use stack to load status
+324f : b94702 > lda absORa,y ;precharge accu
+3252 : 28 > plp
+
+3253 : 114a ora (indOR),y
+ tst_ay absrlo,absflo,0
+3255 : 08 > php ;save flags
+3256 : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+3259 : d0fe > bne * ;failed not equal (non zero)
+ >
+325b : 68 > pla ;load status
+ > eor_flag 0
+325c : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+325e : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+3261 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+3263 : 88 dey
+3264 : 10e6 bpl tora14
+3266 : a003 ldy #3
+3268 : tora15
+ set_ay absORa,$ff
+ > load_flag $ff
+3268 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+326a : 48 > pha ;use stack to load status
+326b : b94702 > lda absORa,y ;precharge accu
+326e : 28 > plp
+
+326f : 114a ora (indOR),y
+ tst_ay absrlo,absflo,$ff-fnz
+3271 : 08 > php ;save flags
+3272 : d95302 > cmp absrlo,y ;test result
+ > trap_ne ;
+3275 : d0fe > bne * ;failed not equal (non zero)
+ >
+3277 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+3278 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+327a : d95702 > cmp absflo,y ;test flags
+ > trap_ne
+327d : d0fe > bne * ;failed not equal (non zero)
+ >
+
+327f : 88 dey
+3280 : 10e6 bpl tora15
+ if I_flag = 3
+3282 : 58 cli
+ endif
+ next_test
+3283 : ad0002 > lda test_case ;previous test
+3286 : c928 > cmp #test_num
+ > trap_ne ;test is out of sequence
+3288 : d0fe > bne * ;failed not equal (non zero)
+ >
+0029 = >test_num = test_num + 1
+328a : a929 > lda #test_num ;*** next tests' number
+328c : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; full binary add/subtract test
+ ; iterates through all combinations of operands and carry input
+ ; uses increments/decrements to predict result & result flags
+328f : d8 cld
+3290 : a20e ldx #ad2 ;for indexed test
+3292 : a0ff ldy #$ff ;max range
+3294 : a900 lda #0 ;start with adding zeroes & no carry
+3296 : 850c sta adfc ;carry in - for diag
+3298 : 850d sta ad1 ;operand 1 - accumulator
+329a : 850e sta ad2 ;operand 2 - memory or immediate
+329c : 8d0302 sta ada2 ;non zp
+329f : 850f sta adrl ;expected result bits 0-7
+32a1 : 8510 sta adrh ;expected result bit 8 (carry out)
+32a3 : a9ff lda #$ff ;complemented operand 2 for subtract
+32a5 : 8512 sta sb2
+32a7 : 8d0402 sta sba2 ;non zp
+32aa : a902 lda #2 ;expected Z-flag
+32ac : 8511 sta adrf
+32ae : 18 tadd clc ;test with carry clear
+32af : 20d034 jsr chkadd
+32b2 : e60c inc adfc ;now with carry
+32b4 : e60f inc adrl ;result +1
+32b6 : 08 php ;save N & Z from low result
+32b7 : 08 php
+32b8 : 68 pla ;accu holds expected flags
+32b9 : 2982 and #$82 ;mask N & Z
+32bb : 28 plp
+32bc : d002 bne tadd1
+32be : e610 inc adrh ;result bit 8 - carry
+32c0 : 0510 tadd1 ora adrh ;merge C to expected flags
+32c2 : 8511 sta adrf ;save expected flags except overflow
+32c4 : 38 sec ;test with carry set
+32c5 : 20d034 jsr chkadd
+32c8 : c60c dec adfc ;same for operand +1 but no carry
+32ca : e60d inc ad1
+32cc : d0e0 bne tadd ;iterate op1
+32ce : a900 lda #0 ;preset result to op2 when op1 = 0
+32d0 : 8510 sta adrh
+32d2 : ee0302 inc ada2
+32d5 : e60e inc ad2
+32d7 : 08 php ;save NZ as operand 2 becomes the new result
+32d8 : 68 pla
+32d9 : 2982 and #$82 ;mask N00000Z0
+32db : 8511 sta adrf ;no need to check carry as we are adding to 0
+32dd : c612 dec sb2 ;complement subtract operand 2
+32df : ce0402 dec sba2
+32e2 : a50e lda ad2
+32e4 : 850f sta adrl
+32e6 : d0c6 bne tadd ;iterate op2
+ next_test
+32e8 : ad0002 > lda test_case ;previous test
+32eb : c929 > cmp #test_num
+ > trap_ne ;test is out of sequence
+32ed : d0fe > bne * ;failed not equal (non zero)
+ >
+002a = >test_num = test_num + 1
+32ef : a92a > lda #test_num ;*** next tests' number
+32f1 : 8d0002 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; decimal add/subtract test
+ ; *** WARNING - tests documented behavior only! ***
+ ; only valid BCD operands are tested, N V Z flags are ignored
+ ; iterates through all valid combinations of operands and carry input
+ ; uses increments/decrements to predict result & carry flag
+32f4 : f8 sed
+32f5 : a20e ldx #ad2 ;for indexed test
+32f7 : a0ff ldy #$ff ;max range
+32f9 : a999 lda #$99 ;start with adding 99 to 99 with carry
+32fb : 850d sta ad1 ;operand 1 - accumulator
+32fd : 850e sta ad2 ;operand 2 - memory or immediate
+32ff : 8d0302 sta ada2 ;non zp
+3302 : 850f sta adrl ;expected result bits 0-7
+3304 : a901 lda #1 ;set carry in & out
+3306 : 850c sta adfc ;carry in - for diag
+3308 : 8510 sta adrh ;expected result bit 8 (carry out)
+330a : a900 lda #0 ;complemented operand 2 for subtract
+330c : 8512 sta sb2
+330e : 8d0402 sta sba2 ;non zp
+3311 : 38 tdad sec ;test with carry set
+3312 : 209f33 jsr chkdad
+3315 : c60c dec adfc ;now with carry clear
+3317 : a50f lda adrl ;decimal adjust result
+3319 : d008 bne tdad1 ;skip clear carry & preset result 99 (9A-1)
+331b : c610 dec adrh
+331d : a999 lda #$99
+331f : 850f sta adrl
+3321 : d012 bne tdad3
+3323 : 290f tdad1 and #$f ;lower nibble mask
+3325 : d00c bne tdad2 ;no decimal adjust needed
+3327 : c60f dec adrl ;decimal adjust (?0-6)
+3329 : c60f dec adrl
+332b : c60f dec adrl
+332d : c60f dec adrl
+332f : c60f dec adrl
+3331 : c60f dec adrl
+3333 : c60f tdad2 dec adrl ;result -1
+3335 : 18 tdad3 clc ;test with carry clear
+3336 : 209f33 jsr chkdad
+3339 : e60c inc adfc ;same for operand -1 but with carry
+333b : a50d lda ad1 ;decimal adjust operand 1
+333d : f015 beq tdad5 ;iterate operand 2
+333f : 290f and #$f ;lower nibble mask
+3341 : d00c bne tdad4 ;skip decimal adjust
+3343 : c60d dec ad1 ;decimal adjust (?0-6)
+3345 : c60d dec ad1
+3347 : c60d dec ad1
+3349 : c60d dec ad1
+334b : c60d dec ad1
+334d : c60d dec ad1
+334f : c60d tdad4 dec ad1 ;operand 1 -1
+3351 : 4c1133 jmp tdad ;iterate op1
+
+3354 : a999 tdad5 lda #$99 ;precharge op1 max
+3356 : 850d sta ad1
+3358 : a50e lda ad2 ;decimal adjust operand 2
+335a : f030 beq tdad7 ;end of iteration
+335c : 290f and #$f ;lower nibble mask
+335e : d018 bne tdad6 ;skip decimal adjust
+3360 : c60e dec ad2 ;decimal adjust (?0-6)
+3362 : c60e dec ad2
+3364 : c60e dec ad2
+3366 : c60e dec ad2
+3368 : c60e dec ad2
+336a : c60e dec ad2
+336c : e612 inc sb2 ;complemented decimal adjust for subtract (?9+6)
+336e : e612 inc sb2
+3370 : e612 inc sb2
+3372 : e612 inc sb2
+3374 : e612 inc sb2
+3376 : e612 inc sb2
+3378 : c60e tdad6 dec ad2 ;operand 2 -1
+337a : e612 inc sb2 ;complemented operand for subtract
+337c : a512 lda sb2
+337e : 8d0402 sta sba2 ;copy as non zp operand
+3381 : a50e lda ad2
+3383 : 8d0302 sta ada2 ;copy as non zp operand
+3386 : 850f sta adrl ;new result since op1+carry=00+carry +op2=op2
+3388 : e610 inc adrh ;result carry
+338a : d085 bne tdad ;iterate op2
+338c : d8 tdad7 cld
+
+338d : ad0002 lda test_case
+3390 : c92a cmp #test_num
+ trap_ne ;previous test is out of sequence
+3392 : d0fe > bne * ;failed not equal (non zero)
+
+3394 : a9f0 lda #$f0 ;mark opcode testing complete
+3396 : 8d0002 sta test_case
+
+ ; final RAM integrity test
+ ; verifies that none of the previous tests has altered RAM outside of the
+ ; designated write areas.
+ check_ram
+ > ;RAM check disabled - RAM size not set
+
+ ; *** DEBUG INFO ***
+ ; to debug checksum errors uncomment check_ram in the next_test macro to
+ ; narrow down the responsible opcode.
+ ; may give false errors when monitor, OS or other background activity is
+ ; allowed during previous tests.
+
+
+ ; S U C C E S S ************************************************
+ ; -------------
+ success ;if you get here everything went well
+3399 : 4c9933 > jmp * ;test passed, no errors
+
+ ; -------------
+ ; S U C C E S S ************************************************
+339c : 4c0004 jmp start ;run again
+
+ ; core subroutine of the decimal add/subtract test
+ ; *** WARNING - tests documented behavior only! ***
+ ; only valid BCD operands are tested, N V Z flags are ignored
+ ; iterates through all valid combinations of operands and carry input
+ ; uses increments/decrements to predict result & carry flag
+339f : chkdad
+ ; decimal ADC / SBC zp
+339f : 08 php ;save carry for subtract
+33a0 : a50d lda ad1
+33a2 : 650e adc ad2 ;perform add
+33a4 : 08 php
+33a5 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+33a7 : d0fe > bne * ;failed not equal (non zero)
+
+33a9 : 68 pla ;check flags
+33aa : 2901 and #1 ;mask carry
+33ac : c510 cmp adrh
+ trap_ne ;bad carry
+33ae : d0fe > bne * ;failed not equal (non zero)
+
+33b0 : 28 plp
+33b1 : 08 php ;save carry for next add
+33b2 : a50d lda ad1
+33b4 : e512 sbc sb2 ;perform subtract
+33b6 : 08 php
+33b7 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+33b9 : d0fe > bne * ;failed not equal (non zero)
+
+33bb : 68 pla ;check flags
+33bc : 2901 and #1 ;mask carry
+33be : c510 cmp adrh
+ trap_ne ;bad flags
+33c0 : d0fe > bne * ;failed not equal (non zero)
+
+33c2 : 28 plp
+ ; decimal ADC / SBC abs
+33c3 : 08 php ;save carry for subtract
+33c4 : a50d lda ad1
+33c6 : 6d0302 adc ada2 ;perform add
+33c9 : 08 php
+33ca : c50f cmp adrl ;check result
+ trap_ne ;bad result
+33cc : d0fe > bne * ;failed not equal (non zero)
+
+33ce : 68 pla ;check flags
+33cf : 2901 and #1 ;mask carry
+33d1 : c510 cmp adrh
+ trap_ne ;bad carry
+33d3 : d0fe > bne * ;failed not equal (non zero)
+
+33d5 : 28 plp
+33d6 : 08 php ;save carry for next add
+33d7 : a50d lda ad1
+33d9 : ed0402 sbc sba2 ;perform subtract
+33dc : 08 php
+33dd : c50f cmp adrl ;check result
+ trap_ne ;bad result
+33df : d0fe > bne * ;failed not equal (non zero)
+
+33e1 : 68 pla ;check flags
+33e2 : 2901 and #1 ;mask carry
+33e4 : c510 cmp adrh
+ trap_ne ;bad carry
+33e6 : d0fe > bne * ;failed not equal (non zero)
+
+33e8 : 28 plp
+ ; decimal ADC / SBC #
+33e9 : 08 php ;save carry for subtract
+33ea : a50e lda ad2
+33ec : 8df233 sta chkdadi ;self modify immediate
+33ef : a50d lda ad1
+33f2 = chkdadi = * + 1 ;operand of the immediate ADC
+33f1 : 6900 adc #0 ;perform add
+33f3 : 08 php
+33f4 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+33f6 : d0fe > bne * ;failed not equal (non zero)
+
+33f8 : 68 pla ;check flags
+33f9 : 2901 and #1 ;mask carry
+33fb : c510 cmp adrh
+ trap_ne ;bad carry
+33fd : d0fe > bne * ;failed not equal (non zero)
+
+33ff : 28 plp
+3400 : 08 php ;save carry for next add
+3401 : a512 lda sb2
+3403 : 8d0934 sta chkdsbi ;self modify immediate
+3406 : a50d lda ad1
+3409 = chkdsbi = * + 1 ;operand of the immediate SBC
+3408 : e900 sbc #0 ;perform subtract
+340a : 08 php
+340b : c50f cmp adrl ;check result
+ trap_ne ;bad result
+340d : d0fe > bne * ;failed not equal (non zero)
+
+340f : 68 pla ;check flags
+3410 : 2901 and #1 ;mask carry
+3412 : c510 cmp adrh
+ trap_ne ;bad carry
+3414 : d0fe > bne * ;failed not equal (non zero)
+
+3416 : 28 plp
+ ; decimal ADC / SBC zp,x
+3417 : 08 php ;save carry for subtract
+3418 : a50d lda ad1
+341a : 7500 adc 0,x ;perform add
+341c : 08 php
+341d : c50f cmp adrl ;check result
+ trap_ne ;bad result
+341f : d0fe > bne * ;failed not equal (non zero)
+
+3421 : 68 pla ;check flags
+3422 : 2901 and #1 ;mask carry
+3424 : c510 cmp adrh
+ trap_ne ;bad carry
+3426 : d0fe > bne * ;failed not equal (non zero)
+
+3428 : 28 plp
+3429 : 08 php ;save carry for next add
+342a : a50d lda ad1
+342c : f504 sbc sb2-ad2,x ;perform subtract
+342e : 08 php
+342f : c50f cmp adrl ;check result
+ trap_ne ;bad result
+3431 : d0fe > bne * ;failed not equal (non zero)
+
+3433 : 68 pla ;check flags
+3434 : 2901 and #1 ;mask carry
+3436 : c510 cmp adrh
+ trap_ne ;bad carry
+3438 : d0fe > bne * ;failed not equal (non zero)
+
+343a : 28 plp
+ ; decimal ADC / SBC abs,x
+343b : 08 php ;save carry for subtract
+343c : a50d lda ad1
+343e : 7df501 adc ada2-ad2,x ;perform add
+3441 : 08 php
+3442 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+3444 : d0fe > bne * ;failed not equal (non zero)
+
+3446 : 68 pla ;check flags
+3447 : 2901 and #1 ;mask carry
+3449 : c510 cmp adrh
+ trap_ne ;bad carry
+344b : d0fe > bne * ;failed not equal (non zero)
+
+344d : 28 plp
+344e : 08 php ;save carry for next add
+344f : a50d lda ad1
+3451 : fdf601 sbc sba2-ad2,x ;perform subtract
+3454 : 08 php
+3455 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+3457 : d0fe > bne * ;failed not equal (non zero)
+
+3459 : 68 pla ;check flags
+345a : 2901 and #1 ;mask carry
+345c : c510 cmp adrh
+ trap_ne ;bad carry
+345e : d0fe > bne * ;failed not equal (non zero)
+
+3460 : 28 plp
+ ; decimal ADC / SBC abs,y
+3461 : 08 php ;save carry for subtract
+3462 : a50d lda ad1
+3464 : 790401 adc ada2-$ff,y ;perform add
+3467 : 08 php
+3468 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+346a : d0fe > bne * ;failed not equal (non zero)
+
+346c : 68 pla ;check flags
+346d : 2901 and #1 ;mask carry
+346f : c510 cmp adrh
+ trap_ne ;bad carry
+3471 : d0fe > bne * ;failed not equal (non zero)
+
+3473 : 28 plp
+3474 : 08 php ;save carry for next add
+3475 : a50d lda ad1
+3477 : f90501 sbc sba2-$ff,y ;perform subtract
+347a : 08 php
+347b : c50f cmp adrl ;check result
+ trap_ne ;bad result
+347d : d0fe > bne * ;failed not equal (non zero)
+
+347f : 68 pla ;check flags
+3480 : 2901 and #1 ;mask carry
+3482 : c510 cmp adrh
+ trap_ne ;bad carry
+3484 : d0fe > bne * ;failed not equal (non zero)
+
+3486 : 28 plp
+ ; decimal ADC / SBC (zp,x)
+3487 : 08 php ;save carry for subtract
+3488 : a50d lda ad1
+348a : 6144 adc (lo adi2-ad2,x) ;perform add
+348c : 08 php
+348d : c50f cmp adrl ;check result
+ trap_ne ;bad result
+348f : d0fe > bne * ;failed not equal (non zero)
+
+3491 : 68 pla ;check flags
+3492 : 2901 and #1 ;mask carry
+3494 : c510 cmp adrh
+ trap_ne ;bad carry
+3496 : d0fe > bne * ;failed not equal (non zero)
+
+3498 : 28 plp
+3499 : 08 php ;save carry for next add
+349a : a50d lda ad1
+349c : e146 sbc (lo sbi2-ad2,x) ;perform subtract
+349e : 08 php
+349f : c50f cmp adrl ;check result
+ trap_ne ;bad result
+34a1 : d0fe > bne * ;failed not equal (non zero)
+
+34a3 : 68 pla ;check flags
+34a4 : 2901 and #1 ;mask carry
+34a6 : c510 cmp adrh
+ trap_ne ;bad carry
+34a8 : d0fe > bne * ;failed not equal (non zero)
+
+34aa : 28 plp
+ ; decimal ADC / SBC (abs),y
+34ab : 08 php ;save carry for subtract
+34ac : a50d lda ad1
+34ae : 7156 adc (adiy2),y ;perform add
+34b0 : 08 php
+34b1 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+34b3 : d0fe > bne * ;failed not equal (non zero)
+
+34b5 : 68 pla ;check flags
+34b6 : 2901 and #1 ;mask carry
+34b8 : c510 cmp adrh
+ trap_ne ;bad carry
+34ba : d0fe > bne * ;failed not equal (non zero)
+
+34bc : 28 plp
+34bd : 08 php ;save carry for next add
+34be : a50d lda ad1
+34c0 : f158 sbc (sbiy2),y ;perform subtract
+34c2 : 08 php
+34c3 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+34c5 : d0fe > bne * ;failed not equal (non zero)
+
+34c7 : 68 pla ;check flags
+34c8 : 2901 and #1 ;mask carry
+34ca : c510 cmp adrh
+ trap_ne ;bad carry
+34cc : d0fe > bne * ;failed not equal (non zero)
+
+34ce : 28 plp
+34cf : 60 rts
+
+ ; core subroutine of the full binary add/subtract test
+ ; iterates through all combinations of operands and carry input
+ ; uses increments/decrements to predict result & result flags
+34d0 : a511 chkadd lda adrf ;add V-flag if overflow
+34d2 : 2983 and #$83 ;keep N-----ZC / clear V
+34d4 : 48 pha
+34d5 : a50d lda ad1 ;test sign unequal between operands
+34d7 : 450e eor ad2
+34d9 : 300a bmi ckad1 ;no overflow possible - operands have different sign
+34db : a50d lda ad1 ;test sign equal between operands and result
+34dd : 450f eor adrl
+34df : 1004 bpl ckad1 ;no overflow occured - operand and result have same sign
+34e1 : 68 pla
+34e2 : 0940 ora #$40 ;set V
+34e4 : 48 pha
+34e5 : 68 ckad1 pla
+34e6 : 8511 sta adrf ;save expected flags
+ ; binary ADC / SBC zp
+34e8 : 08 php ;save carry for subtract
+34e9 : a50d lda ad1
+34eb : 650e adc ad2 ;perform add
+34ed : 08 php
+34ee : c50f cmp adrl ;check result
+ trap_ne ;bad result
+34f0 : d0fe > bne * ;failed not equal (non zero)
+
+34f2 : 68 pla ;check flags
+34f3 : 29c3 and #$c3 ;mask NV----ZC
+34f5 : c511 cmp adrf
+ trap_ne ;bad flags
+34f7 : d0fe > bne * ;failed not equal (non zero)
+
+34f9 : 28 plp
+34fa : 08 php ;save carry for next add
+34fb : a50d lda ad1
+34fd : e512 sbc sb2 ;perform subtract
+34ff : 08 php
+3500 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+3502 : d0fe > bne * ;failed not equal (non zero)
+
+3504 : 68 pla ;check flags
+3505 : 29c3 and #$c3 ;mask NV----ZC
+3507 : c511 cmp adrf
+ trap_ne ;bad flags
+3509 : d0fe > bne * ;failed not equal (non zero)
+
+350b : 28 plp
+ ; binary ADC / SBC abs
+350c : 08 php ;save carry for subtract
+350d : a50d lda ad1
+350f : 6d0302 adc ada2 ;perform add
+3512 : 08 php
+3513 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+3515 : d0fe > bne * ;failed not equal (non zero)
+
+3517 : 68 pla ;check flags
+3518 : 29c3 and #$c3 ;mask NV----ZC
+351a : c511 cmp adrf
+ trap_ne ;bad flags
+351c : d0fe > bne * ;failed not equal (non zero)
+
+351e : 28 plp
+351f : 08 php ;save carry for next add
+3520 : a50d lda ad1
+3522 : ed0402 sbc sba2 ;perform subtract
+3525 : 08 php
+3526 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+3528 : d0fe > bne * ;failed not equal (non zero)
+
+352a : 68 pla ;check flags
+352b : 29c3 and #$c3 ;mask NV----ZC
+352d : c511 cmp adrf
+ trap_ne ;bad flags
+352f : d0fe > bne * ;failed not equal (non zero)
+
+3531 : 28 plp
+ ; binary ADC / SBC #
+3532 : 08 php ;save carry for subtract
+3533 : a50e lda ad2
+3535 : 8d3b35 sta chkadi ;self modify immediate
+3538 : a50d lda ad1
+353b = chkadi = * + 1 ;operand of the immediate ADC
+353a : 6900 adc #0 ;perform add
+353c : 08 php
+353d : c50f cmp adrl ;check result
+ trap_ne ;bad result
+353f : d0fe > bne * ;failed not equal (non zero)
+
+3541 : 68 pla ;check flags
+3542 : 29c3 and #$c3 ;mask NV----ZC
+3544 : c511 cmp adrf
+ trap_ne ;bad flags
+3546 : d0fe > bne * ;failed not equal (non zero)
+
+3548 : 28 plp
+3549 : 08 php ;save carry for next add
+354a : a512 lda sb2
+354c : 8d5235 sta chksbi ;self modify immediate
+354f : a50d lda ad1
+3552 = chksbi = * + 1 ;operand of the immediate SBC
+3551 : e900 sbc #0 ;perform subtract
+3553 : 08 php
+3554 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+3556 : d0fe > bne * ;failed not equal (non zero)
+
+3558 : 68 pla ;check flags
+3559 : 29c3 and #$c3 ;mask NV----ZC
+355b : c511 cmp adrf
+ trap_ne ;bad flags
+355d : d0fe > bne * ;failed not equal (non zero)
+
+355f : 28 plp
+ ; binary ADC / SBC zp,x
+3560 : 08 php ;save carry for subtract
+3561 : a50d lda ad1
+3563 : 7500 adc 0,x ;perform add
+3565 : 08 php
+3566 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+3568 : d0fe > bne * ;failed not equal (non zero)
+
+356a : 68 pla ;check flags
+356b : 29c3 and #$c3 ;mask NV----ZC
+356d : c511 cmp adrf
+ trap_ne ;bad flags
+356f : d0fe > bne * ;failed not equal (non zero)
+
+3571 : 28 plp
+3572 : 08 php ;save carry for next add
+3573 : a50d lda ad1
+3575 : f504 sbc sb2-ad2,x ;perform subtract
+3577 : 08 php
+3578 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+357a : d0fe > bne * ;failed not equal (non zero)
+
+357c : 68 pla ;check flags
+357d : 29c3 and #$c3 ;mask NV----ZC
+357f : c511 cmp adrf
+ trap_ne ;bad flags
+3581 : d0fe > bne * ;failed not equal (non zero)
+
+3583 : 28 plp
+ ; binary ADC / SBC abs,x
+3584 : 08 php ;save carry for subtract
+3585 : a50d lda ad1
+3587 : 7df501 adc ada2-ad2,x ;perform add
+358a : 08 php
+358b : c50f cmp adrl ;check result
+ trap_ne ;bad result
+358d : d0fe > bne * ;failed not equal (non zero)
+
+358f : 68 pla ;check flags
+3590 : 29c3 and #$c3 ;mask NV----ZC
+3592 : c511 cmp adrf
+ trap_ne ;bad flags
+3594 : d0fe > bne * ;failed not equal (non zero)
+
+3596 : 28 plp
+3597 : 08 php ;save carry for next add
+3598 : a50d lda ad1
+359a : fdf601 sbc sba2-ad2,x ;perform subtract
+359d : 08 php
+359e : c50f cmp adrl ;check result
+ trap_ne ;bad result
+35a0 : d0fe > bne * ;failed not equal (non zero)
+
+35a2 : 68 pla ;check flags
+35a3 : 29c3 and #$c3 ;mask NV----ZC
+35a5 : c511 cmp adrf
+ trap_ne ;bad flags
+35a7 : d0fe > bne * ;failed not equal (non zero)
+
+35a9 : 28 plp
+ ; binary ADC / SBC abs,y
+35aa : 08 php ;save carry for subtract
+35ab : a50d lda ad1
+35ad : 790401 adc ada2-$ff,y ;perform add
+35b0 : 08 php
+35b1 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+35b3 : d0fe > bne * ;failed not equal (non zero)
+
+35b5 : 68 pla ;check flags
+35b6 : 29c3 and #$c3 ;mask NV----ZC
+35b8 : c511 cmp adrf
+ trap_ne ;bad flags
+35ba : d0fe > bne * ;failed not equal (non zero)
+
+35bc : 28 plp
+35bd : 08 php ;save carry for next add
+35be : a50d lda ad1
+35c0 : f90501 sbc sba2-$ff,y ;perform subtract
+35c3 : 08 php
+35c4 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+35c6 : d0fe > bne * ;failed not equal (non zero)
+
+35c8 : 68 pla ;check flags
+35c9 : 29c3 and #$c3 ;mask NV----ZC
+35cb : c511 cmp adrf
+ trap_ne ;bad flags
+35cd : d0fe > bne * ;failed not equal (non zero)
+
+35cf : 28 plp
+ ; binary ADC / SBC (zp,x)
+35d0 : 08 php ;save carry for subtract
+35d1 : a50d lda ad1
+35d3 : 6144 adc (lo adi2-ad2,x) ;perform add
+35d5 : 08 php
+35d6 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+35d8 : d0fe > bne * ;failed not equal (non zero)
+
+35da : 68 pla ;check flags
+35db : 29c3 and #$c3 ;mask NV----ZC
+35dd : c511 cmp adrf
+ trap_ne ;bad flags
+35df : d0fe > bne * ;failed not equal (non zero)
+
+35e1 : 28 plp
+35e2 : 08 php ;save carry for next add
+35e3 : a50d lda ad1
+35e5 : e146 sbc (lo sbi2-ad2,x) ;perform subtract
+35e7 : 08 php
+35e8 : c50f cmp adrl ;check result
+ trap_ne ;bad result
+35ea : d0fe > bne * ;failed not equal (non zero)
+
+35ec : 68 pla ;check flags
+35ed : 29c3 and #$c3 ;mask NV----ZC
+35ef : c511 cmp adrf
+ trap_ne ;bad flags
+35f1 : d0fe > bne * ;failed not equal (non zero)
+
+35f3 : 28 plp
+ ; binary ADC / SBC (abs),y
+35f4 : 08 php ;save carry for subtract
+35f5 : a50d lda ad1
+35f7 : 7156 adc (adiy2),y ;perform add
+35f9 : 08 php
+35fa : c50f cmp adrl ;check result
+ trap_ne ;bad result
+35fc : d0fe > bne * ;failed not equal (non zero)
+
+35fe : 68 pla ;check flags
+35ff : 29c3 and #$c3 ;mask NV----ZC
+3601 : c511 cmp adrf
+ trap_ne ;bad flags
+3603 : d0fe > bne * ;failed not equal (non zero)
+
+3605 : 28 plp
+3606 : 08 php ;save carry for next add
+3607 : a50d lda ad1
+3609 : f158 sbc (sbiy2),y ;perform subtract
+360b : 08 php
+360c : c50f cmp adrl ;check result
+ trap_ne ;bad result
+360e : d0fe > bne * ;failed not equal (non zero)
+
+3610 : 68 pla ;check flags
+3611 : 29c3 and #$c3 ;mask NV----ZC
+3613 : c511 cmp adrf
+ trap_ne ;bad flags
+3615 : d0fe > bne * ;failed not equal (non zero)
+
+3617 : 28 plp
+3618 : 60 rts
+
+ ; target for the jump absolute test
+3619 : 88 dey
+361a : 88 dey
+361b : test_far
+361b : 08 php ;either SP or Y count will fail, if we do not hit
+361c : 88 dey
+361d : 88 dey
+361e : 88 dey
+361f : 28 plp
+ trap_cs ;flags loaded?
+3620 : b0fe > bcs * ;failed carry set
+
+ trap_vs
+3622 : 70fe > bvs * ;failed overflow set
+
+ trap_mi
+3624 : 30fe > bmi * ;failed minus (bit 7 set)
+
+ trap_eq
+3626 : f0fe > beq * ;failed equal (zero)
+
+3628 : c946 cmp #'F' ;registers loaded?
+ trap_ne
+362a : d0fe > bne * ;failed not equal (non zero)
+
+362c : e041 cpx #'A'
+ trap_ne
+362e : d0fe > bne * ;failed not equal (non zero)
+
+3630 : c04f cpy #('R'-3)
+ trap_ne
+3632 : d0fe > bne * ;failed not equal (non zero)
+
+3634 : 48 pha ;save a,x
+3635 : 8a txa
+3636 : 48 pha
+3637 : ba tsx
+3638 : e0fd cpx #$fd ;check SP
+ trap_ne
+363a : d0fe > bne * ;failed not equal (non zero)
+
+363c : 68 pla ;restore x
+363d : aa tax
+ set_stat $ff
+ > load_flag $ff
+363e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+3640 : 48 > pha ;use stack to load status
+3641 : 28 > plp
+
+3642 : 68 pla ;restore a
+3643 : e8 inx ;return registers with modifications
+3644 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
+3646 : 4cc208 jmp far_ret
+
+ ; target for the jump indirect test
+3649 : 00 align
+364a : 5336 ptr_tst_ind dw test_ind
+364c : 1709 ptr_ind_ret dw ind_ret
+ trap ;runover protection
+364e : 4c4e36 > jmp * ;failed anyway
+
+3651 : 88 dey
+3652 : 88 dey
+3653 : test_ind
+3653 : 08 php ;either SP or Y count will fail, if we do not hit
+3654 : 88 dey
+3655 : 88 dey
+3656 : 88 dey
+3657 : 28 plp
+ trap_cs ;flags loaded?
+3658 : b0fe > bcs * ;failed carry set
+
+ trap_vs
+365a : 70fe > bvs * ;failed overflow set
+
+ trap_mi
+365c : 30fe > bmi * ;failed minus (bit 7 set)
+
+ trap_eq
+365e : f0fe > beq * ;failed equal (zero)
+
+3660 : c949 cmp #'I' ;registers loaded?
+ trap_ne
+3662 : d0fe > bne * ;failed not equal (non zero)
+
+3664 : e04e cpx #'N'
+ trap_ne
+3666 : d0fe > bne * ;failed not equal (non zero)
+
+3668 : c041 cpy #('D'-3)
+ trap_ne
+366a : d0fe > bne * ;failed not equal (non zero)
+
+366c : 48 pha ;save a,x
+366d : 8a txa
+366e : 48 pha
+366f : ba tsx
+3670 : e0fd cpx #$fd ;check SP
+ trap_ne
+3672 : d0fe > bne * ;failed not equal (non zero)
+
+3674 : 68 pla ;restore x
+3675 : aa tax
+ set_stat $ff
+ > load_flag $ff
+3676 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+3678 : 48 > pha ;use stack to load status
+3679 : 28 > plp
+
+367a : 68 pla ;restore a
+367b : e8 inx ;return registers with modifications
+367c : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
+367e : 6c4c36 jmp (ptr_ind_ret)
+ trap ;runover protection
+3681 : 4c8136 > jmp * ;failed anyway
+
+
+ ; target for the jump subroutine test
+3684 : 88 dey
+3685 : 88 dey
+3686 : test_jsr
+3686 : 08 php ;either SP or Y count will fail, if we do not hit
+3687 : 88 dey
+3688 : 88 dey
+3689 : 88 dey
+368a : 28 plp
+ trap_cs ;flags loaded?
+368b : b0fe > bcs * ;failed carry set
+
+ trap_vs
+368d : 70fe > bvs * ;failed overflow set
+
+ trap_mi
+368f : 30fe > bmi * ;failed minus (bit 7 set)
+
+ trap_eq
+3691 : f0fe > beq * ;failed equal (zero)
+
+3693 : c94a cmp #'J' ;registers loaded?
+ trap_ne
+3695 : d0fe > bne * ;failed not equal (non zero)
+
+3697 : e053 cpx #'S'
+ trap_ne
+3699 : d0fe > bne * ;failed not equal (non zero)
+
+369b : c04f cpy #('R'-3)
+ trap_ne
+369d : d0fe > bne * ;failed not equal (non zero)
+
+369f : 48 pha ;save a,x
+36a0 : 8a txa
+36a1 : 48 pha
+36a2 : ba tsx ;sp -4? (return addr,a,x)
+36a3 : e0fb cpx #$fb
+ trap_ne
+36a5 : d0fe > bne * ;failed not equal (non zero)
+
+36a7 : adff01 lda $1ff ;propper return on stack
+36aa : c909 cmp #hi(jsr_ret)
+ trap_ne
+36ac : d0fe > bne * ;failed not equal (non zero)
+
+36ae : adfe01 lda $1fe
+36b1 : c94d cmp #lo(jsr_ret)
+ trap_ne
+36b3 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+36b5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+36b7 : 48 > pha ;use stack to load status
+36b8 : 28 > plp
+
+36b9 : 68 pla ;pull x,a
+36ba : aa tax
+36bb : 68 pla
+36bc : e8 inx ;return registers with modifications
+36bd : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
+36bf : 60 rts
+ trap ;runover protection
+36c0 : 4cc036 > jmp * ;failed anyway
+
+
+ ;trap in case of unexpected IRQ, NMI, BRK, RESET - BRK test target
+36c3 : nmi_trap
+ trap ;check stack for conditions at NMI
+36c3 : 4cc336 > jmp * ;failed anyway
+
+36c6 : res_trap
+ trap ;unexpected RESET
+36c6 : 4cc636 > jmp * ;failed anyway
+
+
+36c9 : 88 dey
+36ca : 88 dey
+36cb : irq_trap ;BRK test or unextpected BRK or IRQ
+36cb : 08 php ;either SP or Y count will fail, if we do not hit
+36cc : 88 dey
+36cd : 88 dey
+36ce : 88 dey
+ ;next 4 traps could be caused by unexpected BRK or IRQ
+ ;check stack for BREAK and originating location
+ ;possible jump/branch into weeds (uninitialized space)
+36cf : c942 cmp #'B' ;registers loaded?
+ trap_ne
+36d1 : d0fe > bne * ;failed not equal (non zero)
+
+36d3 : e052 cpx #'R'
+ trap_ne
+36d5 : d0fe > bne * ;failed not equal (non zero)
+
+36d7 : c048 cpy #('K'-3)
+ trap_ne
+36d9 : d0fe > bne * ;failed not equal (non zero)
+
+36db : 850a sta irq_a ;save registers during break test
+36dd : 860b stx irq_x
+36df : ba tsx ;test break on stack
+36e0 : bd0201 lda $102,x
+ cmp_flag 0 ;break test should have B=1
+36e3 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits
+
+ trap_ne ; - no break flag on stack
+36e5 : d0fe > bne * ;failed not equal (non zero)
+
+36e7 : 68 pla
+36e8 : c934 cmp #fai ;should have added interrupt disable
+ trap_ne
+36ea : d0fe > bne * ;failed not equal (non zero)
+
+36ec : ba tsx
+36ed : e0fc cpx #$fc ;sp -3? (return addr, flags)
+ trap_ne
+36ef : d0fe > bne * ;failed not equal (non zero)
+
+36f1 : adff01 lda $1ff ;propper return on stack
+36f4 : c909 cmp #hi(brk_ret)
+ trap_ne
+36f6 : d0fe > bne * ;failed not equal (non zero)
+
+36f8 : adfe01 lda $1fe
+36fb : c984 cmp #lo(brk_ret)
+ trap_ne
+36fd : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+36ff : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+3701 : 48 > pha ;use stack to load status
+3702 : 28 > plp
+
+3703 : a60b ldx irq_x
+3705 : e8 inx ;return registers with modifications
+3706 : a50a lda irq_a
+3708 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 but original flags should be restored
+370a : 40 rti
+ trap ;runover protection
+370b : 4c0b37 > jmp * ;failed anyway
+
+
+ if report = 1
+ include "report.i65"
+ endif
+
+ ;copy of data to initialize BSS segment
+ if load_data_direct != 1
+ zp_init
+ zp1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
+ zp7f_ db $7f ;test pattern for compare
+ ;logical zeropage operands
+ zpOR_ db 0,$1f,$71,$80 ;test pattern for OR
+ zpAN_ db $0f,$ff,$7f,$80 ;test pattern for AND
+ zpEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR
+ ;indirect addressing pointers
+ ind1_ dw abs1 ;indirect pointer to pattern in absolute memory
+ dw abs1+1
+ dw abs1+2
+ dw abs1+3
+ dw abs7f
+ inw1_ dw abs1-$f8 ;indirect pointer for wrap-test pattern
+ indt_ dw abst ;indirect pointer to store area in absolute memory
+ dw abst+1
+ dw abst+2
+ dw abst+3
+ inwt_ dw abst-$f8 ;indirect pointer for wrap-test store
+ indAN_ dw absAN ;indirect pointer to AND pattern in absolute memory
+ dw absAN+1
+ dw absAN+2
+ dw absAN+3
+ indEO_ dw absEO ;indirect pointer to EOR pattern in absolute memory
+ dw absEO+1
+ dw absEO+2
+ dw absEO+3
+ indOR_ dw absOR ;indirect pointer to OR pattern in absolute memory
+ dw absOR+1
+ dw absOR+2
+ dw absOR+3
+ ;add/subtract indirect pointers
+ adi2_ dw ada2 ;indirect pointer to operand 2 in absolute memory
+ sbi2_ dw sba2 ;indirect pointer to complemented operand 2 (SBC)
+ adiy2_ dw ada2-$ff ;with offset for indirect indexed
+ sbiy2_ dw sba2-$ff
+ zp_end
+ if (zp_end - zp_init) != (zp_bss_end - zp_bss)
+ ;force assembler error if size is different
+ ERROR ERROR ERROR ;mismatch between bss and zeropage data
+ endif
+ data_init
+ abs1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
+ abs7f_ db $7f ;test pattern for compare
+ ;loads
+ fLDx_ db fn,fn,0,fz ;expected flags for load
+ ;shifts
+ rASL_ ;expected result ASL & ROL -carry
+ rROL_ db $86,$04,$82,0 ; "
+ rROLc_ db $87,$05,$83,1 ;expected result ROL +carry
+ rLSR_ ;expected result LSR & ROR -carry
+ rROR_ db $61,$41,$20,0 ; "
+ rRORc_ db $e1,$c1,$a0,$80 ;expected result ROR +carry
+ fASL_ ;expected flags for shifts
+ fROL_ db fnc,fc,fn,fz ;no carry in
+ fROLc_ db fnc,fc,fn,0 ;carry in
+ fLSR_
+ fROR_ db fc,0,fc,fz ;no carry in
+ fRORc_ db fnc,fn,fnc,fn ;carry in
+ ;increments (decrements)
+ rINC_ db $7f,$80,$ff,0,1 ;expected result for INC/DEC
+ fINC_ db 0,fn,fn,fz,0 ;expected flags for INC/DEC
+ ;logical memory operand
+ absOR_ db 0,$1f,$71,$80 ;test pattern for OR
+ absAN_ db $0f,$ff,$7f,$80 ;test pattern for AND
+ absEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR
+ ;logical accu operand
+ absORa_ db 0,$f1,$1f,0 ;test pattern for OR
+ absANa_ db $f0,$ff,$ff,$ff ;test pattern for AND
+ absEOa_ db $ff,$f0,$f0,$0f ;test pattern for EOR
+ ;logical results
+ absrlo_ db 0,$ff,$7f,$80
+ absflo_ db fz,fn,0,fn
+ data_end
+ if (data_end - data_init) != (data_bss_end - data_bss)
+ ;force assembler error if size is different
+ ERROR ERROR ERROR ;mismatch between bss and data
+ endif
+
+ vec_init
+ dw nmi_trap
+ dw res_trap
+ dw irq_trap
+ vec_bss equ $fffa
+ endif ;end of RAM init data
+
+ if (load_data_direct = 1) & (ROM_vectors = 1)
+fffa = org $fffa ;vectors
+fffa : c336 dw nmi_trap
+fffc : c636 dw res_trap
+fffe : cb36 dw irq_trap
+ endif
+
+fffa = end start
+
+No errors in pass 2.
+Wrote binary from address $0000 through $ffff.
+Total size 65536 bytes.
+Program start address is at $0400 (1024).
+
\ No newline at end of file
diff --git a/bin_files/65C02_extended_opcodes_test.bin b/bin_files/65C02_extended_opcodes_test.bin
new file mode 100644
index 0000000..de99bc4
Binary files /dev/null and b/bin_files/65C02_extended_opcodes_test.bin differ
diff --git a/bin_files/65C02_extended_opcodes_test.lst b/bin_files/65C02_extended_opcodes_test.lst
new file mode 100644
index 0000000..d38ab84
--- /dev/null
+++ b/bin_files/65C02_extended_opcodes_test.lst
@@ -0,0 +1,11308 @@
+AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 1
+------------------------------------------------ 65C02_extended_opcodes_test.a65c ------------------------------------------------
+
+2748 lines read, no errors in pass 1.
+ ;
+ ; 6 5 C 0 2 E X T E N D E D O P C O D E S T E S T
+ ;
+ ; Copyright (C) 2013 Klaus Dormann
+ ;
+ ; This program is free software: you can redistribute it and/or modify
+ ; it under the terms of the GNU General Public License as published by
+ ; the Free Software Foundation, either version 3 of the License, or
+ ; (at your option) any later version.
+ ;
+ ; This program is distributed in the hope that it will be useful,
+ ; but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ; GNU General Public License for more details.
+ ;
+ ; You should have received a copy of the GNU General Public License
+ ; along with this program. If not, see .
+
+
+ ; This program is designed to test all additional 65C02 opcodes, addressing
+ ; modes and functionality not available in the NMOS version of the 6502.
+ ; The 6502_functional_test is a prerequisite to this test.
+ ; NMI, IRQ, BRK, STP & WAI are covered in the 6502_interrupt_test.
+ ;
+ ; version 16-aug-2013
+ ; edited to provide a pre-configured bin file loadable at $0000 for full 64k
+ ; contact info at http://2m5.de or email K@2m5.de
+ ;
+ ; assembled with AS65 from http://www.kingswood-consulting.co.uk/assemblers/
+ ; command line switches: -l -m -s2 -w -x -h0
+ ; | | | | | no page headers in listing
+ ; | | | | 65C02 extensions
+ ; | | | wide listing (133 char/col)
+ ; | | write intel hex file instead of binary
+ ; | expand macros in listing
+ ; generate pass2 listing
+ ;
+ ; No IO - should be run from a monitor with access to registers.
+ ; To run load intel hex image with a load command, than alter PC to 400 hex
+ ; (code_segment) and enter a go command.
+ ; Loop on program counter determines error or successful completion of test.
+ ; Check listing for relevant traps (jump/branch *).
+ ; Please note that in early tests some instructions will have to be used before
+ ; they are actually tested!
+ ;
+ ; RESET, NMI or IRQ should not occur and will be trapped if vectors are enabled.
+ ; Tests documented behavior of the original 65C02 only!
+ ; Decimal ops will only be tested with valid BCD operands and the V flag will
+ ; be ignored as it is absolutely useless in decimal mode.
+ ;
+ ; Debugging hints:
+ ; Most of the code is written sequentially. if you hit a trap, check the
+ ; immediately preceeding code for the instruction to be tested. Results are
+ ; tested first, flags are checked second by pushing them onto the stack and
+ ; pulling them to the accumulator after the result was checked. The "real"
+ ; flags are no longer valid for the tested instruction at this time!
+ ; If the tested instruction was indexed, the relevant index (X or Y) must
+ ; also be checked. Opposed to the flags, X and Y registers are still valid.
+ ;
+ ; versions:
+ ; 19-jul-2013 1st version distributed for testing
+ ; 23-jul-2013 fixed BRA out of range due to larger trap macros
+ ; added RAM integrity check
+ ; 16-aug-2013 added error report to standard output option
+
+
+ ; C O N F I G U R A T I O N
+
+ ;ROM_vectors writable (0=no, 1=yes)
+ ;if ROM vectors can not be used interrupts will not be trapped
+ ;as a consequence BRK can not be tested but will be emulated to test RTI
+0001 = ROM_vectors = 1
+
+ ;load_data_direct (0=move from code segment, 1=load directly)
+ ;loading directly is preferred but may not be supported by your platform
+ ;0 produces only consecutive object code, 1 is not suitable for a binary image
+0001 = load_data_direct = 1
+
+ ;I_flag behavior (0=force enabled, 1=force disabled, 2=prohibit change, 3=allow
+ ;change) 2 requires extra code and is not recommended.
+0003 = I_flag = 3
+
+ ;configure memory - try to stay away from memory used by the system
+ ;zero_page memory start address, $4e (78) consecutive Bytes required
+ ; add 2 if I_flag = 2
+000a = zero_page = $a
+
+ ;data_segment memory start address, $5D (93) consecutive Bytes required
+ ; + 12 Bytes at data_segment + $f9 (JMP indirect page cross test)
+0200 = data_segment = $200
+ if (data_segment & $ff) != 0
+ ERROR ERROR ERROR low byte of data_segment MUST be $00 !!
+ endif
+
+ ;code_segment memory start address, 10kB of consecutive space required
+ ; add 1 kB if I_flag = 2
+ ;parts of the code are self modifying and must reside in RAM
+0400 = code_segment = $400
+
+ ;added WDC only opcodes WAI & STP (0=test as NOPs, >0=no test)
+0001 = wdc_op = 1
+
+ ;added Rockwell & WDC opcodes BBR, BBS, RMB & SMB
+ ;(0=test as NOPs, 1=full test, >1=no test)
+0001 = rkwl_wdc_op = 1
+
+ ;report errors through I/O channel (0=use standard self trap loops, 1=include
+ ;report.i65 as I/O channel, add 3 kB)
+0000 = report = 0
+
+ ;RAM integrity test option. Checks for undesired RAM writes.
+ ;set lowest non RAM or RAM mirror address page (-1=disable, 0=64k, $40=16k)
+ ;leave disabled if a monitor, OS or background interrupt is allowed to alter RAM
+ffff = ram_top = -1
+
+ noopt ;do not take shortcuts
+
+ ;macros for error & success traps to allow user modification
+ ;example:
+ ;trap macro
+ ; jsr my_error_handler
+ ; endm
+ ;trap_eq macro
+ ; bne skip\?
+ ; trap ;failed equal (zero)
+ ;skip\?
+ ; endm
+ ;
+ ; my_error_handler should pop the calling address from the stack and report it.
+ ; putting larger portions of code (more than 3 bytes) inside the trap macro
+ ; may lead to branch range problems for some tests.
+ if report = 0
+ trap macro
+ jmp * ;failed anyway
+ endm
+ trap_eq macro
+ beq * ;failed equal (zero)
+ endm
+ trap_ne macro
+ bne * ;failed not equal (non zero)
+ endm
+ trap_cs macro
+ bcs * ;failed carry set
+ endm
+ trap_cc macro
+ bcc * ;failed carry clear
+ endm
+ trap_mi macro
+ bmi * ;failed minus (bit 7 set)
+ endm
+ trap_pl macro
+ bpl * ;failed plus (bit 7 clear)
+ endm
+ trap_vs macro
+ bvs * ;failed overflow set
+ endm
+ trap_vc macro
+ bvc * ;failed overflow clear
+ endm
+ ; please observe that during the test the stack gets invalidated
+ ; therefore a RTS inside the success macro is not possible
+ success macro
+ jmp * ;test passed, no errors
+ endm
+ endif
+ if report = 1
+ trap macro
+ jsr report_error
+ endm
+ trap_eq macro
+ bne skip\?
+ trap ;failed equal (zero)
+ skip\?
+ endm
+ trap_ne macro
+ beq skip\?
+ trap ;failed not equal (non zero)
+ skip\?
+ endm
+ trap_cs macro
+ bcc skip\?
+ trap ;failed carry set
+ skip\?
+ endm
+ trap_cc macro
+ bcs skip\?
+ trap ;failed carry clear
+ skip\?
+ endm
+ trap_mi macro
+ bpl skip\?
+ trap ;failed minus (bit 7 set)
+ skip\?
+ endm
+ trap_pl macro
+ bmi skip\?
+ trap ;failed plus (bit 7 clear)
+ skip\?
+ endm
+ trap_vs macro
+ bvc skip\?
+ trap ;failed overflow set
+ skip\?
+ endm
+ trap_vc macro
+ bvs skip\?
+ trap ;failed overflow clear
+ skip\?
+ endm
+ ; please observe that during the test the stack gets invalidated
+ ; therefore a RTS inside the success macro is not possible
+ success macro
+ jsr report_success
+ endm
+ endif
+
+
+0001 = carry equ %00000001 ;flag bits in status
+0002 = zero equ %00000010
+0004 = intdis equ %00000100
+0008 = decmode equ %00001000
+0010 = break equ %00010000
+0020 = reserv equ %00100000
+0040 = overfl equ %01000000
+0080 = minus equ %10000000
+
+0001 = fc equ carry
+0002 = fz equ zero
+0003 = fzc equ carry+zero
+0040 = fv equ overfl
+0042 = fvz equ overfl+zero
+0080 = fn equ minus
+0081 = fnc equ minus+carry
+0082 = fnz equ minus+zero
+0083 = fnzc equ minus+zero+carry
+00c0 = fnv equ minus+overfl
+
+0030 = fao equ break+reserv ;bits always on after PHP, BRK
+0034 = fai equ fao+intdis ;+ forced interrupt disable
+00ff = m8 equ $ff ;8 bit mask
+00fb = m8i equ $ff&~intdis ;8 bit mask - interrupt disable
+
+ ;macros to allow masking of status bits.
+ ;masking of interrupt enable/disable on load and compare
+ ;masking of always on bits after PHP or BRK (unused & break) on compare
+ if I_flag = 0
+ load_flag macro
+ lda #\1&m8i ;force enable interrupts (mask I)
+ endm
+ cmp_flag macro
+ cmp #(\1|fao)&m8i ;I_flag is always enabled + always on bits
+ endm
+ eor_flag macro
+ eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits
+ endm
+ endif
+ if I_flag = 1
+ load_flag macro
+ lda #\1|intdis ;force disable interrupts
+ endm
+ cmp_flag macro
+ cmp #(\1|fai)&m8 ;I_flag is always disabled + always on bits
+ endm
+ eor_flag macro
+ eor #(\1|fai) ;invert expected flags + always on bits + I
+ endm
+ endif
+ if I_flag = 2
+ load_flag macro
+ lda #\1
+ ora flag_I_on ;restore I-flag
+ and flag_I_off
+ endm
+ cmp_flag macro
+ eor flag_I_on ;I_flag is never changed
+ cmp #(\1|fao)&m8i ;expected flags + always on bits, mask I
+ endm
+ eor_flag macro
+ eor flag_I_on ;I_flag is never changed
+ eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits
+ endm
+ endif
+ if I_flag = 3
+ load_flag macro
+ lda #\1 ;allow test to change I-flag (no mask)
+ endm
+ cmp_flag macro
+ cmp #(\1|fao)&m8 ;expected flags + always on bits
+ endm
+ eor_flag macro
+ eor #\1|fao ;invert expected flags + always on bits
+ endm
+ endif
+
+ ;macros to set (register|memory|zeropage) & status
+ set_stat macro ;setting flags in the processor status register
+ load_flag \1
+ pha ;use stack to load status
+ plp
+ endm
+
+ set_a macro ;precharging accu & status
+ load_flag \2
+ pha ;use stack to load status
+ lda #\1 ;precharge accu
+ plp
+ endm
+
+ set_x macro ;precharging index & status
+ load_flag \2
+ pha ;use stack to load status
+ ldx #\1 ;precharge index x
+ plp
+ endm
+
+ set_y macro ;precharging index & status
+ load_flag \2
+ pha ;use stack to load status
+ ldy #\1 ;precharge index y
+ plp
+ endm
+
+ set_ax macro ;precharging indexed accu & immediate status
+ load_flag \2
+ pha ;use stack to load status
+ lda \1,x ;precharge accu
+ plp
+ endm
+
+ set_ay macro ;precharging indexed accu & immediate status
+ load_flag \2
+ pha ;use stack to load status
+ lda \1,y ;precharge accu
+ plp
+ endm
+
+ set_z macro ;precharging indexed zp & immediate status
+ load_flag \2
+ pha ;use stack to load status
+ lda \1,x ;load to zeropage
+ sta zpt
+ plp
+ endm
+
+ set_zx macro ;precharging zp,x & immediate status
+ load_flag \2
+ pha ;use stack to load status
+ lda \1,x ;load to indexed zeropage
+ sta zpt,x
+ plp
+ endm
+
+ set_abs macro ;precharging indexed memory & immediate status
+ load_flag \2
+ pha ;use stack to load status
+ lda \1,x ;load to memory
+ sta abst
+ plp
+ endm
+
+ set_absx macro ;precharging abs,x & immediate status
+ load_flag \2
+ pha ;use stack to load status
+ lda \1,x ;load to indexed memory
+ sta abst,x
+ plp
+ endm
+
+ ;macros to test (register|memory|zeropage) & status & (mask)
+ tst_stat macro ;testing flags in the processor status register
+ php ;save status
+ pla ;use stack to retrieve status
+ pha
+ cmp_flag \1
+ trap_ne
+ plp ;restore status
+ endm
+
+ tst_a macro ;testing result in accu & flags
+ php ;save flags
+ cmp #\1 ;test result
+ trap_ne
+ pla ;load status
+ pha
+ cmp_flag \2
+ trap_ne
+ plp ;restore status
+ endm
+
+ tst_as macro ;testing result in accu & flags, save accu
+ pha
+ php ;save flags
+ cmp #\1 ;test result
+ trap_ne
+ pla ;load status
+ pha
+ cmp_flag \2
+ trap_ne
+ plp ;restore status
+ pla
+ endm
+
+ tst_x macro ;testing result in x index & flags
+ php ;save flags
+ cpx #\1 ;test result
+ trap_ne
+ pla ;load status
+ pha
+ cmp_flag \2
+ trap_ne
+ plp ;restore status
+ endm
+
+ tst_y macro ;testing result in y index & flags
+ php ;save flags
+ cpy #\1 ;test result
+ trap_ne
+ pla ;load status
+ pha
+ cmp_flag \2
+ trap_ne
+ plp ;restore status
+ endm
+
+ tst_ax macro ;indexed testing result in accu & flags
+ php ;save flags
+ cmp \1,x ;test result
+ trap_ne
+ pla ;load status
+ eor_flag \3
+ cmp \2,x ;test flags
+ trap_ne ;
+ endm
+
+ tst_ay macro ;indexed testing result in accu & flags
+ php ;save flags
+ cmp \1,y ;test result
+ trap_ne ;
+ pla ;load status
+ eor_flag \3
+ cmp \2,y ;test flags
+ trap_ne
+ endm
+
+ tst_z macro ;indexed testing result in zp & flags
+ php ;save flags
+ lda zpt
+ cmp \1,x ;test result
+ trap_ne
+ pla ;load status
+ eor_flag \3
+ cmp \2,x ;test flags
+ trap_ne
+ endm
+
+ tst_zx macro ;testing result in zp,x & flags
+ php ;save flags
+ lda zpt,x
+ cmp \1,x ;test result
+ trap_ne
+ pla ;load status
+ eor_flag \3
+ cmp \2,x ;test flags
+ trap_ne
+ endm
+
+ tst_abs macro ;indexed testing result in memory & flags
+ php ;save flags
+ lda abst
+ cmp \1,x ;test result
+ trap_ne
+ pla ;load status
+ eor_flag \3
+ cmp \2,x ;test flags
+ trap_ne
+ endm
+
+ tst_absx macro ;testing result in abs,x & flags
+ php ;save flags
+ lda abst,x
+ cmp \1,x ;test result
+ trap_ne
+ pla ;load status
+ eor_flag \3
+ cmp \2,x ;test flags
+ trap_ne
+ endm
+
+ ; RAM integrity test
+ ; verifies that none of the previous tests has altered RAM outside of the
+ ; designated write areas.
+ ; uses zpt word as indirect pointer, zpt+2 word as checksum
+ if ram_top > -1
+ check_ram macro
+ cld
+ lda #0
+ sta zpt ;set low byte of indirect pointer
+ sta zpt+3 ;checksum high byte
+ ldx #11 ;reset modifiable RAM
+ ccs1\? sta jxi_tab,x ;JMP indirect page cross area
+ dex
+ bpl ccs1\?
+ sta chkdadi ;self modifying code
+ sta chkdsbi
+ clc
+ ldx #zp_bss-zero_page ;zeropage - write test area
+ ccs3\? adc zero_page,x
+ bcc ccs2\?
+ inc zpt+3 ;carry to high byte
+ clc
+ ccs2\? inx
+ bne ccs3\?
+ ldx #hi(data_segment) ;set high byte of indirect pointer
+ stx zpt+1
+ ldy #lo(data_bss) ;data after write test area
+ ccs5\? adc (zpt),y
+ bcc ccs4\?
+ inc zpt+3 ;carry to high byte
+ clc
+ ccs4\? iny
+ bne ccs5\?
+ inx ;advance RAM high address
+ stx zpt+1
+ cpx #ram_top
+ bne ccs5\?
+ sta zpt+2 ;checksum low is
+ cmp ram_chksm ;checksum low expected
+ trap_ne ;checksum mismatch
+ lda zpt+3 ;checksum high is
+ cmp ram_chksm+1 ;checksum high expected
+ trap_ne ;checksum mismatch
+ endm
+ else
+ check_ram macro
+ ;RAM check disabled - RAM size not set
+ endm
+ endif
+
+ next_test macro ;make sure, tests don't jump the fence
+ lda test_case ;previous test
+ cmp #test_num
+ trap_ne ;test is out of sequence
+ test_num = test_num + 1
+ lda #test_num ;*** next tests' number
+ sta test_case
+ ;check_ram ;uncomment to find altered RAM after each test
+ endm
+
+ if load_data_direct = 1
+ data
+ else
+ bss ;uninitialized segment, copy of data at end of code!
+ endif
+ ; org zero_page
+0000 = org 0 ;edited to provide binaries loading from 0
+0000 : 00000000000000.. ds zero_page
+ if I_flag = 2
+ ;masking for I bit in status
+ flag_I_on ds 1 ;or mask to load flags
+ flag_I_off ds 1 ;and mask to load flags
+ endif
+000a : zpt ;5 bytes store/modify test area
+ ;add/subtract operand generation and result/flag prediction
+000a : 00 adfc ds 1 ;carry flag before op
+000b : 00 ad1 ds 1 ;operand 1 - accumulator
+000c : 00 ad2 ds 1 ;operand 2 - memory / immediate
+000d : 00 adrl ds 1 ;expected result bits 0-7
+000e : 00 adrh ds 1 ;expected result bit 8 (carry)
+000f : 00 adrf ds 1 ;expected flags NV0000ZC (-V in decimal mode)
+0010 : 00 sb2 ds 1 ;operand 2 complemented for subtract
+0011 : zp_bss
+0011 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
+0015 : 7f zp7f db $7f ;test pattern for compare
+ ;logical zeropage operands
+0016 : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR
+001a : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND
+001e : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR
+ ;indirect addressing pointers
+0022 : 0a02 ind1 dw abs1 ;indirect pointer to pattern in absolute memory
+0024 : 0b02 dw abs1+1
+0026 : 0c02 dw abs1+2
+0028 : 0d02 dw abs1+3
+002a : 0e02 dw abs7f
+002c : 1201 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern
+002e : 0502 indt dw abst ;indirect pointer to store area in absolute memory
+0030 : 0602 dw abst+1
+0032 : 0702 dw abst+2
+0034 : 0802 dw abst+3
+0036 : 0d01 inwt dw abst-$f8 ;indirect pointer for wrap-test store
+0038 : 4102 indAN dw absAN ;indirect pointer to AND pattern in absolute memory
+003a : 4202 dw absAN+1
+003c : 4302 dw absAN+2
+003e : 4402 dw absAN+3
+0040 : 4502 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory
+0042 : 4602 dw absEO+1
+0044 : 4702 dw absEO+2
+0046 : 4802 dw absEO+3
+0048 : 3d02 indOR dw absOR ;indirect pointer to OR pattern in absolute memory
+004a : 3e02 dw absOR+1
+004c : 3f02 dw absOR+2
+004e : 4002 dw absOR+3
+ ;add/subtract indirect pointers
+0050 : 0502 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory
+0052 : 0602 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC)
+0054 : 0601 adiy2 dw ada2-$ff ;with offset for indirect indexed
+0056 : 0701 sbiy2 dw sba2-$ff
+0058 : zp_bss_end
+
+0200 = org data_segment
+0200 : 0000 pg_x ds 2 ;high JMP indirect address for page cross bug
+0202 : 00 test_case ds 1 ;current test number
+0203 : 0000 ram_chksm ds 2 ;checksum for RAM integrity test
+ ;add/subtract operand copy - abs tests write area
+0205 : abst ;5 bytes store/modify test area
+0205 : 00 ada2 ds 1 ;operand 2
+0206 : 00 sba2 ds 1 ;operand 2 complemented for subtract
+0207 : 000000 ds 3 ;fill remaining bytes
+020a : data_bss
+020a : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
+020e : 7f abs7f db $7f ;test pattern for compare
+ ;loads
+020f : 80800002 fLDx db fn,fn,0,fz ;expected flags for load
+ ;shifts
+0213 : rASL ;expected result ASL & ROL -carry
+0213 : 86048200 rROL db $86,$04,$82,0 ; "
+0217 : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry
+021b : rLSR ;expected result LSR & ROR -carry
+021b : 61412000 rROR db $61,$41,$20,0 ; "
+021f : e1c1a080 rRORc db $e1,$c1,$a0,$80 ;expected result ROR +carry
+0223 : fASL ;expected flags for shifts
+0223 : 81018002 fROL db fnc,fc,fn,fz ;no carry in
+0227 : 81018000 fROLc db fnc,fc,fn,0 ;carry in
+022b : fLSR
+022b : 01000102 fROR db fc,0,fc,fz ;no carry in
+022f : 81808180 fRORc db fnc,fn,fnc,fn ;carry in
+ ;increments (decrements)
+0233 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC
+0238 : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC
+ ;logical memory operand
+023d : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR
+0241 : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND
+0245 : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR
+ ;logical accu operand
+0249 : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR
+024d : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND
+0251 : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR
+ ;logical results
+0255 : 00ff7f80 absrlo db 0,$ff,$7f,$80
+0259 : 02800080 absflo db fz,fn,0,fn
+025d : data_bss_end
+ ;define area for page crossing JMP (abs) & JMP (abs,x) test
+02f9 = jxi_tab equ data_segment + $100 - 7 ;JMP (jxi_tab,x) x=6
+02fd = ji_tab equ data_segment + $100 - 3 ;JMP (ji_tab+2)
+0300 = jxp_tab equ data_segment + $100 ;JMP (jxp_tab-255) x=255
+
+
+ code
+0400 = org code_segment
+0400 : d8 start cld
+0401 : a2ff ldx #$ff
+0403 : 9a txs
+0404 : a900 lda #0 ;*** test 0 = initialize
+0406 : 8d0202 sta test_case
+0000 = test_num = 0
+
+ ;stop interrupts before initializing BSS
+ if I_flag = 1
+ sei
+ endif
+
+ ;initialize I/O for report channel
+ if report = 1
+ jsr report_init
+ endif
+
+ ;initialize BSS segment
+ if load_data_direct != 1
+ ldx #zp_end-zp_init-1
+ ld_zp lda zp_init,x
+ sta zp_bss,x
+ dex
+ bpl ld_zp
+ ldx #data_end-data_init-1
+ ld_data lda data_init,x
+ sta data_bss,x
+ dex
+ bpl ld_data
+ if ROM_vectors = 1
+ ldx #5
+ ld_vect lda vec_init,x
+ sta vec_bss,x
+ dex
+ bpl ld_vect
+ endif
+ endif
+
+ ;retain status of interrupt flag
+ if I_flag = 2
+ php
+ pla
+ and #4 ;isolate flag
+ sta flag_I_on ;or mask
+ eor #lo(~4) ;reverse
+ sta flag_I_off ;and mask
+ endif
+
+ ;generate checksum for RAM integrity test
+ if ram_top > -1
+ lda #0
+ sta zpt ;set low byte of indirect pointer
+ sta ram_chksm+1 ;checksum high byte
+ ldx #11 ;reset modifiable RAM
+ gcs1 sta jxi_tab,x ;JMP indirect page cross area
+ dex
+ bpl gcs1
+ sta chkdadi ;self modifying code
+ sta chkdsbi
+ clc
+ ldx #zp_bss-zero_page ;zeropage - write test area
+ gcs3 adc zero_page,x
+ bcc gcs2
+ inc ram_chksm+1 ;carry to high byte
+ clc
+ gcs2 inx
+ bne gcs3
+ ldx #hi(data_segment) ;set high byte of indirect pointer
+ stx zpt+1
+ ldy #lo(data_bss) ;data after write test area
+ gcs5 adc (zpt),y
+ bcc gcs4
+ inc ram_chksm+1 ;carry to high byte
+ clc
+ gcs4 iny
+ bne gcs5
+ inx ;advance RAM high address
+ stx zpt+1
+ cpx #ram_top
+ bne gcs5
+ sta ram_chksm ;checksum complete
+ endif
+ next_test
+0409 : ad0202 > lda test_case ;previous test
+040c : c900 > cmp #test_num
+ > trap_ne ;test is out of sequence
+040e : d0fe > bne * ;failed not equal (non zero)
+ >
+0001 = >test_num = test_num + 1
+0410 : a901 > lda #test_num ;*** next tests' number
+0412 : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ;testing stack operations PHX PHY PLX PLY
+0415 : a999 lda #$99 ;protect a
+0417 : a2ff ldx #$ff ;initialize stack
+0419 : 9a txs
+041a : a255 ldx #$55
+041c : da phx
+041d : a2aa ldx #$aa
+041f : da phx
+0420 : ecfe01 cpx $1fe ;on stack ?
+ trap_ne
+0423 : d0fe > bne * ;failed not equal (non zero)
+
+0425 : ba tsx
+0426 : e0fd cpx #$fd ;sp decremented?
+ trap_ne
+0428 : d0fe > bne * ;failed not equal (non zero)
+
+042a : 7a ply
+042b : c0aa cpy #$aa ;successful retreived from stack?
+ trap_ne
+042d : d0fe > bne * ;failed not equal (non zero)
+
+042f : 7a ply
+0430 : c055 cpy #$55
+ trap_ne
+0432 : d0fe > bne * ;failed not equal (non zero)
+
+0434 : ccff01 cpy $1ff ;remains on stack?
+ trap_ne
+0437 : d0fe > bne * ;failed not equal (non zero)
+
+0439 : ba tsx
+043a : e0ff cpx #$ff ;sp incremented?
+ trap_ne
+043c : d0fe > bne * ;failed not equal (non zero)
+
+
+043e : a0a5 ldy #$a5
+0440 : 5a phy
+0441 : a05a ldy #$5a
+0443 : 5a phy
+0444 : ccfe01 cpy $1fe ;on stack ?
+ trap_ne
+0447 : d0fe > bne * ;failed not equal (non zero)
+
+0449 : ba tsx
+044a : e0fd cpx #$fd ;sp decremented?
+ trap_ne
+044c : d0fe > bne * ;failed not equal (non zero)
+
+044e : fa plx
+044f : e05a cpx #$5a ;successful retreived from stack?
+ trap_ne
+0451 : d0fe > bne * ;failed not equal (non zero)
+
+0453 : fa plx
+0454 : e0a5 cpx #$a5
+ trap_ne
+0456 : d0fe > bne * ;failed not equal (non zero)
+
+0458 : ecff01 cpx $1ff ;remains on stack?
+ trap_ne
+045b : d0fe > bne * ;failed not equal (non zero)
+
+045d : ba tsx
+045e : e0ff cpx #$ff ;sp incremented?
+ trap_ne
+0460 : d0fe > bne * ;failed not equal (non zero)
+
+0462 : c999 cmp #$99 ;unchanged?
+ trap_ne
+0464 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+0466 : ad0202 > lda test_case ;previous test
+0469 : c901 > cmp #test_num
+ > trap_ne ;test is out of sequence
+046b : d0fe > bne * ;failed not equal (non zero)
+ >
+0002 = >test_num = test_num + 1
+046d : a902 > lda #test_num ;*** next tests' number
+046f : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; test PHX does not alter flags or X but PLX does
+0472 : a0aa ldy #$aa ;protect y
+ set_x 1,$ff ;push
+ > load_flag $ff
+0474 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0476 : 48 > pha ;use stack to load status
+0477 : a201 > ldx #1 ;precharge index x
+0479 : 28 > plp
+
+047a : da phx
+ tst_x 1,$ff
+047b : 08 > php ;save flags
+047c : e001 > cpx #1 ;test result
+ > trap_ne
+047e : d0fe > bne * ;failed not equal (non zero)
+ >
+0480 : 68 > pla ;load status
+0481 : 48 > pha
+ > cmp_flag $ff
+0482 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0484 : d0fe > bne * ;failed not equal (non zero)
+ >
+0486 : 28 > plp ;restore status
+
+ set_x 0,0
+ > load_flag 0
+0487 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0489 : 48 > pha ;use stack to load status
+048a : a200 > ldx #0 ;precharge index x
+048c : 28 > plp
+
+048d : da phx
+ tst_x 0,0
+048e : 08 > php ;save flags
+048f : e000 > cpx #0 ;test result
+ > trap_ne
+0491 : d0fe > bne * ;failed not equal (non zero)
+ >
+0493 : 68 > pla ;load status
+0494 : 48 > pha
+ > cmp_flag 0
+0495 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0497 : d0fe > bne * ;failed not equal (non zero)
+ >
+0499 : 28 > plp ;restore status
+
+ set_x $ff,$ff
+ > load_flag $ff
+049a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+049c : 48 > pha ;use stack to load status
+049d : a2ff > ldx #$ff ;precharge index x
+049f : 28 > plp
+
+04a0 : da phx
+ tst_x $ff,$ff
+04a1 : 08 > php ;save flags
+04a2 : e0ff > cpx #$ff ;test result
+ > trap_ne
+04a4 : d0fe > bne * ;failed not equal (non zero)
+ >
+04a6 : 68 > pla ;load status
+04a7 : 48 > pha
+ > cmp_flag $ff
+04a8 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+04aa : d0fe > bne * ;failed not equal (non zero)
+ >
+04ac : 28 > plp ;restore status
+
+ set_x 1,0
+ > load_flag 0
+04ad : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+04af : 48 > pha ;use stack to load status
+04b0 : a201 > ldx #1 ;precharge index x
+04b2 : 28 > plp
+
+04b3 : da phx
+ tst_x 1,0
+04b4 : 08 > php ;save flags
+04b5 : e001 > cpx #1 ;test result
+ > trap_ne
+04b7 : d0fe > bne * ;failed not equal (non zero)
+ >
+04b9 : 68 > pla ;load status
+04ba : 48 > pha
+ > cmp_flag 0
+04bb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+04bd : d0fe > bne * ;failed not equal (non zero)
+ >
+04bf : 28 > plp ;restore status
+
+ set_x 0,$ff
+ > load_flag $ff
+04c0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+04c2 : 48 > pha ;use stack to load status
+04c3 : a200 > ldx #0 ;precharge index x
+04c5 : 28 > plp
+
+04c6 : da phx
+ tst_x 0,$ff
+04c7 : 08 > php ;save flags
+04c8 : e000 > cpx #0 ;test result
+ > trap_ne
+04ca : d0fe > bne * ;failed not equal (non zero)
+ >
+04cc : 68 > pla ;load status
+04cd : 48 > pha
+ > cmp_flag $ff
+04ce : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+04d0 : d0fe > bne * ;failed not equal (non zero)
+ >
+04d2 : 28 > plp ;restore status
+
+ set_x $ff,0
+ > load_flag 0
+04d3 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+04d5 : 48 > pha ;use stack to load status
+04d6 : a2ff > ldx #$ff ;precharge index x
+04d8 : 28 > plp
+
+04d9 : da phx
+ tst_x $ff,0
+04da : 08 > php ;save flags
+04db : e0ff > cpx #$ff ;test result
+ > trap_ne
+04dd : d0fe > bne * ;failed not equal (non zero)
+ >
+04df : 68 > pla ;load status
+04e0 : 48 > pha
+ > cmp_flag 0
+04e1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+04e3 : d0fe > bne * ;failed not equal (non zero)
+ >
+04e5 : 28 > plp ;restore status
+
+ set_x 0,$ff ;pull
+ > load_flag $ff
+04e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+04e8 : 48 > pha ;use stack to load status
+04e9 : a200 > ldx #0 ;precharge index x
+04eb : 28 > plp
+
+04ec : fa plx
+ tst_x $ff,$ff-zero
+04ed : 08 > php ;save flags
+04ee : e0ff > cpx #$ff ;test result
+ > trap_ne
+04f0 : d0fe > bne * ;failed not equal (non zero)
+ >
+04f2 : 68 > pla ;load status
+04f3 : 48 > pha
+ > cmp_flag $ff-zero
+04f4 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+04f6 : d0fe > bne * ;failed not equal (non zero)
+ >
+04f8 : 28 > plp ;restore status
+
+ set_x $ff,0
+ > load_flag 0
+04f9 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+04fb : 48 > pha ;use stack to load status
+04fc : a2ff > ldx #$ff ;precharge index x
+04fe : 28 > plp
+
+04ff : fa plx
+ tst_x 0,zero
+0500 : 08 > php ;save flags
+0501 : e000 > cpx #0 ;test result
+ > trap_ne
+0503 : d0fe > bne * ;failed not equal (non zero)
+ >
+0505 : 68 > pla ;load status
+0506 : 48 > pha
+ > cmp_flag zero
+0507 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0509 : d0fe > bne * ;failed not equal (non zero)
+ >
+050b : 28 > plp ;restore status
+
+ set_x $fe,$ff
+ > load_flag $ff
+050c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+050e : 48 > pha ;use stack to load status
+050f : a2fe > ldx #$fe ;precharge index x
+0511 : 28 > plp
+
+0512 : fa plx
+ tst_x 1,$ff-zero-minus
+0513 : 08 > php ;save flags
+0514 : e001 > cpx #1 ;test result
+ > trap_ne
+0516 : d0fe > bne * ;failed not equal (non zero)
+ >
+0518 : 68 > pla ;load status
+0519 : 48 > pha
+ > cmp_flag $ff-zero-minus
+051a : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+051c : d0fe > bne * ;failed not equal (non zero)
+ >
+051e : 28 > plp ;restore status
+
+ set_x 0,0
+ > load_flag 0
+051f : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0521 : 48 > pha ;use stack to load status
+0522 : a200 > ldx #0 ;precharge index x
+0524 : 28 > plp
+
+0525 : fa plx
+ tst_x $ff,minus
+0526 : 08 > php ;save flags
+0527 : e0ff > cpx #$ff ;test result
+ > trap_ne
+0529 : d0fe > bne * ;failed not equal (non zero)
+ >
+052b : 68 > pla ;load status
+052c : 48 > pha
+ > cmp_flag minus
+052d : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+052f : d0fe > bne * ;failed not equal (non zero)
+ >
+0531 : 28 > plp ;restore status
+
+ set_x $ff,$ff
+ > load_flag $ff
+0532 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0534 : 48 > pha ;use stack to load status
+0535 : a2ff > ldx #$ff ;precharge index x
+0537 : 28 > plp
+
+0538 : fa plx
+ tst_x 0,$ff-minus
+0539 : 08 > php ;save flags
+053a : e000 > cpx #0 ;test result
+ > trap_ne
+053c : d0fe > bne * ;failed not equal (non zero)
+ >
+053e : 68 > pla ;load status
+053f : 48 > pha
+ > cmp_flag $ff-minus
+0540 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0542 : d0fe > bne * ;failed not equal (non zero)
+ >
+0544 : 28 > plp ;restore status
+
+ set_x $fe,0
+ > load_flag 0
+0545 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0547 : 48 > pha ;use stack to load status
+0548 : a2fe > ldx #$fe ;precharge index x
+054a : 28 > plp
+
+054b : fa plx
+ tst_x 1,0
+054c : 08 > php ;save flags
+054d : e001 > cpx #1 ;test result
+ > trap_ne
+054f : d0fe > bne * ;failed not equal (non zero)
+ >
+0551 : 68 > pla ;load status
+0552 : 48 > pha
+ > cmp_flag 0
+0553 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0555 : d0fe > bne * ;failed not equal (non zero)
+ >
+0557 : 28 > plp ;restore status
+
+0558 : c0aa cpy #$aa ;Y unchanged
+ trap_ne
+055a : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+055c : ad0202 > lda test_case ;previous test
+055f : c902 > cmp #test_num
+ > trap_ne ;test is out of sequence
+0561 : d0fe > bne * ;failed not equal (non zero)
+ >
+0003 = >test_num = test_num + 1
+0563 : a903 > lda #test_num ;*** next tests' number
+0565 : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; test PHY does not alter flags or Y but PLY does
+0568 : a255 ldx #$55 ;x & a protected
+ set_y 1,$ff ;push
+ > load_flag $ff
+056a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+056c : 48 > pha ;use stack to load status
+056d : a001 > ldy #1 ;precharge index y
+056f : 28 > plp
+
+0570 : 5a phy
+ tst_y 1,$ff
+0571 : 08 > php ;save flags
+0572 : c001 > cpy #1 ;test result
+ > trap_ne
+0574 : d0fe > bne * ;failed not equal (non zero)
+ >
+0576 : 68 > pla ;load status
+0577 : 48 > pha
+ > cmp_flag $ff
+0578 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+057a : d0fe > bne * ;failed not equal (non zero)
+ >
+057c : 28 > plp ;restore status
+
+ set_y 0,0
+ > load_flag 0
+057d : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+057f : 48 > pha ;use stack to load status
+0580 : a000 > ldy #0 ;precharge index y
+0582 : 28 > plp
+
+0583 : 5a phy
+ tst_y 0,0
+0584 : 08 > php ;save flags
+0585 : c000 > cpy #0 ;test result
+ > trap_ne
+0587 : d0fe > bne * ;failed not equal (non zero)
+ >
+0589 : 68 > pla ;load status
+058a : 48 > pha
+ > cmp_flag 0
+058b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+058d : d0fe > bne * ;failed not equal (non zero)
+ >
+058f : 28 > plp ;restore status
+
+ set_y $ff,$ff
+ > load_flag $ff
+0590 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0592 : 48 > pha ;use stack to load status
+0593 : a0ff > ldy #$ff ;precharge index y
+0595 : 28 > plp
+
+0596 : 5a phy
+ tst_y $ff,$ff
+0597 : 08 > php ;save flags
+0598 : c0ff > cpy #$ff ;test result
+ > trap_ne
+059a : d0fe > bne * ;failed not equal (non zero)
+ >
+059c : 68 > pla ;load status
+059d : 48 > pha
+ > cmp_flag $ff
+059e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+05a0 : d0fe > bne * ;failed not equal (non zero)
+ >
+05a2 : 28 > plp ;restore status
+
+ set_y 1,0
+ > load_flag 0
+05a3 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+05a5 : 48 > pha ;use stack to load status
+05a6 : a001 > ldy #1 ;precharge index y
+05a8 : 28 > plp
+
+05a9 : 5a phy
+ tst_y 1,0
+05aa : 08 > php ;save flags
+05ab : c001 > cpy #1 ;test result
+ > trap_ne
+05ad : d0fe > bne * ;failed not equal (non zero)
+ >
+05af : 68 > pla ;load status
+05b0 : 48 > pha
+ > cmp_flag 0
+05b1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+05b3 : d0fe > bne * ;failed not equal (non zero)
+ >
+05b5 : 28 > plp ;restore status
+
+ set_y 0,$ff
+ > load_flag $ff
+05b6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+05b8 : 48 > pha ;use stack to load status
+05b9 : a000 > ldy #0 ;precharge index y
+05bb : 28 > plp
+
+05bc : 5a phy
+ tst_y 0,$ff
+05bd : 08 > php ;save flags
+05be : c000 > cpy #0 ;test result
+ > trap_ne
+05c0 : d0fe > bne * ;failed not equal (non zero)
+ >
+05c2 : 68 > pla ;load status
+05c3 : 48 > pha
+ > cmp_flag $ff
+05c4 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+05c6 : d0fe > bne * ;failed not equal (non zero)
+ >
+05c8 : 28 > plp ;restore status
+
+ set_y $ff,0
+ > load_flag 0
+05c9 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+05cb : 48 > pha ;use stack to load status
+05cc : a0ff > ldy #$ff ;precharge index y
+05ce : 28 > plp
+
+05cf : 5a phy
+ tst_y $ff,0
+05d0 : 08 > php ;save flags
+05d1 : c0ff > cpy #$ff ;test result
+ > trap_ne
+05d3 : d0fe > bne * ;failed not equal (non zero)
+ >
+05d5 : 68 > pla ;load status
+05d6 : 48 > pha
+ > cmp_flag 0
+05d7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+05d9 : d0fe > bne * ;failed not equal (non zero)
+ >
+05db : 28 > plp ;restore status
+
+ set_y 0,$ff ;pull
+ > load_flag $ff
+05dc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+05de : 48 > pha ;use stack to load status
+05df : a000 > ldy #0 ;precharge index y
+05e1 : 28 > plp
+
+05e2 : 7a ply
+ tst_y $ff,$ff-zero
+05e3 : 08 > php ;save flags
+05e4 : c0ff > cpy #$ff ;test result
+ > trap_ne
+05e6 : d0fe > bne * ;failed not equal (non zero)
+ >
+05e8 : 68 > pla ;load status
+05e9 : 48 > pha
+ > cmp_flag $ff-zero
+05ea : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+05ec : d0fe > bne * ;failed not equal (non zero)
+ >
+05ee : 28 > plp ;restore status
+
+ set_y $ff,0
+ > load_flag 0
+05ef : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+05f1 : 48 > pha ;use stack to load status
+05f2 : a0ff > ldy #$ff ;precharge index y
+05f4 : 28 > plp
+
+05f5 : 7a ply
+ tst_y 0,zero
+05f6 : 08 > php ;save flags
+05f7 : c000 > cpy #0 ;test result
+ > trap_ne
+05f9 : d0fe > bne * ;failed not equal (non zero)
+ >
+05fb : 68 > pla ;load status
+05fc : 48 > pha
+ > cmp_flag zero
+05fd : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+05ff : d0fe > bne * ;failed not equal (non zero)
+ >
+0601 : 28 > plp ;restore status
+
+ set_y $fe,$ff
+ > load_flag $ff
+0602 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0604 : 48 > pha ;use stack to load status
+0605 : a0fe > ldy #$fe ;precharge index y
+0607 : 28 > plp
+
+0608 : 7a ply
+ tst_y 1,$ff-zero-minus
+0609 : 08 > php ;save flags
+060a : c001 > cpy #1 ;test result
+ > trap_ne
+060c : d0fe > bne * ;failed not equal (non zero)
+ >
+060e : 68 > pla ;load status
+060f : 48 > pha
+ > cmp_flag $ff-zero-minus
+0610 : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0612 : d0fe > bne * ;failed not equal (non zero)
+ >
+0614 : 28 > plp ;restore status
+
+ set_y 0,0
+ > load_flag 0
+0615 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0617 : 48 > pha ;use stack to load status
+0618 : a000 > ldy #0 ;precharge index y
+061a : 28 > plp
+
+061b : 7a ply
+ tst_y $ff,minus
+061c : 08 > php ;save flags
+061d : c0ff > cpy #$ff ;test result
+ > trap_ne
+061f : d0fe > bne * ;failed not equal (non zero)
+ >
+0621 : 68 > pla ;load status
+0622 : 48 > pha
+ > cmp_flag minus
+0623 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0625 : d0fe > bne * ;failed not equal (non zero)
+ >
+0627 : 28 > plp ;restore status
+
+ set_y $ff,$ff
+ > load_flag $ff
+0628 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+062a : 48 > pha ;use stack to load status
+062b : a0ff > ldy #$ff ;precharge index y
+062d : 28 > plp
+
+062e : 7a ply
+ tst_y 0,$ff-minus
+062f : 08 > php ;save flags
+0630 : c000 > cpy #0 ;test result
+ > trap_ne
+0632 : d0fe > bne * ;failed not equal (non zero)
+ >
+0634 : 68 > pla ;load status
+0635 : 48 > pha
+ > cmp_flag $ff-minus
+0636 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0638 : d0fe > bne * ;failed not equal (non zero)
+ >
+063a : 28 > plp ;restore status
+
+ set_y $fe,0
+ > load_flag 0
+063b : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+063d : 48 > pha ;use stack to load status
+063e : a0fe > ldy #$fe ;precharge index y
+0640 : 28 > plp
+
+0641 : 7a ply
+ tst_y 1,0
+0642 : 08 > php ;save flags
+0643 : c001 > cpy #1 ;test result
+ > trap_ne
+0645 : d0fe > bne * ;failed not equal (non zero)
+ >
+0647 : 68 > pla ;load status
+0648 : 48 > pha
+ > cmp_flag 0
+0649 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+064b : d0fe > bne * ;failed not equal (non zero)
+ >
+064d : 28 > plp ;restore status
+
+064e : e055 cpx #$55 ;x unchanged?
+ trap_ne
+0650 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+0652 : ad0202 > lda test_case ;previous test
+0655 : c903 > cmp #test_num
+ > trap_ne ;test is out of sequence
+0657 : d0fe > bne * ;failed not equal (non zero)
+ >
+0004 = >test_num = test_num + 1
+0659 : a904 > lda #test_num ;*** next tests' number
+065b : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; PC modifying instructions (BRA, BBR, BBS, 1, 2, 3 byte NOPs, JMP(abs,x))
+ ; testing unconditional branch BRA
+
+065e : a281 ldx #$81 ;protect unused registers
+0660 : a07e ldy #$7e
+ set_a 0,$ff
+ > load_flag $ff
+0662 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0664 : 48 > pha ;use stack to load status
+0665 : a900 > lda #0 ;precharge accu
+0667 : 28 > plp
+
+0668 : 8003 bra br1 ;branch should always be taken
+ trap
+066a : 4c6a06 > jmp * ;failed anyway
+
+066d : br1
+ tst_a 0,$ff
+066d : 08 > php ;save flags
+066e : c900 > cmp #0 ;test result
+ > trap_ne
+0670 : d0fe > bne * ;failed not equal (non zero)
+ >
+0672 : 68 > pla ;load status
+0673 : 48 > pha
+ > cmp_flag $ff
+0674 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0676 : d0fe > bne * ;failed not equal (non zero)
+ >
+0678 : 28 > plp ;restore status
+
+ set_a $ff,0
+ > load_flag 0
+0679 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+067b : 48 > pha ;use stack to load status
+067c : a9ff > lda #$ff ;precharge accu
+067e : 28 > plp
+
+067f : 8003 bra br2 ;branch should always be taken
+ trap
+0681 : 4c8106 > jmp * ;failed anyway
+
+0684 : br2
+ tst_a $ff,0
+0684 : 08 > php ;save flags
+0685 : c9ff > cmp #$ff ;test result
+ > trap_ne
+0687 : d0fe > bne * ;failed not equal (non zero)
+ >
+0689 : 68 > pla ;load status
+068a : 48 > pha
+ > cmp_flag 0
+068b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+068d : d0fe > bne * ;failed not equal (non zero)
+ >
+068f : 28 > plp ;restore status
+
+0690 : e081 cpx #$81
+ trap_ne
+0692 : d0fe > bne * ;failed not equal (non zero)
+
+0694 : c07e cpy #$7e
+ trap_ne
+0696 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+0698 : ad0202 > lda test_case ;previous test
+069b : c904 > cmp #test_num
+ > trap_ne ;test is out of sequence
+069d : d0fe > bne * ;failed not equal (non zero)
+ >
+0005 = >test_num = test_num + 1
+069f : a905 > lda #test_num ;*** next tests' number
+06a1 : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+06a4 : a000 ldy #0 ;branch range test
+06a6 : 8061 bra bra0
+
+06a8 : c001 bra1 cpy #1
+ trap_ne ;long range backward
+06aa : d0fe > bne * ;failed not equal (non zero)
+
+06ac : c8 iny
+06ad : 8053 bra bra2
+
+06af : c003 bra3 cpy #3
+ trap_ne ;long range backward
+06b1 : d0fe > bne * ;failed not equal (non zero)
+
+06b3 : c8 iny
+06b4 : 8045 bra bra4
+
+06b6 : c005 bra5 cpy #5
+ trap_ne ;long range backward
+06b8 : d0fe > bne * ;failed not equal (non zero)
+
+06ba : c8 iny
+06bb : a000 ldy #0
+06bd : 8004 bra brf0
+
+06bf : c8 iny
+06c0 : c8 iny
+06c1 : c8 iny
+06c2 : c8 iny
+06c3 : 8003 brf0 bra brf1
+
+06c5 : c8 iny
+06c6 : c8 iny
+06c7 : c8 iny
+06c8 : c8 brf1 iny
+06c9 : 8002 bra brf2
+
+06cb : c8 iny
+06cc : c8 iny
+06cd : c8 brf2 iny
+06ce : c8 iny
+06cf : 8001 bra brf3
+
+06d1 : c8 iny
+06d2 : c8 brf3 iny
+06d3 : c8 iny
+06d4 : c8 iny
+06d5 : 8000 bra brf4
+
+06d7 : c8 brf4 iny
+06d8 : c8 iny
+06d9 : c8 iny
+06da : c8 iny
+06db : c00a cpy #10
+ trap_ne ;short range forward
+06dd : d0fe > bne * ;failed not equal (non zero)
+
+06df : 8012 bra brb0
+
+06e1 : 88 brb4 dey
+06e2 : 88 dey
+06e3 : 88 dey
+06e4 : 88 dey
+06e5 : 800e bra brb5
+
+06e7 : 88 brb3 dey
+06e8 : 88 dey
+06e9 : 88 dey
+06ea : 80f5 bra brb4
+
+06ec : 88 brb2 dey
+06ed : 88 dey
+06ee : 80f7 bra brb3
+
+06f0 : 88 brb1 dey
+06f1 : 80f9 bra brb2
+
+06f3 : 80fb brb0 bra brb1
+
+06f5 : c000 brb5 cpy #0
+ trap_ne ;short range backward
+06f7 : d0fe > bne * ;failed not equal (non zero)
+
+06f9 : 8015 bra bra6
+
+06fb : c004 bra4 cpy #4
+ trap_ne ;long range forward
+06fd : d0fe > bne * ;failed not equal (non zero)
+
+06ff : c8 iny
+0700 : 80b4 bra bra5
+
+0702 : c002 bra2 cpy #2
+ trap_ne ;long range forward
+0704 : d0fe > bne * ;failed not equal (non zero)
+
+0706 : c8 iny
+0707 : 80a6 bra bra3
+
+0709 : c000 bra0 cpy #0
+ trap_ne ;long range forward
+070b : d0fe > bne * ;failed not equal (non zero)
+
+070d : c8 iny
+070e : 8098 bra bra1
+
+0710 : bra6
+ next_test
+0710 : ad0202 > lda test_case ;previous test
+0713 : c905 > cmp #test_num
+ > trap_ne ;test is out of sequence
+0715 : d0fe > bne * ;failed not equal (non zero)
+ >
+0006 = >test_num = test_num + 1
+0717 : a906 > lda #test_num ;*** next tests' number
+0719 : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ if rkwl_wdc_op = 1
+ ; testing BBR & BBS
+
+ bbt macro ;\1 = bitnum
+ lda #(1<<\1) ;testing 1 bit on
+ sta zpt
+ set_a $33,0 ;with flags off
+ bbr \1,zpt,fail1\?
+ bbs \1,zpt,ok1\?
+ trap ;bbs branch not taken
+ fail1\?
+ trap ;bbr branch taken
+ ok1\?
+ tst_a $33,0
+ set_a $cc,$ff ;with flags on
+ bbr \1,zpt,fail2\?
+ bbs \1,zpt,ok2\?
+ trap ;bbs branch not taken
+ fail2\?
+ trap ;bbr branch taken
+ ok2\?
+ tst_a $cc,$ff
+ lda zpt
+ cmp #(1<<\1)
+ trap_ne ;zp altered
+ lda #$ff-(1<<\1) ;testing 1 bit off
+ sta zpt
+ set_a $33,0 ;with flags off
+ bbs \1,zpt,fail3\?
+ bbr \1,zpt,ok3\?
+ trap ;bbr branch not taken
+ fail3\?
+ trap ;bbs branch taken
+ ok3\?
+ tst_a $33,0
+ set_a $cc,$ff ;with flags on
+ bbs \1,zpt,fail4\?
+ bbr \1,zpt,ok4\?
+ trap ;bbr branch not taken
+ fail4\?
+ trap ;bbs branch taken
+ ok4\?
+ tst_a $cc,$ff
+ lda zpt
+ cmp #$ff-(1<<\1)
+ trap_ne ;zp altered
+ endm
+
+071c : a211 ldx #$11 ;test bbr/bbs integrity
+071e : a022 ldy #$22
+ bbt 0
+0720 : a901 > lda #(1<<0) ;testing 1 bit on
+0722 : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+0724 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0726 : 48 > pha ;use stack to load status
+0727 : a933 > lda #$33 ;precharge accu
+0729 : 28 > plp
+ >
+072a : 0f0a06 > bbr 0,zpt,fail10196
+072d : 8f0a06 > bbs 0,zpt,ok10196
+ > trap ;bbs branch not taken
+0730 : 4c3007 > jmp * ;failed anyway
+ >
+0733 : >fail10196
+ > trap ;bbr branch taken
+0733 : 4c3307 > jmp * ;failed anyway
+ >
+0736 : >ok10196
+ > tst_a $33,0
+0736 : 08 > php ;save flags
+0737 : c933 > cmp #$33 ;test result
+ > trap_ne
+0739 : d0fe > bne * ;failed not equal (non zero)
+ >
+073b : 68 > pla ;load status
+073c : 48 > pha
+ > cmp_flag 0
+073d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+073f : d0fe > bne * ;failed not equal (non zero)
+ >
+0741 : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+0742 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0744 : 48 > pha ;use stack to load status
+0745 : a9cc > lda #$cc ;precharge accu
+0747 : 28 > plp
+ >
+0748 : 0f0a06 > bbr 0,zpt,fail20196
+074b : 8f0a06 > bbs 0,zpt,ok20196
+ > trap ;bbs branch not taken
+074e : 4c4e07 > jmp * ;failed anyway
+ >
+0751 : >fail20196
+ > trap ;bbr branch taken
+0751 : 4c5107 > jmp * ;failed anyway
+ >
+0754 : >ok20196
+ > tst_a $cc,$ff
+0754 : 08 > php ;save flags
+0755 : c9cc > cmp #$cc ;test result
+ > trap_ne
+0757 : d0fe > bne * ;failed not equal (non zero)
+ >
+0759 : 68 > pla ;load status
+075a : 48 > pha
+ > cmp_flag $ff
+075b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+075d : d0fe > bne * ;failed not equal (non zero)
+ >
+075f : 28 > plp ;restore status
+ >
+0760 : a50a > lda zpt
+0762 : c901 > cmp #(1<<0)
+ > trap_ne ;zp altered
+0764 : d0fe > bne * ;failed not equal (non zero)
+ >
+0766 : a9fe > lda #$ff-(1<<0) ;testing 1 bit off
+0768 : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+076a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+076c : 48 > pha ;use stack to load status
+076d : a933 > lda #$33 ;precharge accu
+076f : 28 > plp
+ >
+0770 : 8f0a06 > bbs 0,zpt,fail30196
+0773 : 0f0a06 > bbr 0,zpt,ok30196
+ > trap ;bbr branch not taken
+0776 : 4c7607 > jmp * ;failed anyway
+ >
+0779 : >fail30196
+ > trap ;bbs branch taken
+0779 : 4c7907 > jmp * ;failed anyway
+ >
+077c : >ok30196
+ > tst_a $33,0
+077c : 08 > php ;save flags
+077d : c933 > cmp #$33 ;test result
+ > trap_ne
+077f : d0fe > bne * ;failed not equal (non zero)
+ >
+0781 : 68 > pla ;load status
+0782 : 48 > pha
+ > cmp_flag 0
+0783 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0785 : d0fe > bne * ;failed not equal (non zero)
+ >
+0787 : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+0788 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+078a : 48 > pha ;use stack to load status
+078b : a9cc > lda #$cc ;precharge accu
+078d : 28 > plp
+ >
+078e : 8f0a06 > bbs 0,zpt,fail40196
+0791 : 0f0a06 > bbr 0,zpt,ok40196
+ > trap ;bbr branch not taken
+0794 : 4c9407 > jmp * ;failed anyway
+ >
+0797 : >fail40196
+ > trap ;bbs branch taken
+0797 : 4c9707 > jmp * ;failed anyway
+ >
+079a : >ok40196
+ > tst_a $cc,$ff
+079a : 08 > php ;save flags
+079b : c9cc > cmp #$cc ;test result
+ > trap_ne
+079d : d0fe > bne * ;failed not equal (non zero)
+ >
+079f : 68 > pla ;load status
+07a0 : 48 > pha
+ > cmp_flag $ff
+07a1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+07a3 : d0fe > bne * ;failed not equal (non zero)
+ >
+07a5 : 28 > plp ;restore status
+ >
+07a6 : a50a > lda zpt
+07a8 : c9fe > cmp #$ff-(1<<0)
+ > trap_ne ;zp altered
+07aa : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ bbt 1
+07ac : a902 > lda #(1<<1) ;testing 1 bit on
+07ae : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+07b0 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+07b2 : 48 > pha ;use stack to load status
+07b3 : a933 > lda #$33 ;precharge accu
+07b5 : 28 > plp
+ >
+07b6 : 1f0a06 > bbr 1,zpt,fail10231
+07b9 : 9f0a06 > bbs 1,zpt,ok10231
+ > trap ;bbs branch not taken
+07bc : 4cbc07 > jmp * ;failed anyway
+ >
+07bf : >fail10231
+ > trap ;bbr branch taken
+07bf : 4cbf07 > jmp * ;failed anyway
+ >
+07c2 : >ok10231
+ > tst_a $33,0
+07c2 : 08 > php ;save flags
+07c3 : c933 > cmp #$33 ;test result
+ > trap_ne
+07c5 : d0fe > bne * ;failed not equal (non zero)
+ >
+07c7 : 68 > pla ;load status
+07c8 : 48 > pha
+ > cmp_flag 0
+07c9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+07cb : d0fe > bne * ;failed not equal (non zero)
+ >
+07cd : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+07ce : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+07d0 : 48 > pha ;use stack to load status
+07d1 : a9cc > lda #$cc ;precharge accu
+07d3 : 28 > plp
+ >
+07d4 : 1f0a06 > bbr 1,zpt,fail20231
+07d7 : 9f0a06 > bbs 1,zpt,ok20231
+ > trap ;bbs branch not taken
+07da : 4cda07 > jmp * ;failed anyway
+ >
+07dd : >fail20231
+ > trap ;bbr branch taken
+07dd : 4cdd07 > jmp * ;failed anyway
+ >
+07e0 : >ok20231
+ > tst_a $cc,$ff
+07e0 : 08 > php ;save flags
+07e1 : c9cc > cmp #$cc ;test result
+ > trap_ne
+07e3 : d0fe > bne * ;failed not equal (non zero)
+ >
+07e5 : 68 > pla ;load status
+07e6 : 48 > pha
+ > cmp_flag $ff
+07e7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+07e9 : d0fe > bne * ;failed not equal (non zero)
+ >
+07eb : 28 > plp ;restore status
+ >
+07ec : a50a > lda zpt
+07ee : c902 > cmp #(1<<1)
+ > trap_ne ;zp altered
+07f0 : d0fe > bne * ;failed not equal (non zero)
+ >
+07f2 : a9fd > lda #$ff-(1<<1) ;testing 1 bit off
+07f4 : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+07f6 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+07f8 : 48 > pha ;use stack to load status
+07f9 : a933 > lda #$33 ;precharge accu
+07fb : 28 > plp
+ >
+07fc : 9f0a06 > bbs 1,zpt,fail30231
+07ff : 1f0a06 > bbr 1,zpt,ok30231
+ > trap ;bbr branch not taken
+0802 : 4c0208 > jmp * ;failed anyway
+ >
+0805 : >fail30231
+ > trap ;bbs branch taken
+0805 : 4c0508 > jmp * ;failed anyway
+ >
+0808 : >ok30231
+ > tst_a $33,0
+0808 : 08 > php ;save flags
+0809 : c933 > cmp #$33 ;test result
+ > trap_ne
+080b : d0fe > bne * ;failed not equal (non zero)
+ >
+080d : 68 > pla ;load status
+080e : 48 > pha
+ > cmp_flag 0
+080f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0811 : d0fe > bne * ;failed not equal (non zero)
+ >
+0813 : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+0814 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0816 : 48 > pha ;use stack to load status
+0817 : a9cc > lda #$cc ;precharge accu
+0819 : 28 > plp
+ >
+081a : 9f0a06 > bbs 1,zpt,fail40231
+081d : 1f0a06 > bbr 1,zpt,ok40231
+ > trap ;bbr branch not taken
+0820 : 4c2008 > jmp * ;failed anyway
+ >
+0823 : >fail40231
+ > trap ;bbs branch taken
+0823 : 4c2308 > jmp * ;failed anyway
+ >
+0826 : >ok40231
+ > tst_a $cc,$ff
+0826 : 08 > php ;save flags
+0827 : c9cc > cmp #$cc ;test result
+ > trap_ne
+0829 : d0fe > bne * ;failed not equal (non zero)
+ >
+082b : 68 > pla ;load status
+082c : 48 > pha
+ > cmp_flag $ff
+082d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+082f : d0fe > bne * ;failed not equal (non zero)
+ >
+0831 : 28 > plp ;restore status
+ >
+0832 : a50a > lda zpt
+0834 : c9fd > cmp #$ff-(1<<1)
+ > trap_ne ;zp altered
+0836 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ bbt 2
+0838 : a904 > lda #(1<<2) ;testing 1 bit on
+083a : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+083c : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+083e : 48 > pha ;use stack to load status
+083f : a933 > lda #$33 ;precharge accu
+0841 : 28 > plp
+ >
+0842 : 2f0a06 > bbr 2,zpt,fail10266
+0845 : af0a06 > bbs 2,zpt,ok10266
+ > trap ;bbs branch not taken
+0848 : 4c4808 > jmp * ;failed anyway
+ >
+084b : >fail10266
+ > trap ;bbr branch taken
+084b : 4c4b08 > jmp * ;failed anyway
+ >
+084e : >ok10266
+ > tst_a $33,0
+084e : 08 > php ;save flags
+084f : c933 > cmp #$33 ;test result
+ > trap_ne
+0851 : d0fe > bne * ;failed not equal (non zero)
+ >
+0853 : 68 > pla ;load status
+0854 : 48 > pha
+ > cmp_flag 0
+0855 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0857 : d0fe > bne * ;failed not equal (non zero)
+ >
+0859 : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+085a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+085c : 48 > pha ;use stack to load status
+085d : a9cc > lda #$cc ;precharge accu
+085f : 28 > plp
+ >
+0860 : 2f0a06 > bbr 2,zpt,fail20266
+0863 : af0a06 > bbs 2,zpt,ok20266
+ > trap ;bbs branch not taken
+0866 : 4c6608 > jmp * ;failed anyway
+ >
+0869 : >fail20266
+ > trap ;bbr branch taken
+0869 : 4c6908 > jmp * ;failed anyway
+ >
+086c : >ok20266
+ > tst_a $cc,$ff
+086c : 08 > php ;save flags
+086d : c9cc > cmp #$cc ;test result
+ > trap_ne
+086f : d0fe > bne * ;failed not equal (non zero)
+ >
+0871 : 68 > pla ;load status
+0872 : 48 > pha
+ > cmp_flag $ff
+0873 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0875 : d0fe > bne * ;failed not equal (non zero)
+ >
+0877 : 28 > plp ;restore status
+ >
+0878 : a50a > lda zpt
+087a : c904 > cmp #(1<<2)
+ > trap_ne ;zp altered
+087c : d0fe > bne * ;failed not equal (non zero)
+ >
+087e : a9fb > lda #$ff-(1<<2) ;testing 1 bit off
+0880 : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+0882 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0884 : 48 > pha ;use stack to load status
+0885 : a933 > lda #$33 ;precharge accu
+0887 : 28 > plp
+ >
+0888 : af0a06 > bbs 2,zpt,fail30266
+088b : 2f0a06 > bbr 2,zpt,ok30266
+ > trap ;bbr branch not taken
+088e : 4c8e08 > jmp * ;failed anyway
+ >
+0891 : >fail30266
+ > trap ;bbs branch taken
+0891 : 4c9108 > jmp * ;failed anyway
+ >
+0894 : >ok30266
+ > tst_a $33,0
+0894 : 08 > php ;save flags
+0895 : c933 > cmp #$33 ;test result
+ > trap_ne
+0897 : d0fe > bne * ;failed not equal (non zero)
+ >
+0899 : 68 > pla ;load status
+089a : 48 > pha
+ > cmp_flag 0
+089b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+089d : d0fe > bne * ;failed not equal (non zero)
+ >
+089f : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+08a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+08a2 : 48 > pha ;use stack to load status
+08a3 : a9cc > lda #$cc ;precharge accu
+08a5 : 28 > plp
+ >
+08a6 : af0a06 > bbs 2,zpt,fail40266
+08a9 : 2f0a06 > bbr 2,zpt,ok40266
+ > trap ;bbr branch not taken
+08ac : 4cac08 > jmp * ;failed anyway
+ >
+08af : >fail40266
+ > trap ;bbs branch taken
+08af : 4caf08 > jmp * ;failed anyway
+ >
+08b2 : >ok40266
+ > tst_a $cc,$ff
+08b2 : 08 > php ;save flags
+08b3 : c9cc > cmp #$cc ;test result
+ > trap_ne
+08b5 : d0fe > bne * ;failed not equal (non zero)
+ >
+08b7 : 68 > pla ;load status
+08b8 : 48 > pha
+ > cmp_flag $ff
+08b9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+08bb : d0fe > bne * ;failed not equal (non zero)
+ >
+08bd : 28 > plp ;restore status
+ >
+08be : a50a > lda zpt
+08c0 : c9fb > cmp #$ff-(1<<2)
+ > trap_ne ;zp altered
+08c2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ bbt 3
+08c4 : a908 > lda #(1<<3) ;testing 1 bit on
+08c6 : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+08c8 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+08ca : 48 > pha ;use stack to load status
+08cb : a933 > lda #$33 ;precharge accu
+08cd : 28 > plp
+ >
+08ce : 3f0a06 > bbr 3,zpt,fail10301
+08d1 : bf0a06 > bbs 3,zpt,ok10301
+ > trap ;bbs branch not taken
+08d4 : 4cd408 > jmp * ;failed anyway
+ >
+08d7 : >fail10301
+ > trap ;bbr branch taken
+08d7 : 4cd708 > jmp * ;failed anyway
+ >
+08da : >ok10301
+ > tst_a $33,0
+08da : 08 > php ;save flags
+08db : c933 > cmp #$33 ;test result
+ > trap_ne
+08dd : d0fe > bne * ;failed not equal (non zero)
+ >
+08df : 68 > pla ;load status
+08e0 : 48 > pha
+ > cmp_flag 0
+08e1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+08e3 : d0fe > bne * ;failed not equal (non zero)
+ >
+08e5 : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+08e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+08e8 : 48 > pha ;use stack to load status
+08e9 : a9cc > lda #$cc ;precharge accu
+08eb : 28 > plp
+ >
+08ec : 3f0a06 > bbr 3,zpt,fail20301
+08ef : bf0a06 > bbs 3,zpt,ok20301
+ > trap ;bbs branch not taken
+08f2 : 4cf208 > jmp * ;failed anyway
+ >
+08f5 : >fail20301
+ > trap ;bbr branch taken
+08f5 : 4cf508 > jmp * ;failed anyway
+ >
+08f8 : >ok20301
+ > tst_a $cc,$ff
+08f8 : 08 > php ;save flags
+08f9 : c9cc > cmp #$cc ;test result
+ > trap_ne
+08fb : d0fe > bne * ;failed not equal (non zero)
+ >
+08fd : 68 > pla ;load status
+08fe : 48 > pha
+ > cmp_flag $ff
+08ff : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0901 : d0fe > bne * ;failed not equal (non zero)
+ >
+0903 : 28 > plp ;restore status
+ >
+0904 : a50a > lda zpt
+0906 : c908 > cmp #(1<<3)
+ > trap_ne ;zp altered
+0908 : d0fe > bne * ;failed not equal (non zero)
+ >
+090a : a9f7 > lda #$ff-(1<<3) ;testing 1 bit off
+090c : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+090e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0910 : 48 > pha ;use stack to load status
+0911 : a933 > lda #$33 ;precharge accu
+0913 : 28 > plp
+ >
+0914 : bf0a06 > bbs 3,zpt,fail30301
+0917 : 3f0a06 > bbr 3,zpt,ok30301
+ > trap ;bbr branch not taken
+091a : 4c1a09 > jmp * ;failed anyway
+ >
+091d : >fail30301
+ > trap ;bbs branch taken
+091d : 4c1d09 > jmp * ;failed anyway
+ >
+0920 : >ok30301
+ > tst_a $33,0
+0920 : 08 > php ;save flags
+0921 : c933 > cmp #$33 ;test result
+ > trap_ne
+0923 : d0fe > bne * ;failed not equal (non zero)
+ >
+0925 : 68 > pla ;load status
+0926 : 48 > pha
+ > cmp_flag 0
+0927 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0929 : d0fe > bne * ;failed not equal (non zero)
+ >
+092b : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+092c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+092e : 48 > pha ;use stack to load status
+092f : a9cc > lda #$cc ;precharge accu
+0931 : 28 > plp
+ >
+0932 : bf0a06 > bbs 3,zpt,fail40301
+0935 : 3f0a06 > bbr 3,zpt,ok40301
+ > trap ;bbr branch not taken
+0938 : 4c3809 > jmp * ;failed anyway
+ >
+093b : >fail40301
+ > trap ;bbs branch taken
+093b : 4c3b09 > jmp * ;failed anyway
+ >
+093e : >ok40301
+ > tst_a $cc,$ff
+093e : 08 > php ;save flags
+093f : c9cc > cmp #$cc ;test result
+ > trap_ne
+0941 : d0fe > bne * ;failed not equal (non zero)
+ >
+0943 : 68 > pla ;load status
+0944 : 48 > pha
+ > cmp_flag $ff
+0945 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0947 : d0fe > bne * ;failed not equal (non zero)
+ >
+0949 : 28 > plp ;restore status
+ >
+094a : a50a > lda zpt
+094c : c9f7 > cmp #$ff-(1<<3)
+ > trap_ne ;zp altered
+094e : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ bbt 4
+0950 : a910 > lda #(1<<4) ;testing 1 bit on
+0952 : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+0954 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0956 : 48 > pha ;use stack to load status
+0957 : a933 > lda #$33 ;precharge accu
+0959 : 28 > plp
+ >
+095a : 4f0a06 > bbr 4,zpt,fail10336
+095d : cf0a06 > bbs 4,zpt,ok10336
+ > trap ;bbs branch not taken
+0960 : 4c6009 > jmp * ;failed anyway
+ >
+0963 : >fail10336
+ > trap ;bbr branch taken
+0963 : 4c6309 > jmp * ;failed anyway
+ >
+0966 : >ok10336
+ > tst_a $33,0
+0966 : 08 > php ;save flags
+0967 : c933 > cmp #$33 ;test result
+ > trap_ne
+0969 : d0fe > bne * ;failed not equal (non zero)
+ >
+096b : 68 > pla ;load status
+096c : 48 > pha
+ > cmp_flag 0
+096d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+096f : d0fe > bne * ;failed not equal (non zero)
+ >
+0971 : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+0972 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0974 : 48 > pha ;use stack to load status
+0975 : a9cc > lda #$cc ;precharge accu
+0977 : 28 > plp
+ >
+0978 : 4f0a06 > bbr 4,zpt,fail20336
+097b : cf0a06 > bbs 4,zpt,ok20336
+ > trap ;bbs branch not taken
+097e : 4c7e09 > jmp * ;failed anyway
+ >
+0981 : >fail20336
+ > trap ;bbr branch taken
+0981 : 4c8109 > jmp * ;failed anyway
+ >
+0984 : >ok20336
+ > tst_a $cc,$ff
+0984 : 08 > php ;save flags
+0985 : c9cc > cmp #$cc ;test result
+ > trap_ne
+0987 : d0fe > bne * ;failed not equal (non zero)
+ >
+0989 : 68 > pla ;load status
+098a : 48 > pha
+ > cmp_flag $ff
+098b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+098d : d0fe > bne * ;failed not equal (non zero)
+ >
+098f : 28 > plp ;restore status
+ >
+0990 : a50a > lda zpt
+0992 : c910 > cmp #(1<<4)
+ > trap_ne ;zp altered
+0994 : d0fe > bne * ;failed not equal (non zero)
+ >
+0996 : a9ef > lda #$ff-(1<<4) ;testing 1 bit off
+0998 : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+099a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+099c : 48 > pha ;use stack to load status
+099d : a933 > lda #$33 ;precharge accu
+099f : 28 > plp
+ >
+09a0 : cf0a06 > bbs 4,zpt,fail30336
+09a3 : 4f0a06 > bbr 4,zpt,ok30336
+ > trap ;bbr branch not taken
+09a6 : 4ca609 > jmp * ;failed anyway
+ >
+09a9 : >fail30336
+ > trap ;bbs branch taken
+09a9 : 4ca909 > jmp * ;failed anyway
+ >
+09ac : >ok30336
+ > tst_a $33,0
+09ac : 08 > php ;save flags
+09ad : c933 > cmp #$33 ;test result
+ > trap_ne
+09af : d0fe > bne * ;failed not equal (non zero)
+ >
+09b1 : 68 > pla ;load status
+09b2 : 48 > pha
+ > cmp_flag 0
+09b3 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+09b5 : d0fe > bne * ;failed not equal (non zero)
+ >
+09b7 : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+09b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+09ba : 48 > pha ;use stack to load status
+09bb : a9cc > lda #$cc ;precharge accu
+09bd : 28 > plp
+ >
+09be : cf0a06 > bbs 4,zpt,fail40336
+09c1 : 4f0a06 > bbr 4,zpt,ok40336
+ > trap ;bbr branch not taken
+09c4 : 4cc409 > jmp * ;failed anyway
+ >
+09c7 : >fail40336
+ > trap ;bbs branch taken
+09c7 : 4cc709 > jmp * ;failed anyway
+ >
+09ca : >ok40336
+ > tst_a $cc,$ff
+09ca : 08 > php ;save flags
+09cb : c9cc > cmp #$cc ;test result
+ > trap_ne
+09cd : d0fe > bne * ;failed not equal (non zero)
+ >
+09cf : 68 > pla ;load status
+09d0 : 48 > pha
+ > cmp_flag $ff
+09d1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+09d3 : d0fe > bne * ;failed not equal (non zero)
+ >
+09d5 : 28 > plp ;restore status
+ >
+09d6 : a50a > lda zpt
+09d8 : c9ef > cmp #$ff-(1<<4)
+ > trap_ne ;zp altered
+09da : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ bbt 5
+09dc : a920 > lda #(1<<5) ;testing 1 bit on
+09de : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+09e0 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+09e2 : 48 > pha ;use stack to load status
+09e3 : a933 > lda #$33 ;precharge accu
+09e5 : 28 > plp
+ >
+09e6 : 5f0a06 > bbr 5,zpt,fail10371
+09e9 : df0a06 > bbs 5,zpt,ok10371
+ > trap ;bbs branch not taken
+09ec : 4cec09 > jmp * ;failed anyway
+ >
+09ef : >fail10371
+ > trap ;bbr branch taken
+09ef : 4cef09 > jmp * ;failed anyway
+ >
+09f2 : >ok10371
+ > tst_a $33,0
+09f2 : 08 > php ;save flags
+09f3 : c933 > cmp #$33 ;test result
+ > trap_ne
+09f5 : d0fe > bne * ;failed not equal (non zero)
+ >
+09f7 : 68 > pla ;load status
+09f8 : 48 > pha
+ > cmp_flag 0
+09f9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+09fb : d0fe > bne * ;failed not equal (non zero)
+ >
+09fd : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+09fe : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0a00 : 48 > pha ;use stack to load status
+0a01 : a9cc > lda #$cc ;precharge accu
+0a03 : 28 > plp
+ >
+0a04 : 5f0a06 > bbr 5,zpt,fail20371
+0a07 : df0a06 > bbs 5,zpt,ok20371
+ > trap ;bbs branch not taken
+0a0a : 4c0a0a > jmp * ;failed anyway
+ >
+0a0d : >fail20371
+ > trap ;bbr branch taken
+0a0d : 4c0d0a > jmp * ;failed anyway
+ >
+0a10 : >ok20371
+ > tst_a $cc,$ff
+0a10 : 08 > php ;save flags
+0a11 : c9cc > cmp #$cc ;test result
+ > trap_ne
+0a13 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a15 : 68 > pla ;load status
+0a16 : 48 > pha
+ > cmp_flag $ff
+0a17 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a19 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a1b : 28 > plp ;restore status
+ >
+0a1c : a50a > lda zpt
+0a1e : c920 > cmp #(1<<5)
+ > trap_ne ;zp altered
+0a20 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a22 : a9df > lda #$ff-(1<<5) ;testing 1 bit off
+0a24 : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+0a26 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0a28 : 48 > pha ;use stack to load status
+0a29 : a933 > lda #$33 ;precharge accu
+0a2b : 28 > plp
+ >
+0a2c : df0a06 > bbs 5,zpt,fail30371
+0a2f : 5f0a06 > bbr 5,zpt,ok30371
+ > trap ;bbr branch not taken
+0a32 : 4c320a > jmp * ;failed anyway
+ >
+0a35 : >fail30371
+ > trap ;bbs branch taken
+0a35 : 4c350a > jmp * ;failed anyway
+ >
+0a38 : >ok30371
+ > tst_a $33,0
+0a38 : 08 > php ;save flags
+0a39 : c933 > cmp #$33 ;test result
+ > trap_ne
+0a3b : d0fe > bne * ;failed not equal (non zero)
+ >
+0a3d : 68 > pla ;load status
+0a3e : 48 > pha
+ > cmp_flag 0
+0a3f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a41 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a43 : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+0a44 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0a46 : 48 > pha ;use stack to load status
+0a47 : a9cc > lda #$cc ;precharge accu
+0a49 : 28 > plp
+ >
+0a4a : df0a06 > bbs 5,zpt,fail40371
+0a4d : 5f0a06 > bbr 5,zpt,ok40371
+ > trap ;bbr branch not taken
+0a50 : 4c500a > jmp * ;failed anyway
+ >
+0a53 : >fail40371
+ > trap ;bbs branch taken
+0a53 : 4c530a > jmp * ;failed anyway
+ >
+0a56 : >ok40371
+ > tst_a $cc,$ff
+0a56 : 08 > php ;save flags
+0a57 : c9cc > cmp #$cc ;test result
+ > trap_ne
+0a59 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a5b : 68 > pla ;load status
+0a5c : 48 > pha
+ > cmp_flag $ff
+0a5d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a5f : d0fe > bne * ;failed not equal (non zero)
+ >
+0a61 : 28 > plp ;restore status
+ >
+0a62 : a50a > lda zpt
+0a64 : c9df > cmp #$ff-(1<<5)
+ > trap_ne ;zp altered
+0a66 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ bbt 6
+0a68 : a940 > lda #(1<<6) ;testing 1 bit on
+0a6a : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+0a6c : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0a6e : 48 > pha ;use stack to load status
+0a6f : a933 > lda #$33 ;precharge accu
+0a71 : 28 > plp
+ >
+0a72 : 6f0a06 > bbr 6,zpt,fail10406
+0a75 : ef0a06 > bbs 6,zpt,ok10406
+ > trap ;bbs branch not taken
+0a78 : 4c780a > jmp * ;failed anyway
+ >
+0a7b : >fail10406
+ > trap ;bbr branch taken
+0a7b : 4c7b0a > jmp * ;failed anyway
+ >
+0a7e : >ok10406
+ > tst_a $33,0
+0a7e : 08 > php ;save flags
+0a7f : c933 > cmp #$33 ;test result
+ > trap_ne
+0a81 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a83 : 68 > pla ;load status
+0a84 : 48 > pha
+ > cmp_flag 0
+0a85 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0a87 : d0fe > bne * ;failed not equal (non zero)
+ >
+0a89 : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+0a8a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0a8c : 48 > pha ;use stack to load status
+0a8d : a9cc > lda #$cc ;precharge accu
+0a8f : 28 > plp
+ >
+0a90 : 6f0a06 > bbr 6,zpt,fail20406
+0a93 : ef0a06 > bbs 6,zpt,ok20406
+ > trap ;bbs branch not taken
+0a96 : 4c960a > jmp * ;failed anyway
+ >
+0a99 : >fail20406
+ > trap ;bbr branch taken
+0a99 : 4c990a > jmp * ;failed anyway
+ >
+0a9c : >ok20406
+ > tst_a $cc,$ff
+0a9c : 08 > php ;save flags
+0a9d : c9cc > cmp #$cc ;test result
+ > trap_ne
+0a9f : d0fe > bne * ;failed not equal (non zero)
+ >
+0aa1 : 68 > pla ;load status
+0aa2 : 48 > pha
+ > cmp_flag $ff
+0aa3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0aa5 : d0fe > bne * ;failed not equal (non zero)
+ >
+0aa7 : 28 > plp ;restore status
+ >
+0aa8 : a50a > lda zpt
+0aaa : c940 > cmp #(1<<6)
+ > trap_ne ;zp altered
+0aac : d0fe > bne * ;failed not equal (non zero)
+ >
+0aae : a9bf > lda #$ff-(1<<6) ;testing 1 bit off
+0ab0 : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+0ab2 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0ab4 : 48 > pha ;use stack to load status
+0ab5 : a933 > lda #$33 ;precharge accu
+0ab7 : 28 > plp
+ >
+0ab8 : ef0a06 > bbs 6,zpt,fail30406
+0abb : 6f0a06 > bbr 6,zpt,ok30406
+ > trap ;bbr branch not taken
+0abe : 4cbe0a > jmp * ;failed anyway
+ >
+0ac1 : >fail30406
+ > trap ;bbs branch taken
+0ac1 : 4cc10a > jmp * ;failed anyway
+ >
+0ac4 : >ok30406
+ > tst_a $33,0
+0ac4 : 08 > php ;save flags
+0ac5 : c933 > cmp #$33 ;test result
+ > trap_ne
+0ac7 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ac9 : 68 > pla ;load status
+0aca : 48 > pha
+ > cmp_flag 0
+0acb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0acd : d0fe > bne * ;failed not equal (non zero)
+ >
+0acf : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+0ad0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0ad2 : 48 > pha ;use stack to load status
+0ad3 : a9cc > lda #$cc ;precharge accu
+0ad5 : 28 > plp
+ >
+0ad6 : ef0a06 > bbs 6,zpt,fail40406
+0ad9 : 6f0a06 > bbr 6,zpt,ok40406
+ > trap ;bbr branch not taken
+0adc : 4cdc0a > jmp * ;failed anyway
+ >
+0adf : >fail40406
+ > trap ;bbs branch taken
+0adf : 4cdf0a > jmp * ;failed anyway
+ >
+0ae2 : >ok40406
+ > tst_a $cc,$ff
+0ae2 : 08 > php ;save flags
+0ae3 : c9cc > cmp #$cc ;test result
+ > trap_ne
+0ae5 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ae7 : 68 > pla ;load status
+0ae8 : 48 > pha
+ > cmp_flag $ff
+0ae9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0aeb : d0fe > bne * ;failed not equal (non zero)
+ >
+0aed : 28 > plp ;restore status
+ >
+0aee : a50a > lda zpt
+0af0 : c9bf > cmp #$ff-(1<<6)
+ > trap_ne ;zp altered
+0af2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ bbt 7
+0af4 : a980 > lda #(1<<7) ;testing 1 bit on
+0af6 : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+0af8 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0afa : 48 > pha ;use stack to load status
+0afb : a933 > lda #$33 ;precharge accu
+0afd : 28 > plp
+ >
+0afe : 7f0a06 > bbr 7,zpt,fail10441
+0b01 : ff0a06 > bbs 7,zpt,ok10441
+ > trap ;bbs branch not taken
+0b04 : 4c040b > jmp * ;failed anyway
+ >
+0b07 : >fail10441
+ > trap ;bbr branch taken
+0b07 : 4c070b > jmp * ;failed anyway
+ >
+0b0a : >ok10441
+ > tst_a $33,0
+0b0a : 08 > php ;save flags
+0b0b : c933 > cmp #$33 ;test result
+ > trap_ne
+0b0d : d0fe > bne * ;failed not equal (non zero)
+ >
+0b0f : 68 > pla ;load status
+0b10 : 48 > pha
+ > cmp_flag 0
+0b11 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b13 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b15 : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+0b16 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0b18 : 48 > pha ;use stack to load status
+0b19 : a9cc > lda #$cc ;precharge accu
+0b1b : 28 > plp
+ >
+0b1c : 7f0a06 > bbr 7,zpt,fail20441
+0b1f : ff0a06 > bbs 7,zpt,ok20441
+ > trap ;bbs branch not taken
+0b22 : 4c220b > jmp * ;failed anyway
+ >
+0b25 : >fail20441
+ > trap ;bbr branch taken
+0b25 : 4c250b > jmp * ;failed anyway
+ >
+0b28 : >ok20441
+ > tst_a $cc,$ff
+0b28 : 08 > php ;save flags
+0b29 : c9cc > cmp #$cc ;test result
+ > trap_ne
+0b2b : d0fe > bne * ;failed not equal (non zero)
+ >
+0b2d : 68 > pla ;load status
+0b2e : 48 > pha
+ > cmp_flag $ff
+0b2f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b31 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b33 : 28 > plp ;restore status
+ >
+0b34 : a50a > lda zpt
+0b36 : c980 > cmp #(1<<7)
+ > trap_ne ;zp altered
+0b38 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b3a : a97f > lda #$ff-(1<<7) ;testing 1 bit off
+0b3c : 850a > sta zpt
+ > set_a $33,0 ;with flags off
+ > load_flag 0
+0b3e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0b40 : 48 > pha ;use stack to load status
+0b41 : a933 > lda #$33 ;precharge accu
+0b43 : 28 > plp
+ >
+0b44 : ff0a06 > bbs 7,zpt,fail30441
+0b47 : 7f0a06 > bbr 7,zpt,ok30441
+ > trap ;bbr branch not taken
+0b4a : 4c4a0b > jmp * ;failed anyway
+ >
+0b4d : >fail30441
+ > trap ;bbs branch taken
+0b4d : 4c4d0b > jmp * ;failed anyway
+ >
+0b50 : >ok30441
+ > tst_a $33,0
+0b50 : 08 > php ;save flags
+0b51 : c933 > cmp #$33 ;test result
+ > trap_ne
+0b53 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b55 : 68 > pla ;load status
+0b56 : 48 > pha
+ > cmp_flag 0
+0b57 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b59 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b5b : 28 > plp ;restore status
+ >
+ > set_a $cc,$ff ;with flags on
+ > load_flag $ff
+0b5c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0b5e : 48 > pha ;use stack to load status
+0b5f : a9cc > lda #$cc ;precharge accu
+0b61 : 28 > plp
+ >
+0b62 : ff0a06 > bbs 7,zpt,fail40441
+0b65 : 7f0a06 > bbr 7,zpt,ok40441
+ > trap ;bbr branch not taken
+0b68 : 4c680b > jmp * ;failed anyway
+ >
+0b6b : >fail40441
+ > trap ;bbs branch taken
+0b6b : 4c6b0b > jmp * ;failed anyway
+ >
+0b6e : >ok40441
+ > tst_a $cc,$ff
+0b6e : 08 > php ;save flags
+0b6f : c9cc > cmp #$cc ;test result
+ > trap_ne
+0b71 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b73 : 68 > pla ;load status
+0b74 : 48 > pha
+ > cmp_flag $ff
+0b75 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0b77 : d0fe > bne * ;failed not equal (non zero)
+ >
+0b79 : 28 > plp ;restore status
+ >
+0b7a : a50a > lda zpt
+0b7c : c97f > cmp #$ff-(1<<7)
+ > trap_ne ;zp altered
+0b7e : d0fe > bne * ;failed not equal (non zero)
+ >
+
+0b80 : e011 cpx #$11
+ trap_ne ;x overwritten
+0b82 : d0fe > bne * ;failed not equal (non zero)
+
+0b84 : c022 cpy #$22
+ trap_ne ;y overwritten
+0b86 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+0b88 : ad0202 > lda test_case ;previous test
+0b8b : c906 > cmp #test_num
+ > trap_ne ;test is out of sequence
+0b8d : d0fe > bne * ;failed not equal (non zero)
+ >
+0007 = >test_num = test_num + 1
+0b8f : a907 > lda #test_num ;*** next tests' number
+0b91 : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ bbrc macro ;\1 = bitnum
+ bbr \1,zpt,skip\?
+ eor #(1<<\1)
+ skip\?
+ endm
+ bbsc macro ;\1 = bitnum
+ bbs \1,zpt,skip\?
+ eor #(1<<\1)
+ skip\?
+ endm
+
+0b94 : a900 lda #0 ;combined bit test
+0b96 : 850a sta zpt
+0b98 : a900 bbcl lda #0
+ bbrc 0
+0b9a : 0f0a02 > bbr 0,zpt,skip0480
+0b9d : 4901 > eor #(1<<0)
+0b9f : >skip0480
+
+ bbrc 1
+0b9f : 1f0a02 > bbr 1,zpt,skip0481
+0ba2 : 4902 > eor #(1<<1)
+0ba4 : >skip0481
+
+ bbrc 2
+0ba4 : 2f0a02 > bbr 2,zpt,skip0482
+0ba7 : 4904 > eor #(1<<2)
+0ba9 : >skip0482
+
+ bbrc 3
+0ba9 : 3f0a02 > bbr 3,zpt,skip0483
+0bac : 4908 > eor #(1<<3)
+0bae : >skip0483
+
+ bbrc 4
+0bae : 4f0a02 > bbr 4,zpt,skip0484
+0bb1 : 4910 > eor #(1<<4)
+0bb3 : >skip0484
+
+ bbrc 5
+0bb3 : 5f0a02 > bbr 5,zpt,skip0485
+0bb6 : 4920 > eor #(1<<5)
+0bb8 : >skip0485
+
+ bbrc 6
+0bb8 : 6f0a02 > bbr 6,zpt,skip0486
+0bbb : 4940 > eor #(1<<6)
+0bbd : >skip0486
+
+ bbrc 7
+0bbd : 7f0a02 > bbr 7,zpt,skip0487
+0bc0 : 4980 > eor #(1<<7)
+0bc2 : >skip0487
+
+0bc2 : 450a eor zpt
+ trap_ne ;failed bbr bitnum in accu
+0bc4 : d0fe > bne * ;failed not equal (non zero)
+
+0bc6 : a9ff lda #$ff
+ bbsc 0
+0bc8 : 8f0a02 > bbs 0,zpt,skip0489
+0bcb : 4901 > eor #(1<<0)
+0bcd : >skip0489
+
+ bbsc 1
+0bcd : 9f0a02 > bbs 1,zpt,skip0490
+0bd0 : 4902 > eor #(1<<1)
+0bd2 : >skip0490
+
+ bbsc 2
+0bd2 : af0a02 > bbs 2,zpt,skip0491
+0bd5 : 4904 > eor #(1<<2)
+0bd7 : >skip0491
+
+ bbsc 3
+0bd7 : bf0a02 > bbs 3,zpt,skip0492
+0bda : 4908 > eor #(1<<3)
+0bdc : >skip0492
+
+ bbsc 4
+0bdc : cf0a02 > bbs 4,zpt,skip0493
+0bdf : 4910 > eor #(1<<4)
+0be1 : >skip0493
+
+ bbsc 5
+0be1 : df0a02 > bbs 5,zpt,skip0494
+0be4 : 4920 > eor #(1<<5)
+0be6 : >skip0494
+
+ bbsc 6
+0be6 : ef0a02 > bbs 6,zpt,skip0495
+0be9 : 4940 > eor #(1<<6)
+0beb : >skip0495
+
+ bbsc 7
+0beb : ff0a02 > bbs 7,zpt,skip0496
+0bee : 4980 > eor #(1<<7)
+0bf0 : >skip0496
+
+0bf0 : 450a eor zpt
+ trap_ne ;failed bbs bitnum in accu
+0bf2 : d0fe > bne * ;failed not equal (non zero)
+
+0bf4 : e60a inc zpt
+0bf6 : d0a0 bne bbcl
+ next_test
+0bf8 : ad0202 > lda test_case ;previous test
+0bfb : c907 > cmp #test_num
+ > trap_ne ;test is out of sequence
+0bfd : d0fe > bne * ;failed not equal (non zero)
+ >
+0008 = >test_num = test_num + 1
+0bff : a908 > lda #test_num ;*** next tests' number
+0c01 : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+ endif
+
+ ; testing NOP
+
+ nop_test macro ;\1 = opcode, \2 = # of bytes
+ ldy #$42
+ ldx #4-\2
+ db \1 ;test nop length
+ if \2 = 1
+ dex
+ dex
+ endif
+ if \2 = 2
+ iny
+ dex
+ endif
+ if \2 = 3
+ iny
+ iny
+ endif
+ dex
+ trap_ne ;wrong number of bytes
+ set_a $ff-\1,0
+ db \1 ;test nop integrity - flags off
+ nop
+ nop
+ tst_a $ff-\1,0
+ set_a $aa-\1,$ff
+ db \1 ;test nop integrity - flags on
+ nop
+ nop
+ tst_a $aa-\1,$ff
+ cpy #$42
+ trap_ne ;y changed
+ cpx #0
+ trap_ne ;x changed
+ endm
+
+ nop_test $02,2
+0c04 : a042 > ldy #$42
+0c06 : a202 > ldx #4-2
+0c08 : 02 > db $02 ;test nop length
+ > if 2 = 1
+ > dex
+ > dex
+ > endif
+ > if 2 = 2
+0c09 : c8 > iny
+0c0a : ca > dex
+ > endif
+ > if 2 = 3
+ > iny
+ > iny
+ > endif
+0c0b : ca > dex
+ > trap_ne ;wrong number of bytes
+0c0c : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$02,0
+ > load_flag 0
+0c0e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0c10 : 48 > pha ;use stack to load status
+0c11 : a9fd > lda #$ff-$02 ;precharge accu
+0c13 : 28 > plp
+ >
+0c14 : 02 > db $02 ;test nop integrity - flags off
+0c15 : ea > nop
+0c16 : ea > nop
+ > tst_a $ff-$02,0
+0c17 : 08 > php ;save flags
+0c18 : c9fd > cmp #$ff-$02 ;test result
+ > trap_ne
+0c1a : d0fe > bne * ;failed not equal (non zero)
+ >
+0c1c : 68 > pla ;load status
+0c1d : 48 > pha
+ > cmp_flag 0
+0c1e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c20 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c22 : 28 > plp ;restore status
+ >
+ > set_a $aa-$02,$ff
+ > load_flag $ff
+0c23 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0c25 : 48 > pha ;use stack to load status
+0c26 : a9a8 > lda #$aa-$02 ;precharge accu
+0c28 : 28 > plp
+ >
+0c29 : 02 > db $02 ;test nop integrity - flags on
+0c2a : ea > nop
+0c2b : ea > nop
+ > tst_a $aa-$02,$ff
+0c2c : 08 > php ;save flags
+0c2d : c9a8 > cmp #$aa-$02 ;test result
+ > trap_ne
+0c2f : d0fe > bne * ;failed not equal (non zero)
+ >
+0c31 : 68 > pla ;load status
+0c32 : 48 > pha
+ > cmp_flag $ff
+0c33 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c35 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c37 : 28 > plp ;restore status
+ >
+0c38 : c042 > cpy #$42
+ > trap_ne ;y changed
+0c3a : d0fe > bne * ;failed not equal (non zero)
+ >
+0c3c : e000 > cpx #0
+ > trap_ne ;x changed
+0c3e : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $22,2
+0c40 : a042 > ldy #$42
+0c42 : a202 > ldx #4-2
+0c44 : 22 > db $22 ;test nop length
+ > if 2 = 1
+ > dex
+ > dex
+ > endif
+ > if 2 = 2
+0c45 : c8 > iny
+0c46 : ca > dex
+ > endif
+ > if 2 = 3
+ > iny
+ > iny
+ > endif
+0c47 : ca > dex
+ > trap_ne ;wrong number of bytes
+0c48 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$22,0
+ > load_flag 0
+0c4a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0c4c : 48 > pha ;use stack to load status
+0c4d : a9dd > lda #$ff-$22 ;precharge accu
+0c4f : 28 > plp
+ >
+0c50 : 22 > db $22 ;test nop integrity - flags off
+0c51 : ea > nop
+0c52 : ea > nop
+ > tst_a $ff-$22,0
+0c53 : 08 > php ;save flags
+0c54 : c9dd > cmp #$ff-$22 ;test result
+ > trap_ne
+0c56 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c58 : 68 > pla ;load status
+0c59 : 48 > pha
+ > cmp_flag 0
+0c5a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c5c : d0fe > bne * ;failed not equal (non zero)
+ >
+0c5e : 28 > plp ;restore status
+ >
+ > set_a $aa-$22,$ff
+ > load_flag $ff
+0c5f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0c61 : 48 > pha ;use stack to load status
+0c62 : a988 > lda #$aa-$22 ;precharge accu
+0c64 : 28 > plp
+ >
+0c65 : 22 > db $22 ;test nop integrity - flags on
+0c66 : ea > nop
+0c67 : ea > nop
+ > tst_a $aa-$22,$ff
+0c68 : 08 > php ;save flags
+0c69 : c988 > cmp #$aa-$22 ;test result
+ > trap_ne
+0c6b : d0fe > bne * ;failed not equal (non zero)
+ >
+0c6d : 68 > pla ;load status
+0c6e : 48 > pha
+ > cmp_flag $ff
+0c6f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c71 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c73 : 28 > plp ;restore status
+ >
+0c74 : c042 > cpy #$42
+ > trap_ne ;y changed
+0c76 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c78 : e000 > cpx #0
+ > trap_ne ;x changed
+0c7a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $42,2
+0c7c : a042 > ldy #$42
+0c7e : a202 > ldx #4-2
+0c80 : 42 > db $42 ;test nop length
+ > if 2 = 1
+ > dex
+ > dex
+ > endif
+ > if 2 = 2
+0c81 : c8 > iny
+0c82 : ca > dex
+ > endif
+ > if 2 = 3
+ > iny
+ > iny
+ > endif
+0c83 : ca > dex
+ > trap_ne ;wrong number of bytes
+0c84 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$42,0
+ > load_flag 0
+0c86 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0c88 : 48 > pha ;use stack to load status
+0c89 : a9bd > lda #$ff-$42 ;precharge accu
+0c8b : 28 > plp
+ >
+0c8c : 42 > db $42 ;test nop integrity - flags off
+0c8d : ea > nop
+0c8e : ea > nop
+ > tst_a $ff-$42,0
+0c8f : 08 > php ;save flags
+0c90 : c9bd > cmp #$ff-$42 ;test result
+ > trap_ne
+0c92 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c94 : 68 > pla ;load status
+0c95 : 48 > pha
+ > cmp_flag 0
+0c96 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0c98 : d0fe > bne * ;failed not equal (non zero)
+ >
+0c9a : 28 > plp ;restore status
+ >
+ > set_a $aa-$42,$ff
+ > load_flag $ff
+0c9b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0c9d : 48 > pha ;use stack to load status
+0c9e : a968 > lda #$aa-$42 ;precharge accu
+0ca0 : 28 > plp
+ >
+0ca1 : 42 > db $42 ;test nop integrity - flags on
+0ca2 : ea > nop
+0ca3 : ea > nop
+ > tst_a $aa-$42,$ff
+0ca4 : 08 > php ;save flags
+0ca5 : c968 > cmp #$aa-$42 ;test result
+ > trap_ne
+0ca7 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ca9 : 68 > pla ;load status
+0caa : 48 > pha
+ > cmp_flag $ff
+0cab : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0cad : d0fe > bne * ;failed not equal (non zero)
+ >
+0caf : 28 > plp ;restore status
+ >
+0cb0 : c042 > cpy #$42
+ > trap_ne ;y changed
+0cb2 : d0fe > bne * ;failed not equal (non zero)
+ >
+0cb4 : e000 > cpx #0
+ > trap_ne ;x changed
+0cb6 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $62,2
+0cb8 : a042 > ldy #$42
+0cba : a202 > ldx #4-2
+0cbc : 62 > db $62 ;test nop length
+ > if 2 = 1
+ > dex
+ > dex
+ > endif
+ > if 2 = 2
+0cbd : c8 > iny
+0cbe : ca > dex
+ > endif
+ > if 2 = 3
+ > iny
+ > iny
+ > endif
+0cbf : ca > dex
+ > trap_ne ;wrong number of bytes
+0cc0 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$62,0
+ > load_flag 0
+0cc2 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0cc4 : 48 > pha ;use stack to load status
+0cc5 : a99d > lda #$ff-$62 ;precharge accu
+0cc7 : 28 > plp
+ >
+0cc8 : 62 > db $62 ;test nop integrity - flags off
+0cc9 : ea > nop
+0cca : ea > nop
+ > tst_a $ff-$62,0
+0ccb : 08 > php ;save flags
+0ccc : c99d > cmp #$ff-$62 ;test result
+ > trap_ne
+0cce : d0fe > bne * ;failed not equal (non zero)
+ >
+0cd0 : 68 > pla ;load status
+0cd1 : 48 > pha
+ > cmp_flag 0
+0cd2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0cd4 : d0fe > bne * ;failed not equal (non zero)
+ >
+0cd6 : 28 > plp ;restore status
+ >
+ > set_a $aa-$62,$ff
+ > load_flag $ff
+0cd7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0cd9 : 48 > pha ;use stack to load status
+0cda : a948 > lda #$aa-$62 ;precharge accu
+0cdc : 28 > plp
+ >
+0cdd : 62 > db $62 ;test nop integrity - flags on
+0cde : ea > nop
+0cdf : ea > nop
+ > tst_a $aa-$62,$ff
+0ce0 : 08 > php ;save flags
+0ce1 : c948 > cmp #$aa-$62 ;test result
+ > trap_ne
+0ce3 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ce5 : 68 > pla ;load status
+0ce6 : 48 > pha
+ > cmp_flag $ff
+0ce7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0ce9 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ceb : 28 > plp ;restore status
+ >
+0cec : c042 > cpy #$42
+ > trap_ne ;y changed
+0cee : d0fe > bne * ;failed not equal (non zero)
+ >
+0cf0 : e000 > cpx #0
+ > trap_ne ;x changed
+0cf2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $82,2
+0cf4 : a042 > ldy #$42
+0cf6 : a202 > ldx #4-2
+0cf8 : 82 > db $82 ;test nop length
+ > if 2 = 1
+ > dex
+ > dex
+ > endif
+ > if 2 = 2
+0cf9 : c8 > iny
+0cfa : ca > dex
+ > endif
+ > if 2 = 3
+ > iny
+ > iny
+ > endif
+0cfb : ca > dex
+ > trap_ne ;wrong number of bytes
+0cfc : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$82,0
+ > load_flag 0
+0cfe : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0d00 : 48 > pha ;use stack to load status
+0d01 : a97d > lda #$ff-$82 ;precharge accu
+0d03 : 28 > plp
+ >
+0d04 : 82 > db $82 ;test nop integrity - flags off
+0d05 : ea > nop
+0d06 : ea > nop
+ > tst_a $ff-$82,0
+0d07 : 08 > php ;save flags
+0d08 : c97d > cmp #$ff-$82 ;test result
+ > trap_ne
+0d0a : d0fe > bne * ;failed not equal (non zero)
+ >
+0d0c : 68 > pla ;load status
+0d0d : 48 > pha
+ > cmp_flag 0
+0d0e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0d10 : d0fe > bne * ;failed not equal (non zero)
+ >
+0d12 : 28 > plp ;restore status
+ >
+ > set_a $aa-$82,$ff
+ > load_flag $ff
+0d13 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0d15 : 48 > pha ;use stack to load status
+0d16 : a928 > lda #$aa-$82 ;precharge accu
+0d18 : 28 > plp
+ >
+0d19 : 82 > db $82 ;test nop integrity - flags on
+0d1a : ea > nop
+0d1b : ea > nop
+ > tst_a $aa-$82,$ff
+0d1c : 08 > php ;save flags
+0d1d : c928 > cmp #$aa-$82 ;test result
+ > trap_ne
+0d1f : d0fe > bne * ;failed not equal (non zero)
+ >
+0d21 : 68 > pla ;load status
+0d22 : 48 > pha
+ > cmp_flag $ff
+0d23 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0d25 : d0fe > bne * ;failed not equal (non zero)
+ >
+0d27 : 28 > plp ;restore status
+ >
+0d28 : c042 > cpy #$42
+ > trap_ne ;y changed
+0d2a : d0fe > bne * ;failed not equal (non zero)
+ >
+0d2c : e000 > cpx #0
+ > trap_ne ;x changed
+0d2e : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $c2,2
+0d30 : a042 > ldy #$42
+0d32 : a202 > ldx #4-2
+0d34 : c2 > db $c2 ;test nop length
+ > if 2 = 1
+ > dex
+ > dex
+ > endif
+ > if 2 = 2
+0d35 : c8 > iny
+0d36 : ca > dex
+ > endif
+ > if 2 = 3
+ > iny
+ > iny
+ > endif
+0d37 : ca > dex
+ > trap_ne ;wrong number of bytes
+0d38 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$c2,0
+ > load_flag 0
+0d3a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0d3c : 48 > pha ;use stack to load status
+0d3d : a93d > lda #$ff-$c2 ;precharge accu
+0d3f : 28 > plp
+ >
+0d40 : c2 > db $c2 ;test nop integrity - flags off
+0d41 : ea > nop
+0d42 : ea > nop
+ > tst_a $ff-$c2,0
+0d43 : 08 > php ;save flags
+0d44 : c93d > cmp #$ff-$c2 ;test result
+ > trap_ne
+0d46 : d0fe > bne * ;failed not equal (non zero)
+ >
+0d48 : 68 > pla ;load status
+0d49 : 48 > pha
+ > cmp_flag 0
+0d4a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0d4c : d0fe > bne * ;failed not equal (non zero)
+ >
+0d4e : 28 > plp ;restore status
+ >
+ > set_a $aa-$c2,$ff
+ > load_flag $ff
+0d4f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0d51 : 48 > pha ;use stack to load status
+0d52 : a9e8 > lda #$aa-$c2 ;precharge accu
+0d54 : 28 > plp
+ >
+0d55 : c2 > db $c2 ;test nop integrity - flags on
+0d56 : ea > nop
+0d57 : ea > nop
+ > tst_a $aa-$c2,$ff
+0d58 : 08 > php ;save flags
+0d59 : c9e8 > cmp #$aa-$c2 ;test result
+ > trap_ne
+0d5b : d0fe > bne * ;failed not equal (non zero)
+ >
+0d5d : 68 > pla ;load status
+0d5e : 48 > pha
+ > cmp_flag $ff
+0d5f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0d61 : d0fe > bne * ;failed not equal (non zero)
+ >
+0d63 : 28 > plp ;restore status
+ >
+0d64 : c042 > cpy #$42
+ > trap_ne ;y changed
+0d66 : d0fe > bne * ;failed not equal (non zero)
+ >
+0d68 : e000 > cpx #0
+ > trap_ne ;x changed
+0d6a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $e2,2
+0d6c : a042 > ldy #$42
+0d6e : a202 > ldx #4-2
+0d70 : e2 > db $e2 ;test nop length
+ > if 2 = 1
+ > dex
+ > dex
+ > endif
+ > if 2 = 2
+0d71 : c8 > iny
+0d72 : ca > dex
+ > endif
+ > if 2 = 3
+ > iny
+ > iny
+ > endif
+0d73 : ca > dex
+ > trap_ne ;wrong number of bytes
+0d74 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$e2,0
+ > load_flag 0
+0d76 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0d78 : 48 > pha ;use stack to load status
+0d79 : a91d > lda #$ff-$e2 ;precharge accu
+0d7b : 28 > plp
+ >
+0d7c : e2 > db $e2 ;test nop integrity - flags off
+0d7d : ea > nop
+0d7e : ea > nop
+ > tst_a $ff-$e2,0
+0d7f : 08 > php ;save flags
+0d80 : c91d > cmp #$ff-$e2 ;test result
+ > trap_ne
+0d82 : d0fe > bne * ;failed not equal (non zero)
+ >
+0d84 : 68 > pla ;load status
+0d85 : 48 > pha
+ > cmp_flag 0
+0d86 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0d88 : d0fe > bne * ;failed not equal (non zero)
+ >
+0d8a : 28 > plp ;restore status
+ >
+ > set_a $aa-$e2,$ff
+ > load_flag $ff
+0d8b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0d8d : 48 > pha ;use stack to load status
+0d8e : a9c8 > lda #$aa-$e2 ;precharge accu
+0d90 : 28 > plp
+ >
+0d91 : e2 > db $e2 ;test nop integrity - flags on
+0d92 : ea > nop
+0d93 : ea > nop
+ > tst_a $aa-$e2,$ff
+0d94 : 08 > php ;save flags
+0d95 : c9c8 > cmp #$aa-$e2 ;test result
+ > trap_ne
+0d97 : d0fe > bne * ;failed not equal (non zero)
+ >
+0d99 : 68 > pla ;load status
+0d9a : 48 > pha
+ > cmp_flag $ff
+0d9b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0d9d : d0fe > bne * ;failed not equal (non zero)
+ >
+0d9f : 28 > plp ;restore status
+ >
+0da0 : c042 > cpy #$42
+ > trap_ne ;y changed
+0da2 : d0fe > bne * ;failed not equal (non zero)
+ >
+0da4 : e000 > cpx #0
+ > trap_ne ;x changed
+0da6 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $44,2
+0da8 : a042 > ldy #$42
+0daa : a202 > ldx #4-2
+0dac : 44 > db $44 ;test nop length
+ > if 2 = 1
+ > dex
+ > dex
+ > endif
+ > if 2 = 2
+0dad : c8 > iny
+0dae : ca > dex
+ > endif
+ > if 2 = 3
+ > iny
+ > iny
+ > endif
+0daf : ca > dex
+ > trap_ne ;wrong number of bytes
+0db0 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$44,0
+ > load_flag 0
+0db2 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0db4 : 48 > pha ;use stack to load status
+0db5 : a9bb > lda #$ff-$44 ;precharge accu
+0db7 : 28 > plp
+ >
+0db8 : 44 > db $44 ;test nop integrity - flags off
+0db9 : ea > nop
+0dba : ea > nop
+ > tst_a $ff-$44,0
+0dbb : 08 > php ;save flags
+0dbc : c9bb > cmp #$ff-$44 ;test result
+ > trap_ne
+0dbe : d0fe > bne * ;failed not equal (non zero)
+ >
+0dc0 : 68 > pla ;load status
+0dc1 : 48 > pha
+ > cmp_flag 0
+0dc2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0dc4 : d0fe > bne * ;failed not equal (non zero)
+ >
+0dc6 : 28 > plp ;restore status
+ >
+ > set_a $aa-$44,$ff
+ > load_flag $ff
+0dc7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0dc9 : 48 > pha ;use stack to load status
+0dca : a966 > lda #$aa-$44 ;precharge accu
+0dcc : 28 > plp
+ >
+0dcd : 44 > db $44 ;test nop integrity - flags on
+0dce : ea > nop
+0dcf : ea > nop
+ > tst_a $aa-$44,$ff
+0dd0 : 08 > php ;save flags
+0dd1 : c966 > cmp #$aa-$44 ;test result
+ > trap_ne
+0dd3 : d0fe > bne * ;failed not equal (non zero)
+ >
+0dd5 : 68 > pla ;load status
+0dd6 : 48 > pha
+ > cmp_flag $ff
+0dd7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0dd9 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ddb : 28 > plp ;restore status
+ >
+0ddc : c042 > cpy #$42
+ > trap_ne ;y changed
+0dde : d0fe > bne * ;failed not equal (non zero)
+ >
+0de0 : e000 > cpx #0
+ > trap_ne ;x changed
+0de2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $54,2
+0de4 : a042 > ldy #$42
+0de6 : a202 > ldx #4-2
+0de8 : 54 > db $54 ;test nop length
+ > if 2 = 1
+ > dex
+ > dex
+ > endif
+ > if 2 = 2
+0de9 : c8 > iny
+0dea : ca > dex
+ > endif
+ > if 2 = 3
+ > iny
+ > iny
+ > endif
+0deb : ca > dex
+ > trap_ne ;wrong number of bytes
+0dec : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$54,0
+ > load_flag 0
+0dee : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0df0 : 48 > pha ;use stack to load status
+0df1 : a9ab > lda #$ff-$54 ;precharge accu
+0df3 : 28 > plp
+ >
+0df4 : 54 > db $54 ;test nop integrity - flags off
+0df5 : ea > nop
+0df6 : ea > nop
+ > tst_a $ff-$54,0
+0df7 : 08 > php ;save flags
+0df8 : c9ab > cmp #$ff-$54 ;test result
+ > trap_ne
+0dfa : d0fe > bne * ;failed not equal (non zero)
+ >
+0dfc : 68 > pla ;load status
+0dfd : 48 > pha
+ > cmp_flag 0
+0dfe : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0e00 : d0fe > bne * ;failed not equal (non zero)
+ >
+0e02 : 28 > plp ;restore status
+ >
+ > set_a $aa-$54,$ff
+ > load_flag $ff
+0e03 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0e05 : 48 > pha ;use stack to load status
+0e06 : a956 > lda #$aa-$54 ;precharge accu
+0e08 : 28 > plp
+ >
+0e09 : 54 > db $54 ;test nop integrity - flags on
+0e0a : ea > nop
+0e0b : ea > nop
+ > tst_a $aa-$54,$ff
+0e0c : 08 > php ;save flags
+0e0d : c956 > cmp #$aa-$54 ;test result
+ > trap_ne
+0e0f : d0fe > bne * ;failed not equal (non zero)
+ >
+0e11 : 68 > pla ;load status
+0e12 : 48 > pha
+ > cmp_flag $ff
+0e13 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0e15 : d0fe > bne * ;failed not equal (non zero)
+ >
+0e17 : 28 > plp ;restore status
+ >
+0e18 : c042 > cpy #$42
+ > trap_ne ;y changed
+0e1a : d0fe > bne * ;failed not equal (non zero)
+ >
+0e1c : e000 > cpx #0
+ > trap_ne ;x changed
+0e1e : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $d4,2
+0e20 : a042 > ldy #$42
+0e22 : a202 > ldx #4-2
+0e24 : d4 > db $d4 ;test nop length
+ > if 2 = 1
+ > dex
+ > dex
+ > endif
+ > if 2 = 2
+0e25 : c8 > iny
+0e26 : ca > dex
+ > endif
+ > if 2 = 3
+ > iny
+ > iny
+ > endif
+0e27 : ca > dex
+ > trap_ne ;wrong number of bytes
+0e28 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$d4,0
+ > load_flag 0
+0e2a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0e2c : 48 > pha ;use stack to load status
+0e2d : a92b > lda #$ff-$d4 ;precharge accu
+0e2f : 28 > plp
+ >
+0e30 : d4 > db $d4 ;test nop integrity - flags off
+0e31 : ea > nop
+0e32 : ea > nop
+ > tst_a $ff-$d4,0
+0e33 : 08 > php ;save flags
+0e34 : c92b > cmp #$ff-$d4 ;test result
+ > trap_ne
+0e36 : d0fe > bne * ;failed not equal (non zero)
+ >
+0e38 : 68 > pla ;load status
+0e39 : 48 > pha
+ > cmp_flag 0
+0e3a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0e3c : d0fe > bne * ;failed not equal (non zero)
+ >
+0e3e : 28 > plp ;restore status
+ >
+ > set_a $aa-$d4,$ff
+ > load_flag $ff
+0e3f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0e41 : 48 > pha ;use stack to load status
+0e42 : a9d6 > lda #$aa-$d4 ;precharge accu
+0e44 : 28 > plp
+ >
+0e45 : d4 > db $d4 ;test nop integrity - flags on
+0e46 : ea > nop
+0e47 : ea > nop
+ > tst_a $aa-$d4,$ff
+0e48 : 08 > php ;save flags
+0e49 : c9d6 > cmp #$aa-$d4 ;test result
+ > trap_ne
+0e4b : d0fe > bne * ;failed not equal (non zero)
+ >
+0e4d : 68 > pla ;load status
+0e4e : 48 > pha
+ > cmp_flag $ff
+0e4f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0e51 : d0fe > bne * ;failed not equal (non zero)
+ >
+0e53 : 28 > plp ;restore status
+ >
+0e54 : c042 > cpy #$42
+ > trap_ne ;y changed
+0e56 : d0fe > bne * ;failed not equal (non zero)
+ >
+0e58 : e000 > cpx #0
+ > trap_ne ;x changed
+0e5a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $f4,2
+0e5c : a042 > ldy #$42
+0e5e : a202 > ldx #4-2
+0e60 : f4 > db $f4 ;test nop length
+ > if 2 = 1
+ > dex
+ > dex
+ > endif
+ > if 2 = 2
+0e61 : c8 > iny
+0e62 : ca > dex
+ > endif
+ > if 2 = 3
+ > iny
+ > iny
+ > endif
+0e63 : ca > dex
+ > trap_ne ;wrong number of bytes
+0e64 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$f4,0
+ > load_flag 0
+0e66 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0e68 : 48 > pha ;use stack to load status
+0e69 : a90b > lda #$ff-$f4 ;precharge accu
+0e6b : 28 > plp
+ >
+0e6c : f4 > db $f4 ;test nop integrity - flags off
+0e6d : ea > nop
+0e6e : ea > nop
+ > tst_a $ff-$f4,0
+0e6f : 08 > php ;save flags
+0e70 : c90b > cmp #$ff-$f4 ;test result
+ > trap_ne
+0e72 : d0fe > bne * ;failed not equal (non zero)
+ >
+0e74 : 68 > pla ;load status
+0e75 : 48 > pha
+ > cmp_flag 0
+0e76 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0e78 : d0fe > bne * ;failed not equal (non zero)
+ >
+0e7a : 28 > plp ;restore status
+ >
+ > set_a $aa-$f4,$ff
+ > load_flag $ff
+0e7b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0e7d : 48 > pha ;use stack to load status
+0e7e : a9b6 > lda #$aa-$f4 ;precharge accu
+0e80 : 28 > plp
+ >
+0e81 : f4 > db $f4 ;test nop integrity - flags on
+0e82 : ea > nop
+0e83 : ea > nop
+ > tst_a $aa-$f4,$ff
+0e84 : 08 > php ;save flags
+0e85 : c9b6 > cmp #$aa-$f4 ;test result
+ > trap_ne
+0e87 : d0fe > bne * ;failed not equal (non zero)
+ >
+0e89 : 68 > pla ;load status
+0e8a : 48 > pha
+ > cmp_flag $ff
+0e8b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0e8d : d0fe > bne * ;failed not equal (non zero)
+ >
+0e8f : 28 > plp ;restore status
+ >
+0e90 : c042 > cpy #$42
+ > trap_ne ;y changed
+0e92 : d0fe > bne * ;failed not equal (non zero)
+ >
+0e94 : e000 > cpx #0
+ > trap_ne ;x changed
+0e96 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $5c,3
+0e98 : a042 > ldy #$42
+0e9a : a201 > ldx #4-3
+0e9c : 5c > db $5c ;test nop length
+ > if 3 = 1
+ > dex
+ > dex
+ > endif
+ > if 3 = 2
+ > iny
+ > dex
+ > endif
+ > if 3 = 3
+0e9d : c8 > iny
+0e9e : c8 > iny
+ > endif
+0e9f : ca > dex
+ > trap_ne ;wrong number of bytes
+0ea0 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$5c,0
+ > load_flag 0
+0ea2 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0ea4 : 48 > pha ;use stack to load status
+0ea5 : a9a3 > lda #$ff-$5c ;precharge accu
+0ea7 : 28 > plp
+ >
+0ea8 : 5c > db $5c ;test nop integrity - flags off
+0ea9 : ea > nop
+0eaa : ea > nop
+ > tst_a $ff-$5c,0
+0eab : 08 > php ;save flags
+0eac : c9a3 > cmp #$ff-$5c ;test result
+ > trap_ne
+0eae : d0fe > bne * ;failed not equal (non zero)
+ >
+0eb0 : 68 > pla ;load status
+0eb1 : 48 > pha
+ > cmp_flag 0
+0eb2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0eb4 : d0fe > bne * ;failed not equal (non zero)
+ >
+0eb6 : 28 > plp ;restore status
+ >
+ > set_a $aa-$5c,$ff
+ > load_flag $ff
+0eb7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0eb9 : 48 > pha ;use stack to load status
+0eba : a94e > lda #$aa-$5c ;precharge accu
+0ebc : 28 > plp
+ >
+0ebd : 5c > db $5c ;test nop integrity - flags on
+0ebe : ea > nop
+0ebf : ea > nop
+ > tst_a $aa-$5c,$ff
+0ec0 : 08 > php ;save flags
+0ec1 : c94e > cmp #$aa-$5c ;test result
+ > trap_ne
+0ec3 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ec5 : 68 > pla ;load status
+0ec6 : 48 > pha
+ > cmp_flag $ff
+0ec7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0ec9 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ecb : 28 > plp ;restore status
+ >
+0ecc : c042 > cpy #$42
+ > trap_ne ;y changed
+0ece : d0fe > bne * ;failed not equal (non zero)
+ >
+0ed0 : e000 > cpx #0
+ > trap_ne ;x changed
+0ed2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $dc,3
+0ed4 : a042 > ldy #$42
+0ed6 : a201 > ldx #4-3
+0ed8 : dc > db $dc ;test nop length
+ > if 3 = 1
+ > dex
+ > dex
+ > endif
+ > if 3 = 2
+ > iny
+ > dex
+ > endif
+ > if 3 = 3
+0ed9 : c8 > iny
+0eda : c8 > iny
+ > endif
+0edb : ca > dex
+ > trap_ne ;wrong number of bytes
+0edc : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$dc,0
+ > load_flag 0
+0ede : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0ee0 : 48 > pha ;use stack to load status
+0ee1 : a923 > lda #$ff-$dc ;precharge accu
+0ee3 : 28 > plp
+ >
+0ee4 : dc > db $dc ;test nop integrity - flags off
+0ee5 : ea > nop
+0ee6 : ea > nop
+ > tst_a $ff-$dc,0
+0ee7 : 08 > php ;save flags
+0ee8 : c923 > cmp #$ff-$dc ;test result
+ > trap_ne
+0eea : d0fe > bne * ;failed not equal (non zero)
+ >
+0eec : 68 > pla ;load status
+0eed : 48 > pha
+ > cmp_flag 0
+0eee : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0ef0 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ef2 : 28 > plp ;restore status
+ >
+ > set_a $aa-$dc,$ff
+ > load_flag $ff
+0ef3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0ef5 : 48 > pha ;use stack to load status
+0ef6 : a9ce > lda #$aa-$dc ;precharge accu
+0ef8 : 28 > plp
+ >
+0ef9 : dc > db $dc ;test nop integrity - flags on
+0efa : ea > nop
+0efb : ea > nop
+ > tst_a $aa-$dc,$ff
+0efc : 08 > php ;save flags
+0efd : c9ce > cmp #$aa-$dc ;test result
+ > trap_ne
+0eff : d0fe > bne * ;failed not equal (non zero)
+ >
+0f01 : 68 > pla ;load status
+0f02 : 48 > pha
+ > cmp_flag $ff
+0f03 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0f05 : d0fe > bne * ;failed not equal (non zero)
+ >
+0f07 : 28 > plp ;restore status
+ >
+0f08 : c042 > cpy #$42
+ > trap_ne ;y changed
+0f0a : d0fe > bne * ;failed not equal (non zero)
+ >
+0f0c : e000 > cpx #0
+ > trap_ne ;x changed
+0f0e : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $fc,3
+0f10 : a042 > ldy #$42
+0f12 : a201 > ldx #4-3
+0f14 : fc > db $fc ;test nop length
+ > if 3 = 1
+ > dex
+ > dex
+ > endif
+ > if 3 = 2
+ > iny
+ > dex
+ > endif
+ > if 3 = 3
+0f15 : c8 > iny
+0f16 : c8 > iny
+ > endif
+0f17 : ca > dex
+ > trap_ne ;wrong number of bytes
+0f18 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$fc,0
+ > load_flag 0
+0f1a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0f1c : 48 > pha ;use stack to load status
+0f1d : a903 > lda #$ff-$fc ;precharge accu
+0f1f : 28 > plp
+ >
+0f20 : fc > db $fc ;test nop integrity - flags off
+0f21 : ea > nop
+0f22 : ea > nop
+ > tst_a $ff-$fc,0
+0f23 : 08 > php ;save flags
+0f24 : c903 > cmp #$ff-$fc ;test result
+ > trap_ne
+0f26 : d0fe > bne * ;failed not equal (non zero)
+ >
+0f28 : 68 > pla ;load status
+0f29 : 48 > pha
+ > cmp_flag 0
+0f2a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0f2c : d0fe > bne * ;failed not equal (non zero)
+ >
+0f2e : 28 > plp ;restore status
+ >
+ > set_a $aa-$fc,$ff
+ > load_flag $ff
+0f2f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0f31 : 48 > pha ;use stack to load status
+0f32 : a9ae > lda #$aa-$fc ;precharge accu
+0f34 : 28 > plp
+ >
+0f35 : fc > db $fc ;test nop integrity - flags on
+0f36 : ea > nop
+0f37 : ea > nop
+ > tst_a $aa-$fc,$ff
+0f38 : 08 > php ;save flags
+0f39 : c9ae > cmp #$aa-$fc ;test result
+ > trap_ne
+0f3b : d0fe > bne * ;failed not equal (non zero)
+ >
+0f3d : 68 > pla ;load status
+0f3e : 48 > pha
+ > cmp_flag $ff
+0f3f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0f41 : d0fe > bne * ;failed not equal (non zero)
+ >
+0f43 : 28 > plp ;restore status
+ >
+0f44 : c042 > cpy #$42
+ > trap_ne ;y changed
+0f46 : d0fe > bne * ;failed not equal (non zero)
+ >
+0f48 : e000 > cpx #0
+ > trap_ne ;x changed
+0f4a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $03,1
+0f4c : a042 > ldy #$42
+0f4e : a203 > ldx #4-1
+0f50 : 03 > db $03 ;test nop length
+ > if 1 = 1
+0f51 : ca > dex
+0f52 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+0f53 : ca > dex
+ > trap_ne ;wrong number of bytes
+0f54 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$03,0
+ > load_flag 0
+0f56 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0f58 : 48 > pha ;use stack to load status
+0f59 : a9fc > lda #$ff-$03 ;precharge accu
+0f5b : 28 > plp
+ >
+0f5c : 03 > db $03 ;test nop integrity - flags off
+0f5d : ea > nop
+0f5e : ea > nop
+ > tst_a $ff-$03,0
+0f5f : 08 > php ;save flags
+0f60 : c9fc > cmp #$ff-$03 ;test result
+ > trap_ne
+0f62 : d0fe > bne * ;failed not equal (non zero)
+ >
+0f64 : 68 > pla ;load status
+0f65 : 48 > pha
+ > cmp_flag 0
+0f66 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0f68 : d0fe > bne * ;failed not equal (non zero)
+ >
+0f6a : 28 > plp ;restore status
+ >
+ > set_a $aa-$03,$ff
+ > load_flag $ff
+0f6b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0f6d : 48 > pha ;use stack to load status
+0f6e : a9a7 > lda #$aa-$03 ;precharge accu
+0f70 : 28 > plp
+ >
+0f71 : 03 > db $03 ;test nop integrity - flags on
+0f72 : ea > nop
+0f73 : ea > nop
+ > tst_a $aa-$03,$ff
+0f74 : 08 > php ;save flags
+0f75 : c9a7 > cmp #$aa-$03 ;test result
+ > trap_ne
+0f77 : d0fe > bne * ;failed not equal (non zero)
+ >
+0f79 : 68 > pla ;load status
+0f7a : 48 > pha
+ > cmp_flag $ff
+0f7b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0f7d : d0fe > bne * ;failed not equal (non zero)
+ >
+0f7f : 28 > plp ;restore status
+ >
+0f80 : c042 > cpy #$42
+ > trap_ne ;y changed
+0f82 : d0fe > bne * ;failed not equal (non zero)
+ >
+0f84 : e000 > cpx #0
+ > trap_ne ;x changed
+0f86 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $13,1
+0f88 : a042 > ldy #$42
+0f8a : a203 > ldx #4-1
+0f8c : 13 > db $13 ;test nop length
+ > if 1 = 1
+0f8d : ca > dex
+0f8e : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+0f8f : ca > dex
+ > trap_ne ;wrong number of bytes
+0f90 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$13,0
+ > load_flag 0
+0f92 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0f94 : 48 > pha ;use stack to load status
+0f95 : a9ec > lda #$ff-$13 ;precharge accu
+0f97 : 28 > plp
+ >
+0f98 : 13 > db $13 ;test nop integrity - flags off
+0f99 : ea > nop
+0f9a : ea > nop
+ > tst_a $ff-$13,0
+0f9b : 08 > php ;save flags
+0f9c : c9ec > cmp #$ff-$13 ;test result
+ > trap_ne
+0f9e : d0fe > bne * ;failed not equal (non zero)
+ >
+0fa0 : 68 > pla ;load status
+0fa1 : 48 > pha
+ > cmp_flag 0
+0fa2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0fa4 : d0fe > bne * ;failed not equal (non zero)
+ >
+0fa6 : 28 > plp ;restore status
+ >
+ > set_a $aa-$13,$ff
+ > load_flag $ff
+0fa7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0fa9 : 48 > pha ;use stack to load status
+0faa : a997 > lda #$aa-$13 ;precharge accu
+0fac : 28 > plp
+ >
+0fad : 13 > db $13 ;test nop integrity - flags on
+0fae : ea > nop
+0faf : ea > nop
+ > tst_a $aa-$13,$ff
+0fb0 : 08 > php ;save flags
+0fb1 : c997 > cmp #$aa-$13 ;test result
+ > trap_ne
+0fb3 : d0fe > bne * ;failed not equal (non zero)
+ >
+0fb5 : 68 > pla ;load status
+0fb6 : 48 > pha
+ > cmp_flag $ff
+0fb7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0fb9 : d0fe > bne * ;failed not equal (non zero)
+ >
+0fbb : 28 > plp ;restore status
+ >
+0fbc : c042 > cpy #$42
+ > trap_ne ;y changed
+0fbe : d0fe > bne * ;failed not equal (non zero)
+ >
+0fc0 : e000 > cpx #0
+ > trap_ne ;x changed
+0fc2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $23,1
+0fc4 : a042 > ldy #$42
+0fc6 : a203 > ldx #4-1
+0fc8 : 23 > db $23 ;test nop length
+ > if 1 = 1
+0fc9 : ca > dex
+0fca : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+0fcb : ca > dex
+ > trap_ne ;wrong number of bytes
+0fcc : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$23,0
+ > load_flag 0
+0fce : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+0fd0 : 48 > pha ;use stack to load status
+0fd1 : a9dc > lda #$ff-$23 ;precharge accu
+0fd3 : 28 > plp
+ >
+0fd4 : 23 > db $23 ;test nop integrity - flags off
+0fd5 : ea > nop
+0fd6 : ea > nop
+ > tst_a $ff-$23,0
+0fd7 : 08 > php ;save flags
+0fd8 : c9dc > cmp #$ff-$23 ;test result
+ > trap_ne
+0fda : d0fe > bne * ;failed not equal (non zero)
+ >
+0fdc : 68 > pla ;load status
+0fdd : 48 > pha
+ > cmp_flag 0
+0fde : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0fe0 : d0fe > bne * ;failed not equal (non zero)
+ >
+0fe2 : 28 > plp ;restore status
+ >
+ > set_a $aa-$23,$ff
+ > load_flag $ff
+0fe3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+0fe5 : 48 > pha ;use stack to load status
+0fe6 : a987 > lda #$aa-$23 ;precharge accu
+0fe8 : 28 > plp
+ >
+0fe9 : 23 > db $23 ;test nop integrity - flags on
+0fea : ea > nop
+0feb : ea > nop
+ > tst_a $aa-$23,$ff
+0fec : 08 > php ;save flags
+0fed : c987 > cmp #$aa-$23 ;test result
+ > trap_ne
+0fef : d0fe > bne * ;failed not equal (non zero)
+ >
+0ff1 : 68 > pla ;load status
+0ff2 : 48 > pha
+ > cmp_flag $ff
+0ff3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+0ff5 : d0fe > bne * ;failed not equal (non zero)
+ >
+0ff7 : 28 > plp ;restore status
+ >
+0ff8 : c042 > cpy #$42
+ > trap_ne ;y changed
+0ffa : d0fe > bne * ;failed not equal (non zero)
+ >
+0ffc : e000 > cpx #0
+ > trap_ne ;x changed
+0ffe : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $33,1
+1000 : a042 > ldy #$42
+1002 : a203 > ldx #4-1
+1004 : 33 > db $33 ;test nop length
+ > if 1 = 1
+1005 : ca > dex
+1006 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+1007 : ca > dex
+ > trap_ne ;wrong number of bytes
+1008 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$33,0
+ > load_flag 0
+100a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+100c : 48 > pha ;use stack to load status
+100d : a9cc > lda #$ff-$33 ;precharge accu
+100f : 28 > plp
+ >
+1010 : 33 > db $33 ;test nop integrity - flags off
+1011 : ea > nop
+1012 : ea > nop
+ > tst_a $ff-$33,0
+1013 : 08 > php ;save flags
+1014 : c9cc > cmp #$ff-$33 ;test result
+ > trap_ne
+1016 : d0fe > bne * ;failed not equal (non zero)
+ >
+1018 : 68 > pla ;load status
+1019 : 48 > pha
+ > cmp_flag 0
+101a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+101c : d0fe > bne * ;failed not equal (non zero)
+ >
+101e : 28 > plp ;restore status
+ >
+ > set_a $aa-$33,$ff
+ > load_flag $ff
+101f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1021 : 48 > pha ;use stack to load status
+1022 : a977 > lda #$aa-$33 ;precharge accu
+1024 : 28 > plp
+ >
+1025 : 33 > db $33 ;test nop integrity - flags on
+1026 : ea > nop
+1027 : ea > nop
+ > tst_a $aa-$33,$ff
+1028 : 08 > php ;save flags
+1029 : c977 > cmp #$aa-$33 ;test result
+ > trap_ne
+102b : d0fe > bne * ;failed not equal (non zero)
+ >
+102d : 68 > pla ;load status
+102e : 48 > pha
+ > cmp_flag $ff
+102f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1031 : d0fe > bne * ;failed not equal (non zero)
+ >
+1033 : 28 > plp ;restore status
+ >
+1034 : c042 > cpy #$42
+ > trap_ne ;y changed
+1036 : d0fe > bne * ;failed not equal (non zero)
+ >
+1038 : e000 > cpx #0
+ > trap_ne ;x changed
+103a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $43,1
+103c : a042 > ldy #$42
+103e : a203 > ldx #4-1
+1040 : 43 > db $43 ;test nop length
+ > if 1 = 1
+1041 : ca > dex
+1042 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+1043 : ca > dex
+ > trap_ne ;wrong number of bytes
+1044 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$43,0
+ > load_flag 0
+1046 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1048 : 48 > pha ;use stack to load status
+1049 : a9bc > lda #$ff-$43 ;precharge accu
+104b : 28 > plp
+ >
+104c : 43 > db $43 ;test nop integrity - flags off
+104d : ea > nop
+104e : ea > nop
+ > tst_a $ff-$43,0
+104f : 08 > php ;save flags
+1050 : c9bc > cmp #$ff-$43 ;test result
+ > trap_ne
+1052 : d0fe > bne * ;failed not equal (non zero)
+ >
+1054 : 68 > pla ;load status
+1055 : 48 > pha
+ > cmp_flag 0
+1056 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1058 : d0fe > bne * ;failed not equal (non zero)
+ >
+105a : 28 > plp ;restore status
+ >
+ > set_a $aa-$43,$ff
+ > load_flag $ff
+105b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+105d : 48 > pha ;use stack to load status
+105e : a967 > lda #$aa-$43 ;precharge accu
+1060 : 28 > plp
+ >
+1061 : 43 > db $43 ;test nop integrity - flags on
+1062 : ea > nop
+1063 : ea > nop
+ > tst_a $aa-$43,$ff
+1064 : 08 > php ;save flags
+1065 : c967 > cmp #$aa-$43 ;test result
+ > trap_ne
+1067 : d0fe > bne * ;failed not equal (non zero)
+ >
+1069 : 68 > pla ;load status
+106a : 48 > pha
+ > cmp_flag $ff
+106b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+106d : d0fe > bne * ;failed not equal (non zero)
+ >
+106f : 28 > plp ;restore status
+ >
+1070 : c042 > cpy #$42
+ > trap_ne ;y changed
+1072 : d0fe > bne * ;failed not equal (non zero)
+ >
+1074 : e000 > cpx #0
+ > trap_ne ;x changed
+1076 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $53,1
+1078 : a042 > ldy #$42
+107a : a203 > ldx #4-1
+107c : 53 > db $53 ;test nop length
+ > if 1 = 1
+107d : ca > dex
+107e : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+107f : ca > dex
+ > trap_ne ;wrong number of bytes
+1080 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$53,0
+ > load_flag 0
+1082 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1084 : 48 > pha ;use stack to load status
+1085 : a9ac > lda #$ff-$53 ;precharge accu
+1087 : 28 > plp
+ >
+1088 : 53 > db $53 ;test nop integrity - flags off
+1089 : ea > nop
+108a : ea > nop
+ > tst_a $ff-$53,0
+108b : 08 > php ;save flags
+108c : c9ac > cmp #$ff-$53 ;test result
+ > trap_ne
+108e : d0fe > bne * ;failed not equal (non zero)
+ >
+1090 : 68 > pla ;load status
+1091 : 48 > pha
+ > cmp_flag 0
+1092 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1094 : d0fe > bne * ;failed not equal (non zero)
+ >
+1096 : 28 > plp ;restore status
+ >
+ > set_a $aa-$53,$ff
+ > load_flag $ff
+1097 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1099 : 48 > pha ;use stack to load status
+109a : a957 > lda #$aa-$53 ;precharge accu
+109c : 28 > plp
+ >
+109d : 53 > db $53 ;test nop integrity - flags on
+109e : ea > nop
+109f : ea > nop
+ > tst_a $aa-$53,$ff
+10a0 : 08 > php ;save flags
+10a1 : c957 > cmp #$aa-$53 ;test result
+ > trap_ne
+10a3 : d0fe > bne * ;failed not equal (non zero)
+ >
+10a5 : 68 > pla ;load status
+10a6 : 48 > pha
+ > cmp_flag $ff
+10a7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+10a9 : d0fe > bne * ;failed not equal (non zero)
+ >
+10ab : 28 > plp ;restore status
+ >
+10ac : c042 > cpy #$42
+ > trap_ne ;y changed
+10ae : d0fe > bne * ;failed not equal (non zero)
+ >
+10b0 : e000 > cpx #0
+ > trap_ne ;x changed
+10b2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $63,1
+10b4 : a042 > ldy #$42
+10b6 : a203 > ldx #4-1
+10b8 : 63 > db $63 ;test nop length
+ > if 1 = 1
+10b9 : ca > dex
+10ba : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+10bb : ca > dex
+ > trap_ne ;wrong number of bytes
+10bc : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$63,0
+ > load_flag 0
+10be : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+10c0 : 48 > pha ;use stack to load status
+10c1 : a99c > lda #$ff-$63 ;precharge accu
+10c3 : 28 > plp
+ >
+10c4 : 63 > db $63 ;test nop integrity - flags off
+10c5 : ea > nop
+10c6 : ea > nop
+ > tst_a $ff-$63,0
+10c7 : 08 > php ;save flags
+10c8 : c99c > cmp #$ff-$63 ;test result
+ > trap_ne
+10ca : d0fe > bne * ;failed not equal (non zero)
+ >
+10cc : 68 > pla ;load status
+10cd : 48 > pha
+ > cmp_flag 0
+10ce : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+10d0 : d0fe > bne * ;failed not equal (non zero)
+ >
+10d2 : 28 > plp ;restore status
+ >
+ > set_a $aa-$63,$ff
+ > load_flag $ff
+10d3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+10d5 : 48 > pha ;use stack to load status
+10d6 : a947 > lda #$aa-$63 ;precharge accu
+10d8 : 28 > plp
+ >
+10d9 : 63 > db $63 ;test nop integrity - flags on
+10da : ea > nop
+10db : ea > nop
+ > tst_a $aa-$63,$ff
+10dc : 08 > php ;save flags
+10dd : c947 > cmp #$aa-$63 ;test result
+ > trap_ne
+10df : d0fe > bne * ;failed not equal (non zero)
+ >
+10e1 : 68 > pla ;load status
+10e2 : 48 > pha
+ > cmp_flag $ff
+10e3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+10e5 : d0fe > bne * ;failed not equal (non zero)
+ >
+10e7 : 28 > plp ;restore status
+ >
+10e8 : c042 > cpy #$42
+ > trap_ne ;y changed
+10ea : d0fe > bne * ;failed not equal (non zero)
+ >
+10ec : e000 > cpx #0
+ > trap_ne ;x changed
+10ee : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $73,1
+10f0 : a042 > ldy #$42
+10f2 : a203 > ldx #4-1
+10f4 : 73 > db $73 ;test nop length
+ > if 1 = 1
+10f5 : ca > dex
+10f6 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+10f7 : ca > dex
+ > trap_ne ;wrong number of bytes
+10f8 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$73,0
+ > load_flag 0
+10fa : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+10fc : 48 > pha ;use stack to load status
+10fd : a98c > lda #$ff-$73 ;precharge accu
+10ff : 28 > plp
+ >
+1100 : 73 > db $73 ;test nop integrity - flags off
+1101 : ea > nop
+1102 : ea > nop
+ > tst_a $ff-$73,0
+1103 : 08 > php ;save flags
+1104 : c98c > cmp #$ff-$73 ;test result
+ > trap_ne
+1106 : d0fe > bne * ;failed not equal (non zero)
+ >
+1108 : 68 > pla ;load status
+1109 : 48 > pha
+ > cmp_flag 0
+110a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+110c : d0fe > bne * ;failed not equal (non zero)
+ >
+110e : 28 > plp ;restore status
+ >
+ > set_a $aa-$73,$ff
+ > load_flag $ff
+110f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1111 : 48 > pha ;use stack to load status
+1112 : a937 > lda #$aa-$73 ;precharge accu
+1114 : 28 > plp
+ >
+1115 : 73 > db $73 ;test nop integrity - flags on
+1116 : ea > nop
+1117 : ea > nop
+ > tst_a $aa-$73,$ff
+1118 : 08 > php ;save flags
+1119 : c937 > cmp #$aa-$73 ;test result
+ > trap_ne
+111b : d0fe > bne * ;failed not equal (non zero)
+ >
+111d : 68 > pla ;load status
+111e : 48 > pha
+ > cmp_flag $ff
+111f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1121 : d0fe > bne * ;failed not equal (non zero)
+ >
+1123 : 28 > plp ;restore status
+ >
+1124 : c042 > cpy #$42
+ > trap_ne ;y changed
+1126 : d0fe > bne * ;failed not equal (non zero)
+ >
+1128 : e000 > cpx #0
+ > trap_ne ;x changed
+112a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $83,1
+112c : a042 > ldy #$42
+112e : a203 > ldx #4-1
+1130 : 83 > db $83 ;test nop length
+ > if 1 = 1
+1131 : ca > dex
+1132 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+1133 : ca > dex
+ > trap_ne ;wrong number of bytes
+1134 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$83,0
+ > load_flag 0
+1136 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1138 : 48 > pha ;use stack to load status
+1139 : a97c > lda #$ff-$83 ;precharge accu
+113b : 28 > plp
+ >
+113c : 83 > db $83 ;test nop integrity - flags off
+113d : ea > nop
+113e : ea > nop
+ > tst_a $ff-$83,0
+113f : 08 > php ;save flags
+1140 : c97c > cmp #$ff-$83 ;test result
+ > trap_ne
+1142 : d0fe > bne * ;failed not equal (non zero)
+ >
+1144 : 68 > pla ;load status
+1145 : 48 > pha
+ > cmp_flag 0
+1146 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1148 : d0fe > bne * ;failed not equal (non zero)
+ >
+114a : 28 > plp ;restore status
+ >
+ > set_a $aa-$83,$ff
+ > load_flag $ff
+114b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+114d : 48 > pha ;use stack to load status
+114e : a927 > lda #$aa-$83 ;precharge accu
+1150 : 28 > plp
+ >
+1151 : 83 > db $83 ;test nop integrity - flags on
+1152 : ea > nop
+1153 : ea > nop
+ > tst_a $aa-$83,$ff
+1154 : 08 > php ;save flags
+1155 : c927 > cmp #$aa-$83 ;test result
+ > trap_ne
+1157 : d0fe > bne * ;failed not equal (non zero)
+ >
+1159 : 68 > pla ;load status
+115a : 48 > pha
+ > cmp_flag $ff
+115b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+115d : d0fe > bne * ;failed not equal (non zero)
+ >
+115f : 28 > plp ;restore status
+ >
+1160 : c042 > cpy #$42
+ > trap_ne ;y changed
+1162 : d0fe > bne * ;failed not equal (non zero)
+ >
+1164 : e000 > cpx #0
+ > trap_ne ;x changed
+1166 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $93,1
+1168 : a042 > ldy #$42
+116a : a203 > ldx #4-1
+116c : 93 > db $93 ;test nop length
+ > if 1 = 1
+116d : ca > dex
+116e : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+116f : ca > dex
+ > trap_ne ;wrong number of bytes
+1170 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$93,0
+ > load_flag 0
+1172 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1174 : 48 > pha ;use stack to load status
+1175 : a96c > lda #$ff-$93 ;precharge accu
+1177 : 28 > plp
+ >
+1178 : 93 > db $93 ;test nop integrity - flags off
+1179 : ea > nop
+117a : ea > nop
+ > tst_a $ff-$93,0
+117b : 08 > php ;save flags
+117c : c96c > cmp #$ff-$93 ;test result
+ > trap_ne
+117e : d0fe > bne * ;failed not equal (non zero)
+ >
+1180 : 68 > pla ;load status
+1181 : 48 > pha
+ > cmp_flag 0
+1182 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1184 : d0fe > bne * ;failed not equal (non zero)
+ >
+1186 : 28 > plp ;restore status
+ >
+ > set_a $aa-$93,$ff
+ > load_flag $ff
+1187 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1189 : 48 > pha ;use stack to load status
+118a : a917 > lda #$aa-$93 ;precharge accu
+118c : 28 > plp
+ >
+118d : 93 > db $93 ;test nop integrity - flags on
+118e : ea > nop
+118f : ea > nop
+ > tst_a $aa-$93,$ff
+1190 : 08 > php ;save flags
+1191 : c917 > cmp #$aa-$93 ;test result
+ > trap_ne
+1193 : d0fe > bne * ;failed not equal (non zero)
+ >
+1195 : 68 > pla ;load status
+1196 : 48 > pha
+ > cmp_flag $ff
+1197 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1199 : d0fe > bne * ;failed not equal (non zero)
+ >
+119b : 28 > plp ;restore status
+ >
+119c : c042 > cpy #$42
+ > trap_ne ;y changed
+119e : d0fe > bne * ;failed not equal (non zero)
+ >
+11a0 : e000 > cpx #0
+ > trap_ne ;x changed
+11a2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $a3,1
+11a4 : a042 > ldy #$42
+11a6 : a203 > ldx #4-1
+11a8 : a3 > db $a3 ;test nop length
+ > if 1 = 1
+11a9 : ca > dex
+11aa : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+11ab : ca > dex
+ > trap_ne ;wrong number of bytes
+11ac : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$a3,0
+ > load_flag 0
+11ae : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+11b0 : 48 > pha ;use stack to load status
+11b1 : a95c > lda #$ff-$a3 ;precharge accu
+11b3 : 28 > plp
+ >
+11b4 : a3 > db $a3 ;test nop integrity - flags off
+11b5 : ea > nop
+11b6 : ea > nop
+ > tst_a $ff-$a3,0
+11b7 : 08 > php ;save flags
+11b8 : c95c > cmp #$ff-$a3 ;test result
+ > trap_ne
+11ba : d0fe > bne * ;failed not equal (non zero)
+ >
+11bc : 68 > pla ;load status
+11bd : 48 > pha
+ > cmp_flag 0
+11be : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+11c0 : d0fe > bne * ;failed not equal (non zero)
+ >
+11c2 : 28 > plp ;restore status
+ >
+ > set_a $aa-$a3,$ff
+ > load_flag $ff
+11c3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+11c5 : 48 > pha ;use stack to load status
+11c6 : a907 > lda #$aa-$a3 ;precharge accu
+11c8 : 28 > plp
+ >
+11c9 : a3 > db $a3 ;test nop integrity - flags on
+11ca : ea > nop
+11cb : ea > nop
+ > tst_a $aa-$a3,$ff
+11cc : 08 > php ;save flags
+11cd : c907 > cmp #$aa-$a3 ;test result
+ > trap_ne
+11cf : d0fe > bne * ;failed not equal (non zero)
+ >
+11d1 : 68 > pla ;load status
+11d2 : 48 > pha
+ > cmp_flag $ff
+11d3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+11d5 : d0fe > bne * ;failed not equal (non zero)
+ >
+11d7 : 28 > plp ;restore status
+ >
+11d8 : c042 > cpy #$42
+ > trap_ne ;y changed
+11da : d0fe > bne * ;failed not equal (non zero)
+ >
+11dc : e000 > cpx #0
+ > trap_ne ;x changed
+11de : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $b3,1
+11e0 : a042 > ldy #$42
+11e2 : a203 > ldx #4-1
+11e4 : b3 > db $b3 ;test nop length
+ > if 1 = 1
+11e5 : ca > dex
+11e6 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+11e7 : ca > dex
+ > trap_ne ;wrong number of bytes
+11e8 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$b3,0
+ > load_flag 0
+11ea : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+11ec : 48 > pha ;use stack to load status
+11ed : a94c > lda #$ff-$b3 ;precharge accu
+11ef : 28 > plp
+ >
+11f0 : b3 > db $b3 ;test nop integrity - flags off
+11f1 : ea > nop
+11f2 : ea > nop
+ > tst_a $ff-$b3,0
+11f3 : 08 > php ;save flags
+11f4 : c94c > cmp #$ff-$b3 ;test result
+ > trap_ne
+11f6 : d0fe > bne * ;failed not equal (non zero)
+ >
+11f8 : 68 > pla ;load status
+11f9 : 48 > pha
+ > cmp_flag 0
+11fa : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+11fc : d0fe > bne * ;failed not equal (non zero)
+ >
+11fe : 28 > plp ;restore status
+ >
+ > set_a $aa-$b3,$ff
+ > load_flag $ff
+11ff : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1201 : 48 > pha ;use stack to load status
+1202 : a9f7 > lda #$aa-$b3 ;precharge accu
+1204 : 28 > plp
+ >
+1205 : b3 > db $b3 ;test nop integrity - flags on
+1206 : ea > nop
+1207 : ea > nop
+ > tst_a $aa-$b3,$ff
+1208 : 08 > php ;save flags
+1209 : c9f7 > cmp #$aa-$b3 ;test result
+ > trap_ne
+120b : d0fe > bne * ;failed not equal (non zero)
+ >
+120d : 68 > pla ;load status
+120e : 48 > pha
+ > cmp_flag $ff
+120f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1211 : d0fe > bne * ;failed not equal (non zero)
+ >
+1213 : 28 > plp ;restore status
+ >
+1214 : c042 > cpy #$42
+ > trap_ne ;y changed
+1216 : d0fe > bne * ;failed not equal (non zero)
+ >
+1218 : e000 > cpx #0
+ > trap_ne ;x changed
+121a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $c3,1
+121c : a042 > ldy #$42
+121e : a203 > ldx #4-1
+1220 : c3 > db $c3 ;test nop length
+ > if 1 = 1
+1221 : ca > dex
+1222 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+1223 : ca > dex
+ > trap_ne ;wrong number of bytes
+1224 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$c3,0
+ > load_flag 0
+1226 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1228 : 48 > pha ;use stack to load status
+1229 : a93c > lda #$ff-$c3 ;precharge accu
+122b : 28 > plp
+ >
+122c : c3 > db $c3 ;test nop integrity - flags off
+122d : ea > nop
+122e : ea > nop
+ > tst_a $ff-$c3,0
+122f : 08 > php ;save flags
+1230 : c93c > cmp #$ff-$c3 ;test result
+ > trap_ne
+1232 : d0fe > bne * ;failed not equal (non zero)
+ >
+1234 : 68 > pla ;load status
+1235 : 48 > pha
+ > cmp_flag 0
+1236 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1238 : d0fe > bne * ;failed not equal (non zero)
+ >
+123a : 28 > plp ;restore status
+ >
+ > set_a $aa-$c3,$ff
+ > load_flag $ff
+123b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+123d : 48 > pha ;use stack to load status
+123e : a9e7 > lda #$aa-$c3 ;precharge accu
+1240 : 28 > plp
+ >
+1241 : c3 > db $c3 ;test nop integrity - flags on
+1242 : ea > nop
+1243 : ea > nop
+ > tst_a $aa-$c3,$ff
+1244 : 08 > php ;save flags
+1245 : c9e7 > cmp #$aa-$c3 ;test result
+ > trap_ne
+1247 : d0fe > bne * ;failed not equal (non zero)
+ >
+1249 : 68 > pla ;load status
+124a : 48 > pha
+ > cmp_flag $ff
+124b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+124d : d0fe > bne * ;failed not equal (non zero)
+ >
+124f : 28 > plp ;restore status
+ >
+1250 : c042 > cpy #$42
+ > trap_ne ;y changed
+1252 : d0fe > bne * ;failed not equal (non zero)
+ >
+1254 : e000 > cpx #0
+ > trap_ne ;x changed
+1256 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $d3,1
+1258 : a042 > ldy #$42
+125a : a203 > ldx #4-1
+125c : d3 > db $d3 ;test nop length
+ > if 1 = 1
+125d : ca > dex
+125e : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+125f : ca > dex
+ > trap_ne ;wrong number of bytes
+1260 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$d3,0
+ > load_flag 0
+1262 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1264 : 48 > pha ;use stack to load status
+1265 : a92c > lda #$ff-$d3 ;precharge accu
+1267 : 28 > plp
+ >
+1268 : d3 > db $d3 ;test nop integrity - flags off
+1269 : ea > nop
+126a : ea > nop
+ > tst_a $ff-$d3,0
+126b : 08 > php ;save flags
+126c : c92c > cmp #$ff-$d3 ;test result
+ > trap_ne
+126e : d0fe > bne * ;failed not equal (non zero)
+ >
+1270 : 68 > pla ;load status
+1271 : 48 > pha
+ > cmp_flag 0
+1272 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1274 : d0fe > bne * ;failed not equal (non zero)
+ >
+1276 : 28 > plp ;restore status
+ >
+ > set_a $aa-$d3,$ff
+ > load_flag $ff
+1277 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1279 : 48 > pha ;use stack to load status
+127a : a9d7 > lda #$aa-$d3 ;precharge accu
+127c : 28 > plp
+ >
+127d : d3 > db $d3 ;test nop integrity - flags on
+127e : ea > nop
+127f : ea > nop
+ > tst_a $aa-$d3,$ff
+1280 : 08 > php ;save flags
+1281 : c9d7 > cmp #$aa-$d3 ;test result
+ > trap_ne
+1283 : d0fe > bne * ;failed not equal (non zero)
+ >
+1285 : 68 > pla ;load status
+1286 : 48 > pha
+ > cmp_flag $ff
+1287 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1289 : d0fe > bne * ;failed not equal (non zero)
+ >
+128b : 28 > plp ;restore status
+ >
+128c : c042 > cpy #$42
+ > trap_ne ;y changed
+128e : d0fe > bne * ;failed not equal (non zero)
+ >
+1290 : e000 > cpx #0
+ > trap_ne ;x changed
+1292 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $e3,1
+1294 : a042 > ldy #$42
+1296 : a203 > ldx #4-1
+1298 : e3 > db $e3 ;test nop length
+ > if 1 = 1
+1299 : ca > dex
+129a : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+129b : ca > dex
+ > trap_ne ;wrong number of bytes
+129c : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$e3,0
+ > load_flag 0
+129e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+12a0 : 48 > pha ;use stack to load status
+12a1 : a91c > lda #$ff-$e3 ;precharge accu
+12a3 : 28 > plp
+ >
+12a4 : e3 > db $e3 ;test nop integrity - flags off
+12a5 : ea > nop
+12a6 : ea > nop
+ > tst_a $ff-$e3,0
+12a7 : 08 > php ;save flags
+12a8 : c91c > cmp #$ff-$e3 ;test result
+ > trap_ne
+12aa : d0fe > bne * ;failed not equal (non zero)
+ >
+12ac : 68 > pla ;load status
+12ad : 48 > pha
+ > cmp_flag 0
+12ae : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+12b0 : d0fe > bne * ;failed not equal (non zero)
+ >
+12b2 : 28 > plp ;restore status
+ >
+ > set_a $aa-$e3,$ff
+ > load_flag $ff
+12b3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+12b5 : 48 > pha ;use stack to load status
+12b6 : a9c7 > lda #$aa-$e3 ;precharge accu
+12b8 : 28 > plp
+ >
+12b9 : e3 > db $e3 ;test nop integrity - flags on
+12ba : ea > nop
+12bb : ea > nop
+ > tst_a $aa-$e3,$ff
+12bc : 08 > php ;save flags
+12bd : c9c7 > cmp #$aa-$e3 ;test result
+ > trap_ne
+12bf : d0fe > bne * ;failed not equal (non zero)
+ >
+12c1 : 68 > pla ;load status
+12c2 : 48 > pha
+ > cmp_flag $ff
+12c3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+12c5 : d0fe > bne * ;failed not equal (non zero)
+ >
+12c7 : 28 > plp ;restore status
+ >
+12c8 : c042 > cpy #$42
+ > trap_ne ;y changed
+12ca : d0fe > bne * ;failed not equal (non zero)
+ >
+12cc : e000 > cpx #0
+ > trap_ne ;x changed
+12ce : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $f3,1
+12d0 : a042 > ldy #$42
+12d2 : a203 > ldx #4-1
+12d4 : f3 > db $f3 ;test nop length
+ > if 1 = 1
+12d5 : ca > dex
+12d6 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+12d7 : ca > dex
+ > trap_ne ;wrong number of bytes
+12d8 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$f3,0
+ > load_flag 0
+12da : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+12dc : 48 > pha ;use stack to load status
+12dd : a90c > lda #$ff-$f3 ;precharge accu
+12df : 28 > plp
+ >
+12e0 : f3 > db $f3 ;test nop integrity - flags off
+12e1 : ea > nop
+12e2 : ea > nop
+ > tst_a $ff-$f3,0
+12e3 : 08 > php ;save flags
+12e4 : c90c > cmp #$ff-$f3 ;test result
+ > trap_ne
+12e6 : d0fe > bne * ;failed not equal (non zero)
+ >
+12e8 : 68 > pla ;load status
+12e9 : 48 > pha
+ > cmp_flag 0
+12ea : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+12ec : d0fe > bne * ;failed not equal (non zero)
+ >
+12ee : 28 > plp ;restore status
+ >
+ > set_a $aa-$f3,$ff
+ > load_flag $ff
+12ef : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+12f1 : 48 > pha ;use stack to load status
+12f2 : a9b7 > lda #$aa-$f3 ;precharge accu
+12f4 : 28 > plp
+ >
+12f5 : f3 > db $f3 ;test nop integrity - flags on
+12f6 : ea > nop
+12f7 : ea > nop
+ > tst_a $aa-$f3,$ff
+12f8 : 08 > php ;save flags
+12f9 : c9b7 > cmp #$aa-$f3 ;test result
+ > trap_ne
+12fb : d0fe > bne * ;failed not equal (non zero)
+ >
+12fd : 68 > pla ;load status
+12fe : 48 > pha
+ > cmp_flag $ff
+12ff : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1301 : d0fe > bne * ;failed not equal (non zero)
+ >
+1303 : 28 > plp ;restore status
+ >
+1304 : c042 > cpy #$42
+ > trap_ne ;y changed
+1306 : d0fe > bne * ;failed not equal (non zero)
+ >
+1308 : e000 > cpx #0
+ > trap_ne ;x changed
+130a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $0b,1
+130c : a042 > ldy #$42
+130e : a203 > ldx #4-1
+1310 : 0b > db $0b ;test nop length
+ > if 1 = 1
+1311 : ca > dex
+1312 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+1313 : ca > dex
+ > trap_ne ;wrong number of bytes
+1314 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$0b,0
+ > load_flag 0
+1316 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1318 : 48 > pha ;use stack to load status
+1319 : a9f4 > lda #$ff-$0b ;precharge accu
+131b : 28 > plp
+ >
+131c : 0b > db $0b ;test nop integrity - flags off
+131d : ea > nop
+131e : ea > nop
+ > tst_a $ff-$0b,0
+131f : 08 > php ;save flags
+1320 : c9f4 > cmp #$ff-$0b ;test result
+ > trap_ne
+1322 : d0fe > bne * ;failed not equal (non zero)
+ >
+1324 : 68 > pla ;load status
+1325 : 48 > pha
+ > cmp_flag 0
+1326 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1328 : d0fe > bne * ;failed not equal (non zero)
+ >
+132a : 28 > plp ;restore status
+ >
+ > set_a $aa-$0b,$ff
+ > load_flag $ff
+132b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+132d : 48 > pha ;use stack to load status
+132e : a99f > lda #$aa-$0b ;precharge accu
+1330 : 28 > plp
+ >
+1331 : 0b > db $0b ;test nop integrity - flags on
+1332 : ea > nop
+1333 : ea > nop
+ > tst_a $aa-$0b,$ff
+1334 : 08 > php ;save flags
+1335 : c99f > cmp #$aa-$0b ;test result
+ > trap_ne
+1337 : d0fe > bne * ;failed not equal (non zero)
+ >
+1339 : 68 > pla ;load status
+133a : 48 > pha
+ > cmp_flag $ff
+133b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+133d : d0fe > bne * ;failed not equal (non zero)
+ >
+133f : 28 > plp ;restore status
+ >
+1340 : c042 > cpy #$42
+ > trap_ne ;y changed
+1342 : d0fe > bne * ;failed not equal (non zero)
+ >
+1344 : e000 > cpx #0
+ > trap_ne ;x changed
+1346 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $1b,1
+1348 : a042 > ldy #$42
+134a : a203 > ldx #4-1
+134c : 1b > db $1b ;test nop length
+ > if 1 = 1
+134d : ca > dex
+134e : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+134f : ca > dex
+ > trap_ne ;wrong number of bytes
+1350 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$1b,0
+ > load_flag 0
+1352 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1354 : 48 > pha ;use stack to load status
+1355 : a9e4 > lda #$ff-$1b ;precharge accu
+1357 : 28 > plp
+ >
+1358 : 1b > db $1b ;test nop integrity - flags off
+1359 : ea > nop
+135a : ea > nop
+ > tst_a $ff-$1b,0
+135b : 08 > php ;save flags
+135c : c9e4 > cmp #$ff-$1b ;test result
+ > trap_ne
+135e : d0fe > bne * ;failed not equal (non zero)
+ >
+1360 : 68 > pla ;load status
+1361 : 48 > pha
+ > cmp_flag 0
+1362 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1364 : d0fe > bne * ;failed not equal (non zero)
+ >
+1366 : 28 > plp ;restore status
+ >
+ > set_a $aa-$1b,$ff
+ > load_flag $ff
+1367 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1369 : 48 > pha ;use stack to load status
+136a : a98f > lda #$aa-$1b ;precharge accu
+136c : 28 > plp
+ >
+136d : 1b > db $1b ;test nop integrity - flags on
+136e : ea > nop
+136f : ea > nop
+ > tst_a $aa-$1b,$ff
+1370 : 08 > php ;save flags
+1371 : c98f > cmp #$aa-$1b ;test result
+ > trap_ne
+1373 : d0fe > bne * ;failed not equal (non zero)
+ >
+1375 : 68 > pla ;load status
+1376 : 48 > pha
+ > cmp_flag $ff
+1377 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1379 : d0fe > bne * ;failed not equal (non zero)
+ >
+137b : 28 > plp ;restore status
+ >
+137c : c042 > cpy #$42
+ > trap_ne ;y changed
+137e : d0fe > bne * ;failed not equal (non zero)
+ >
+1380 : e000 > cpx #0
+ > trap_ne ;x changed
+1382 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $2b,1
+1384 : a042 > ldy #$42
+1386 : a203 > ldx #4-1
+1388 : 2b > db $2b ;test nop length
+ > if 1 = 1
+1389 : ca > dex
+138a : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+138b : ca > dex
+ > trap_ne ;wrong number of bytes
+138c : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$2b,0
+ > load_flag 0
+138e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1390 : 48 > pha ;use stack to load status
+1391 : a9d4 > lda #$ff-$2b ;precharge accu
+1393 : 28 > plp
+ >
+1394 : 2b > db $2b ;test nop integrity - flags off
+1395 : ea > nop
+1396 : ea > nop
+ > tst_a $ff-$2b,0
+1397 : 08 > php ;save flags
+1398 : c9d4 > cmp #$ff-$2b ;test result
+ > trap_ne
+139a : d0fe > bne * ;failed not equal (non zero)
+ >
+139c : 68 > pla ;load status
+139d : 48 > pha
+ > cmp_flag 0
+139e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+13a0 : d0fe > bne * ;failed not equal (non zero)
+ >
+13a2 : 28 > plp ;restore status
+ >
+ > set_a $aa-$2b,$ff
+ > load_flag $ff
+13a3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+13a5 : 48 > pha ;use stack to load status
+13a6 : a97f > lda #$aa-$2b ;precharge accu
+13a8 : 28 > plp
+ >
+13a9 : 2b > db $2b ;test nop integrity - flags on
+13aa : ea > nop
+13ab : ea > nop
+ > tst_a $aa-$2b,$ff
+13ac : 08 > php ;save flags
+13ad : c97f > cmp #$aa-$2b ;test result
+ > trap_ne
+13af : d0fe > bne * ;failed not equal (non zero)
+ >
+13b1 : 68 > pla ;load status
+13b2 : 48 > pha
+ > cmp_flag $ff
+13b3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+13b5 : d0fe > bne * ;failed not equal (non zero)
+ >
+13b7 : 28 > plp ;restore status
+ >
+13b8 : c042 > cpy #$42
+ > trap_ne ;y changed
+13ba : d0fe > bne * ;failed not equal (non zero)
+ >
+13bc : e000 > cpx #0
+ > trap_ne ;x changed
+13be : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $3b,1
+13c0 : a042 > ldy #$42
+13c2 : a203 > ldx #4-1
+13c4 : 3b > db $3b ;test nop length
+ > if 1 = 1
+13c5 : ca > dex
+13c6 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+13c7 : ca > dex
+ > trap_ne ;wrong number of bytes
+13c8 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$3b,0
+ > load_flag 0
+13ca : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+13cc : 48 > pha ;use stack to load status
+13cd : a9c4 > lda #$ff-$3b ;precharge accu
+13cf : 28 > plp
+ >
+13d0 : 3b > db $3b ;test nop integrity - flags off
+13d1 : ea > nop
+13d2 : ea > nop
+ > tst_a $ff-$3b,0
+13d3 : 08 > php ;save flags
+13d4 : c9c4 > cmp #$ff-$3b ;test result
+ > trap_ne
+13d6 : d0fe > bne * ;failed not equal (non zero)
+ >
+13d8 : 68 > pla ;load status
+13d9 : 48 > pha
+ > cmp_flag 0
+13da : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+13dc : d0fe > bne * ;failed not equal (non zero)
+ >
+13de : 28 > plp ;restore status
+ >
+ > set_a $aa-$3b,$ff
+ > load_flag $ff
+13df : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+13e1 : 48 > pha ;use stack to load status
+13e2 : a96f > lda #$aa-$3b ;precharge accu
+13e4 : 28 > plp
+ >
+13e5 : 3b > db $3b ;test nop integrity - flags on
+13e6 : ea > nop
+13e7 : ea > nop
+ > tst_a $aa-$3b,$ff
+13e8 : 08 > php ;save flags
+13e9 : c96f > cmp #$aa-$3b ;test result
+ > trap_ne
+13eb : d0fe > bne * ;failed not equal (non zero)
+ >
+13ed : 68 > pla ;load status
+13ee : 48 > pha
+ > cmp_flag $ff
+13ef : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+13f1 : d0fe > bne * ;failed not equal (non zero)
+ >
+13f3 : 28 > plp ;restore status
+ >
+13f4 : c042 > cpy #$42
+ > trap_ne ;y changed
+13f6 : d0fe > bne * ;failed not equal (non zero)
+ >
+13f8 : e000 > cpx #0
+ > trap_ne ;x changed
+13fa : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $4b,1
+13fc : a042 > ldy #$42
+13fe : a203 > ldx #4-1
+1400 : 4b > db $4b ;test nop length
+ > if 1 = 1
+1401 : ca > dex
+1402 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+1403 : ca > dex
+ > trap_ne ;wrong number of bytes
+1404 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$4b,0
+ > load_flag 0
+1406 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1408 : 48 > pha ;use stack to load status
+1409 : a9b4 > lda #$ff-$4b ;precharge accu
+140b : 28 > plp
+ >
+140c : 4b > db $4b ;test nop integrity - flags off
+140d : ea > nop
+140e : ea > nop
+ > tst_a $ff-$4b,0
+140f : 08 > php ;save flags
+1410 : c9b4 > cmp #$ff-$4b ;test result
+ > trap_ne
+1412 : d0fe > bne * ;failed not equal (non zero)
+ >
+1414 : 68 > pla ;load status
+1415 : 48 > pha
+ > cmp_flag 0
+1416 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1418 : d0fe > bne * ;failed not equal (non zero)
+ >
+141a : 28 > plp ;restore status
+ >
+ > set_a $aa-$4b,$ff
+ > load_flag $ff
+141b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+141d : 48 > pha ;use stack to load status
+141e : a95f > lda #$aa-$4b ;precharge accu
+1420 : 28 > plp
+ >
+1421 : 4b > db $4b ;test nop integrity - flags on
+1422 : ea > nop
+1423 : ea > nop
+ > tst_a $aa-$4b,$ff
+1424 : 08 > php ;save flags
+1425 : c95f > cmp #$aa-$4b ;test result
+ > trap_ne
+1427 : d0fe > bne * ;failed not equal (non zero)
+ >
+1429 : 68 > pla ;load status
+142a : 48 > pha
+ > cmp_flag $ff
+142b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+142d : d0fe > bne * ;failed not equal (non zero)
+ >
+142f : 28 > plp ;restore status
+ >
+1430 : c042 > cpy #$42
+ > trap_ne ;y changed
+1432 : d0fe > bne * ;failed not equal (non zero)
+ >
+1434 : e000 > cpx #0
+ > trap_ne ;x changed
+1436 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $5b,1
+1438 : a042 > ldy #$42
+143a : a203 > ldx #4-1
+143c : 5b > db $5b ;test nop length
+ > if 1 = 1
+143d : ca > dex
+143e : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+143f : ca > dex
+ > trap_ne ;wrong number of bytes
+1440 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$5b,0
+ > load_flag 0
+1442 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1444 : 48 > pha ;use stack to load status
+1445 : a9a4 > lda #$ff-$5b ;precharge accu
+1447 : 28 > plp
+ >
+1448 : 5b > db $5b ;test nop integrity - flags off
+1449 : ea > nop
+144a : ea > nop
+ > tst_a $ff-$5b,0
+144b : 08 > php ;save flags
+144c : c9a4 > cmp #$ff-$5b ;test result
+ > trap_ne
+144e : d0fe > bne * ;failed not equal (non zero)
+ >
+1450 : 68 > pla ;load status
+1451 : 48 > pha
+ > cmp_flag 0
+1452 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1454 : d0fe > bne * ;failed not equal (non zero)
+ >
+1456 : 28 > plp ;restore status
+ >
+ > set_a $aa-$5b,$ff
+ > load_flag $ff
+1457 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1459 : 48 > pha ;use stack to load status
+145a : a94f > lda #$aa-$5b ;precharge accu
+145c : 28 > plp
+ >
+145d : 5b > db $5b ;test nop integrity - flags on
+145e : ea > nop
+145f : ea > nop
+ > tst_a $aa-$5b,$ff
+1460 : 08 > php ;save flags
+1461 : c94f > cmp #$aa-$5b ;test result
+ > trap_ne
+1463 : d0fe > bne * ;failed not equal (non zero)
+ >
+1465 : 68 > pla ;load status
+1466 : 48 > pha
+ > cmp_flag $ff
+1467 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1469 : d0fe > bne * ;failed not equal (non zero)
+ >
+146b : 28 > plp ;restore status
+ >
+146c : c042 > cpy #$42
+ > trap_ne ;y changed
+146e : d0fe > bne * ;failed not equal (non zero)
+ >
+1470 : e000 > cpx #0
+ > trap_ne ;x changed
+1472 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $6b,1
+1474 : a042 > ldy #$42
+1476 : a203 > ldx #4-1
+1478 : 6b > db $6b ;test nop length
+ > if 1 = 1
+1479 : ca > dex
+147a : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+147b : ca > dex
+ > trap_ne ;wrong number of bytes
+147c : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$6b,0
+ > load_flag 0
+147e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1480 : 48 > pha ;use stack to load status
+1481 : a994 > lda #$ff-$6b ;precharge accu
+1483 : 28 > plp
+ >
+1484 : 6b > db $6b ;test nop integrity - flags off
+1485 : ea > nop
+1486 : ea > nop
+ > tst_a $ff-$6b,0
+1487 : 08 > php ;save flags
+1488 : c994 > cmp #$ff-$6b ;test result
+ > trap_ne
+148a : d0fe > bne * ;failed not equal (non zero)
+ >
+148c : 68 > pla ;load status
+148d : 48 > pha
+ > cmp_flag 0
+148e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1490 : d0fe > bne * ;failed not equal (non zero)
+ >
+1492 : 28 > plp ;restore status
+ >
+ > set_a $aa-$6b,$ff
+ > load_flag $ff
+1493 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1495 : 48 > pha ;use stack to load status
+1496 : a93f > lda #$aa-$6b ;precharge accu
+1498 : 28 > plp
+ >
+1499 : 6b > db $6b ;test nop integrity - flags on
+149a : ea > nop
+149b : ea > nop
+ > tst_a $aa-$6b,$ff
+149c : 08 > php ;save flags
+149d : c93f > cmp #$aa-$6b ;test result
+ > trap_ne
+149f : d0fe > bne * ;failed not equal (non zero)
+ >
+14a1 : 68 > pla ;load status
+14a2 : 48 > pha
+ > cmp_flag $ff
+14a3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+14a5 : d0fe > bne * ;failed not equal (non zero)
+ >
+14a7 : 28 > plp ;restore status
+ >
+14a8 : c042 > cpy #$42
+ > trap_ne ;y changed
+14aa : d0fe > bne * ;failed not equal (non zero)
+ >
+14ac : e000 > cpx #0
+ > trap_ne ;x changed
+14ae : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $7b,1
+14b0 : a042 > ldy #$42
+14b2 : a203 > ldx #4-1
+14b4 : 7b > db $7b ;test nop length
+ > if 1 = 1
+14b5 : ca > dex
+14b6 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+14b7 : ca > dex
+ > trap_ne ;wrong number of bytes
+14b8 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$7b,0
+ > load_flag 0
+14ba : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+14bc : 48 > pha ;use stack to load status
+14bd : a984 > lda #$ff-$7b ;precharge accu
+14bf : 28 > plp
+ >
+14c0 : 7b > db $7b ;test nop integrity - flags off
+14c1 : ea > nop
+14c2 : ea > nop
+ > tst_a $ff-$7b,0
+14c3 : 08 > php ;save flags
+14c4 : c984 > cmp #$ff-$7b ;test result
+ > trap_ne
+14c6 : d0fe > bne * ;failed not equal (non zero)
+ >
+14c8 : 68 > pla ;load status
+14c9 : 48 > pha
+ > cmp_flag 0
+14ca : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+14cc : d0fe > bne * ;failed not equal (non zero)
+ >
+14ce : 28 > plp ;restore status
+ >
+ > set_a $aa-$7b,$ff
+ > load_flag $ff
+14cf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+14d1 : 48 > pha ;use stack to load status
+14d2 : a92f > lda #$aa-$7b ;precharge accu
+14d4 : 28 > plp
+ >
+14d5 : 7b > db $7b ;test nop integrity - flags on
+14d6 : ea > nop
+14d7 : ea > nop
+ > tst_a $aa-$7b,$ff
+14d8 : 08 > php ;save flags
+14d9 : c92f > cmp #$aa-$7b ;test result
+ > trap_ne
+14db : d0fe > bne * ;failed not equal (non zero)
+ >
+14dd : 68 > pla ;load status
+14de : 48 > pha
+ > cmp_flag $ff
+14df : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+14e1 : d0fe > bne * ;failed not equal (non zero)
+ >
+14e3 : 28 > plp ;restore status
+ >
+14e4 : c042 > cpy #$42
+ > trap_ne ;y changed
+14e6 : d0fe > bne * ;failed not equal (non zero)
+ >
+14e8 : e000 > cpx #0
+ > trap_ne ;x changed
+14ea : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $8b,1
+14ec : a042 > ldy #$42
+14ee : a203 > ldx #4-1
+14f0 : 8b > db $8b ;test nop length
+ > if 1 = 1
+14f1 : ca > dex
+14f2 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+14f3 : ca > dex
+ > trap_ne ;wrong number of bytes
+14f4 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$8b,0
+ > load_flag 0
+14f6 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+14f8 : 48 > pha ;use stack to load status
+14f9 : a974 > lda #$ff-$8b ;precharge accu
+14fb : 28 > plp
+ >
+14fc : 8b > db $8b ;test nop integrity - flags off
+14fd : ea > nop
+14fe : ea > nop
+ > tst_a $ff-$8b,0
+14ff : 08 > php ;save flags
+1500 : c974 > cmp #$ff-$8b ;test result
+ > trap_ne
+1502 : d0fe > bne * ;failed not equal (non zero)
+ >
+1504 : 68 > pla ;load status
+1505 : 48 > pha
+ > cmp_flag 0
+1506 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1508 : d0fe > bne * ;failed not equal (non zero)
+ >
+150a : 28 > plp ;restore status
+ >
+ > set_a $aa-$8b,$ff
+ > load_flag $ff
+150b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+150d : 48 > pha ;use stack to load status
+150e : a91f > lda #$aa-$8b ;precharge accu
+1510 : 28 > plp
+ >
+1511 : 8b > db $8b ;test nop integrity - flags on
+1512 : ea > nop
+1513 : ea > nop
+ > tst_a $aa-$8b,$ff
+1514 : 08 > php ;save flags
+1515 : c91f > cmp #$aa-$8b ;test result
+ > trap_ne
+1517 : d0fe > bne * ;failed not equal (non zero)
+ >
+1519 : 68 > pla ;load status
+151a : 48 > pha
+ > cmp_flag $ff
+151b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+151d : d0fe > bne * ;failed not equal (non zero)
+ >
+151f : 28 > plp ;restore status
+ >
+1520 : c042 > cpy #$42
+ > trap_ne ;y changed
+1522 : d0fe > bne * ;failed not equal (non zero)
+ >
+1524 : e000 > cpx #0
+ > trap_ne ;x changed
+1526 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $9b,1
+1528 : a042 > ldy #$42
+152a : a203 > ldx #4-1
+152c : 9b > db $9b ;test nop length
+ > if 1 = 1
+152d : ca > dex
+152e : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+152f : ca > dex
+ > trap_ne ;wrong number of bytes
+1530 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$9b,0
+ > load_flag 0
+1532 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1534 : 48 > pha ;use stack to load status
+1535 : a964 > lda #$ff-$9b ;precharge accu
+1537 : 28 > plp
+ >
+1538 : 9b > db $9b ;test nop integrity - flags off
+1539 : ea > nop
+153a : ea > nop
+ > tst_a $ff-$9b,0
+153b : 08 > php ;save flags
+153c : c964 > cmp #$ff-$9b ;test result
+ > trap_ne
+153e : d0fe > bne * ;failed not equal (non zero)
+ >
+1540 : 68 > pla ;load status
+1541 : 48 > pha
+ > cmp_flag 0
+1542 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1544 : d0fe > bne * ;failed not equal (non zero)
+ >
+1546 : 28 > plp ;restore status
+ >
+ > set_a $aa-$9b,$ff
+ > load_flag $ff
+1547 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1549 : 48 > pha ;use stack to load status
+154a : a90f > lda #$aa-$9b ;precharge accu
+154c : 28 > plp
+ >
+154d : 9b > db $9b ;test nop integrity - flags on
+154e : ea > nop
+154f : ea > nop
+ > tst_a $aa-$9b,$ff
+1550 : 08 > php ;save flags
+1551 : c90f > cmp #$aa-$9b ;test result
+ > trap_ne
+1553 : d0fe > bne * ;failed not equal (non zero)
+ >
+1555 : 68 > pla ;load status
+1556 : 48 > pha
+ > cmp_flag $ff
+1557 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1559 : d0fe > bne * ;failed not equal (non zero)
+ >
+155b : 28 > plp ;restore status
+ >
+155c : c042 > cpy #$42
+ > trap_ne ;y changed
+155e : d0fe > bne * ;failed not equal (non zero)
+ >
+1560 : e000 > cpx #0
+ > trap_ne ;x changed
+1562 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $ab,1
+1564 : a042 > ldy #$42
+1566 : a203 > ldx #4-1
+1568 : ab > db $ab ;test nop length
+ > if 1 = 1
+1569 : ca > dex
+156a : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+156b : ca > dex
+ > trap_ne ;wrong number of bytes
+156c : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$ab,0
+ > load_flag 0
+156e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1570 : 48 > pha ;use stack to load status
+1571 : a954 > lda #$ff-$ab ;precharge accu
+1573 : 28 > plp
+ >
+1574 : ab > db $ab ;test nop integrity - flags off
+1575 : ea > nop
+1576 : ea > nop
+ > tst_a $ff-$ab,0
+1577 : 08 > php ;save flags
+1578 : c954 > cmp #$ff-$ab ;test result
+ > trap_ne
+157a : d0fe > bne * ;failed not equal (non zero)
+ >
+157c : 68 > pla ;load status
+157d : 48 > pha
+ > cmp_flag 0
+157e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1580 : d0fe > bne * ;failed not equal (non zero)
+ >
+1582 : 28 > plp ;restore status
+ >
+ > set_a $aa-$ab,$ff
+ > load_flag $ff
+1583 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1585 : 48 > pha ;use stack to load status
+1586 : a9ff > lda #$aa-$ab ;precharge accu
+1588 : 28 > plp
+ >
+1589 : ab > db $ab ;test nop integrity - flags on
+158a : ea > nop
+158b : ea > nop
+ > tst_a $aa-$ab,$ff
+158c : 08 > php ;save flags
+158d : c9ff > cmp #$aa-$ab ;test result
+ > trap_ne
+158f : d0fe > bne * ;failed not equal (non zero)
+ >
+1591 : 68 > pla ;load status
+1592 : 48 > pha
+ > cmp_flag $ff
+1593 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1595 : d0fe > bne * ;failed not equal (non zero)
+ >
+1597 : 28 > plp ;restore status
+ >
+1598 : c042 > cpy #$42
+ > trap_ne ;y changed
+159a : d0fe > bne * ;failed not equal (non zero)
+ >
+159c : e000 > cpx #0
+ > trap_ne ;x changed
+159e : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $bb,1
+15a0 : a042 > ldy #$42
+15a2 : a203 > ldx #4-1
+15a4 : bb > db $bb ;test nop length
+ > if 1 = 1
+15a5 : ca > dex
+15a6 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+15a7 : ca > dex
+ > trap_ne ;wrong number of bytes
+15a8 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$bb,0
+ > load_flag 0
+15aa : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+15ac : 48 > pha ;use stack to load status
+15ad : a944 > lda #$ff-$bb ;precharge accu
+15af : 28 > plp
+ >
+15b0 : bb > db $bb ;test nop integrity - flags off
+15b1 : ea > nop
+15b2 : ea > nop
+ > tst_a $ff-$bb,0
+15b3 : 08 > php ;save flags
+15b4 : c944 > cmp #$ff-$bb ;test result
+ > trap_ne
+15b6 : d0fe > bne * ;failed not equal (non zero)
+ >
+15b8 : 68 > pla ;load status
+15b9 : 48 > pha
+ > cmp_flag 0
+15ba : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+15bc : d0fe > bne * ;failed not equal (non zero)
+ >
+15be : 28 > plp ;restore status
+ >
+ > set_a $aa-$bb,$ff
+ > load_flag $ff
+15bf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+15c1 : 48 > pha ;use stack to load status
+15c2 : a9ef > lda #$aa-$bb ;precharge accu
+15c4 : 28 > plp
+ >
+15c5 : bb > db $bb ;test nop integrity - flags on
+15c6 : ea > nop
+15c7 : ea > nop
+ > tst_a $aa-$bb,$ff
+15c8 : 08 > php ;save flags
+15c9 : c9ef > cmp #$aa-$bb ;test result
+ > trap_ne
+15cb : d0fe > bne * ;failed not equal (non zero)
+ >
+15cd : 68 > pla ;load status
+15ce : 48 > pha
+ > cmp_flag $ff
+15cf : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+15d1 : d0fe > bne * ;failed not equal (non zero)
+ >
+15d3 : 28 > plp ;restore status
+ >
+15d4 : c042 > cpy #$42
+ > trap_ne ;y changed
+15d6 : d0fe > bne * ;failed not equal (non zero)
+ >
+15d8 : e000 > cpx #0
+ > trap_ne ;x changed
+15da : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $eb,1
+15dc : a042 > ldy #$42
+15de : a203 > ldx #4-1
+15e0 : eb > db $eb ;test nop length
+ > if 1 = 1
+15e1 : ca > dex
+15e2 : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+15e3 : ca > dex
+ > trap_ne ;wrong number of bytes
+15e4 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$eb,0
+ > load_flag 0
+15e6 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+15e8 : 48 > pha ;use stack to load status
+15e9 : a914 > lda #$ff-$eb ;precharge accu
+15eb : 28 > plp
+ >
+15ec : eb > db $eb ;test nop integrity - flags off
+15ed : ea > nop
+15ee : ea > nop
+ > tst_a $ff-$eb,0
+15ef : 08 > php ;save flags
+15f0 : c914 > cmp #$ff-$eb ;test result
+ > trap_ne
+15f2 : d0fe > bne * ;failed not equal (non zero)
+ >
+15f4 : 68 > pla ;load status
+15f5 : 48 > pha
+ > cmp_flag 0
+15f6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+15f8 : d0fe > bne * ;failed not equal (non zero)
+ >
+15fa : 28 > plp ;restore status
+ >
+ > set_a $aa-$eb,$ff
+ > load_flag $ff
+15fb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+15fd : 48 > pha ;use stack to load status
+15fe : a9bf > lda #$aa-$eb ;precharge accu
+1600 : 28 > plp
+ >
+1601 : eb > db $eb ;test nop integrity - flags on
+1602 : ea > nop
+1603 : ea > nop
+ > tst_a $aa-$eb,$ff
+1604 : 08 > php ;save flags
+1605 : c9bf > cmp #$aa-$eb ;test result
+ > trap_ne
+1607 : d0fe > bne * ;failed not equal (non zero)
+ >
+1609 : 68 > pla ;load status
+160a : 48 > pha
+ > cmp_flag $ff
+160b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+160d : d0fe > bne * ;failed not equal (non zero)
+ >
+160f : 28 > plp ;restore status
+ >
+1610 : c042 > cpy #$42
+ > trap_ne ;y changed
+1612 : d0fe > bne * ;failed not equal (non zero)
+ >
+1614 : e000 > cpx #0
+ > trap_ne ;x changed
+1616 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ nop_test $fb,1
+1618 : a042 > ldy #$42
+161a : a203 > ldx #4-1
+161c : fb > db $fb ;test nop length
+ > if 1 = 1
+161d : ca > dex
+161e : ca > dex
+ > endif
+ > if 1 = 2
+ > iny
+ > dex
+ > endif
+ > if 1 = 3
+ > iny
+ > iny
+ > endif
+161f : ca > dex
+ > trap_ne ;wrong number of bytes
+1620 : d0fe > bne * ;failed not equal (non zero)
+ >
+ > set_a $ff-$fb,0
+ > load_flag 0
+1622 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1624 : 48 > pha ;use stack to load status
+1625 : a904 > lda #$ff-$fb ;precharge accu
+1627 : 28 > plp
+ >
+1628 : fb > db $fb ;test nop integrity - flags off
+1629 : ea > nop
+162a : ea > nop
+ > tst_a $ff-$fb,0
+162b : 08 > php ;save flags
+162c : c904 > cmp #$ff-$fb ;test result
+ > trap_ne
+162e : d0fe > bne * ;failed not equal (non zero)
+ >
+1630 : 68 > pla ;load status
+1631 : 48 > pha
+ > cmp_flag 0
+1632 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1634 : d0fe > bne * ;failed not equal (non zero)
+ >
+1636 : 28 > plp ;restore status
+ >
+ > set_a $aa-$fb,$ff
+ > load_flag $ff
+1637 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1639 : 48 > pha ;use stack to load status
+163a : a9af > lda #$aa-$fb ;precharge accu
+163c : 28 > plp
+ >
+163d : fb > db $fb ;test nop integrity - flags on
+163e : ea > nop
+163f : ea > nop
+ > tst_a $aa-$fb,$ff
+1640 : 08 > php ;save flags
+1641 : c9af > cmp #$aa-$fb ;test result
+ > trap_ne
+1643 : d0fe > bne * ;failed not equal (non zero)
+ >
+1645 : 68 > pla ;load status
+1646 : 48 > pha
+ > cmp_flag $ff
+1647 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1649 : d0fe > bne * ;failed not equal (non zero)
+ >
+164b : 28 > plp ;restore status
+ >
+164c : c042 > cpy #$42
+ > trap_ne ;y changed
+164e : d0fe > bne * ;failed not equal (non zero)
+ >
+1650 : e000 > cpx #0
+ > trap_ne ;x changed
+1652 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ if rkwl_wdc_op = 0 ;NOPs not available on Rockwell & WDC 65C02
+ nop_test $07,1
+ nop_test $17,1
+ nop_test $27,1
+ nop_test $37,1
+ nop_test $47,1
+ nop_test $57,1
+ nop_test $67,1
+ nop_test $77,1
+ nop_test $87,1
+ nop_test $97,1
+ nop_test $a7,1
+ nop_test $b7,1
+ nop_test $c7,1
+ nop_test $d7,1
+ nop_test $e7,1
+ nop_test $f7,1
+ nop_test $0f,1
+ nop_test $1f,1
+ nop_test $2f,1
+ nop_test $3f,1
+ nop_test $4f,1
+ nop_test $5f,1
+ nop_test $6f,1
+ nop_test $7f,1
+ nop_test $8f,1
+ nop_test $9f,1
+ nop_test $af,1
+ nop_test $bf,1
+ nop_test $cf,1
+ nop_test $df,1
+ nop_test $ef,1
+ nop_test $ff,1
+ endif
+ if wdc_op = 0 ;NOPs not available on WDC 65C02 (WAI, STP)
+ nop_test $cb,1
+ nop_test $db,1
+ endif
+ next_test
+1654 : ad0202 > lda test_case ;previous test
+1657 : c908 > cmp #test_num
+ > trap_ne ;test is out of sequence
+1659 : d0fe > bne * ;failed not equal (non zero)
+ >
+0009 = >test_num = test_num + 1
+165b : a909 > lda #test_num ;*** next tests' number
+165d : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; jump indirect (test page cross bug is fixed)
+1660 : a203 ldx #3 ;prepare table
+1662 : bd4026 ji1 lda ji_adr,x
+1665 : 9dfd02 sta ji_tab,x
+1668 : ca dex
+1669 : 10f7 bpl ji1
+166b : a927 lda #hi(ji_px) ;high address if page cross bug
+166d : 8d0002 sta pg_x
+ set_stat 0
+ > load_flag 0
+1670 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1672 : 48 > pha ;use stack to load status
+1673 : 28 > plp
+
+1674 : a949 lda #'I'
+1676 : a24e ldx #'N'
+1678 : a044 ldy #'D' ;N=0, V=0, Z=0, C=0
+167a : 6cfd02 jmp (ji_tab)
+167d : ea nop
+ trap_ne ;runover protection
+167e : d0fe > bne * ;failed not equal (non zero)
+
+
+1680 : 88 dey
+1681 : 88 dey
+1682 : 08 ji_ret php ;either SP or Y count will fail, if we do not hit
+1683 : 88 dey
+1684 : 88 dey
+1685 : 88 dey
+1686 : 28 plp
+ trap_eq ;returned flags OK?
+1687 : f0fe > beq * ;failed equal (zero)
+
+ trap_pl
+1689 : 10fe > bpl * ;failed plus (bit 7 clear)
+
+ trap_cc
+168b : 90fe > bcc * ;failed carry clear
+
+ trap_vc
+168d : 50fe > bvc * ;failed overflow clear
+
+168f : c9e3 cmp #('I'^$aa) ;returned registers OK?
+ trap_ne
+1691 : d0fe > bne * ;failed not equal (non zero)
+
+1693 : e04f cpx #('N'+1)
+ trap_ne
+1695 : d0fe > bne * ;failed not equal (non zero)
+
+1697 : c03e cpy #('D'-6)
+ trap_ne
+1699 : d0fe > bne * ;failed not equal (non zero)
+
+169b : ba tsx ;SP check
+169c : e0ff cpx #$ff
+ trap_ne
+169e : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+16a0 : ad0202 > lda test_case ;previous test
+16a3 : c909 > cmp #test_num
+ > trap_ne ;test is out of sequence
+16a5 : d0fe > bne * ;failed not equal (non zero)
+ >
+000a = >test_num = test_num + 1
+16a7 : a90a > lda #test_num ;*** next tests' number
+16a9 : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; jump indexed indirect
+16ac : a20b ldx #11 ;prepare table
+16ae : bd7926 jxi1 lda jxi_adr,x
+16b1 : 9df902 sta jxi_tab,x
+16b4 : ca dex
+16b5 : 10f7 bpl jxi1
+16b7 : a927 lda #hi(jxi_px) ;high address if page cross bug
+16b9 : 8d0002 sta pg_x
+ set_stat 0
+ > load_flag 0
+16bc : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+16be : 48 > pha ;use stack to load status
+16bf : 28 > plp
+
+16c0 : a958 lda #'X'
+16c2 : a204 ldx #4
+16c4 : a049 ldy #'I' ;N=0, V=0, Z=0, C=0
+16c6 : 7cf902 jmp (jxi_tab,x)
+16c9 : ea nop
+ trap_ne ;runover protection
+16ca : d0fe > bne * ;failed not equal (non zero)
+
+
+16cc : 88 dey
+16cd : 88 dey
+16ce : 08 jxi_ret php ;either SP or Y count will fail, if we do not hit
+16cf : 88 dey
+16d0 : 88 dey
+16d1 : 88 dey
+16d2 : 28 plp
+ trap_eq ;returned flags OK?
+16d3 : f0fe > beq * ;failed equal (zero)
+
+ trap_pl
+16d5 : 10fe > bpl * ;failed plus (bit 7 clear)
+
+ trap_cc
+16d7 : 90fe > bcc * ;failed carry clear
+
+ trap_vc
+16d9 : 50fe > bvc * ;failed overflow clear
+
+16db : c9f2 cmp #('X'^$aa) ;returned registers OK?
+ trap_ne
+16dd : d0fe > bne * ;failed not equal (non zero)
+
+16df : e006 cpx #6
+ trap_ne
+16e1 : d0fe > bne * ;failed not equal (non zero)
+
+16e3 : c043 cpy #('I'-6)
+ trap_ne
+16e5 : d0fe > bne * ;failed not equal (non zero)
+
+16e7 : ba tsx ;SP check
+16e8 : e0ff cpx #$ff
+ trap_ne
+16ea : d0fe > bne * ;failed not equal (non zero)
+
+
+16ec : a908 lda #lo(jxp_ok) ;test with index causing a page cross
+16ee : 8d0003 sta jxp_tab
+16f1 : a917 lda #hi(jxp_ok)
+16f3 : 8d0103 sta jxp_tab+1
+16f6 : a905 lda #lo(jxp_px)
+16f8 : 8d0002 sta pg_x
+16fb : a917 lda #hi(jxp_px)
+16fd : 8d0102 sta pg_x+1
+1700 : a2ff ldx #$ff
+1702 : 7c0102 jmp (jxp_tab-$ff,x)
+
+1705 : jxp_px
+ trap ;page cross by index to wrong page
+1705 : 4c0517 > jmp * ;failed anyway
+
+
+1708 : jxp_ok
+ next_test
+1708 : ad0202 > lda test_case ;previous test
+170b : c90a > cmp #test_num
+ > trap_ne ;test is out of sequence
+170d : d0fe > bne * ;failed not equal (non zero)
+ >
+000b = >test_num = test_num + 1
+170f : a90b > lda #test_num ;*** next tests' number
+1711 : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ if ROM_vectors = 1
+ ; test BRK clears decimal mode
+1714 : f8 sed
+1715 : 00 brk
+1716 : ea nop
+1717 : brk_ret
+ next_test
+1717 : ad0202 > lda test_case ;previous test
+171a : c90b > cmp #test_num
+ > trap_ne ;test is out of sequence
+171c : d0fe > bne * ;failed not equal (non zero)
+ >
+000c = >test_num = test_num + 1
+171e : a90c > lda #test_num ;*** next tests' number
+1720 : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+ endif
+
+ ; testing accumulator increment/decrement INC A & DEC A
+1723 : a2ac ldx #$ac ;protect x & y
+1725 : a0dc ldy #$dc
+ set_a $fe,$ff
+ > load_flag $ff
+1727 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1729 : 48 > pha ;use stack to load status
+172a : a9fe > lda #$fe ;precharge accu
+172c : 28 > plp
+
+172d : 1a inc a ;ff
+ tst_as $ff,$ff-zero
+172e : 48 > pha
+172f : 08 > php ;save flags
+1730 : c9ff > cmp #$ff ;test result
+ > trap_ne
+1732 : d0fe > bne * ;failed not equal (non zero)
+ >
+1734 : 68 > pla ;load status
+1735 : 48 > pha
+ > cmp_flag $ff-zero
+1736 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1738 : d0fe > bne * ;failed not equal (non zero)
+ >
+173a : 28 > plp ;restore status
+173b : 68 > pla
+
+173c : 1a inc a ;00
+ tst_as 0,$ff-minus
+173d : 48 > pha
+173e : 08 > php ;save flags
+173f : c900 > cmp #0 ;test result
+ > trap_ne
+1741 : d0fe > bne * ;failed not equal (non zero)
+ >
+1743 : 68 > pla ;load status
+1744 : 48 > pha
+ > cmp_flag $ff-minus
+1745 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1747 : d0fe > bne * ;failed not equal (non zero)
+ >
+1749 : 28 > plp ;restore status
+174a : 68 > pla
+
+174b : 1a inc a ;01
+ tst_as 1,$ff-minus-zero
+174c : 48 > pha
+174d : 08 > php ;save flags
+174e : c901 > cmp #1 ;test result
+ > trap_ne
+1750 : d0fe > bne * ;failed not equal (non zero)
+ >
+1752 : 68 > pla ;load status
+1753 : 48 > pha
+ > cmp_flag $ff-minus-zero
+1754 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1756 : d0fe > bne * ;failed not equal (non zero)
+ >
+1758 : 28 > plp ;restore status
+1759 : 68 > pla
+
+175a : 3a dec a ;00
+ tst_as 0,$ff-minus
+175b : 48 > pha
+175c : 08 > php ;save flags
+175d : c900 > cmp #0 ;test result
+ > trap_ne
+175f : d0fe > bne * ;failed not equal (non zero)
+ >
+1761 : 68 > pla ;load status
+1762 : 48 > pha
+ > cmp_flag $ff-minus
+1763 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1765 : d0fe > bne * ;failed not equal (non zero)
+ >
+1767 : 28 > plp ;restore status
+1768 : 68 > pla
+
+1769 : 3a dec a ;ff
+ tst_as $ff,$ff-zero
+176a : 48 > pha
+176b : 08 > php ;save flags
+176c : c9ff > cmp #$ff ;test result
+ > trap_ne
+176e : d0fe > bne * ;failed not equal (non zero)
+ >
+1770 : 68 > pla ;load status
+1771 : 48 > pha
+ > cmp_flag $ff-zero
+1772 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1774 : d0fe > bne * ;failed not equal (non zero)
+ >
+1776 : 28 > plp ;restore status
+1777 : 68 > pla
+
+1778 : 3a dec a ;fe
+ set_a $fe,0
+ > load_flag 0
+1779 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+177b : 48 > pha ;use stack to load status
+177c : a9fe > lda #$fe ;precharge accu
+177e : 28 > plp
+
+177f : 1a inc a ;ff
+ tst_as $ff,minus
+1780 : 48 > pha
+1781 : 08 > php ;save flags
+1782 : c9ff > cmp #$ff ;test result
+ > trap_ne
+1784 : d0fe > bne * ;failed not equal (non zero)
+ >
+1786 : 68 > pla ;load status
+1787 : 48 > pha
+ > cmp_flag minus
+1788 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+178a : d0fe > bne * ;failed not equal (non zero)
+ >
+178c : 28 > plp ;restore status
+178d : 68 > pla
+
+178e : 1a inc a ;00
+ tst_as 0,zero
+178f : 48 > pha
+1790 : 08 > php ;save flags
+1791 : c900 > cmp #0 ;test result
+ > trap_ne
+1793 : d0fe > bne * ;failed not equal (non zero)
+ >
+1795 : 68 > pla ;load status
+1796 : 48 > pha
+ > cmp_flag zero
+1797 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1799 : d0fe > bne * ;failed not equal (non zero)
+ >
+179b : 28 > plp ;restore status
+179c : 68 > pla
+
+179d : 1a inc a ;01
+ tst_as 1,0
+179e : 48 > pha
+179f : 08 > php ;save flags
+17a0 : c901 > cmp #1 ;test result
+ > trap_ne
+17a2 : d0fe > bne * ;failed not equal (non zero)
+ >
+17a4 : 68 > pla ;load status
+17a5 : 48 > pha
+ > cmp_flag 0
+17a6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+17a8 : d0fe > bne * ;failed not equal (non zero)
+ >
+17aa : 28 > plp ;restore status
+17ab : 68 > pla
+
+17ac : 3a dec a ;00
+ tst_as 0,zero
+17ad : 48 > pha
+17ae : 08 > php ;save flags
+17af : c900 > cmp #0 ;test result
+ > trap_ne
+17b1 : d0fe > bne * ;failed not equal (non zero)
+ >
+17b3 : 68 > pla ;load status
+17b4 : 48 > pha
+ > cmp_flag zero
+17b5 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+17b7 : d0fe > bne * ;failed not equal (non zero)
+ >
+17b9 : 28 > plp ;restore status
+17ba : 68 > pla
+
+17bb : 3a dec a ;ff
+ tst_as $ff,minus
+17bc : 48 > pha
+17bd : 08 > php ;save flags
+17be : c9ff > cmp #$ff ;test result
+ > trap_ne
+17c0 : d0fe > bne * ;failed not equal (non zero)
+ >
+17c2 : 68 > pla ;load status
+17c3 : 48 > pha
+ > cmp_flag minus
+17c4 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+17c6 : d0fe > bne * ;failed not equal (non zero)
+ >
+17c8 : 28 > plp ;restore status
+17c9 : 68 > pla
+
+17ca : e0ac cpx #$ac
+ trap_ne ;x altered during test
+17cc : d0fe > bne * ;failed not equal (non zero)
+
+17ce : c0dc cpy #$dc
+ trap_ne ;y altered during test
+17d0 : d0fe > bne * ;failed not equal (non zero)
+
+17d2 : ba tsx
+17d3 : e0ff cpx #$ff
+ trap_ne ;sp push/pop mismatch
+17d5 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+17d7 : ad0202 > lda test_case ;previous test
+17da : c90c > cmp #test_num
+ > trap_ne ;test is out of sequence
+17dc : d0fe > bne * ;failed not equal (non zero)
+ >
+000d = >test_num = test_num + 1
+17de : a90d > lda #test_num ;*** next tests' number
+17e0 : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; testing load / store accumulator LDA / STA (zp)
+17e3 : a299 ldx #$99 ;protect x & y
+17e5 : a066 ldy #$66
+ set_stat 0
+ > load_flag 0
+17e7 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+17e9 : 48 > pha ;use stack to load status
+17ea : 28 > plp
+
+17eb : b222 lda (ind1)
+17ed : 08 php ;test stores do not alter flags
+17ee : 49c3 eor #$c3
+17f0 : 28 plp
+17f1 : 922e sta (indt)
+17f3 : 08 php ;flags after load/store sequence
+17f4 : 49c3 eor #$c3
+17f6 : c9c3 cmp #$c3 ;test result
+ trap_ne
+17f8 : d0fe > bne * ;failed not equal (non zero)
+
+17fa : 68 pla ;load status
+ eor_flag 0
+17fb : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+17fd : cd0f02 cmp fLDx ;test flags
+ trap_ne
+1800 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1802 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1804 : 48 > pha ;use stack to load status
+1805 : 28 > plp
+
+1806 : b224 lda (ind1+2)
+1808 : 08 php ;test stores do not alter flags
+1809 : 49c3 eor #$c3
+180b : 28 plp
+180c : 9230 sta (indt+2)
+180e : 08 php ;flags after load/store sequence
+180f : 49c3 eor #$c3
+1811 : c982 cmp #$82 ;test result
+ trap_ne
+1813 : d0fe > bne * ;failed not equal (non zero)
+
+1815 : 68 pla ;load status
+ eor_flag 0
+1816 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1818 : cd1002 cmp fLDx+1 ;test flags
+ trap_ne
+181b : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+181d : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+181f : 48 > pha ;use stack to load status
+1820 : 28 > plp
+
+1821 : b226 lda (ind1+4)
+1823 : 08 php ;test stores do not alter flags
+1824 : 49c3 eor #$c3
+1826 : 28 plp
+1827 : 9232 sta (indt+4)
+1829 : 08 php ;flags after load/store sequence
+182a : 49c3 eor #$c3
+182c : c941 cmp #$41 ;test result
+ trap_ne
+182e : d0fe > bne * ;failed not equal (non zero)
+
+1830 : 68 pla ;load status
+ eor_flag 0
+1831 : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+1833 : cd1102 cmp fLDx+2 ;test flags
+ trap_ne
+1836 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat 0
+ > load_flag 0
+1838 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+183a : 48 > pha ;use stack to load status
+183b : 28 > plp
+
+183c : b228 lda (ind1+6)
+183e : 08 php ;test stores do not alter flags
+183f : 49c3 eor #$c3
+1841 : 28 plp
+1842 : 9234 sta (indt+6)
+1844 : 08 php ;flags after load/store sequence
+1845 : 49c3 eor #$c3
+1847 : c900 cmp #0 ;test result
+ trap_ne
+1849 : d0fe > bne * ;failed not equal (non zero)
+
+184b : 68 pla ;load status
+ eor_flag 0
+184c : 4930 > eor #0|fao ;invert expected flags + always on bits
+
+184e : cd1202 cmp fLDx+3 ;test flags
+ trap_ne
+1851 : d0fe > bne * ;failed not equal (non zero)
+
+1853 : e099 cpx #$99
+ trap_ne ;x altered during test
+1855 : d0fe > bne * ;failed not equal (non zero)
+
+1857 : c066 cpy #$66
+ trap_ne ;y altered during test
+1859 : d0fe > bne * ;failed not equal (non zero)
+
+
+185b : a003 ldy #3 ;testing store result
+185d : a200 ldx #0
+185f : b90502 tstai1 lda abst,y
+1862 : 49c3 eor #$c3
+1864 : d90a02 cmp abs1,y
+ trap_ne ;store to indirect data
+1867 : d0fe > bne * ;failed not equal (non zero)
+
+1869 : 8a txa
+186a : 990502 sta abst,y ;clear
+186d : 88 dey
+186e : 10ef bpl tstai1
+
+1870 : a299 ldx #$99 ;protect x & y
+1872 : a066 ldy #$66
+ set_stat $ff
+ > load_flag $ff
+1874 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1876 : 48 > pha ;use stack to load status
+1877 : 28 > plp
+
+1878 : b222 lda (ind1)
+187a : 08 php ;test stores do not alter flags
+187b : 49c3 eor #$c3
+187d : 28 plp
+187e : 922e sta (indt)
+1880 : 08 php ;flags after load/store sequence
+1881 : 49c3 eor #$c3
+1883 : c9c3 cmp #$c3 ;test result
+ trap_ne
+1885 : d0fe > bne * ;failed not equal (non zero)
+
+1887 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+1888 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+188a : cd0f02 cmp fLDx ;test flags
+ trap_ne
+188d : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+188f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1891 : 48 > pha ;use stack to load status
+1892 : 28 > plp
+
+1893 : b224 lda (ind1+2)
+1895 : 08 php ;test stores do not alter flags
+1896 : 49c3 eor #$c3
+1898 : 28 plp
+1899 : 9230 sta (indt+2)
+189b : 08 php ;flags after load/store sequence
+189c : 49c3 eor #$c3
+189e : c982 cmp #$82 ;test result
+ trap_ne
+18a0 : d0fe > bne * ;failed not equal (non zero)
+
+18a2 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+18a3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+18a5 : cd1002 cmp fLDx+1 ;test flags
+ trap_ne
+18a8 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+18aa : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+18ac : 48 > pha ;use stack to load status
+18ad : 28 > plp
+
+18ae : b226 lda (ind1+4)
+18b0 : 08 php ;test stores do not alter flags
+18b1 : 49c3 eor #$c3
+18b3 : 28 plp
+18b4 : 9232 sta (indt+4)
+18b6 : 08 php ;flags after load/store sequence
+18b7 : 49c3 eor #$c3
+18b9 : c941 cmp #$41 ;test result
+ trap_ne
+18bb : d0fe > bne * ;failed not equal (non zero)
+
+18bd : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+18be : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+18c0 : cd1102 cmp fLDx+2 ;test flags
+ trap_ne
+18c3 : d0fe > bne * ;failed not equal (non zero)
+
+ set_stat $ff
+ > load_flag $ff
+18c5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+18c7 : 48 > pha ;use stack to load status
+18c8 : 28 > plp
+
+18c9 : b228 lda (ind1+6)
+18cb : 08 php ;test stores do not alter flags
+18cc : 49c3 eor #$c3
+18ce : 28 plp
+18cf : 9234 sta (indt+6)
+18d1 : 08 php ;flags after load/store sequence
+18d2 : 49c3 eor #$c3
+18d4 : c900 cmp #0 ;test result
+ trap_ne
+18d6 : d0fe > bne * ;failed not equal (non zero)
+
+18d8 : 68 pla ;load status
+ eor_flag lo~fnz ;mask bits not altered
+18d9 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
+
+18db : cd1202 cmp fLDx+3 ;test flags
+ trap_ne
+18de : d0fe > bne * ;failed not equal (non zero)
+
+18e0 : e099 cpx #$99
+ trap_ne ;x altered during test
+18e2 : d0fe > bne * ;failed not equal (non zero)
+
+18e4 : c066 cpy #$66
+ trap_ne ;y altered during test
+18e6 : d0fe > bne * ;failed not equal (non zero)
+
+
+18e8 : a003 ldy #3 ;testing store result
+18ea : a200 ldx #0
+18ec : b90502 tstai2 lda abst,y
+18ef : 49c3 eor #$c3
+18f1 : d90a02 cmp abs1,y
+ trap_ne ;store to indirect data
+18f4 : d0fe > bne * ;failed not equal (non zero)
+
+18f6 : 8a txa
+18f7 : 990502 sta abst,y ;clear
+18fa : 88 dey
+18fb : 10ef bpl tstai2
+18fd : ba tsx
+18fe : e0ff cpx #$ff
+ trap_ne ;sp push/pop mismatch
+1900 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+1902 : ad0202 > lda test_case ;previous test
+1905 : c90d > cmp #test_num
+ > trap_ne ;test is out of sequence
+1907 : d0fe > bne * ;failed not equal (non zero)
+ >
+000e = >test_num = test_num + 1
+1909 : a90e > lda #test_num ;*** next tests' number
+190b : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; testing STZ - zp / abs / zp,x / abs,x
+190e : a07b ldy #123 ;protect y
+1910 : a204 ldx #4 ;precharge test area
+1912 : a907 lda #7
+1914 : 950a tstz1 sta zpt,x
+1916 : 0a asl a
+1917 : ca dex
+1918 : 10fa bpl tstz1
+191a : a204 ldx #4
+ set_a $55,$ff
+ > load_flag $ff
+191c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+191e : 48 > pha ;use stack to load status
+191f : a955 > lda #$55 ;precharge accu
+1921 : 28 > plp
+
+1922 : 640a stz zpt
+1924 : 640b stz zpt+1
+1926 : 640c stz zpt+2
+1928 : 640d stz zpt+3
+192a : 640e stz zpt+4
+ tst_a $55,$ff
+192c : 08 > php ;save flags
+192d : c955 > cmp #$55 ;test result
+ > trap_ne
+192f : d0fe > bne * ;failed not equal (non zero)
+ >
+1931 : 68 > pla ;load status
+1932 : 48 > pha
+ > cmp_flag $ff
+1933 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1935 : d0fe > bne * ;failed not equal (non zero)
+ >
+1937 : 28 > plp ;restore status
+
+1938 : b50a tstz2 lda zpt,x ;verify zeros stored
+ trap_ne ;non zero after STZ zp
+193a : d0fe > bne * ;failed not equal (non zero)
+
+193c : ca dex
+193d : 10f9 bpl tstz2
+193f : a204 ldx #4 ;precharge test area
+1941 : a907 lda #7
+1943 : 950a tstz3 sta zpt,x
+1945 : 0a asl a
+1946 : ca dex
+1947 : 10fa bpl tstz3
+1949 : a204 ldx #4
+ set_a $aa,0
+ > load_flag 0
+194b : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+194d : 48 > pha ;use stack to load status
+194e : a9aa > lda #$aa ;precharge accu
+1950 : 28 > plp
+
+1951 : 640a stz zpt
+1953 : 640b stz zpt+1
+1955 : 640c stz zpt+2
+1957 : 640d stz zpt+3
+1959 : 640e stz zpt+4
+ tst_a $aa,0
+195b : 08 > php ;save flags
+195c : c9aa > cmp #$aa ;test result
+ > trap_ne
+195e : d0fe > bne * ;failed not equal (non zero)
+ >
+1960 : 68 > pla ;load status
+1961 : 48 > pha
+ > cmp_flag 0
+1962 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1964 : d0fe > bne * ;failed not equal (non zero)
+ >
+1966 : 28 > plp ;restore status
+
+1967 : b50a tstz4 lda zpt,x ;verify zeros stored
+ trap_ne ;non zero after STZ zp
+1969 : d0fe > bne * ;failed not equal (non zero)
+
+196b : ca dex
+196c : 10f9 bpl tstz4
+
+196e : a204 ldx #4 ;precharge test area
+1970 : a907 lda #7
+1972 : 9d0502 tstz5 sta abst,x
+1975 : 0a asl a
+1976 : ca dex
+1977 : 10f9 bpl tstz5
+1979 : a204 ldx #4
+ set_a $55,$ff
+ > load_flag $ff
+197b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+197d : 48 > pha ;use stack to load status
+197e : a955 > lda #$55 ;precharge accu
+1980 : 28 > plp
+
+1981 : 9c0502 stz abst
+1984 : 9c0602 stz abst+1
+1987 : 9c0702 stz abst+2
+198a : 9c0802 stz abst+3
+198d : 9c0902 stz abst+4
+ tst_a $55,$ff
+1990 : 08 > php ;save flags
+1991 : c955 > cmp #$55 ;test result
+ > trap_ne
+1993 : d0fe > bne * ;failed not equal (non zero)
+ >
+1995 : 68 > pla ;load status
+1996 : 48 > pha
+ > cmp_flag $ff
+1997 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1999 : d0fe > bne * ;failed not equal (non zero)
+ >
+199b : 28 > plp ;restore status
+
+199c : bd0502 tstz6 lda abst,x ;verify zeros stored
+ trap_ne ;non zero after STZ abs
+199f : d0fe > bne * ;failed not equal (non zero)
+
+19a1 : ca dex
+19a2 : 10f8 bpl tstz6
+19a4 : a204 ldx #4 ;precharge test area
+19a6 : a907 lda #7
+19a8 : 9d0502 tstz7 sta abst,x
+19ab : 0a asl a
+19ac : ca dex
+19ad : 10f9 bpl tstz7
+19af : a204 ldx #4
+ set_a $aa,0
+ > load_flag 0
+19b1 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+19b3 : 48 > pha ;use stack to load status
+19b4 : a9aa > lda #$aa ;precharge accu
+19b6 : 28 > plp
+
+19b7 : 9c0502 stz abst
+19ba : 9c0602 stz abst+1
+19bd : 9c0702 stz abst+2
+19c0 : 9c0802 stz abst+3
+19c3 : 9c0902 stz abst+4
+ tst_a $aa,0
+19c6 : 08 > php ;save flags
+19c7 : c9aa > cmp #$aa ;test result
+ > trap_ne
+19c9 : d0fe > bne * ;failed not equal (non zero)
+ >
+19cb : 68 > pla ;load status
+19cc : 48 > pha
+ > cmp_flag 0
+19cd : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+19cf : d0fe > bne * ;failed not equal (non zero)
+ >
+19d1 : 28 > plp ;restore status
+
+19d2 : bd0502 tstz8 lda abst,x ;verify zeros stored
+ trap_ne ;non zero after STZ abs
+19d5 : d0fe > bne * ;failed not equal (non zero)
+
+19d7 : ca dex
+19d8 : 10f8 bpl tstz8
+
+19da : a204 ldx #4 ;precharge test area
+19dc : a907 lda #7
+19de : 950a tstz11 sta zpt,x
+19e0 : 0a asl a
+19e1 : ca dex
+19e2 : 10fa bpl tstz11
+19e4 : a204 ldx #4
+19e6 : tstz15
+ set_a $55,$ff
+ > load_flag $ff
+19e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+19e8 : 48 > pha ;use stack to load status
+19e9 : a955 > lda #$55 ;precharge accu
+19eb : 28 > plp
+
+19ec : 740a stz zpt,x
+ tst_a $55,$ff
+19ee : 08 > php ;save flags
+19ef : c955 > cmp #$55 ;test result
+ > trap_ne
+19f1 : d0fe > bne * ;failed not equal (non zero)
+ >
+19f3 : 68 > pla ;load status
+19f4 : 48 > pha
+ > cmp_flag $ff
+19f5 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+19f7 : d0fe > bne * ;failed not equal (non zero)
+ >
+19f9 : 28 > plp ;restore status
+
+19fa : ca dex
+19fb : 10e9 bpl tstz15
+19fd : a204 ldx #4
+19ff : b50a tstz12 lda zpt,x ;verify zeros stored
+ trap_ne ;non zero after STZ zp
+1a01 : d0fe > bne * ;failed not equal (non zero)
+
+1a03 : ca dex
+1a04 : 10f9 bpl tstz12
+1a06 : a204 ldx #4 ;precharge test area
+1a08 : a907 lda #7
+1a0a : 950a tstz13 sta zpt,x
+1a0c : 0a asl a
+1a0d : ca dex
+1a0e : 10fa bpl tstz13
+1a10 : a204 ldx #4
+1a12 : tstz16
+ set_a $aa,0
+ > load_flag 0
+1a12 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1a14 : 48 > pha ;use stack to load status
+1a15 : a9aa > lda #$aa ;precharge accu
+1a17 : 28 > plp
+
+1a18 : 740a stz zpt,x
+ tst_a $aa,0
+1a1a : 08 > php ;save flags
+1a1b : c9aa > cmp #$aa ;test result
+ > trap_ne
+1a1d : d0fe > bne * ;failed not equal (non zero)
+ >
+1a1f : 68 > pla ;load status
+1a20 : 48 > pha
+ > cmp_flag 0
+1a21 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1a23 : d0fe > bne * ;failed not equal (non zero)
+ >
+1a25 : 28 > plp ;restore status
+
+1a26 : ca dex
+1a27 : 10e9 bpl tstz16
+1a29 : a204 ldx #4
+1a2b : b50a tstz14 lda zpt,x ;verify zeros stored
+ trap_ne ;non zero after STZ zp
+1a2d : d0fe > bne * ;failed not equal (non zero)
+
+1a2f : ca dex
+1a30 : 10f9 bpl tstz14
+
+1a32 : a204 ldx #4 ;precharge test area
+1a34 : a907 lda #7
+1a36 : 9d0502 tstz21 sta abst,x
+1a39 : 0a asl a
+1a3a : ca dex
+1a3b : 10f9 bpl tstz21
+1a3d : a204 ldx #4
+1a3f : tstz25
+ set_a $55,$ff
+ > load_flag $ff
+1a3f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1a41 : 48 > pha ;use stack to load status
+1a42 : a955 > lda #$55 ;precharge accu
+1a44 : 28 > plp
+
+1a45 : 9e0502 stz abst,x
+ tst_a $55,$ff
+1a48 : 08 > php ;save flags
+1a49 : c955 > cmp #$55 ;test result
+ > trap_ne
+1a4b : d0fe > bne * ;failed not equal (non zero)
+ >
+1a4d : 68 > pla ;load status
+1a4e : 48 > pha
+ > cmp_flag $ff
+1a4f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1a51 : d0fe > bne * ;failed not equal (non zero)
+ >
+1a53 : 28 > plp ;restore status
+
+1a54 : ca dex
+1a55 : 10e8 bpl tstz25
+1a57 : a204 ldx #4
+1a59 : bd0502 tstz22 lda abst,x ;verify zeros stored
+ trap_ne ;non zero after STZ zp
+1a5c : d0fe > bne * ;failed not equal (non zero)
+
+1a5e : ca dex
+1a5f : 10f8 bpl tstz22
+1a61 : a204 ldx #4 ;precharge test area
+1a63 : a907 lda #7
+1a65 : 9d0502 tstz23 sta abst,x
+1a68 : 0a asl a
+1a69 : ca dex
+1a6a : 10f9 bpl tstz23
+1a6c : a204 ldx #4
+1a6e : tstz26
+ set_a $aa,0
+ > load_flag 0
+1a6e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1a70 : 48 > pha ;use stack to load status
+1a71 : a9aa > lda #$aa ;precharge accu
+1a73 : 28 > plp
+
+1a74 : 9e0502 stz abst,x
+ tst_a $aa,0
+1a77 : 08 > php ;save flags
+1a78 : c9aa > cmp #$aa ;test result
+ > trap_ne
+1a7a : d0fe > bne * ;failed not equal (non zero)
+ >
+1a7c : 68 > pla ;load status
+1a7d : 48 > pha
+ > cmp_flag 0
+1a7e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1a80 : d0fe > bne * ;failed not equal (non zero)
+ >
+1a82 : 28 > plp ;restore status
+
+1a83 : ca dex
+1a84 : 10e8 bpl tstz26
+1a86 : a204 ldx #4
+1a88 : bd0502 tstz24 lda abst,x ;verify zeros stored
+ trap_ne ;non zero after STZ zp
+1a8b : d0fe > bne * ;failed not equal (non zero)
+
+1a8d : ca dex
+1a8e : 10f8 bpl tstz24
+
+1a90 : c07b cpy #123
+ trap_ne ;y altered during test
+1a92 : d0fe > bne * ;failed not equal (non zero)
+
+1a94 : ba tsx
+1a95 : e0ff cpx #$ff
+ trap_ne ;sp push/pop mismatch
+1a97 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+1a99 : ad0202 > lda test_case ;previous test
+1a9c : c90e > cmp #test_num
+ > trap_ne ;test is out of sequence
+1a9e : d0fe > bne * ;failed not equal (non zero)
+ >
+000f = >test_num = test_num + 1
+1aa0 : a90f > lda #test_num ;*** next tests' number
+1aa2 : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; testing BIT - zp,x / abs,x / #
+1aa5 : a042 ldy #$42
+1aa7 : a203 ldx #3
+ set_a $ff,0
+ > load_flag 0
+1aa9 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1aab : 48 > pha ;use stack to load status
+1aac : a9ff > lda #$ff ;precharge accu
+1aae : 28 > plp
+
+1aaf : 3411 bit zp1,x ;00 - should set Z / clear NV
+ tst_a $ff,fz
+1ab1 : 08 > php ;save flags
+1ab2 : c9ff > cmp #$ff ;test result
+ > trap_ne
+1ab4 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ab6 : 68 > pla ;load status
+1ab7 : 48 > pha
+ > cmp_flag fz
+1ab8 : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1aba : d0fe > bne * ;failed not equal (non zero)
+ >
+1abc : 28 > plp ;restore status
+
+1abd : ca dex
+ set_a 1,0
+ > load_flag 0
+1abe : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1ac0 : 48 > pha ;use stack to load status
+1ac1 : a901 > lda #1 ;precharge accu
+1ac3 : 28 > plp
+
+1ac4 : 3411 bit zp1,x ;41 - should set V (M6) / clear NZ
+ tst_a 1,fv
+1ac6 : 08 > php ;save flags
+1ac7 : c901 > cmp #1 ;test result
+ > trap_ne
+1ac9 : d0fe > bne * ;failed not equal (non zero)
+ >
+1acb : 68 > pla ;load status
+1acc : 48 > pha
+ > cmp_flag fv
+1acd : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1acf : d0fe > bne * ;failed not equal (non zero)
+ >
+1ad1 : 28 > plp ;restore status
+
+1ad2 : ca dex
+ set_a 1,0
+ > load_flag 0
+1ad3 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1ad5 : 48 > pha ;use stack to load status
+1ad6 : a901 > lda #1 ;precharge accu
+1ad8 : 28 > plp
+
+1ad9 : 3411 bit zp1,x ;82 - should set N (M7) & Z / clear V
+ tst_a 1,fnz
+1adb : 08 > php ;save flags
+1adc : c901 > cmp #1 ;test result
+ > trap_ne
+1ade : d0fe > bne * ;failed not equal (non zero)
+ >
+1ae0 : 68 > pla ;load status
+1ae1 : 48 > pha
+ > cmp_flag fnz
+1ae2 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ae4 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ae6 : 28 > plp ;restore status
+
+1ae7 : ca dex
+ set_a 1,0
+ > load_flag 0
+1ae8 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1aea : 48 > pha ;use stack to load status
+1aeb : a901 > lda #1 ;precharge accu
+1aed : 28 > plp
+
+1aee : 3411 bit zp1,x ;c3 - should set N (M7) & V (M6) / clear Z
+ tst_a 1,fnv
+1af0 : 08 > php ;save flags
+1af1 : c901 > cmp #1 ;test result
+ > trap_ne
+1af3 : d0fe > bne * ;failed not equal (non zero)
+ >
+1af5 : 68 > pla ;load status
+1af6 : 48 > pha
+ > cmp_flag fnv
+1af7 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1af9 : d0fe > bne * ;failed not equal (non zero)
+ >
+1afb : 28 > plp ;restore status
+
+
+ set_a 1,$ff
+ > load_flag $ff
+1afc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1afe : 48 > pha ;use stack to load status
+1aff : a901 > lda #1 ;precharge accu
+1b01 : 28 > plp
+
+1b02 : 3411 bit zp1,x ;c3 - should set N (M7) & V (M6) / clear Z
+ tst_a 1,~fz
+1b04 : 08 > php ;save flags
+1b05 : c901 > cmp #1 ;test result
+ > trap_ne
+1b07 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b09 : 68 > pla ;load status
+1b0a : 48 > pha
+ > cmp_flag ~fz
+1b0b : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b0d : d0fe > bne * ;failed not equal (non zero)
+ >
+1b0f : 28 > plp ;restore status
+
+1b10 : e8 inx
+ set_a 1,$ff
+ > load_flag $ff
+1b11 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1b13 : 48 > pha ;use stack to load status
+1b14 : a901 > lda #1 ;precharge accu
+1b16 : 28 > plp
+
+1b17 : 3411 bit zp1,x ;82 - should set N (M7) & Z / clear V
+ tst_a 1,~fv
+1b19 : 08 > php ;save flags
+1b1a : c901 > cmp #1 ;test result
+ > trap_ne
+1b1c : d0fe > bne * ;failed not equal (non zero)
+ >
+1b1e : 68 > pla ;load status
+1b1f : 48 > pha
+ > cmp_flag ~fv
+1b20 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b22 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b24 : 28 > plp ;restore status
+
+1b25 : e8 inx
+ set_a 1,$ff
+ > load_flag $ff
+1b26 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1b28 : 48 > pha ;use stack to load status
+1b29 : a901 > lda #1 ;precharge accu
+1b2b : 28 > plp
+
+1b2c : 3411 bit zp1,x ;41 - should set V (M6) / clear NZ
+ tst_a 1,~fnz
+1b2e : 08 > php ;save flags
+1b2f : c901 > cmp #1 ;test result
+ > trap_ne
+1b31 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b33 : 68 > pla ;load status
+1b34 : 48 > pha
+ > cmp_flag ~fnz
+1b35 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b37 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b39 : 28 > plp ;restore status
+
+1b3a : e8 inx
+ set_a $ff,$ff
+ > load_flag $ff
+1b3b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1b3d : 48 > pha ;use stack to load status
+1b3e : a9ff > lda #$ff ;precharge accu
+1b40 : 28 > plp
+
+1b41 : 3411 bit zp1,x ;00 - should set Z / clear NV
+ tst_a $ff,~fnv
+1b43 : 08 > php ;save flags
+1b44 : c9ff > cmp #$ff ;test result
+ > trap_ne
+1b46 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b48 : 68 > pla ;load status
+1b49 : 48 > pha
+ > cmp_flag ~fnv
+1b4a : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b4c : d0fe > bne * ;failed not equal (non zero)
+ >
+1b4e : 28 > plp ;restore status
+
+
+ set_a $ff,0
+ > load_flag 0
+1b4f : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1b51 : 48 > pha ;use stack to load status
+1b52 : a9ff > lda #$ff ;precharge accu
+1b54 : 28 > plp
+
+1b55 : 3c0a02 bit abs1,x ;00 - should set Z / clear NV
+ tst_a $ff,fz
+1b58 : 08 > php ;save flags
+1b59 : c9ff > cmp #$ff ;test result
+ > trap_ne
+1b5b : d0fe > bne * ;failed not equal (non zero)
+ >
+1b5d : 68 > pla ;load status
+1b5e : 48 > pha
+ > cmp_flag fz
+1b5f : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b61 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b63 : 28 > plp ;restore status
+
+1b64 : ca dex
+ set_a 1,0
+ > load_flag 0
+1b65 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1b67 : 48 > pha ;use stack to load status
+1b68 : a901 > lda #1 ;precharge accu
+1b6a : 28 > plp
+
+1b6b : 3c0a02 bit abs1,x ;41 - should set V (M6) / clear NZ
+ tst_a 1,fv
+1b6e : 08 > php ;save flags
+1b6f : c901 > cmp #1 ;test result
+ > trap_ne
+1b71 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b73 : 68 > pla ;load status
+1b74 : 48 > pha
+ > cmp_flag fv
+1b75 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b77 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b79 : 28 > plp ;restore status
+
+1b7a : ca dex
+ set_a 1,0
+ > load_flag 0
+1b7b : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1b7d : 48 > pha ;use stack to load status
+1b7e : a901 > lda #1 ;precharge accu
+1b80 : 28 > plp
+
+1b81 : 3c0a02 bit abs1,x ;82 - should set N (M7) & Z / clear V
+ tst_a 1,fnz
+1b84 : 08 > php ;save flags
+1b85 : c901 > cmp #1 ;test result
+ > trap_ne
+1b87 : d0fe > bne * ;failed not equal (non zero)
+ >
+1b89 : 68 > pla ;load status
+1b8a : 48 > pha
+ > cmp_flag fnz
+1b8b : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1b8d : d0fe > bne * ;failed not equal (non zero)
+ >
+1b8f : 28 > plp ;restore status
+
+1b90 : ca dex
+ set_a 1,0
+ > load_flag 0
+1b91 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1b93 : 48 > pha ;use stack to load status
+1b94 : a901 > lda #1 ;precharge accu
+1b96 : 28 > plp
+
+1b97 : 3c0a02 bit abs1,x ;c3 - should set N (M7) & V (M6) / clear Z
+ tst_a 1,fnv
+1b9a : 08 > php ;save flags
+1b9b : c901 > cmp #1 ;test result
+ > trap_ne
+1b9d : d0fe > bne * ;failed not equal (non zero)
+ >
+1b9f : 68 > pla ;load status
+1ba0 : 48 > pha
+ > cmp_flag fnv
+1ba1 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ba3 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ba5 : 28 > plp ;restore status
+
+
+ set_a 1,$ff
+ > load_flag $ff
+1ba6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1ba8 : 48 > pha ;use stack to load status
+1ba9 : a901 > lda #1 ;precharge accu
+1bab : 28 > plp
+
+1bac : 3c0a02 bit abs1,x ;c3 - should set N (M7) & V (M6) / clear Z
+ tst_a 1,~fz
+1baf : 08 > php ;save flags
+1bb0 : c901 > cmp #1 ;test result
+ > trap_ne
+1bb2 : d0fe > bne * ;failed not equal (non zero)
+ >
+1bb4 : 68 > pla ;load status
+1bb5 : 48 > pha
+ > cmp_flag ~fz
+1bb6 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1bb8 : d0fe > bne * ;failed not equal (non zero)
+ >
+1bba : 28 > plp ;restore status
+
+1bbb : e8 inx
+ set_a 1,$ff
+ > load_flag $ff
+1bbc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1bbe : 48 > pha ;use stack to load status
+1bbf : a901 > lda #1 ;precharge accu
+1bc1 : 28 > plp
+
+1bc2 : 3c0a02 bit abs1,x ;82 - should set N (M7) & Z / clear V
+ tst_a 1,~fv
+1bc5 : 08 > php ;save flags
+1bc6 : c901 > cmp #1 ;test result
+ > trap_ne
+1bc8 : d0fe > bne * ;failed not equal (non zero)
+ >
+1bca : 68 > pla ;load status
+1bcb : 48 > pha
+ > cmp_flag ~fv
+1bcc : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1bce : d0fe > bne * ;failed not equal (non zero)
+ >
+1bd0 : 28 > plp ;restore status
+
+1bd1 : e8 inx
+ set_a 1,$ff
+ > load_flag $ff
+1bd2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1bd4 : 48 > pha ;use stack to load status
+1bd5 : a901 > lda #1 ;precharge accu
+1bd7 : 28 > plp
+
+1bd8 : 3c0a02 bit abs1,x ;41 - should set V (M6) / clear NZ
+ tst_a 1,~fnz
+1bdb : 08 > php ;save flags
+1bdc : c901 > cmp #1 ;test result
+ > trap_ne
+1bde : d0fe > bne * ;failed not equal (non zero)
+ >
+1be0 : 68 > pla ;load status
+1be1 : 48 > pha
+ > cmp_flag ~fnz
+1be2 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1be4 : d0fe > bne * ;failed not equal (non zero)
+ >
+1be6 : 28 > plp ;restore status
+
+1be7 : e8 inx
+ set_a $ff,$ff
+ > load_flag $ff
+1be8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1bea : 48 > pha ;use stack to load status
+1beb : a9ff > lda #$ff ;precharge accu
+1bed : 28 > plp
+
+1bee : 3c0a02 bit abs1,x ;00 - should set Z / clear NV
+ tst_a $ff,~fnv
+1bf1 : 08 > php ;save flags
+1bf2 : c9ff > cmp #$ff ;test result
+ > trap_ne
+1bf4 : d0fe > bne * ;failed not equal (non zero)
+ >
+1bf6 : 68 > pla ;load status
+1bf7 : 48 > pha
+ > cmp_flag ~fnv
+1bf8 : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1bfa : d0fe > bne * ;failed not equal (non zero)
+ >
+1bfc : 28 > plp ;restore status
+
+
+ set_a $ff,0
+ > load_flag 0
+1bfd : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1bff : 48 > pha ;use stack to load status
+1c00 : a9ff > lda #$ff ;precharge accu
+1c02 : 28 > plp
+
+1c03 : 8900 bit #$00 ;00 - should set Z
+ tst_a $ff,fz
+1c05 : 08 > php ;save flags
+1c06 : c9ff > cmp #$ff ;test result
+ > trap_ne
+1c08 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c0a : 68 > pla ;load status
+1c0b : 48 > pha
+ > cmp_flag fz
+1c0c : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c0e : d0fe > bne * ;failed not equal (non zero)
+ >
+1c10 : 28 > plp ;restore status
+
+1c11 : ca dex
+ set_a 1,0
+ > load_flag 0
+1c12 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1c14 : 48 > pha ;use stack to load status
+1c15 : a901 > lda #1 ;precharge accu
+1c17 : 28 > plp
+
+1c18 : 8941 bit #$41 ;41 - should clear Z
+ tst_a 1,0
+1c1a : 08 > php ;save flags
+1c1b : c901 > cmp #1 ;test result
+ > trap_ne
+1c1d : d0fe > bne * ;failed not equal (non zero)
+ >
+1c1f : 68 > pla ;load status
+1c20 : 48 > pha
+ > cmp_flag 0
+1c21 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c23 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c25 : 28 > plp ;restore status
+
+ ; *** DEBUG INFO ***
+ ; if it fails the previous test and your BIT # has set the V flag
+ ; see http://forum.6502.org/viewtopic.php?f=2&t=2241&p=27243#p27239
+ ; why it shouldn't alter N or V flags on a BIT #
+1c26 : ca dex
+ set_a 1,0
+ > load_flag 0
+1c27 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1c29 : 48 > pha ;use stack to load status
+1c2a : a901 > lda #1 ;precharge accu
+1c2c : 28 > plp
+
+1c2d : 8982 bit #$82 ;82 - should set Z
+ tst_a 1,fz
+1c2f : 08 > php ;save flags
+1c30 : c901 > cmp #1 ;test result
+ > trap_ne
+1c32 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c34 : 68 > pla ;load status
+1c35 : 48 > pha
+ > cmp_flag fz
+1c36 : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c38 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c3a : 28 > plp ;restore status
+
+1c3b : ca dex
+ set_a 1,0
+ > load_flag 0
+1c3c : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1c3e : 48 > pha ;use stack to load status
+1c3f : a901 > lda #1 ;precharge accu
+1c41 : 28 > plp
+
+1c42 : 89c3 bit #$c3 ;c3 - should clear Z
+ tst_a 1,0
+1c44 : 08 > php ;save flags
+1c45 : c901 > cmp #1 ;test result
+ > trap_ne
+1c47 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c49 : 68 > pla ;load status
+1c4a : 48 > pha
+ > cmp_flag 0
+1c4b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c4d : d0fe > bne * ;failed not equal (non zero)
+ >
+1c4f : 28 > plp ;restore status
+
+
+ set_a 1,$ff
+ > load_flag $ff
+1c50 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1c52 : 48 > pha ;use stack to load status
+1c53 : a901 > lda #1 ;precharge accu
+1c55 : 28 > plp
+
+1c56 : 89c3 bit #$c3 ;c3 - clear Z
+ tst_a 1,~fz
+1c58 : 08 > php ;save flags
+1c59 : c901 > cmp #1 ;test result
+ > trap_ne
+1c5b : d0fe > bne * ;failed not equal (non zero)
+ >
+1c5d : 68 > pla ;load status
+1c5e : 48 > pha
+ > cmp_flag ~fz
+1c5f : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c61 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c63 : 28 > plp ;restore status
+
+1c64 : e8 inx
+ set_a 1,$ff
+ > load_flag $ff
+1c65 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1c67 : 48 > pha ;use stack to load status
+1c68 : a901 > lda #1 ;precharge accu
+1c6a : 28 > plp
+
+1c6b : 8982 bit #$82 ;82 - should set Z
+ tst_a 1,$ff
+1c6d : 08 > php ;save flags
+1c6e : c901 > cmp #1 ;test result
+ > trap_ne
+1c70 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c72 : 68 > pla ;load status
+1c73 : 48 > pha
+ > cmp_flag $ff
+1c74 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c76 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c78 : 28 > plp ;restore status
+
+1c79 : e8 inx
+ set_a 1,$ff
+ > load_flag $ff
+1c7a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1c7c : 48 > pha ;use stack to load status
+1c7d : a901 > lda #1 ;precharge accu
+1c7f : 28 > plp
+
+1c80 : 8941 bit #$41 ;41 - should clear Z
+ tst_a 1,~fz
+1c82 : 08 > php ;save flags
+1c83 : c901 > cmp #1 ;test result
+ > trap_ne
+1c85 : d0fe > bne * ;failed not equal (non zero)
+ >
+1c87 : 68 > pla ;load status
+1c88 : 48 > pha
+ > cmp_flag ~fz
+1c89 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1c8b : d0fe > bne * ;failed not equal (non zero)
+ >
+1c8d : 28 > plp ;restore status
+
+1c8e : e8 inx
+ set_a $ff,$ff
+ > load_flag $ff
+1c8f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1c91 : 48 > pha ;use stack to load status
+1c92 : a9ff > lda #$ff ;precharge accu
+1c94 : 28 > plp
+
+1c95 : 8900 bit #$00 ;00 - should set Z
+ tst_a $ff,$ff
+1c97 : 08 > php ;save flags
+1c98 : c9ff > cmp #$ff ;test result
+ > trap_ne
+1c9a : d0fe > bne * ;failed not equal (non zero)
+ >
+1c9c : 68 > pla ;load status
+1c9d : 48 > pha
+ > cmp_flag $ff
+1c9e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ca0 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ca2 : 28 > plp ;restore status
+
+
+1ca3 : e003 cpx #3
+ trap_ne ;x altered during test
+1ca5 : d0fe > bne * ;failed not equal (non zero)
+
+1ca7 : c042 cpy #$42
+ trap_ne ;y altered during test
+1ca9 : d0fe > bne * ;failed not equal (non zero)
+
+1cab : ba tsx
+1cac : e0ff cpx #$ff
+ trap_ne ;sp push/pop mismatch
+1cae : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+1cb0 : ad0202 > lda test_case ;previous test
+1cb3 : c90f > cmp #test_num
+ > trap_ne ;test is out of sequence
+1cb5 : d0fe > bne * ;failed not equal (non zero)
+ >
+0010 = >test_num = test_num + 1
+1cb7 : a910 > lda #test_num ;*** next tests' number
+1cb9 : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; testing TRB, TSB - zp / abs
+
+ trbt macro ;\1 = memory, \2 = flags
+ sty \1
+ load_flag \2
+ pha
+ lda zpt+1
+ plp
+ trb \1
+ php
+ cmp zpt+1
+ trap_ne ;accu was changed
+ pla
+ pha
+ ora #fz ;mask Z
+ cmp_flag \2|fz
+ trap_ne ;flags changed except Z
+ pla
+ and #fz
+ cmp zpt+2
+ trap_ne ;Z flag invalid
+ lda zpt+3
+ cmp zpt
+ trap_ne ;altered bits in memory wrong
+ endm
+
+ tsbt macro ;\1 = memory, \2 = flags
+ sty \1
+ load_flag \2
+ pha
+ lda zpt+1
+ plp
+ tsb \1
+ php
+ cmp zpt+1
+ trap_ne ;accu was changed
+ pla
+ pha
+ ora #fz ;mask Z
+ cmp_flag \2|fz
+ trap_ne ;flags changed except Z
+ pla
+ and #fz
+ cmp zpt+2
+ trap_ne ;Z flag invalid
+ lda zpt+4
+ cmp zpt
+ trap_ne ;altered bits in memory wrong
+ endm
+
+1cbc : a2c0 ldx #$c0
+1cbe : a000 ldy #0 ;op1 - memory save
+ ; zpt ;op1 - memory modifiable
+1cc0 : 640b stz zpt+1 ;op2 - accu
+ ; zpt+2 ;and flags
+ ; zpt+3 ;memory after reset
+ ; zpt+4 ;memory after set
+
+1cc2 : 98 tbt1 tya
+1cc3 : 250b and zpt+1 ;set Z by anding the 2 operands
+1cc5 : 08 php
+1cc6 : 68 pla
+1cc7 : 2902 and #fz ;mask Z
+1cc9 : 850c sta zpt+2
+1ccb : 98 tya ;reset op1 bits by op2
+1ccc : 49ff eor #$ff
+1cce : 050b ora zpt+1
+1cd0 : 49ff eor #$ff
+1cd2 : 850d sta zpt+3
+1cd4 : 98 tya ;set op1 bits by op2
+1cd5 : 050b ora zpt+1
+1cd7 : 850e sta zpt+4
+
+ trbt zpt,$ff
+1cd9 : 840a > sty zpt
+ > load_flag $ff
+1cdb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1cdd : 48 > pha
+1cde : a50b > lda zpt+1
+1ce0 : 28 > plp
+1ce1 : 140a > trb zpt
+1ce3 : 08 > php
+1ce4 : c50b > cmp zpt+1
+ > trap_ne ;accu was changed
+1ce6 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ce8 : 68 > pla
+1ce9 : 48 > pha
+1cea : 0902 > ora #fz ;mask Z
+ > cmp_flag $ff|fz
+1cec : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne ;flags changed except Z
+1cee : d0fe > bne * ;failed not equal (non zero)
+ >
+1cf0 : 68 > pla
+1cf1 : 2902 > and #fz
+1cf3 : c50c > cmp zpt+2
+ > trap_ne ;Z flag invalid
+1cf5 : d0fe > bne * ;failed not equal (non zero)
+ >
+1cf7 : a50d > lda zpt+3
+1cf9 : c50a > cmp zpt
+ > trap_ne ;altered bits in memory wrong
+1cfb : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ trbt abst,$ff
+1cfd : 8c0502 > sty abst
+ > load_flag $ff
+1d00 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1d02 : 48 > pha
+1d03 : a50b > lda zpt+1
+1d05 : 28 > plp
+1d06 : 1c0502 > trb abst
+1d09 : 08 > php
+1d0a : c50b > cmp zpt+1
+ > trap_ne ;accu was changed
+1d0c : d0fe > bne * ;failed not equal (non zero)
+ >
+1d0e : 68 > pla
+1d0f : 48 > pha
+1d10 : 0902 > ora #fz ;mask Z
+ > cmp_flag $ff|fz
+1d12 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne ;flags changed except Z
+1d14 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d16 : 68 > pla
+1d17 : 2902 > and #fz
+1d19 : c50c > cmp zpt+2
+ > trap_ne ;Z flag invalid
+1d1b : d0fe > bne * ;failed not equal (non zero)
+ >
+1d1d : a50d > lda zpt+3
+1d1f : c50a > cmp zpt
+ > trap_ne ;altered bits in memory wrong
+1d21 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ trbt zpt,0
+1d23 : 840a > sty zpt
+ > load_flag 0
+1d25 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1d27 : 48 > pha
+1d28 : a50b > lda zpt+1
+1d2a : 28 > plp
+1d2b : 140a > trb zpt
+1d2d : 08 > php
+1d2e : c50b > cmp zpt+1
+ > trap_ne ;accu was changed
+1d30 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d32 : 68 > pla
+1d33 : 48 > pha
+1d34 : 0902 > ora #fz ;mask Z
+ > cmp_flag 0|fz
+1d36 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne ;flags changed except Z
+1d38 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d3a : 68 > pla
+1d3b : 2902 > and #fz
+1d3d : c50c > cmp zpt+2
+ > trap_ne ;Z flag invalid
+1d3f : d0fe > bne * ;failed not equal (non zero)
+ >
+1d41 : a50d > lda zpt+3
+1d43 : c50a > cmp zpt
+ > trap_ne ;altered bits in memory wrong
+1d45 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ trbt abst,0
+1d47 : 8c0502 > sty abst
+ > load_flag 0
+1d4a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1d4c : 48 > pha
+1d4d : a50b > lda zpt+1
+1d4f : 28 > plp
+1d50 : 1c0502 > trb abst
+1d53 : 08 > php
+1d54 : c50b > cmp zpt+1
+ > trap_ne ;accu was changed
+1d56 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d58 : 68 > pla
+1d59 : 48 > pha
+1d5a : 0902 > ora #fz ;mask Z
+ > cmp_flag 0|fz
+1d5c : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne ;flags changed except Z
+1d5e : d0fe > bne * ;failed not equal (non zero)
+ >
+1d60 : 68 > pla
+1d61 : 2902 > and #fz
+1d63 : c50c > cmp zpt+2
+ > trap_ne ;Z flag invalid
+1d65 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d67 : a50d > lda zpt+3
+1d69 : c50a > cmp zpt
+ > trap_ne ;altered bits in memory wrong
+1d6b : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ tsbt zpt,$ff
+1d6d : 840a > sty zpt
+ > load_flag $ff
+1d6f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1d71 : 48 > pha
+1d72 : a50b > lda zpt+1
+1d74 : 28 > plp
+1d75 : 040a > tsb zpt
+1d77 : 08 > php
+1d78 : c50b > cmp zpt+1
+ > trap_ne ;accu was changed
+1d7a : d0fe > bne * ;failed not equal (non zero)
+ >
+1d7c : 68 > pla
+1d7d : 48 > pha
+1d7e : 0902 > ora #fz ;mask Z
+ > cmp_flag $ff|fz
+1d80 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne ;flags changed except Z
+1d82 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d84 : 68 > pla
+1d85 : 2902 > and #fz
+1d87 : c50c > cmp zpt+2
+ > trap_ne ;Z flag invalid
+1d89 : d0fe > bne * ;failed not equal (non zero)
+ >
+1d8b : a50e > lda zpt+4
+1d8d : c50a > cmp zpt
+ > trap_ne ;altered bits in memory wrong
+1d8f : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ tsbt abst,$ff
+1d91 : 8c0502 > sty abst
+ > load_flag $ff
+1d94 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1d96 : 48 > pha
+1d97 : a50b > lda zpt+1
+1d99 : 28 > plp
+1d9a : 0c0502 > tsb abst
+1d9d : 08 > php
+1d9e : c50b > cmp zpt+1
+ > trap_ne ;accu was changed
+1da0 : d0fe > bne * ;failed not equal (non zero)
+ >
+1da2 : 68 > pla
+1da3 : 48 > pha
+1da4 : 0902 > ora #fz ;mask Z
+ > cmp_flag $ff|fz
+1da6 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne ;flags changed except Z
+1da8 : d0fe > bne * ;failed not equal (non zero)
+ >
+1daa : 68 > pla
+1dab : 2902 > and #fz
+1dad : c50c > cmp zpt+2
+ > trap_ne ;Z flag invalid
+1daf : d0fe > bne * ;failed not equal (non zero)
+ >
+1db1 : a50e > lda zpt+4
+1db3 : c50a > cmp zpt
+ > trap_ne ;altered bits in memory wrong
+1db5 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ tsbt zpt,0
+1db7 : 840a > sty zpt
+ > load_flag 0
+1db9 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1dbb : 48 > pha
+1dbc : a50b > lda zpt+1
+1dbe : 28 > plp
+1dbf : 040a > tsb zpt
+1dc1 : 08 > php
+1dc2 : c50b > cmp zpt+1
+ > trap_ne ;accu was changed
+1dc4 : d0fe > bne * ;failed not equal (non zero)
+ >
+1dc6 : 68 > pla
+1dc7 : 48 > pha
+1dc8 : 0902 > ora #fz ;mask Z
+ > cmp_flag 0|fz
+1dca : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne ;flags changed except Z
+1dcc : d0fe > bne * ;failed not equal (non zero)
+ >
+1dce : 68 > pla
+1dcf : 2902 > and #fz
+1dd1 : c50c > cmp zpt+2
+ > trap_ne ;Z flag invalid
+1dd3 : d0fe > bne * ;failed not equal (non zero)
+ >
+1dd5 : a50e > lda zpt+4
+1dd7 : c50a > cmp zpt
+ > trap_ne ;altered bits in memory wrong
+1dd9 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ tsbt abst,0
+1ddb : 8c0502 > sty abst
+ > load_flag 0
+1dde : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1de0 : 48 > pha
+1de1 : a50b > lda zpt+1
+1de3 : 28 > plp
+1de4 : 0c0502 > tsb abst
+1de7 : 08 > php
+1de8 : c50b > cmp zpt+1
+ > trap_ne ;accu was changed
+1dea : d0fe > bne * ;failed not equal (non zero)
+ >
+1dec : 68 > pla
+1ded : 48 > pha
+1dee : 0902 > ora #fz ;mask Z
+ > cmp_flag 0|fz
+1df0 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne ;flags changed except Z
+1df2 : d0fe > bne * ;failed not equal (non zero)
+ >
+1df4 : 68 > pla
+1df5 : 2902 > and #fz
+1df7 : c50c > cmp zpt+2
+ > trap_ne ;Z flag invalid
+1df9 : d0fe > bne * ;failed not equal (non zero)
+ >
+1dfb : a50e > lda zpt+4
+1dfd : c50a > cmp zpt
+ > trap_ne ;altered bits in memory wrong
+1dff : d0fe > bne * ;failed not equal (non zero)
+ >
+
+
+1e01 : c8 iny ;iterate op1
+1e02 : d004 bne tbt3
+1e04 : e60b inc zpt+1 ;iterate op2
+1e06 : f003 beq tbt2
+1e08 : 4cc21c tbt3 jmp tbt1
+1e0b : tbt2
+1e0b : e0c0 cpx #$c0
+ trap_ne ;x altered during test
+1e0d : d0fe > bne * ;failed not equal (non zero)
+
+1e0f : ba tsx
+1e10 : e0ff cpx #$ff
+ trap_ne ;sp push/pop mismatch
+1e12 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+1e14 : ad0202 > lda test_case ;previous test
+1e17 : c910 > cmp #test_num
+ > trap_ne ;test is out of sequence
+1e19 : d0fe > bne * ;failed not equal (non zero)
+ >
+0011 = >test_num = test_num + 1
+1e1b : a911 > lda #test_num ;*** next tests' number
+1e1d : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ if rkwl_wdc_op
+ ; testing RMB, SMB - zp
+ rmbt macro ;\1 = bitnum
+ lda #$ff
+ sta zpt
+ set_a $a5,0
+ rmb \1,zpt
+ tst_a $a5,0
+ lda zpt
+ cmp #$ff-(1<<\1)
+ trap_ne ;wrong bits set or cleared
+ lda #1<<\1
+ sta zpt
+ set_a $5a,$ff
+ rmb \1,zpt
+ tst_a $5a,$ff
+ lda zpt
+ trap_ne ;wrong bits set or cleared
+ endm
+ smbt macro ;\1 = bitnum
+ lda #$ff-(1<<\1)
+ sta zpt
+ set_a $a5,0
+ smb \1,zpt
+ tst_a $a5,0
+ lda zpt
+ cmp #$ff
+ trap_ne ;wrong bits set or cleared
+ lda #0
+ sta zpt
+ set_a $5a,$ff
+ smb \1,zpt
+ tst_a $5a,$ff
+ lda zpt
+ cmp #1<<\1
+ trap_ne ;wrong bits set or cleared
+ endm
+
+1e20 : a2ba ldx #$ba ;protect x & y
+1e22 : a0d0 ldy #$d0
+ rmbt 0
+1e24 : a9ff > lda #$ff
+1e26 : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+1e28 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1e2a : 48 > pha ;use stack to load status
+1e2b : a9a5 > lda #$a5 ;precharge accu
+1e2d : 28 > plp
+ >
+1e2e : 070a > rmb 0,zpt
+ > tst_a $a5,0
+1e30 : 08 > php ;save flags
+1e31 : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+1e33 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e35 : 68 > pla ;load status
+1e36 : 48 > pha
+ > cmp_flag 0
+1e37 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e39 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e3b : 28 > plp ;restore status
+ >
+1e3c : a50a > lda zpt
+1e3e : c9fe > cmp #$ff-(1<<0)
+ > trap_ne ;wrong bits set or cleared
+1e40 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e42 : a901 > lda #1<<0
+1e44 : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+1e46 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1e48 : 48 > pha ;use stack to load status
+1e49 : a95a > lda #$5a ;precharge accu
+1e4b : 28 > plp
+ >
+1e4c : 070a > rmb 0,zpt
+ > tst_a $5a,$ff
+1e4e : 08 > php ;save flags
+1e4f : c95a > cmp #$5a ;test result
+ > trap_ne
+1e51 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e53 : 68 > pla ;load status
+1e54 : 48 > pha
+ > cmp_flag $ff
+1e55 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e57 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e59 : 28 > plp ;restore status
+ >
+1e5a : a50a > lda zpt
+ > trap_ne ;wrong bits set or cleared
+1e5c : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ rmbt 1
+1e5e : a9ff > lda #$ff
+1e60 : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+1e62 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1e64 : 48 > pha ;use stack to load status
+1e65 : a9a5 > lda #$a5 ;precharge accu
+1e67 : 28 > plp
+ >
+1e68 : 170a > rmb 1,zpt
+ > tst_a $a5,0
+1e6a : 08 > php ;save flags
+1e6b : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+1e6d : d0fe > bne * ;failed not equal (non zero)
+ >
+1e6f : 68 > pla ;load status
+1e70 : 48 > pha
+ > cmp_flag 0
+1e71 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e73 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e75 : 28 > plp ;restore status
+ >
+1e76 : a50a > lda zpt
+1e78 : c9fd > cmp #$ff-(1<<1)
+ > trap_ne ;wrong bits set or cleared
+1e7a : d0fe > bne * ;failed not equal (non zero)
+ >
+1e7c : a902 > lda #1<<1
+1e7e : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+1e80 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1e82 : 48 > pha ;use stack to load status
+1e83 : a95a > lda #$5a ;precharge accu
+1e85 : 28 > plp
+ >
+1e86 : 170a > rmb 1,zpt
+ > tst_a $5a,$ff
+1e88 : 08 > php ;save flags
+1e89 : c95a > cmp #$5a ;test result
+ > trap_ne
+1e8b : d0fe > bne * ;failed not equal (non zero)
+ >
+1e8d : 68 > pla ;load status
+1e8e : 48 > pha
+ > cmp_flag $ff
+1e8f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1e91 : d0fe > bne * ;failed not equal (non zero)
+ >
+1e93 : 28 > plp ;restore status
+ >
+1e94 : a50a > lda zpt
+ > trap_ne ;wrong bits set or cleared
+1e96 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ rmbt 2
+1e98 : a9ff > lda #$ff
+1e9a : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+1e9c : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1e9e : 48 > pha ;use stack to load status
+1e9f : a9a5 > lda #$a5 ;precharge accu
+1ea1 : 28 > plp
+ >
+1ea2 : 270a > rmb 2,zpt
+ > tst_a $a5,0
+1ea4 : 08 > php ;save flags
+1ea5 : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+1ea7 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ea9 : 68 > pla ;load status
+1eaa : 48 > pha
+ > cmp_flag 0
+1eab : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ead : d0fe > bne * ;failed not equal (non zero)
+ >
+1eaf : 28 > plp ;restore status
+ >
+1eb0 : a50a > lda zpt
+1eb2 : c9fb > cmp #$ff-(1<<2)
+ > trap_ne ;wrong bits set or cleared
+1eb4 : d0fe > bne * ;failed not equal (non zero)
+ >
+1eb6 : a904 > lda #1<<2
+1eb8 : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+1eba : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1ebc : 48 > pha ;use stack to load status
+1ebd : a95a > lda #$5a ;precharge accu
+1ebf : 28 > plp
+ >
+1ec0 : 270a > rmb 2,zpt
+ > tst_a $5a,$ff
+1ec2 : 08 > php ;save flags
+1ec3 : c95a > cmp #$5a ;test result
+ > trap_ne
+1ec5 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ec7 : 68 > pla ;load status
+1ec8 : 48 > pha
+ > cmp_flag $ff
+1ec9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ecb : d0fe > bne * ;failed not equal (non zero)
+ >
+1ecd : 28 > plp ;restore status
+ >
+1ece : a50a > lda zpt
+ > trap_ne ;wrong bits set or cleared
+1ed0 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ rmbt 3
+1ed2 : a9ff > lda #$ff
+1ed4 : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+1ed6 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1ed8 : 48 > pha ;use stack to load status
+1ed9 : a9a5 > lda #$a5 ;precharge accu
+1edb : 28 > plp
+ >
+1edc : 370a > rmb 3,zpt
+ > tst_a $a5,0
+1ede : 08 > php ;save flags
+1edf : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+1ee1 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ee3 : 68 > pla ;load status
+1ee4 : 48 > pha
+ > cmp_flag 0
+1ee5 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1ee7 : d0fe > bne * ;failed not equal (non zero)
+ >
+1ee9 : 28 > plp ;restore status
+ >
+1eea : a50a > lda zpt
+1eec : c9f7 > cmp #$ff-(1<<3)
+ > trap_ne ;wrong bits set or cleared
+1eee : d0fe > bne * ;failed not equal (non zero)
+ >
+1ef0 : a908 > lda #1<<3
+1ef2 : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+1ef4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1ef6 : 48 > pha ;use stack to load status
+1ef7 : a95a > lda #$5a ;precharge accu
+1ef9 : 28 > plp
+ >
+1efa : 370a > rmb 3,zpt
+ > tst_a $5a,$ff
+1efc : 08 > php ;save flags
+1efd : c95a > cmp #$5a ;test result
+ > trap_ne
+1eff : d0fe > bne * ;failed not equal (non zero)
+ >
+1f01 : 68 > pla ;load status
+1f02 : 48 > pha
+ > cmp_flag $ff
+1f03 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f05 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f07 : 28 > plp ;restore status
+ >
+1f08 : a50a > lda zpt
+ > trap_ne ;wrong bits set or cleared
+1f0a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ rmbt 4
+1f0c : a9ff > lda #$ff
+1f0e : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+1f10 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1f12 : 48 > pha ;use stack to load status
+1f13 : a9a5 > lda #$a5 ;precharge accu
+1f15 : 28 > plp
+ >
+1f16 : 470a > rmb 4,zpt
+ > tst_a $a5,0
+1f18 : 08 > php ;save flags
+1f19 : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+1f1b : d0fe > bne * ;failed not equal (non zero)
+ >
+1f1d : 68 > pla ;load status
+1f1e : 48 > pha
+ > cmp_flag 0
+1f1f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f21 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f23 : 28 > plp ;restore status
+ >
+1f24 : a50a > lda zpt
+1f26 : c9ef > cmp #$ff-(1<<4)
+ > trap_ne ;wrong bits set or cleared
+1f28 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f2a : a910 > lda #1<<4
+1f2c : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+1f2e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1f30 : 48 > pha ;use stack to load status
+1f31 : a95a > lda #$5a ;precharge accu
+1f33 : 28 > plp
+ >
+1f34 : 470a > rmb 4,zpt
+ > tst_a $5a,$ff
+1f36 : 08 > php ;save flags
+1f37 : c95a > cmp #$5a ;test result
+ > trap_ne
+1f39 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f3b : 68 > pla ;load status
+1f3c : 48 > pha
+ > cmp_flag $ff
+1f3d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f3f : d0fe > bne * ;failed not equal (non zero)
+ >
+1f41 : 28 > plp ;restore status
+ >
+1f42 : a50a > lda zpt
+ > trap_ne ;wrong bits set or cleared
+1f44 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ rmbt 5
+1f46 : a9ff > lda #$ff
+1f48 : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+1f4a : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1f4c : 48 > pha ;use stack to load status
+1f4d : a9a5 > lda #$a5 ;precharge accu
+1f4f : 28 > plp
+ >
+1f50 : 570a > rmb 5,zpt
+ > tst_a $a5,0
+1f52 : 08 > php ;save flags
+1f53 : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+1f55 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f57 : 68 > pla ;load status
+1f58 : 48 > pha
+ > cmp_flag 0
+1f59 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f5b : d0fe > bne * ;failed not equal (non zero)
+ >
+1f5d : 28 > plp ;restore status
+ >
+1f5e : a50a > lda zpt
+1f60 : c9df > cmp #$ff-(1<<5)
+ > trap_ne ;wrong bits set or cleared
+1f62 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f64 : a920 > lda #1<<5
+1f66 : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+1f68 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1f6a : 48 > pha ;use stack to load status
+1f6b : a95a > lda #$5a ;precharge accu
+1f6d : 28 > plp
+ >
+1f6e : 570a > rmb 5,zpt
+ > tst_a $5a,$ff
+1f70 : 08 > php ;save flags
+1f71 : c95a > cmp #$5a ;test result
+ > trap_ne
+1f73 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f75 : 68 > pla ;load status
+1f76 : 48 > pha
+ > cmp_flag $ff
+1f77 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f79 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f7b : 28 > plp ;restore status
+ >
+1f7c : a50a > lda zpt
+ > trap_ne ;wrong bits set or cleared
+1f7e : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ rmbt 6
+1f80 : a9ff > lda #$ff
+1f82 : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+1f84 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1f86 : 48 > pha ;use stack to load status
+1f87 : a9a5 > lda #$a5 ;precharge accu
+1f89 : 28 > plp
+ >
+1f8a : 670a > rmb 6,zpt
+ > tst_a $a5,0
+1f8c : 08 > php ;save flags
+1f8d : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+1f8f : d0fe > bne * ;failed not equal (non zero)
+ >
+1f91 : 68 > pla ;load status
+1f92 : 48 > pha
+ > cmp_flag 0
+1f93 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1f95 : d0fe > bne * ;failed not equal (non zero)
+ >
+1f97 : 28 > plp ;restore status
+ >
+1f98 : a50a > lda zpt
+1f9a : c9bf > cmp #$ff-(1<<6)
+ > trap_ne ;wrong bits set or cleared
+1f9c : d0fe > bne * ;failed not equal (non zero)
+ >
+1f9e : a940 > lda #1<<6
+1fa0 : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+1fa2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1fa4 : 48 > pha ;use stack to load status
+1fa5 : a95a > lda #$5a ;precharge accu
+1fa7 : 28 > plp
+ >
+1fa8 : 670a > rmb 6,zpt
+ > tst_a $5a,$ff
+1faa : 08 > php ;save flags
+1fab : c95a > cmp #$5a ;test result
+ > trap_ne
+1fad : d0fe > bne * ;failed not equal (non zero)
+ >
+1faf : 68 > pla ;load status
+1fb0 : 48 > pha
+ > cmp_flag $ff
+1fb1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1fb3 : d0fe > bne * ;failed not equal (non zero)
+ >
+1fb5 : 28 > plp ;restore status
+ >
+1fb6 : a50a > lda zpt
+ > trap_ne ;wrong bits set or cleared
+1fb8 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ rmbt 7
+1fba : a9ff > lda #$ff
+1fbc : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+1fbe : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1fc0 : 48 > pha ;use stack to load status
+1fc1 : a9a5 > lda #$a5 ;precharge accu
+1fc3 : 28 > plp
+ >
+1fc4 : 770a > rmb 7,zpt
+ > tst_a $a5,0
+1fc6 : 08 > php ;save flags
+1fc7 : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+1fc9 : d0fe > bne * ;failed not equal (non zero)
+ >
+1fcb : 68 > pla ;load status
+1fcc : 48 > pha
+ > cmp_flag 0
+1fcd : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1fcf : d0fe > bne * ;failed not equal (non zero)
+ >
+1fd1 : 28 > plp ;restore status
+ >
+1fd2 : a50a > lda zpt
+1fd4 : c97f > cmp #$ff-(1<<7)
+ > trap_ne ;wrong bits set or cleared
+1fd6 : d0fe > bne * ;failed not equal (non zero)
+ >
+1fd8 : a980 > lda #1<<7
+1fda : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+1fdc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+1fde : 48 > pha ;use stack to load status
+1fdf : a95a > lda #$5a ;precharge accu
+1fe1 : 28 > plp
+ >
+1fe2 : 770a > rmb 7,zpt
+ > tst_a $5a,$ff
+1fe4 : 08 > php ;save flags
+1fe5 : c95a > cmp #$5a ;test result
+ > trap_ne
+1fe7 : d0fe > bne * ;failed not equal (non zero)
+ >
+1fe9 : 68 > pla ;load status
+1fea : 48 > pha
+ > cmp_flag $ff
+1feb : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+1fed : d0fe > bne * ;failed not equal (non zero)
+ >
+1fef : 28 > plp ;restore status
+ >
+1ff0 : a50a > lda zpt
+ > trap_ne ;wrong bits set or cleared
+1ff2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ smbt 0
+1ff4 : a9fe > lda #$ff-(1<<0)
+1ff6 : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+1ff8 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+1ffa : 48 > pha ;use stack to load status
+1ffb : a9a5 > lda #$a5 ;precharge accu
+1ffd : 28 > plp
+ >
+1ffe : 870a > smb 0,zpt
+ > tst_a $a5,0
+2000 : 08 > php ;save flags
+2001 : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+2003 : d0fe > bne * ;failed not equal (non zero)
+ >
+2005 : 68 > pla ;load status
+2006 : 48 > pha
+ > cmp_flag 0
+2007 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2009 : d0fe > bne * ;failed not equal (non zero)
+ >
+200b : 28 > plp ;restore status
+ >
+200c : a50a > lda zpt
+200e : c9ff > cmp #$ff
+ > trap_ne ;wrong bits set or cleared
+2010 : d0fe > bne * ;failed not equal (non zero)
+ >
+2012 : a900 > lda #0
+2014 : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+2016 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2018 : 48 > pha ;use stack to load status
+2019 : a95a > lda #$5a ;precharge accu
+201b : 28 > plp
+ >
+201c : 870a > smb 0,zpt
+ > tst_a $5a,$ff
+201e : 08 > php ;save flags
+201f : c95a > cmp #$5a ;test result
+ > trap_ne
+2021 : d0fe > bne * ;failed not equal (non zero)
+ >
+2023 : 68 > pla ;load status
+2024 : 48 > pha
+ > cmp_flag $ff
+2025 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2027 : d0fe > bne * ;failed not equal (non zero)
+ >
+2029 : 28 > plp ;restore status
+ >
+202a : a50a > lda zpt
+202c : c901 > cmp #1<<0
+ > trap_ne ;wrong bits set or cleared
+202e : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ smbt 1
+2030 : a9fd > lda #$ff-(1<<1)
+2032 : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+2034 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2036 : 48 > pha ;use stack to load status
+2037 : a9a5 > lda #$a5 ;precharge accu
+2039 : 28 > plp
+ >
+203a : 970a > smb 1,zpt
+ > tst_a $a5,0
+203c : 08 > php ;save flags
+203d : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+203f : d0fe > bne * ;failed not equal (non zero)
+ >
+2041 : 68 > pla ;load status
+2042 : 48 > pha
+ > cmp_flag 0
+2043 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2045 : d0fe > bne * ;failed not equal (non zero)
+ >
+2047 : 28 > plp ;restore status
+ >
+2048 : a50a > lda zpt
+204a : c9ff > cmp #$ff
+ > trap_ne ;wrong bits set or cleared
+204c : d0fe > bne * ;failed not equal (non zero)
+ >
+204e : a900 > lda #0
+2050 : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+2052 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2054 : 48 > pha ;use stack to load status
+2055 : a95a > lda #$5a ;precharge accu
+2057 : 28 > plp
+ >
+2058 : 970a > smb 1,zpt
+ > tst_a $5a,$ff
+205a : 08 > php ;save flags
+205b : c95a > cmp #$5a ;test result
+ > trap_ne
+205d : d0fe > bne * ;failed not equal (non zero)
+ >
+205f : 68 > pla ;load status
+2060 : 48 > pha
+ > cmp_flag $ff
+2061 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2063 : d0fe > bne * ;failed not equal (non zero)
+ >
+2065 : 28 > plp ;restore status
+ >
+2066 : a50a > lda zpt
+2068 : c902 > cmp #1<<1
+ > trap_ne ;wrong bits set or cleared
+206a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ smbt 2
+206c : a9fb > lda #$ff-(1<<2)
+206e : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+2070 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2072 : 48 > pha ;use stack to load status
+2073 : a9a5 > lda #$a5 ;precharge accu
+2075 : 28 > plp
+ >
+2076 : a70a > smb 2,zpt
+ > tst_a $a5,0
+2078 : 08 > php ;save flags
+2079 : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+207b : d0fe > bne * ;failed not equal (non zero)
+ >
+207d : 68 > pla ;load status
+207e : 48 > pha
+ > cmp_flag 0
+207f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2081 : d0fe > bne * ;failed not equal (non zero)
+ >
+2083 : 28 > plp ;restore status
+ >
+2084 : a50a > lda zpt
+2086 : c9ff > cmp #$ff
+ > trap_ne ;wrong bits set or cleared
+2088 : d0fe > bne * ;failed not equal (non zero)
+ >
+208a : a900 > lda #0
+208c : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+208e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2090 : 48 > pha ;use stack to load status
+2091 : a95a > lda #$5a ;precharge accu
+2093 : 28 > plp
+ >
+2094 : a70a > smb 2,zpt
+ > tst_a $5a,$ff
+2096 : 08 > php ;save flags
+2097 : c95a > cmp #$5a ;test result
+ > trap_ne
+2099 : d0fe > bne * ;failed not equal (non zero)
+ >
+209b : 68 > pla ;load status
+209c : 48 > pha
+ > cmp_flag $ff
+209d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+209f : d0fe > bne * ;failed not equal (non zero)
+ >
+20a1 : 28 > plp ;restore status
+ >
+20a2 : a50a > lda zpt
+20a4 : c904 > cmp #1<<2
+ > trap_ne ;wrong bits set or cleared
+20a6 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ smbt 3
+20a8 : a9f7 > lda #$ff-(1<<3)
+20aa : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+20ac : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+20ae : 48 > pha ;use stack to load status
+20af : a9a5 > lda #$a5 ;precharge accu
+20b1 : 28 > plp
+ >
+20b2 : b70a > smb 3,zpt
+ > tst_a $a5,0
+20b4 : 08 > php ;save flags
+20b5 : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+20b7 : d0fe > bne * ;failed not equal (non zero)
+ >
+20b9 : 68 > pla ;load status
+20ba : 48 > pha
+ > cmp_flag 0
+20bb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+20bd : d0fe > bne * ;failed not equal (non zero)
+ >
+20bf : 28 > plp ;restore status
+ >
+20c0 : a50a > lda zpt
+20c2 : c9ff > cmp #$ff
+ > trap_ne ;wrong bits set or cleared
+20c4 : d0fe > bne * ;failed not equal (non zero)
+ >
+20c6 : a900 > lda #0
+20c8 : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+20ca : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+20cc : 48 > pha ;use stack to load status
+20cd : a95a > lda #$5a ;precharge accu
+20cf : 28 > plp
+ >
+20d0 : b70a > smb 3,zpt
+ > tst_a $5a,$ff
+20d2 : 08 > php ;save flags
+20d3 : c95a > cmp #$5a ;test result
+ > trap_ne
+20d5 : d0fe > bne * ;failed not equal (non zero)
+ >
+20d7 : 68 > pla ;load status
+20d8 : 48 > pha
+ > cmp_flag $ff
+20d9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+20db : d0fe > bne * ;failed not equal (non zero)
+ >
+20dd : 28 > plp ;restore status
+ >
+20de : a50a > lda zpt
+20e0 : c908 > cmp #1<<3
+ > trap_ne ;wrong bits set or cleared
+20e2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ smbt 4
+20e4 : a9ef > lda #$ff-(1<<4)
+20e6 : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+20e8 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+20ea : 48 > pha ;use stack to load status
+20eb : a9a5 > lda #$a5 ;precharge accu
+20ed : 28 > plp
+ >
+20ee : c70a > smb 4,zpt
+ > tst_a $a5,0
+20f0 : 08 > php ;save flags
+20f1 : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+20f3 : d0fe > bne * ;failed not equal (non zero)
+ >
+20f5 : 68 > pla ;load status
+20f6 : 48 > pha
+ > cmp_flag 0
+20f7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+20f9 : d0fe > bne * ;failed not equal (non zero)
+ >
+20fb : 28 > plp ;restore status
+ >
+20fc : a50a > lda zpt
+20fe : c9ff > cmp #$ff
+ > trap_ne ;wrong bits set or cleared
+2100 : d0fe > bne * ;failed not equal (non zero)
+ >
+2102 : a900 > lda #0
+2104 : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+2106 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2108 : 48 > pha ;use stack to load status
+2109 : a95a > lda #$5a ;precharge accu
+210b : 28 > plp
+ >
+210c : c70a > smb 4,zpt
+ > tst_a $5a,$ff
+210e : 08 > php ;save flags
+210f : c95a > cmp #$5a ;test result
+ > trap_ne
+2111 : d0fe > bne * ;failed not equal (non zero)
+ >
+2113 : 68 > pla ;load status
+2114 : 48 > pha
+ > cmp_flag $ff
+2115 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2117 : d0fe > bne * ;failed not equal (non zero)
+ >
+2119 : 28 > plp ;restore status
+ >
+211a : a50a > lda zpt
+211c : c910 > cmp #1<<4
+ > trap_ne ;wrong bits set or cleared
+211e : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ smbt 5
+2120 : a9df > lda #$ff-(1<<5)
+2122 : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+2124 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2126 : 48 > pha ;use stack to load status
+2127 : a9a5 > lda #$a5 ;precharge accu
+2129 : 28 > plp
+ >
+212a : d70a > smb 5,zpt
+ > tst_a $a5,0
+212c : 08 > php ;save flags
+212d : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+212f : d0fe > bne * ;failed not equal (non zero)
+ >
+2131 : 68 > pla ;load status
+2132 : 48 > pha
+ > cmp_flag 0
+2133 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2135 : d0fe > bne * ;failed not equal (non zero)
+ >
+2137 : 28 > plp ;restore status
+ >
+2138 : a50a > lda zpt
+213a : c9ff > cmp #$ff
+ > trap_ne ;wrong bits set or cleared
+213c : d0fe > bne * ;failed not equal (non zero)
+ >
+213e : a900 > lda #0
+2140 : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+2142 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2144 : 48 > pha ;use stack to load status
+2145 : a95a > lda #$5a ;precharge accu
+2147 : 28 > plp
+ >
+2148 : d70a > smb 5,zpt
+ > tst_a $5a,$ff
+214a : 08 > php ;save flags
+214b : c95a > cmp #$5a ;test result
+ > trap_ne
+214d : d0fe > bne * ;failed not equal (non zero)
+ >
+214f : 68 > pla ;load status
+2150 : 48 > pha
+ > cmp_flag $ff
+2151 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2153 : d0fe > bne * ;failed not equal (non zero)
+ >
+2155 : 28 > plp ;restore status
+ >
+2156 : a50a > lda zpt
+2158 : c920 > cmp #1<<5
+ > trap_ne ;wrong bits set or cleared
+215a : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ smbt 6
+215c : a9bf > lda #$ff-(1<<6)
+215e : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+2160 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2162 : 48 > pha ;use stack to load status
+2163 : a9a5 > lda #$a5 ;precharge accu
+2165 : 28 > plp
+ >
+2166 : e70a > smb 6,zpt
+ > tst_a $a5,0
+2168 : 08 > php ;save flags
+2169 : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+216b : d0fe > bne * ;failed not equal (non zero)
+ >
+216d : 68 > pla ;load status
+216e : 48 > pha
+ > cmp_flag 0
+216f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2171 : d0fe > bne * ;failed not equal (non zero)
+ >
+2173 : 28 > plp ;restore status
+ >
+2174 : a50a > lda zpt
+2176 : c9ff > cmp #$ff
+ > trap_ne ;wrong bits set or cleared
+2178 : d0fe > bne * ;failed not equal (non zero)
+ >
+217a : a900 > lda #0
+217c : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+217e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2180 : 48 > pha ;use stack to load status
+2181 : a95a > lda #$5a ;precharge accu
+2183 : 28 > plp
+ >
+2184 : e70a > smb 6,zpt
+ > tst_a $5a,$ff
+2186 : 08 > php ;save flags
+2187 : c95a > cmp #$5a ;test result
+ > trap_ne
+2189 : d0fe > bne * ;failed not equal (non zero)
+ >
+218b : 68 > pla ;load status
+218c : 48 > pha
+ > cmp_flag $ff
+218d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+218f : d0fe > bne * ;failed not equal (non zero)
+ >
+2191 : 28 > plp ;restore status
+ >
+2192 : a50a > lda zpt
+2194 : c940 > cmp #1<<6
+ > trap_ne ;wrong bits set or cleared
+2196 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+ smbt 7
+2198 : a97f > lda #$ff-(1<<7)
+219a : 850a > sta zpt
+ > set_a $a5,0
+ > load_flag 0
+219c : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+219e : 48 > pha ;use stack to load status
+219f : a9a5 > lda #$a5 ;precharge accu
+21a1 : 28 > plp
+ >
+21a2 : f70a > smb 7,zpt
+ > tst_a $a5,0
+21a4 : 08 > php ;save flags
+21a5 : c9a5 > cmp #$a5 ;test result
+ > trap_ne
+21a7 : d0fe > bne * ;failed not equal (non zero)
+ >
+21a9 : 68 > pla ;load status
+21aa : 48 > pha
+ > cmp_flag 0
+21ab : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+21ad : d0fe > bne * ;failed not equal (non zero)
+ >
+21af : 28 > plp ;restore status
+ >
+21b0 : a50a > lda zpt
+21b2 : c9ff > cmp #$ff
+ > trap_ne ;wrong bits set or cleared
+21b4 : d0fe > bne * ;failed not equal (non zero)
+ >
+21b6 : a900 > lda #0
+21b8 : 850a > sta zpt
+ > set_a $5a,$ff
+ > load_flag $ff
+21ba : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+21bc : 48 > pha ;use stack to load status
+21bd : a95a > lda #$5a ;precharge accu
+21bf : 28 > plp
+ >
+21c0 : f70a > smb 7,zpt
+ > tst_a $5a,$ff
+21c2 : 08 > php ;save flags
+21c3 : c95a > cmp #$5a ;test result
+ > trap_ne
+21c5 : d0fe > bne * ;failed not equal (non zero)
+ >
+21c7 : 68 > pla ;load status
+21c8 : 48 > pha
+ > cmp_flag $ff
+21c9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+21cb : d0fe > bne * ;failed not equal (non zero)
+ >
+21cd : 28 > plp ;restore status
+ >
+21ce : a50a > lda zpt
+21d0 : c980 > cmp #1<<7
+ > trap_ne ;wrong bits set or cleared
+21d2 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+21d4 : e0ba cpx #$ba
+ trap_ne ;x altered during test
+21d6 : d0fe > bne * ;failed not equal (non zero)
+
+21d8 : c0d0 cpy #$d0
+ trap_ne ;y altered during test
+21da : d0fe > bne * ;failed not equal (non zero)
+
+21dc : ba tsx
+21dd : e0ff cpx #$ff
+ trap_ne ;sp push/pop mismatch
+21df : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+21e1 : ad0202 > lda test_case ;previous test
+21e4 : c911 > cmp #test_num
+ > trap_ne ;test is out of sequence
+21e6 : d0fe > bne * ;failed not equal (non zero)
+ >
+0012 = >test_num = test_num + 1
+21e8 : a912 > lda #test_num ;*** next tests' number
+21ea : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+ endif
+
+ ; testing CMP - (zp)
+21ed : a2de ldx #$de ;protect x & y
+21ef : a0ad ldy #$ad
+ set_a $80,0
+ > load_flag 0
+21f1 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+21f3 : 48 > pha ;use stack to load status
+21f4 : a980 > lda #$80 ;precharge accu
+21f6 : 28 > plp
+
+21f7 : d22a cmp (ind1+8)
+ tst_a $80,fc
+21f9 : 08 > php ;save flags
+21fa : c980 > cmp #$80 ;test result
+ > trap_ne
+21fc : d0fe > bne * ;failed not equal (non zero)
+ >
+21fe : 68 > pla ;load status
+21ff : 48 > pha
+ > cmp_flag fc
+2200 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2202 : d0fe > bne * ;failed not equal (non zero)
+ >
+2204 : 28 > plp ;restore status
+
+ set_a $7f,0
+ > load_flag 0
+2205 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2207 : 48 > pha ;use stack to load status
+2208 : a97f > lda #$7f ;precharge accu
+220a : 28 > plp
+
+220b : d22a cmp (ind1+8)
+ tst_a $7f,fzc
+220d : 08 > php ;save flags
+220e : c97f > cmp #$7f ;test result
+ > trap_ne
+2210 : d0fe > bne * ;failed not equal (non zero)
+ >
+2212 : 68 > pla ;load status
+2213 : 48 > pha
+ > cmp_flag fzc
+2214 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2216 : d0fe > bne * ;failed not equal (non zero)
+ >
+2218 : 28 > plp ;restore status
+
+ set_a $7e,0
+ > load_flag 0
+2219 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+221b : 48 > pha ;use stack to load status
+221c : a97e > lda #$7e ;precharge accu
+221e : 28 > plp
+
+221f : d22a cmp (ind1+8)
+ tst_a $7e,fn
+2221 : 08 > php ;save flags
+2222 : c97e > cmp #$7e ;test result
+ > trap_ne
+2224 : d0fe > bne * ;failed not equal (non zero)
+ >
+2226 : 68 > pla ;load status
+2227 : 48 > pha
+ > cmp_flag fn
+2228 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+222a : d0fe > bne * ;failed not equal (non zero)
+ >
+222c : 28 > plp ;restore status
+
+ set_a $80,$ff
+ > load_flag $ff
+222d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+222f : 48 > pha ;use stack to load status
+2230 : a980 > lda #$80 ;precharge accu
+2232 : 28 > plp
+
+2233 : d22a cmp (ind1+8)
+ tst_a $80,~fnz
+2235 : 08 > php ;save flags
+2236 : c980 > cmp #$80 ;test result
+ > trap_ne
+2238 : d0fe > bne * ;failed not equal (non zero)
+ >
+223a : 68 > pla ;load status
+223b : 48 > pha
+ > cmp_flag ~fnz
+223c : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+223e : d0fe > bne * ;failed not equal (non zero)
+ >
+2240 : 28 > plp ;restore status
+
+ set_a $7f,$ff
+ > load_flag $ff
+2241 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2243 : 48 > pha ;use stack to load status
+2244 : a97f > lda #$7f ;precharge accu
+2246 : 28 > plp
+
+2247 : d22a cmp (ind1+8)
+ tst_a $7f,~fn
+2249 : 08 > php ;save flags
+224a : c97f > cmp #$7f ;test result
+ > trap_ne
+224c : d0fe > bne * ;failed not equal (non zero)
+ >
+224e : 68 > pla ;load status
+224f : 48 > pha
+ > cmp_flag ~fn
+2250 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2252 : d0fe > bne * ;failed not equal (non zero)
+ >
+2254 : 28 > plp ;restore status
+
+ set_a $7e,$ff
+ > load_flag $ff
+2255 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+2257 : 48 > pha ;use stack to load status
+2258 : a97e > lda #$7e ;precharge accu
+225a : 28 > plp
+
+225b : d22a cmp (ind1+8)
+ tst_a $7e,~fzc
+225d : 08 > php ;save flags
+225e : c97e > cmp #$7e ;test result
+ > trap_ne
+2260 : d0fe > bne * ;failed not equal (non zero)
+ >
+2262 : 68 > pla ;load status
+2263 : 48 > pha
+ > cmp_flag ~fzc
+2264 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
+ >
+ > trap_ne
+2266 : d0fe > bne * ;failed not equal (non zero)
+ >
+2268 : 28 > plp ;restore status
+
+2269 : e0de cpx #$de
+ trap_ne ;x altered during test
+226b : d0fe > bne * ;failed not equal (non zero)
+
+226d : c0ad cpy #$ad
+ trap_ne ;y altered during test
+226f : d0fe > bne * ;failed not equal (non zero)
+
+2271 : ba tsx
+2272 : e0ff cpx #$ff
+ trap_ne ;sp push/pop mismatch
+2274 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+2276 : ad0202 > lda test_case ;previous test
+2279 : c912 > cmp #test_num
+ > trap_ne ;test is out of sequence
+227b : d0fe > bne * ;failed not equal (non zero)
+ >
+0013 = >test_num = test_num + 1
+227d : a913 > lda #test_num ;*** next tests' number
+227f : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; testing logical instructions - AND EOR ORA (zp)
+2282 : a242 ldx #$42 ;protect x & y
+
+2284 : a000 ldy #0 ;AND
+2286 : a538 lda indAN ;set indirect address
+2288 : 850a sta zpt
+228a : a539 lda indAN+1
+228c : 850b sta zpt+1
+228e : tand1
+ set_ay absANa,0
+ > load_flag 0
+228e : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+2290 : 48 > pha ;use stack to load status
+2291 : b94d02 > lda absANa,y ;precharge accu
+2294 : 28 > plp
+
+2295 : 320a and (zpt)
+ tst_ay absrlo,absflo,0
+2297 : 08 > php ;save flags
+2298 : d95502 > cmp absrlo,y ;test result
+ > trap_ne ;
+229b : d0fe > bne * ;failed not equal (non zero)
+ >
+229d : 68 > pla ;load status
+ > eor_flag 0
+229e : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+22a0 : d95902 > cmp absflo,y ;test flags
+ > trap_ne
+22a3 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+22a5 : e60a inc zpt
+22a7 : c8 iny
+22a8 : c004 cpy #4
+22aa : d0e2 bne tand1
+22ac : 88 dey
+22ad : c60a dec zpt
+22af : tand2
+ set_ay absANa,$ff
+ > load_flag $ff
+22af : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+22b1 : 48 > pha ;use stack to load status
+22b2 : b94d02 > lda absANa,y ;precharge accu
+22b5 : 28 > plp
+
+22b6 : 320a and (zpt)
+ tst_ay absrlo,absflo,$ff-fnz
+22b8 : 08 > php ;save flags
+22b9 : d95502 > cmp absrlo,y ;test result
+ > trap_ne ;
+22bc : d0fe > bne * ;failed not equal (non zero)
+ >
+22be : 68 > pla ;load status
+ > eor_flag $ff-fnz
+22bf : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+22c1 : d95902 > cmp absflo,y ;test flags
+ > trap_ne
+22c4 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+22c6 : c60a dec zpt
+22c8 : 88 dey
+22c9 : 10e4 bpl tand2
+
+22cb : a000 ldy #0 ;EOR
+22cd : a540 lda indEO ;set indirect address
+22cf : 850a sta zpt
+22d1 : a541 lda indEO+1
+22d3 : 850b sta zpt+1
+22d5 : teor1
+ set_ay absEOa,0
+ > load_flag 0
+22d5 : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+22d7 : 48 > pha ;use stack to load status
+22d8 : b95102 > lda absEOa,y ;precharge accu
+22db : 28 > plp
+
+22dc : 520a eor (zpt)
+ tst_ay absrlo,absflo,0
+22de : 08 > php ;save flags
+22df : d95502 > cmp absrlo,y ;test result
+ > trap_ne ;
+22e2 : d0fe > bne * ;failed not equal (non zero)
+ >
+22e4 : 68 > pla ;load status
+ > eor_flag 0
+22e5 : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+22e7 : d95902 > cmp absflo,y ;test flags
+ > trap_ne
+22ea : d0fe > bne * ;failed not equal (non zero)
+ >
+
+22ec : e60a inc zpt
+22ee : c8 iny
+22ef : c004 cpy #4
+22f1 : d0e2 bne teor1
+22f3 : 88 dey
+22f4 : c60a dec zpt
+22f6 : teor2
+ set_ay absEOa,$ff
+ > load_flag $ff
+22f6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+22f8 : 48 > pha ;use stack to load status
+22f9 : b95102 > lda absEOa,y ;precharge accu
+22fc : 28 > plp
+
+22fd : 520a eor (zpt)
+ tst_ay absrlo,absflo,$ff-fnz
+22ff : 08 > php ;save flags
+2300 : d95502 > cmp absrlo,y ;test result
+ > trap_ne ;
+2303 : d0fe > bne * ;failed not equal (non zero)
+ >
+2305 : 68 > pla ;load status
+ > eor_flag $ff-fnz
+2306 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+2308 : d95902 > cmp absflo,y ;test flags
+ > trap_ne
+230b : d0fe > bne * ;failed not equal (non zero)
+ >
+
+230d : c60a dec zpt
+230f : 88 dey
+2310 : 10e4 bpl teor2
+
+2312 : a000 ldy #0 ;ORA
+2314 : a548 lda indOR ;set indirect address
+2316 : 850a sta zpt
+2318 : a549 lda indOR+1
+231a : 850b sta zpt+1
+231c : tora1
+ set_ay absORa,0
+ > load_flag 0
+231c : a900 > lda #0 ;allow test to change I-flag (no mask)
+ >
+231e : 48 > pha ;use stack to load status
+231f : b94902 > lda absORa,y ;precharge accu
+2322 : 28 > plp
+
+2323 : 120a ora (zpt)
+ tst_ay absrlo,absflo,0
+2325 : 08 > php ;save flags
+2326 : d95502 > cmp absrlo,y ;test result
+ > trap_ne ;
+2329 : d0fe > bne * ;failed not equal (non zero)
+ >
+232b : 68 > pla ;load status
+ > eor_flag 0
+232c : 4930 > eor #0|fao ;invert expected flags + always on bits
+ >
+232e : d95902 > cmp absflo,y ;test flags
+ > trap_ne
+2331 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2333 : e60a inc zpt
+2335 : c8 iny
+2336 : c004 cpy #4
+2338 : d0e2 bne tora1
+233a : 88 dey
+233b : c60a dec zpt
+233d : tora2
+ set_ay absORa,$ff
+ > load_flag $ff
+233d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+233f : 48 > pha ;use stack to load status
+2340 : b94902 > lda absORa,y ;precharge accu
+2343 : 28 > plp
+
+2344 : 120a ora (zpt)
+ tst_ay absrlo,absflo,$ff-fnz
+2346 : 08 > php ;save flags
+2347 : d95502 > cmp absrlo,y ;test result
+ > trap_ne ;
+234a : d0fe > bne * ;failed not equal (non zero)
+ >
+234c : 68 > pla ;load status
+ > eor_flag $ff-fnz
+234d : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
+ >
+234f : d95902 > cmp absflo,y ;test flags
+ > trap_ne
+2352 : d0fe > bne * ;failed not equal (non zero)
+ >
+
+2354 : c60a dec zpt
+2356 : 88 dey
+2357 : 10e4 bpl tora2
+
+2359 : e042 cpx #$42
+ trap_ne ;x altered during test
+235b : d0fe > bne * ;failed not equal (non zero)
+
+235d : ba tsx
+235e : e0ff cpx #$ff
+ trap_ne ;sp push/pop mismatch
+2360 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+2362 : ad0202 > lda test_case ;previous test
+2365 : c913 > cmp #test_num
+ > trap_ne ;test is out of sequence
+2367 : d0fe > bne * ;failed not equal (non zero)
+ >
+0014 = >test_num = test_num + 1
+2369 : a914 > lda #test_num ;*** next tests' number
+236b : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ if I_flag = 3
+236e : 58 cli
+ endif
+
+ ; full binary add/subtract test - (zp) only
+ ; iterates through all combinations of operands and carry input
+ ; uses increments/decrements to predict result & result flags
+236f : d8 cld
+2370 : a20c ldx #ad2 ;for indexed test
+2372 : a0ff ldy #$ff ;max range
+2374 : a900 lda #0 ;start with adding zeroes & no carry
+2376 : 850a sta adfc ;carry in - for diag
+2378 : 850b sta ad1 ;operand 1 - accumulator
+237a : 850c sta ad2 ;operand 2 - memory or immediate
+237c : 8d0502 sta ada2 ;non zp
+237f : 850d sta adrl ;expected result bits 0-7
+2381 : 850e sta adrh ;expected result bit 8 (carry out)
+2383 : a9ff lda #$ff ;complemented operand 2 for subtract
+2385 : 8510 sta sb2
+2387 : 8d0602 sta sba2 ;non zp
+238a : a902 lda #2 ;expected Z-flag
+238c : 850f sta adrf
+238e : 18 tadd clc ;test with carry clear
+238f : 200326 jsr chkadd
+2392 : e60a inc adfc ;now with carry
+2394 : e60d inc adrl ;result +1
+2396 : 08 php ;save N & Z from low result
+2397 : 08 php
+2398 : 68 pla ;accu holds expected flags
+2399 : 2982 and #$82 ;mask N & Z
+239b : 28 plp
+239c : d002 bne tadd1
+239e : e60e inc adrh ;result bit 8 - carry
+23a0 : 050e tadd1 ora adrh ;merge C to expected flags
+23a2 : 850f sta adrf ;save expected flags except overflow
+23a4 : 38 sec ;test with carry set
+23a5 : 200326 jsr chkadd
+23a8 : c60a dec adfc ;same for operand +1 but no carry
+23aa : e60b inc ad1
+23ac : d0e0 bne tadd ;iterate op1
+23ae : a900 lda #0 ;preset result to op2 when op1 = 0
+23b0 : 850e sta adrh
+23b2 : ee0502 inc ada2
+23b5 : e60c inc ad2
+23b7 : 08 php ;save NZ as operand 2 becomes the new result
+23b8 : 68 pla
+23b9 : 2982 and #$82 ;mask N00000Z0
+23bb : 850f sta adrf ;no need to check carry as we are adding to 0
+23bd : c610 dec sb2 ;complement subtract operand 2
+23bf : ce0602 dec sba2
+23c2 : a50c lda ad2
+23c4 : 850d sta adrl
+23c6 : d0c6 bne tadd ;iterate op2
+
+23c8 : e00c cpx #ad2
+ trap_ne ;x altered during test
+23ca : d0fe > bne * ;failed not equal (non zero)
+
+23cc : c0ff cpy #$ff
+ trap_ne ;y altered during test
+23ce : d0fe > bne * ;failed not equal (non zero)
+
+23d0 : ba tsx
+23d1 : e0ff cpx #$ff
+ trap_ne ;sp push/pop mismatch
+23d3 : d0fe > bne * ;failed not equal (non zero)
+
+ next_test
+23d5 : ad0202 > lda test_case ;previous test
+23d8 : c914 > cmp #test_num
+ > trap_ne ;test is out of sequence
+23da : d0fe > bne * ;failed not equal (non zero)
+ >
+0015 = >test_num = test_num + 1
+23dc : a915 > lda #test_num ;*** next tests' number
+23de : 8d0202 > sta test_case
+ > ;check_ram ;uncomment to find altered RAM after each test
+
+
+ ; decimal add/subtract test
+ ; *** WARNING - tests documented behavior only! ***
+ ; only valid BCD operands are tested, the V flag is ignored
+ ; although V is declared as beeing valid on the 65C02 it has absolutely
+ ; no use in BCD math. No sign = no overflow!
+ ; iterates through all valid combinations of operands and carry input
+ ; uses increments/decrements to predict result & carry flag
+23e1 : f8 sed
+23e2 : a20c ldx #ad2 ;for indexed test
+23e4 : a0ff ldy #$ff ;max range
+23e6 : a999 lda #$99 ;start with adding 99 to 99 with carry
+23e8 : 850b sta ad1 ;operand 1 - accumulator
+23ea : 850c sta ad2 ;operand 2 - memory or immediate
+23ec : 8d0502 sta ada2 ;non zp
+23ef : 850d sta adrl ;expected result bits 0-7
+23f1 : a901 lda #1 ;set carry in & out
+23f3 : 850a sta adfc ;carry in - for diag
+23f5 : 850e sta adrh ;expected result bit 8 (carry out)
+23f7 : a981 lda #$81 ;set N & C (99 + 99 + C = 99 + C)
+23f9 : 850f sta adrf
+23fb : a900 lda #0 ;complemented operand 2 for subtract
+23fd : 8510 sta sb2
+23ff : 8d0602 sta sba2 ;non zp
+2402 : 38 tdad sec ;test with carry set
+2403 : 20ae24 jsr chkdad
+2406 : c60a dec adfc ;now with carry clear
+2408 : a50d lda adrl ;decimal adjust result
+240a : d008 bne tdad1 ;skip clear carry & preset result 99 (9A-1)
+240c : c60e dec adrh
+240e : a999 lda #$99
+2410 : 850d sta adrl
+2412 : d012 bne tdad3
+2414 : 290f tdad1 and #$f ;lower nibble mask
+2416 : d00c bne tdad2 ;no decimal adjust needed
+2418 : c60d dec adrl ;decimal adjust (?0-6)
+241a : c60d dec adrl
+241c : c60d dec adrl
+241e : c60d dec adrl
+2420 : c60d dec adrl
+2422 : c60d dec adrl
+2424 : c60d tdad2 dec adrl ;result -1
+2426 : 08 tdad3 php ;save valid flags
+2427 : 68 pla
+2428 : 2982 and #$82 ;N-----Z-
+242a : 050e ora adrh ;N-----ZC
+242c : 850f sta adrf
+242e : 18 clc ;test with carry clear
+242f : 20ae24 jsr chkdad
+2432 : e60a inc adfc ;same for operand -1 but with carry
+2434 : a50b lda ad1 ;decimal adjust operand 1
+2436 : f015 beq tdad5 ;iterate operand 2
+2438 : 290f and #$f ;lower nibble mask
+243a : d00c bne tdad4 ;skip decimal adjust
+243c : c60b dec ad1 ;decimal adjust (?0-6)
+243e : c60b dec ad1
+2440 : c60b dec ad1
+2442 : c60b dec ad1
+2444 : c60b dec ad1
+2446 : c60b dec ad1
+2448 : c60b tdad4 dec ad1 ;operand 1 -1
+244a : 4c0224 jmp tdad ;iterate op1
+
+244d : a999 tdad5 lda #$99 ;precharge op1 max
+244f : 850b sta ad1
+2451 : a50c lda ad2 ;decimal adjust operand 2
+2453 : f039 beq tdad7 ;end of iteration
+2455 : 290f and #$f ;lower nibble mask
+2457 : d018 bne tdad6 ;skip decimal adjust
+2459 : c60c dec ad2 ;decimal adjust (?0-6)
+245b : c60c dec ad2
+245d : c60c dec ad2
+245f : c60c dec ad2
+2461 : c60c dec ad2
+2463 : c60c dec ad2
+2465 : e610 inc sb2 ;complemented decimal adjust for subtract (?9+6)
+2467 : e610 inc sb2
+2469 : e610 inc sb2
+246b : e610 inc sb2
+246d : e610 inc sb2
+246f : e610 inc sb2
+2471 : c60c tdad6 dec ad2 ;operand 2 -1
+2473 : e610 inc sb2 ;complemented operand for subtract
+2475 : a510 lda sb2
+2477 : 8d0602 sta sba2 ;copy as non zp operand
+247a : a50c lda ad2
+247c : 8d0502 sta ada2 ;copy as non zp operand
+247f : 850d sta adrl ;new result since op1+carry=00+carry +op2=op2
+2481 : 08 php ;save flags
+2482 : 68 pla
+2483 : 2982 and #$82 ;N-----Z-
+2485 : 0901 ora #1 ;N-----ZC
+2487 : 850f sta adrf
+2489 : e60e inc adrh ;result carry
+248b : 4c0224 jmp tdad ;iterate op2
+
+248e : e00c tdad7 cpx #ad2
+ trap_ne ;x altered during test
+2490 : d0fe > bne * ;failed not equal (non zero)
+
+2492 : c0ff cpy #$ff
+ trap_ne ;y altered during test
+2494 : d0fe > bne * ;failed not equal (non zero)
+
+2496 : ba tsx
+2497 : e0ff cpx #$ff
+ trap_ne ;sp push/pop mismatch
+2499 : d0fe > bne * ;failed not equal (non zero)
+
+249b : d8 cld
+
+249c : ad0202 lda test_case
+249f : c915 cmp #test_num
+ trap_ne ;previous test is out of sequence
+24a1 : d0fe > bne * ;failed not equal (non zero)
+
+24a3 : a9f0 lda #$f0 ;mark opcode testing complete
+24a5 : 8d0202 sta test_case
+
+ ; final RAM integrity test
+ ; verifies that none of the previous tests has altered RAM outside of the
+ ; designated write areas.
+ check_ram
+ > ;RAM check disabled - RAM size not set
+
+ ; *** DEBUG INFO ***
+ ; to debug checksum errors uncomment check_ram in the next_test macro to
+ ; narrow down the responsible opcode.
+ ; may give false errors when monitor, OS or other background activity is
+ ; allowed during previous tests.
+
+
+ ; S U C C E S S ************************************************
+ ; -------------
+ success ;if you get here everything went well
+24a8 : 4ca824 > jmp * ;test passed, no errors
+
+ ; -------------
+ ; S U C C E S S ************************************************
+24ab : 4c0004 jmp start ;run again
+
+ ; core subroutine of the decimal add/subtract test
+ ; *** WARNING - tests documented behavior only! ***
+ ; only valid BCD operands are tested, V flag is ignored
+ ; iterates through all valid combinations of operands and carry input
+ ; uses increments/decrements to predict result & carry flag
+24ae : chkdad
+ ; decimal ADC / SBC zp
+24ae : 08 php ;save carry for subtract
+24af : a50b lda ad1
+24b1 : 650c adc ad2 ;perform add
+24b3 : 08 php
+24b4 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+24b6 : d0fe > bne * ;failed not equal (non zero)
+
+24b8 : 68 pla ;check flags
+24b9 : 2983 and #$83 ;mask N-----ZC
+24bb : c50f cmp adrf
+ trap_ne ;bad flags
+24bd : d0fe > bne * ;failed not equal (non zero)
+
+24bf : 28 plp
+24c0 : 08 php ;save carry for next add
+24c1 : a50b lda ad1
+24c3 : e510 sbc sb2 ;perform subtract
+24c5 : 08 php
+24c6 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+24c8 : d0fe > bne * ;failed not equal (non zero)
+
+24ca : 68 pla ;check flags
+24cb : 2983 and #$83 ;mask N-----ZC
+24cd : c50f cmp adrf
+ trap_ne ;bad flags
+24cf : d0fe > bne * ;failed not equal (non zero)
+
+24d1 : 28 plp
+ ; decimal ADC / SBC abs
+24d2 : 08 php ;save carry for subtract
+24d3 : a50b lda ad1
+24d5 : 6d0502 adc ada2 ;perform add
+24d8 : 08 php
+24d9 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+24db : d0fe > bne * ;failed not equal (non zero)
+
+24dd : 68 pla ;check flags
+24de : 2983 and #$83 ;mask N-----ZC
+24e0 : c50f cmp adrf
+ trap_ne ;bad flags
+24e2 : d0fe > bne * ;failed not equal (non zero)
+
+24e4 : 28 plp
+24e5 : 08 php ;save carry for next add
+24e6 : a50b lda ad1
+24e8 : ed0602 sbc sba2 ;perform subtract
+24eb : 08 php
+24ec : c50d cmp adrl ;check result
+ trap_ne ;bad result
+24ee : d0fe > bne * ;failed not equal (non zero)
+
+24f0 : 68 pla ;check flags
+24f1 : 2983 and #$83 ;mask N-----ZC
+24f3 : c50f cmp adrf
+ trap_ne ;bad flags
+24f5 : d0fe > bne * ;failed not equal (non zero)
+
+24f7 : 28 plp
+ ; decimal ADC / SBC #
+24f8 : 08 php ;save carry for subtract
+24f9 : a50c lda ad2
+24fb : 8d0125 sta chkdadi ;self modify immediate
+24fe : a50b lda ad1
+2501 = chkdadi = * + 1 ;operand of the immediate ADC
+2500 : 6900 adc #0 ;perform add
+2502 : 08 php
+2503 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+2505 : d0fe > bne * ;failed not equal (non zero)
+
+2507 : 68 pla ;check flags
+2508 : 2983 and #$83 ;mask N-----ZC
+250a : c50f cmp adrf
+ trap_ne ;bad flags
+250c : d0fe > bne * ;failed not equal (non zero)
+
+250e : 28 plp
+250f : 08 php ;save carry for next add
+2510 : a510 lda sb2
+2512 : 8d1825 sta chkdsbi ;self modify immediate
+2515 : a50b lda ad1
+2518 = chkdsbi = * + 1 ;operand of the immediate SBC
+2517 : e900 sbc #0 ;perform subtract
+2519 : 08 php
+251a : c50d cmp adrl ;check result
+ trap_ne ;bad result
+251c : d0fe > bne * ;failed not equal (non zero)
+
+251e : 68 pla ;check flags
+251f : 2983 and #$83 ;mask N-----ZC
+2521 : c50f cmp adrf
+ trap_ne ;bad flags
+2523 : d0fe > bne * ;failed not equal (non zero)
+
+2525 : 28 plp
+ ; decimal ADC / SBC zp,x
+2526 : 08 php ;save carry for subtract
+2527 : a50b lda ad1
+2529 : 7500 adc 0,x ;perform add
+252b : 08 php
+252c : c50d cmp adrl ;check result
+ trap_ne ;bad result
+252e : d0fe > bne * ;failed not equal (non zero)
+
+2530 : 68 pla ;check flags
+2531 : 2983 and #$83 ;mask N-----ZC
+2533 : c50f cmp adrf
+ trap_ne ;bad flags
+2535 : d0fe > bne * ;failed not equal (non zero)
+
+2537 : 28 plp
+2538 : 08 php ;save carry for next add
+2539 : a50b lda ad1
+253b : f504 sbc sb2-ad2,x ;perform subtract
+253d : 08 php
+253e : c50d cmp adrl ;check result
+ trap_ne ;bad result
+2540 : d0fe > bne * ;failed not equal (non zero)
+
+2542 : 68 pla ;check flags
+2543 : 2983 and #$83 ;mask N-----ZC
+2545 : c50f cmp adrf
+ trap_ne ;bad flags
+2547 : d0fe > bne * ;failed not equal (non zero)
+
+2549 : 28 plp
+ ; decimal ADC / SBC abs,x
+254a : 08 php ;save carry for subtract
+254b : a50b lda ad1
+254d : 7df901 adc ada2-ad2,x ;perform add
+2550 : 08 php
+2551 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+2553 : d0fe > bne * ;failed not equal (non zero)
+
+2555 : 68 pla ;check flags
+2556 : 2983 and #$83 ;mask N-----ZC
+2558 : c50f cmp adrf
+ trap_ne ;bad flags
+255a : d0fe > bne * ;failed not equal (non zero)
+
+255c : 28 plp
+255d : 08 php ;save carry for next add
+255e : a50b lda ad1
+2560 : fdfa01 sbc sba2-ad2,x ;perform subtract
+2563 : 08 php
+2564 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+2566 : d0fe > bne * ;failed not equal (non zero)
+
+2568 : 68 pla ;check flags
+2569 : 2983 and #$83 ;mask N-----ZC
+256b : c50f cmp adrf
+ trap_ne ;bad flags
+256d : d0fe > bne * ;failed not equal (non zero)
+
+256f : 28 plp
+ ; decimal ADC / SBC abs,y
+2570 : 08 php ;save carry for subtract
+2571 : a50b lda ad1
+2573 : 790601 adc ada2-$ff,y ;perform add
+2576 : 08 php
+2577 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+2579 : d0fe > bne * ;failed not equal (non zero)
+
+257b : 68 pla ;check flags
+257c : 2983 and #$83 ;mask N-----ZC
+257e : c50f cmp adrf
+ trap_ne ;bad flags
+2580 : d0fe > bne * ;failed not equal (non zero)
+
+2582 : 28 plp
+2583 : 08 php ;save carry for next add
+2584 : a50b lda ad1
+2586 : f90701 sbc sba2-$ff,y ;perform subtract
+2589 : 08 php
+258a : c50d cmp adrl ;check result
+ trap_ne ;bad result
+258c : d0fe > bne * ;failed not equal (non zero)
+
+258e : 68 pla ;check flags
+258f : 2983 and #$83 ;mask N-----ZC
+2591 : c50f cmp adrf
+ trap_ne ;bad flags
+2593 : d0fe > bne * ;failed not equal (non zero)
+
+2595 : 28 plp
+ ; decimal ADC / SBC (zp,x)
+2596 : 08 php ;save carry for subtract
+2597 : a50b lda ad1
+2599 : 6144 adc (lo adi2-ad2,x) ;perform add
+259b : 08 php
+259c : c50d cmp adrl ;check result
+ trap_ne ;bad result
+259e : d0fe > bne * ;failed not equal (non zero)
+
+25a0 : 68 pla ;check flags
+25a1 : 2983 and #$83 ;mask N-----ZC
+25a3 : c50f cmp adrf
+ trap_ne ;bad flags
+25a5 : d0fe > bne * ;failed not equal (non zero)
+
+25a7 : 28 plp
+25a8 : 08 php ;save carry for next add
+25a9 : a50b lda ad1
+25ab : e146 sbc (lo sbi2-ad2,x) ;perform subtract
+25ad : 08 php
+25ae : c50d cmp adrl ;check result
+ trap_ne ;bad result
+25b0 : d0fe > bne * ;failed not equal (non zero)
+
+25b2 : 68 pla ;check flags
+25b3 : 2983 and #$83 ;mask N-----ZC
+25b5 : c50f cmp adrf
+ trap_ne ;bad flags
+25b7 : d0fe > bne * ;failed not equal (non zero)
+
+25b9 : 28 plp
+ ; decimal ADC / SBC (abs),y
+25ba : 08 php ;save carry for subtract
+25bb : a50b lda ad1
+25bd : 7154 adc (adiy2),y ;perform add
+25bf : 08 php
+25c0 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+25c2 : d0fe > bne * ;failed not equal (non zero)
+
+25c4 : 68 pla ;check flags
+25c5 : 2983 and #$83 ;mask N-----ZC
+25c7 : c50f cmp adrf
+ trap_ne ;bad flags
+25c9 : d0fe > bne * ;failed not equal (non zero)
+
+25cb : 28 plp
+25cc : 08 php ;save carry for next add
+25cd : a50b lda ad1
+25cf : f156 sbc (sbiy2),y ;perform subtract
+25d1 : 08 php
+25d2 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+25d4 : d0fe > bne * ;failed not equal (non zero)
+
+25d6 : 68 pla ;check flags
+25d7 : 2983 and #$83 ;mask N-----ZC
+25d9 : c50f cmp adrf
+ trap_ne ;bad flags
+25db : d0fe > bne * ;failed not equal (non zero)
+
+25dd : 28 plp
+ ; decimal ADC / SBC (zp)
+25de : 08 php ;save carry for subtract
+25df : a50b lda ad1
+25e1 : 7250 adc (adi2) ;perform add
+25e3 : 08 php
+25e4 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+25e6 : d0fe > bne * ;failed not equal (non zero)
+
+25e8 : 68 pla ;check flags
+25e9 : 2983 and #$83 ;mask N-----ZC
+25eb : c50f cmp adrf
+ trap_ne ;bad flags
+25ed : d0fe > bne * ;failed not equal (non zero)
+
+25ef : 28 plp
+25f0 : 08 php ;save carry for next add
+25f1 : a50b lda ad1
+25f3 : f252 sbc (sbi2) ;perform subtract
+25f5 : 08 php
+25f6 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+25f8 : d0fe > bne * ;failed not equal (non zero)
+
+25fa : 68 pla ;check flags
+25fb : 2983 and #$83 ;mask N-----ZC
+25fd : c50f cmp adrf
+ trap_ne ;bad flags
+25ff : d0fe > bne * ;failed not equal (non zero)
+
+2601 : 28 plp
+2602 : 60 rts
+
+ ; core subroutine of the full binary add/subtract test
+ ; iterates through all combinations of operands and carry input
+ ; uses increments/decrements to predict result & result flags
+2603 : a50f chkadd lda adrf ;add V-flag if overflow
+2605 : 2983 and #$83 ;keep N-----ZC / clear V
+2607 : 48 pha
+2608 : a50b lda ad1 ;test sign unequal between operands
+260a : 450c eor ad2
+260c : 300a bmi ckad1 ;no overflow possible - operands have different sign
+260e : a50b lda ad1 ;test sign equal between operands and result
+2610 : 450d eor adrl
+2612 : 1004 bpl ckad1 ;no overflow occured - operand and result have same sign
+2614 : 68 pla
+2615 : 0940 ora #$40 ;set V
+2617 : 48 pha
+2618 : 68 ckad1 pla
+2619 : 850f sta adrf ;save expected flags
+ ; binary ADC / SBC (zp)
+261b : 08 php ;save carry for subtract
+261c : a50b lda ad1
+261e : 7250 adc (adi2) ;perform add
+2620 : 08 php
+2621 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+2623 : d0fe > bne * ;failed not equal (non zero)
+
+2625 : 68 pla ;check flags
+2626 : 29c3 and #$c3 ;mask NV----ZC
+2628 : c50f cmp adrf
+ trap_ne ;bad flags
+262a : d0fe > bne * ;failed not equal (non zero)
+
+262c : 28 plp
+262d : 08 php ;save carry for next add
+262e : a50b lda ad1
+2630 : f252 sbc (sbi2) ;perform subtract
+2632 : 08 php
+2633 : c50d cmp adrl ;check result
+ trap_ne ;bad result
+2635 : d0fe > bne * ;failed not equal (non zero)
+
+2637 : 68 pla ;check flags
+2638 : 29c3 and #$c3 ;mask NV----ZC
+263a : c50f cmp adrf
+ trap_ne ;bad flags
+263c : d0fe > bne * ;failed not equal (non zero)
+
+263e : 28 plp
+263f : 60 rts
+
+ ; target for the jump indirect test
+2640 : 4626 ji_adr dw test_ji
+2642 : 8216 dw ji_ret
+
+2644 : 88 dey
+2645 : 88 dey
+2646 : test_ji
+2646 : 08 php ;either SP or Y count will fail, if we do not hit
+2647 : 88 dey
+2648 : 88 dey
+2649 : 88 dey
+264a : 28 plp
+ trap_cs ;flags loaded?
+264b : b0fe > bcs * ;failed carry set
+
+ trap_vs
+264d : 70fe > bvs * ;failed overflow set
+
+ trap_mi
+264f : 30fe > bmi * ;failed minus (bit 7 set)
+
+ trap_eq
+2651 : f0fe > beq * ;failed equal (zero)
+
+2653 : c949 cmp #'I' ;registers loaded?
+ trap_ne
+2655 : d0fe > bne * ;failed not equal (non zero)
+
+2657 : e04e cpx #'N'
+ trap_ne
+2659 : d0fe > bne * ;failed not equal (non zero)
+
+265b : c041 cpy #('D'-3)
+ trap_ne
+265d : d0fe > bne * ;failed not equal (non zero)
+
+265f : 48 pha ;save a,x
+2660 : 8a txa
+2661 : 48 pha
+2662 : ba tsx
+2663 : e0fd cpx #$fd ;check SP
+ trap_ne
+2665 : d0fe > bne * ;failed not equal (non zero)
+
+2667 : 68 pla ;restore x
+2668 : aa tax
+ set_stat $ff
+ > load_flag $ff
+2669 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+266b : 48 > pha ;use stack to load status
+266c : 28 > plp
+
+266d : 68 pla ;restore a
+266e : e8 inx ;return registers with modifications
+266f : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
+2671 : 6cff02 jmp (ji_tab+2)
+2674 : ea nop
+2675 : ea nop
+ trap ;runover protection
+2676 : 4c7626 > jmp * ;failed anyway
+
+
+ ; target for the jump indirect test
+2679 : bd26 jxi_adr dw trap_ind
+267b : bd26 dw trap_ind
+267d : 8726 dw test_jxi ;+4
+267f : ce16 dw jxi_ret ;+6
+2681 : bd26 dw trap_ind
+2683 : bd26 dw trap_ind
+
+2685 : 88 dey
+2686 : 88 dey
+2687 : test_jxi
+2687 : 08 php ;either SP or Y count will fail, if we do not hit
+2688 : 88 dey
+2689 : 88 dey
+268a : 88 dey
+268b : 28 plp
+ trap_cs ;flags loaded?
+268c : b0fe > bcs * ;failed carry set
+
+ trap_vs
+268e : 70fe > bvs * ;failed overflow set
+
+ trap_mi
+2690 : 30fe > bmi * ;failed minus (bit 7 set)
+
+ trap_eq
+2692 : f0fe > beq * ;failed equal (zero)
+
+2694 : c958 cmp #'X' ;registers loaded?
+ trap_ne
+2696 : d0fe > bne * ;failed not equal (non zero)
+
+2698 : e004 cpx #4
+ trap_ne
+269a : d0fe > bne * ;failed not equal (non zero)
+
+269c : c046 cpy #('I'-3)
+ trap_ne
+269e : d0fe > bne * ;failed not equal (non zero)
+
+26a0 : 48 pha ;save a,x
+26a1 : 8a txa
+26a2 : 48 pha
+26a3 : ba tsx
+26a4 : e0fd cpx #$fd ;check SP
+ trap_ne
+26a6 : d0fe > bne * ;failed not equal (non zero)
+
+26a8 : 68 pla ;restore x
+26a9 : aa tax
+ set_stat $ff
+ > load_flag $ff
+26aa : a9ff > lda #$ff ;allow test to change I-flag (no mask)
+ >
+26ac : 48 > pha ;use stack to load status
+26ad : 28 > plp
+
+26ae : 68 pla ;restore a
+26af : e8 inx ;return registers with modifications
+26b0 : e8 inx
+26b1 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
+26b3 : 7cf902 jmp (jxi_tab,x)
+26b6 : ea nop
+26b7 : ea nop
+ trap ;runover protection
+26b8 : 4cb826 > jmp * ;failed anyway
+
+
+ ; JMP (abs,x) with bad x
+26bb : ea nop
+26bc : ea nop
+26bd : trap_ind
+26bd : ea nop
+26be : ea nop
+ trap ;near miss indexed indirect jump
+26bf : 4cbf26 > jmp * ;failed anyway
+
+
+ ;trap in case of unexpected IRQ, NMI, BRK, RESET
+26c2 : nmi_trap
+ trap ;check stack for conditions at NMI
+26c2 : 4cc226 > jmp * ;failed anyway
+
+26c5 : res_trap
+ trap ;unexpected RESET
+26c5 : 4cc526 > jmp * ;failed anyway
+
+26c8 : irq_trap
+26c8 : 08 php ;save decimal flag
+26c9 : ba tsx ;test break on stack
+26ca : bd0201 lda $102,x
+26cd : 2910 and #break
+ trap_eq ;check stack for conditions at IRQ
+26cf : f0fe > beq * ;failed equal (zero)
+
+ if ROM_vectors = 1
+26d1 : 68 pla ;test decimal mode cleared
+26d2 : 2908 and #decmode
+ trap_ne ;decimal mode not cleared after BRK
+26d4 : d0fe > bne * ;failed not equal (non zero)
+
+26d6 : 28 plp ;pop saved flags
+26d7 : 68 pla ;return address low
+26d8 : c917 cmp #lo(brk_ret)
+ trap_ne ;unexpected BRK
+26da : d0fe > bne * ;failed not equal (non zero)
+
+26dc : 68 pla ;return address high
+26dd : c917 cmp #hi(brk_ret)
+ trap_ne ;unexpected BRK
+26df : d0fe > bne * ;failed not equal (non zero)
+
+26e1 : 4c1717 jmp brk_ret
+ else
+ trap_ne ;check stack for conditions at BRK
+ endif
+
+ if report = 1
+ include "report.i65"
+ endif
+
+ ;copy of data to initialize BSS segment
+ if load_data_direct != 1
+ zp_init
+ zp1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
+ zp7f_ db $7f ;test pattern for compare
+ ;logical zeropage operands
+ zpOR_ db 0,$1f,$71,$80 ;test pattern for OR
+ zpAN_ db $0f,$ff,$7f,$80 ;test pattern for AND
+ zpEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR
+ ;indirect addressing pointers
+ ind1_ dw abs1 ;indirect pointer to pattern in absolute memory
+ dw abs1+1
+ dw abs1+2
+ dw abs1+3
+ dw abs7f
+ inw1_ dw abs1-$f8 ;indirect pointer for wrap-test pattern
+ indt_ dw abst ;indirect pointer to store area in absolute memory
+ dw abst+1
+ dw abst+2
+ dw abst+3
+ inwt_ dw abst-$f8 ;indirect pointer for wrap-test store
+ indAN_ dw absAN ;indirect pointer to AND pattern in absolute memory
+ dw absAN+1
+ dw absAN+2
+ dw absAN+3
+ indEO_ dw absEO ;indirect pointer to EOR pattern in absolute memory
+ dw absEO+1
+ dw absEO+2
+ dw absEO+3
+ indOR_ dw absOR ;indirect pointer to OR pattern in absolute memory
+ dw absOR+1
+ dw absOR+2
+ dw absOR+3
+ ;add/subtract indirect pointers
+ adi2_ dw ada2 ;indirect pointer to operand 2 in absolute memory
+ sbi2_ dw sba2 ;indirect pointer to complemented operand 2 (SBC)
+ adiy2_ dw ada2-$ff ;with offset for indirect indexed
+ sbiy2_ dw sba2-$ff
+ zp_end
+ if (zp_end - zp_init) != (zp_bss_end - zp_bss)
+ ;force assembler error if size is different
+ ERROR ERROR ERROR ;mismatch between bss and zeropage data
+ endif
+ data_init
+ abs1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
+ abs7f_ db $7f ;test pattern for compare
+ ;loads
+ fLDx_ db fn,fn,0,fz ;expected flags for load
+ ;shifts
+ rASL_ ;expected result ASL & ROL -carry
+ rROL_ db $86,$04,$82,0 ; "
+ rROLc_ db $87,$05,$83,1 ;expected result ROL +carry
+ rLSR_ ;expected result LSR & ROR -carry
+ rROR_ db $61,$41,$20,0 ; "
+ rRORc_ db $e1,$c1,$a0,$80 ;expected result ROR +carry
+ fASL_ ;expected flags for shifts
+ fROL_ db fnc,fc,fn,fz ;no carry in
+ fROLc_ db fnc,fc,fn,0 ;carry in
+ fLSR_
+ fROR_ db fc,0,fc,fz ;no carry in
+ fRORc_ db fnc,fn,fnc,fn ;carry in
+ ;increments (decrements)
+ rINC_ db $7f,$80,$ff,0,1 ;expected result for INC/DEC
+ fINC_ db 0,fn,fn,fz,0 ;expected flags for INC/DEC
+ ;logical memory operand
+ absOR_ db 0,$1f,$71,$80 ;test pattern for OR
+ absAN_ db $0f,$ff,$7f,$80 ;test pattern for AND
+ absEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR
+ ;logical accu operand
+ absORa_ db 0,$f1,$1f,0 ;test pattern for OR
+ absANa_ db $f0,$ff,$ff,$ff ;test pattern for AND
+ absEOa_ db $ff,$f0,$f0,$0f ;test pattern for EOR
+ ;logical results
+ absrlo_ db 0,$ff,$7f,$80
+ absflo_ db fz,fn,0,fn
+ data_end
+ if (data_end - data_init) != (data_bss_end - data_bss)
+ ;force assembler error if size is different
+ ERROR ERROR ERROR ;mismatch between bss and data
+ endif
+
+ vec_init
+ dw nmi_trap
+ dw res_trap
+ dw irq_trap
+ vec_bss equ $fffa
+ endif ;end of RAM init data
+
+ ; code at end of image due to the need to add blank space as required
+ if ($ff & (ji_ret - * - 2)) < ($ff & (jxi_ret - * - 2))
+ ; JMP (abs) when $xxff and $xx00 are from same page
+26e4 : 00000000000000.. ds lo(ji_ret - * - 2)
+2780 : ea nop
+2781 : ea nop
+2782 : ea ji_px nop ;low address byte matched with ji_ret
+2783 : ea nop
+ trap ;jmp indirect page cross bug
+2784 : 4c8427 > jmp * ;failed anyway
+
+
+ ; JMP (abs,x) when $xxff and $xx00 are from same page
+2787 : 00000000000000.. ds lo(jxi_ret - * - 2)
+27cc : ea nop
+27cd : ea nop
+27ce : ea jxi_px nop ;low address byte matched with jxi_ret
+27cf : ea nop
+ trap ;jmp indexed indirect page cross bug
+27d0 : 4cd027 > jmp * ;failed anyway
+
+ else
+ ; JMP (abs,x) when $xxff and $xx00 are from same page
+ ds lo(jxi_ret - * - 2)
+ nop
+ nop
+ jxi_px nop ;low address byte matched with jxi_ret
+ nop
+ trap ;jmp indexed indirect page cross bug
+
+ ; JMP (abs) when $xxff and $xx00 are from same page
+ ds lo(ji_ret - * - 2)
+ nop
+ nop
+ ji_px nop ;low address byte matched with ji_ret
+ nop
+ trap ;jmp indirect page cross bug
+ endif
+
+ if (load_data_direct = 1) & (ROM_vectors = 1)
+fffa = org $fffa ;vectors
+fffa : c226 dw nmi_trap
+fffc : c526 dw res_trap
+fffe : c826 dw irq_trap
+ endif
+
+fffa = end start
+
+No errors in pass 2.
+Wrote binary from address $0000 through $ffff.
+Total size 65536 bytes.
+Program start address is at $0400 (1024).
+
\ No newline at end of file