AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                Page    1
---------------------------------------------------- 6502_functional_test.a65 ----------------------------------------------------

6109 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-2020  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 <http://www.gnu.org/licenses/>.
                        
                        
                        ; 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 05-jan-2020
                        ; contact info at http://2m5.de or email K@2m5.de
                        ;
                        ; assembled with AS65 written by Frank A. Kingswood
                        ; The assembler as65_142.zip can be obtained from my GitHub repository 
                        ; 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
                        ;   13-dec-2014  added binary/decimal opcode table switch test
                        ;   14-dec-2014  improved relative address test
                        ;   23-aug-2015  added option to disable self modifying tests
                        ;   24-aug-2015  all self modifying immediate opcodes now execute in data RAM
                        ;                added small branch offset pretest
                        ;   21-oct-2015  added option to disable decimal mode ADC & SBC tests
                        ;   04-dec-2017  fixed BRK only tested with interrupts enabled
                        ;                added option to skip the remainder of a failing test
                        ;                in report.i65
                        ;   05-jan-2020  fixed shifts not testing zero result and flag when last 1-bit
                        ;                is shifted out
                        
                        ; 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, $52 (82) consecutive Bytes required
                        ;                                add 2 if I_flag = 2
0000 =                  zero_page = $0  
                        
                        ;data_segment memory start address, $7B (123) 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, 13.1kB of consecutive space required
                        ;                                   add 2.5 kB if I_flag = 2
0400 =                  code_segment = $400  
                        
                        ;self modifying code may be disabled to allow running in ROM
                        ;0=part of the code is self modifying and must reside in RAM
                        ;1=tests disabled: branch range
0000 =                  disable_selfmod = 0
                        
                        ;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
                        
                        ;disable test decimal mode ADC & SBC, 0=enable, 1=disable,
                        ;2=disable including decimal flag in processor status
0000 =                  disable_decimal = 0
                        
                                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
0038 =                  faod    equ fao+decmode     ;+ ignore decimal
003c =                  faid    equ fai+decmode     ;+ ignore decimal
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 test of decimal bit
                        ;masking of interrupt enable/disable on load and compare
                        ;masking of always on bits after PHP or BRK (unused & break) on compare
                            if disable_decimal < 2
                                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
                            else
                                if I_flag = 0
                        load_flag   macro
                                    lda #\1&m8i         ;force enable interrupts (mask I)
                                    endm
                        cmp_flag    macro
                                    ora #decmode        ;ignore decimal mode bit
                                    cmp #(\1|faod)&m8i  ;I_flag is always enabled + always on bits
                                    endm
                        eor_flag    macro
                                    ora #decmode        ;ignore decimal mode bit
                                    eor #(\1&m8i|faod)  ;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
                                    ora #decmode        ;ignore decimal mode bit
                                    cmp #(\1|faid)&m8   ;I_flag is always disabled + always on bits
                                    endm
                        eor_flag    macro
                                    ora #decmode        ;ignore decimal mode bit
                                    eor #(\1|faid)      ;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
                                    ora #decmode        ;ignore decimal mode bit
                                    cmp #(\1|faod)&m8i  ;expected flags + always on bits, mask I
                                    endm
                        eor_flag    macro
                                    eor flag_I_on       ;I_flag is never changed
                                    ora #decmode        ;ignore decimal mode bit
                                    eor #(\1&m8i|faod)  ;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
                                    ora #decmode        ;ignore decimal mode bit
                                    cmp #(\1|faod)&m8   ;expected flags + always on bits
                                    endm
                        eor_flag    macro
                                    ora #decmode        ;ignore decimal mode bit
                                    eor #\1|faod        ;invert expected flags + always on bits
                                    endm
                                endif
                            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
                                  if disable_selfmod = 0
                                    sta range_adr   ;reset self modifying code
                                  endif
                                    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(abs1)   ;set high byte of indirect pointer
                                    stx zpt+1
                                    ldy #lo(abs1)   ;data after write & execute 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
0000 =                          org zero_page
                        ;break test interrupt save
0000 : 00               irq_a   ds  1               ;a register
0001 : 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
0002 :                  zpt                         ;6 bytes store/modify test area
                        ;add/subtract operand generation and result/flag prediction
0002 : 00               adfc    ds  1               ;carry flag before op
0003 : 00               ad1     ds  1               ;operand 1 - accumulator
0004 : 00               ad2     ds  1               ;operand 2 - memory / immediate
0005 : 00               adrl    ds  1               ;expected result bits 0-7
0006 : 00               adrh    ds  1               ;expected result bit 8 (carry)
0007 : 00               adrf    ds  1               ;expected flags NV0000ZC (only binary mode)
0008 : 00               sb2     ds  1               ;operand 2 complemented for subtract
0009 :                  zp_bss
0009 : 8001             zps     db  $80,1           ;additional shift pattern to test zero result & flag
000b : c3824100         zp1     db  $c3,$82,$41,0   ;test patterns for LDx BIT ROL ROR ASL LSR
000f : 7f               zp7f    db  $7f             ;test pattern for compare  
                        ;logical zeropage operands
0010 : 001f7180         zpOR    db  0,$1f,$71,$80   ;test pattern for OR
0014 : 0fff7f80         zpAN    db  $0f,$ff,$7f,$80 ;test pattern for AND
0018 : ff0f8f8f         zpEO    db  $ff,$0f,$8f,$8f ;test pattern for EOR
                        ;indirect addressing pointers
001c : 1802             ind1    dw  abs1            ;indirect pointer to pattern in absolute memory
001e : 1902                     dw  abs1+1
0020 : 1a02                     dw  abs1+2
0022 : 1b02                     dw  abs1+3
0024 : 1c02                     dw  abs7f
0026 : 2001             inw1    dw  abs1-$f8        ;indirect pointer for wrap-test pattern
0028 : 0302             indt    dw  abst            ;indirect pointer to store area in absolute memory
002a : 0402                     dw  abst+1
002c : 0502                     dw  abst+2
002e : 0602                     dw  abst+3
0030 : 0b01             inwt    dw  abst-$f8        ;indirect pointer for wrap-test store
0032 : 5f02             indAN   dw  absAN           ;indirect pointer to AND pattern in absolute memory
0034 : 6002                     dw  absAN+1
0036 : 6102                     dw  absAN+2
0038 : 6202                     dw  absAN+3
003a : 6302             indEO   dw  absEO           ;indirect pointer to EOR pattern in absolute memory
003c : 6402                     dw  absEO+1
003e : 6502                     dw  absEO+2
0040 : 6602                     dw  absEO+3
0042 : 5b02             indOR   dw  absOR           ;indirect pointer to OR pattern in absolute memory
0044 : 5c02                     dw  absOR+1
0046 : 5d02                     dw  absOR+2
0048 : 5e02                     dw  absOR+3
                        ;add/subtract indirect pointers
004a : 0302             adi2    dw  ada2            ;indirect pointer to operand 2 in absolute memory
004c : 0402             sbi2    dw  sba2            ;indirect pointer to complemented operand 2 (SBC)
004e : 0401             adiy2   dw  ada2-$ff        ;with offset for indirect indexed
0050 : 0501             sbiy2   dw  sba2-$ff
0052 :                  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                        ;6 bytes store/modify test area
0203 : 00               ada2    ds  1               ;operand 2
0204 : 00               sba2    ds  1               ;operand 2 complemented for subtract
0205 : 00000000                 ds  4               ;fill remaining bytes
0209 :                  data_bss
                            if load_data_direct = 1
0209 : 2900             ex_andi and #0              ;execute immediate opcodes
020b : 60                       rts
020c : 4900             ex_eori eor #0              ;execute immediate opcodes
020e : 60                       rts
020f : 0900             ex_orai ora #0              ;execute immediate opcodes
0211 : 60                       rts
0212 : 6900             ex_adci adc #0              ;execute immediate opcodes
0214 : 60                       rts
0215 : e900             ex_sbci sbc #0              ;execute immediate opcodes
0217 : 60                       rts
                            else
                        ex_andi ds  3
                        ex_eori ds  3
                        ex_orai ds  3
                        ex_adci ds  3
                        ex_sbci ds  3
                            endif
                        ;zps    db  $80,1           ;additional shift patterns test zero result & flag
0218 : c3824100         abs1    db  $c3,$82,$41,0   ;test patterns for LDx BIT ROL ROR ASL LSR
021c : 7f               abs7f   db  $7f             ;test pattern for compare
                        ;loads
021d : 80800002         fLDx    db  fn,fn,0,fz              ;expected flags for load
                        ;shifts
0221 :                  rASL                                ;expected result ASL & ROL -carry
0221 : 000286048200     rROL    db  0,2,$86,$04,$82,0
0227 : 010387058301     rROLc   db  1,3,$87,$05,$83,1       ;expected result ROL +carry
022d :                  rLSR                                ;expected result LSR & ROR -carry
022d : 400061412000     rROR    db  $40,0,$61,$41,$20,0
0233 : c080e1c1a080     rRORc   db  $c0,$80,$e1,$c1,$a0,$80 ;expected result ROR +carry
0239 :                  fASL                                ;expected flags for shifts
0239 : 030081018002     fROL    db  fzc,0,fnc,fc,fn,fz      ;no carry in
023f : 010081018000     fROLc   db  fc,0,fnc,fc,fn,0        ;carry in 
0245 :                  fLSR 
0245 : 000301000102     fROR    db  0,fzc,fc,0,fc,fz        ;no carry in
024b : 808181808180     fRORc   db  fn,fnc,fnc,fn,fnc,fn    ;carry in
                        ;increments (decrements)
0251 : 7f80ff0001       rINC    db  $7f,$80,$ff,0,1         ;expected result for INC/DEC
0256 : 0080800200       fINC    db  0,fn,fn,fz,0            ;expected flags for INC/DEC
                        ;logical memory operand
025b : 001f7180         absOR   db  0,$1f,$71,$80           ;test pattern for OR
025f : 0fff7f80         absAN   db  $0f,$ff,$7f,$80         ;test pattern for AND
0263 : ff0f8f8f         absEO   db  $ff,$0f,$8f,$8f         ;test pattern for EOR
                        ;logical accu operand
0267 : 00f11f00         absORa  db  0,$f1,$1f,0             ;test pattern for OR
026b : f0ffffff         absANa  db  $f0,$ff,$ff,$ff         ;test pattern for AND
026f : fff0f00f         absEOa  db  $ff,$f0,$f0,$0f         ;test pattern for EOR
                        ;logical results
0273 : 00ff7f80         absrlo  db  0,$ff,$7f,$80
0277 : 02800080         absflo  db  fz,fn,0,fn
027b :                  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
                            
                        ;pretest small branch offset
0409 : a205                     ldx #5
040b : 4c3304                   jmp psb_test
040e :                  psb_bwok
040e : a005                     ldy #5
0410 : d008                     bne psb_forw
                                trap        ;branch should be taken
0412 : 4c1204          >        jmp *           ;failed anyway
                        
0415 : 88                       dey         ;forward landing zone
0416 : 88                       dey
0417 : 88                       dey
0418 : 88                       dey
0419 : 88                       dey
041a :                  psb_forw
041a : 88                       dey
041b : 88                       dey
041c : 88                       dey
041d : 88                       dey
041e : 88                       dey
041f : f017                     beq psb_fwok
                                trap        ;forward offset
0421 : 4c2104          >        jmp *           ;failed anyway
                        
                        
0424 : ca                       dex         ;backward landing zone
0425 : ca                       dex
0426 : ca                       dex
0427 : ca                       dex
0428 : ca                       dex
0429 :                  psb_back
0429 : ca                       dex
042a : ca                       dex
042b : ca                       dex
042c : ca                       dex
042d : ca                       dex
042e : f0de                     beq psb_bwok
                                trap        ;backward offset
0430 : 4c3004          >        jmp *           ;failed anyway
                        
0433 :                  psb_test
0433 : d0f4                     bne psb_back
                                trap        ;branch should be taken
0435 : 4c3504          >        jmp *           ;failed anyway
                        
0438 :                  psb_fwok
                                
                        ;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
                              if disable_selfmod = 0
                                sta range_adr   ;reset self modifying code
                              endif
                                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(abs1)   ;set high byte of indirect pointer
                                stx zpt+1
                                ldy #lo(abs1)   ;data after write & execute 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            
0438 : ad0002          >            lda test_case   ;previous test
043b : c900            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
043d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0001 =                 >test_num = test_num + 1
043f : a901            >            lda #test_num   ;*** next tests' number
0441 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                            if disable_selfmod = 0
                        ;testing relative addressing with BEQ
0444 : a0fe                     ldy #$fe        ;testing maximum range, not -1/-2 (invalid/self adr)
0446 :                  range_loop
0446 : 88                       dey             ;next relative address
0447 : 98                       tya
0448 : aa                       tax             ;precharge count to end of loop
0449 : 1008                     bpl range_fw    ;calculate relative address
044b : 18                       clc             ;avoid branch self or to relative address of branch
044c : 6902                     adc #2
044e : ea                       nop             ;offset landing zone - tolerate +/-5 offset to branch
044f : ea                       nop
0450 : ea                       nop
0451 : ea                       nop
0452 : ea                       nop
0453 :                  range_fw
0453 : ea                       nop
0454 : ea                       nop
0455 : ea                       nop
0456 : ea                       nop
0457 : ea                       nop
0458 : 497f                     eor #$7f        ;complement except sign
045a : 8de604                   sta range_adr   ;load into test target
045d : a900                     lda #0          ;should set zero flag in status register
045f : 4ce504                   jmp range_op
                                
0462 : ca                       dex             ; offset landing zone - backward branch too far
0463 : ca                       dex
0464 : ca                       dex
0465 : ca                       dex
0466 : ca                       dex
                                ;relative address target field with branch under test in the middle
0467 : ca                       dex             ;-128 - max backward
0468 : ca                       dex
0469 : ca                       dex
046a : ca                       dex
046b : ca                       dex
046c : ca                       dex
046d : ca                       dex
046e : ca                       dex
046f : ca                       dex             ;-120
0470 : ca                       dex
0471 : ca                       dex
0472 : ca                       dex
0473 : ca                       dex
0474 : ca                       dex
0475 : ca                       dex
0476 : ca                       dex
0477 : ca                       dex
0478 : ca                       dex
0479 : ca                       dex             ;-110
047a : ca                       dex
047b : ca                       dex
047c : ca                       dex
047d : ca                       dex
047e : ca                       dex
047f : ca                       dex
0480 : ca                       dex
0481 : ca                       dex
0482 : ca                       dex
0483 : ca                       dex             ;-100
0484 : ca                       dex
0485 : ca                       dex
0486 : ca                       dex
0487 : ca                       dex
0488 : ca                       dex
0489 : ca                       dex
048a : ca                       dex
048b : ca                       dex
048c : ca                       dex
048d : ca                       dex             ;-90
048e : ca                       dex
048f : ca                       dex
0490 : ca                       dex
0491 : ca                       dex
0492 : ca                       dex
0493 : ca                       dex
0494 : ca                       dex
0495 : ca                       dex
0496 : ca                       dex
0497 : ca                       dex             ;-80
0498 : ca                       dex
0499 : ca                       dex
049a : ca                       dex
049b : ca                       dex
049c : ca                       dex
049d : ca                       dex
049e : ca                       dex
049f : ca                       dex
04a0 : ca                       dex
04a1 : ca                       dex             ;-70
04a2 : ca                       dex
04a3 : ca                       dex
04a4 : ca                       dex
04a5 : ca                       dex
04a6 : ca                       dex
04a7 : ca                       dex
04a8 : ca                       dex
04a9 : ca                       dex
04aa : ca                       dex
04ab : ca                       dex             ;-60
04ac : ca                       dex
04ad : ca                       dex
04ae : ca                       dex
04af : ca                       dex
04b0 : ca                       dex
04b1 : ca                       dex
04b2 : ca                       dex
04b3 : ca                       dex
04b4 : ca                       dex
04b5 : ca                       dex             ;-50
04b6 : ca                       dex
04b7 : ca                       dex
04b8 : ca                       dex
04b9 : ca                       dex
04ba : ca                       dex
04bb : ca                       dex
04bc : ca                       dex
04bd : ca                       dex
04be : ca                       dex
04bf : ca                       dex             ;-40
04c0 : ca                       dex
04c1 : ca                       dex
04c2 : ca                       dex
04c3 : ca                       dex
04c4 : ca                       dex
04c5 : ca                       dex
04c6 : ca                       dex
04c7 : ca                       dex
04c8 : ca                       dex
04c9 : ca                       dex             ;-30
04ca : ca                       dex
04cb : ca                       dex
04cc : ca                       dex
04cd : ca                       dex
04ce : ca                       dex
04cf : ca                       dex
04d0 : ca                       dex
04d1 : ca                       dex
04d2 : ca                       dex
04d3 : ca                       dex             ;-20
04d4 : ca                       dex
04d5 : ca                       dex
04d6 : ca                       dex
04d7 : ca                       dex
04d8 : ca                       dex
04d9 : ca                       dex
04da : ca                       dex
04db : ca                       dex
04dc : ca                       dex
04dd : ca                       dex             ;-10
04de : ca                       dex
04df : ca                       dex
04e0 : ca                       dex
04e1 : ca                       dex
04e2 : ca                       dex
04e3 : ca                       dex
04e4 : ca                       dex             ;-3
04e5 :                  range_op                ;test target with zero flag=0, z=1 if previous dex
04e6 =                  range_adr   = *+1       ;modifiable relative address
04e5 : f03e                     beq *+64        ;+64 if called without modification
04e7 : ca                       dex             ;+0
04e8 : ca                       dex
04e9 : ca                       dex
04ea : ca                       dex
04eb : ca                       dex
04ec : ca                       dex
04ed : ca                       dex
04ee : ca                       dex
04ef : ca                       dex
04f0 : ca                       dex
04f1 : ca                       dex             ;+10
04f2 : ca                       dex
04f3 : ca                       dex
04f4 : ca                       dex
04f5 : ca                       dex
04f6 : ca                       dex
04f7 : ca                       dex
04f8 : ca                       dex
04f9 : ca                       dex
04fa : ca                       dex
04fb : ca                       dex             ;+20
04fc : ca                       dex
04fd : ca                       dex
04fe : ca                       dex
04ff : ca                       dex
0500 : ca                       dex
0501 : ca                       dex
0502 : ca                       dex
0503 : ca                       dex
0504 : ca                       dex
0505 : ca                       dex             ;+30
0506 : ca                       dex
0507 : ca                       dex
0508 : ca                       dex
0509 : ca                       dex
050a : ca                       dex
050b : ca                       dex
050c : ca                       dex
050d : ca                       dex
050e : ca                       dex
050f : ca                       dex             ;+40
0510 : ca                       dex
0511 : ca                       dex
0512 : ca                       dex
0513 : ca                       dex
0514 : ca                       dex
0515 : ca                       dex
0516 : ca                       dex
0517 : ca                       dex
0518 : ca                       dex
0519 : ca                       dex             ;+50
051a : ca                       dex
051b : ca                       dex
051c : ca                       dex
051d : ca                       dex
051e : ca                       dex
051f : ca                       dex
0520 : ca                       dex
0521 : ca                       dex
0522 : ca                       dex
0523 : ca                       dex             ;+60
0524 : ca                       dex
0525 : ca                       dex
0526 : ca                       dex
0527 : ca                       dex
0528 : ca                       dex
0529 : ca                       dex
052a : ca                       dex
052b : ca                       dex
052c : ca                       dex
052d : ca                       dex             ;+70
052e : ca                       dex
052f : ca                       dex
0530 : ca                       dex
0531 : ca                       dex
0532 : ca                       dex
0533 : ca                       dex
0534 : ca                       dex
0535 : ca                       dex
0536 : ca                       dex
0537 : ca                       dex             ;+80
0538 : ca                       dex
0539 : ca                       dex
053a : ca                       dex
053b : ca                       dex
053c : ca                       dex
053d : ca                       dex
053e : ca                       dex
053f : ca                       dex
0540 : ca                       dex
0541 : ca                       dex             ;+90
0542 : ca                       dex
0543 : ca                       dex
0544 : ca                       dex
0545 : ca                       dex
0546 : ca                       dex
0547 : ca                       dex
0548 : ca                       dex
0549 : ca                       dex
054a : ca                       dex
054b : ca                       dex             ;+100
054c : ca                       dex
054d : ca                       dex
054e : ca                       dex
054f : ca                       dex
0550 : ca                       dex
0551 : ca                       dex
0552 : ca                       dex
0553 : ca                       dex
0554 : ca                       dex
0555 : ca                       dex             ;+110
0556 : ca                       dex
0557 : ca                       dex
0558 : ca                       dex
0559 : ca                       dex
055a : ca                       dex
055b : ca                       dex
055c : ca                       dex
055d : ca                       dex
055e : ca                       dex
055f : ca                       dex             ;+120
0560 : ca                       dex
0561 : ca                       dex
0562 : ca                       dex
0563 : ca                       dex
0564 : ca                       dex
0565 : ca                       dex
0566 : ea                       nop             ;offset landing zone - forward branch too far
0567 : ea                       nop
0568 : ea                       nop
0569 : ea                       nop
056a : ea                       nop
056b : f008                     beq range_ok    ;+127 - max forward
                                trap            ; bad range
056d : 4c6d05          >        jmp *           ;failed anyway
                        
0570 : ea                       nop             ;offset landing zone - tolerate +/-5 offset to branch
0571 : ea                       nop
0572 : ea                       nop
0573 : ea                       nop
0574 : ea                       nop
0575 :                  range_ok
0575 : ea                       nop
0576 : ea                       nop
0577 : ea                       nop
0578 : ea                       nop
0579 : ea                       nop
057a : c000                     cpy #0
057c : f003                     beq range_end   
057e : 4c4604                   jmp range_loop
0581 :                  range_end               ;range test successful
                            endif
                                next_test
0581 : ad0002          >            lda test_case   ;previous test
0584 : c901            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
0586 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0002 =                 >test_num = test_num + 1
0588 : a902            >            lda #test_num   ;*** next tests' number
058a : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ;partial test BNE & CMP, CPX, CPY immediate
058d : c001                     cpy #1          ;testing BNE true
058f : d003                     bne test_bne
                                trap 
0591 : 4c9105          >        jmp *           ;failed anyway
                        
0594 :                  test_bne
0594 : a900                     lda #0 
0596 : c900                     cmp #0          ;test compare immediate 
                                trap_ne
0598 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                trap_cc
059a : 90fe            >        bcc *           ;failed carry clear
                        
                                trap_mi
059c : 30fe            >        bmi *           ;failed minus (bit 7 set)
                        
059e : c901                     cmp #1
                                trap_eq 
05a0 : f0fe            >        beq *           ;failed equal (zero)
                        
                                trap_cs
05a2 : b0fe            >        bcs *           ;failed carry set
                        
                                trap_pl
05a4 : 10fe            >        bpl *           ;failed plus (bit 7 clear)
                        
05a6 : aa                       tax 
05a7 : e000                     cpx #0          ;test compare x immediate
                                trap_ne
05a9 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                trap_cc
05ab : 90fe            >        bcc *           ;failed carry clear
                        
                                trap_mi
05ad : 30fe            >        bmi *           ;failed minus (bit 7 set)
                        
05af : e001                     cpx #1
                                trap_eq 
05b1 : f0fe            >        beq *           ;failed equal (zero)
                        
                                trap_cs
05b3 : b0fe            >        bcs *           ;failed carry set
                        
                                trap_pl
05b5 : 10fe            >        bpl *           ;failed plus (bit 7 clear)
                        
05b7 : a8                       tay 
05b8 : c000                     cpy #0          ;test compare y immediate
                                trap_ne
05ba : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                trap_cc
05bc : 90fe            >        bcc *           ;failed carry clear
                        
                                trap_mi
05be : 30fe            >        bmi *           ;failed minus (bit 7 set)
                        
05c0 : c001                     cpy #1
                                trap_eq 
05c2 : f0fe            >        beq *           ;failed equal (zero)
                        
                                trap_cs
05c4 : b0fe            >        bcs *           ;failed carry set
                        
                                trap_pl
05c6 : 10fe            >        bpl *           ;failed plus (bit 7 clear)
                        
                                next_test
05c8 : ad0002          >            lda test_case   ;previous test
05cb : c902            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
05cd : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0003 =                 >test_num = test_num + 1
05cf : a903            >            lda #test_num   ;*** next tests' number
05d1 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        ;testing stack operations PHA PHP PLA PLP
                                    
05d4 : a2ff                     ldx #$ff        ;initialize stack
05d6 : 9a                       txs
05d7 : a955                     lda #$55
05d9 : 48                       pha
05da : a9aa                     lda #$aa
05dc : 48                       pha
05dd : cdfe01                   cmp $1fe        ;on stack ?
                                trap_ne
05e0 : d0fe            >        bne *           ;failed not equal (non zero)
                        
05e2 : ba                       tsx
05e3 : 8a                       txa             ;overwrite accu
05e4 : c9fd                     cmp #$fd        ;sp decremented?
                                trap_ne
05e6 : d0fe            >        bne *           ;failed not equal (non zero)
                        
05e8 : 68                       pla
05e9 : c9aa                     cmp #$aa        ;successful retreived from stack?
                                trap_ne
05eb : d0fe            >        bne *           ;failed not equal (non zero)
                        
05ed : 68                       pla
05ee : c955                     cmp #$55
                                trap_ne
05f0 : d0fe            >        bne *           ;failed not equal (non zero)
                        
05f2 : cdff01                   cmp $1ff        ;remains on stack?
                                trap_ne
05f5 : d0fe            >        bne *           ;failed not equal (non zero)
                        
05f7 : ba                       tsx
05f8 : e0ff                     cpx #$ff        ;sp incremented?
                                trap_ne
05fa : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                next_test
05fc : ad0002          >            lda test_case   ;previous test
05ff : c903            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
0601 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0004 =                 >test_num = test_num + 1
0603 : a904            >            lda #test_num   ;*** next tests' number
0605 : 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    
0608 : a9ff            >            lda #$ff                 ;allow test to change I-flag (no mask)
                       >
060a : 48              >            pha         ;use stack to load status
060b : 28              >            plp
                        
060c : 101a                     bpl nbr1        ;branches should not be taken
060e : 501b                     bvc nbr2
0610 : 901c                     bcc nbr3
0612 : d01d                     bne nbr4
0614 : 3003                     bmi br1         ;branches should be taken
                                trap 
0616 : 4c1606          >        jmp *           ;failed anyway
                        
0619 : 7003             br1     bvs br2
                                trap 
061b : 4c1b06          >        jmp *           ;failed anyway
                        
061e : b003             br2     bcs br3
                                trap 
0620 : 4c2006          >        jmp *           ;failed anyway
                        
0623 : f00f             br3     beq br4
                                trap 
0625 : 4c2506          >        jmp *           ;failed anyway
                        
0628 :                  nbr1
                                trap            ;previous bpl taken 
0628 : 4c2806          >        jmp *           ;failed anyway
                        
062b :                  nbr2
                                trap            ;previous bvc taken
062b : 4c2b06          >        jmp *           ;failed anyway
                        
062e :                  nbr3
                                trap            ;previous bcc taken
062e : 4c2e06          >        jmp *           ;failed anyway
                        
0631 :                  nbr4
                                trap            ;previous bne taken
0631 : 4c3106          >        jmp *           ;failed anyway
                        
0634 : 08               br4     php
0635 : ba                       tsx
0636 : e0fe                     cpx #$fe        ;sp after php?
                                trap_ne
0638 : d0fe            >        bne *           ;failed not equal (non zero)
                        
063a : 68                       pla
                                cmp_flag $ff    ;returned all flags on?
063b : c9ff            >            cmp #($ff    |fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
063d : d0fe            >        bne *           ;failed not equal (non zero)
                        
063f : ba                       tsx
0640 : e0ff                     cpx #$ff        ;sp after php?
                                trap_ne
0642 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0      ;all off
                       >            load_flag 0      
0644 : a900            >            lda #0                   ;allow test to change I-flag (no mask)
                       >
0646 : 48              >            pha         ;use stack to load status
0647 : 28              >            plp
                        
0648 : 301a                     bmi nbr11       ;branches should not be taken
064a : 701b                     bvs nbr12
064c : b01c                     bcs nbr13
064e : f01d                     beq nbr14
0650 : 1003                     bpl br11        ;branches should be taken
                                trap 
0652 : 4c5206          >        jmp *           ;failed anyway
                        
0655 : 5003             br11    bvc br12
                                trap 
0657 : 4c5706          >        jmp *           ;failed anyway
                        
065a : 9003             br12    bcc br13
                                trap 
065c : 4c5c06          >        jmp *           ;failed anyway
                        
065f : d00f             br13    bne br14
                                trap 
0661 : 4c6106          >        jmp *           ;failed anyway
                        
0664 :                  nbr11
                                trap            ;previous bmi taken 
0664 : 4c6406          >        jmp *           ;failed anyway
                        
0667 :                  nbr12
                                trap            ;previous bvs taken 
0667 : 4c6706          >        jmp *           ;failed anyway
                        
066a :                  nbr13
                                trap            ;previous bcs taken 
066a : 4c6a06          >        jmp *           ;failed anyway
                        
066d :                  nbr14
                                trap            ;previous beq taken 
066d : 4c6d06          >        jmp *           ;failed anyway
                        
0670 : 08               br14    php
0671 : 68                       pla
                                cmp_flag 0      ;flags off except break (pushed by sw) + reserved?
0672 : c930            >            cmp #(0      |fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0674 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                ;crosscheck flags
                                set_stat zero
                       >            load_flag zero
0676 : a902            >            lda #zero             ;allow test to change I-flag (no mask)
                       >
0678 : 48              >            pha         ;use stack to load status
0679 : 28              >            plp
                        
067a : d002                     bne brzs1
067c : f003                     beq brzs2
067e :                  brzs1
                                trap            ;branch zero/non zero
067e : 4c7e06          >        jmp *           ;failed anyway
                        
0681 : b002             brzs2   bcs brzs3
0683 : 9003                     bcc brzs4
0685 :                  brzs3
                                trap            ;branch carry/no carry
0685 : 4c8506          >        jmp *           ;failed anyway
                        
0688 : 3002             brzs4   bmi brzs5
068a : 1003                     bpl brzs6
068c :                  brzs5
                                trap            ;branch minus/plus
068c : 4c8c06          >        jmp *           ;failed anyway
                        
068f : 7002             brzs6   bvs brzs7
0691 : 5003                     bvc brzs8
0693 :                  brzs7
                                trap            ;branch overflow/no overflow
0693 : 4c9306          >        jmp *           ;failed anyway
                        
0696 :                  brzs8
                                set_stat carry
                       >            load_flag carry
0696 : a901            >            lda #carry             ;allow test to change I-flag (no mask)
                       >
0698 : 48              >            pha         ;use stack to load status
0699 : 28              >            plp
                        
069a : f002                     beq brcs1
069c : d003                     bne brcs2
069e :                  brcs1
                                trap            ;branch zero/non zero
069e : 4c9e06          >        jmp *           ;failed anyway
                        
06a1 : 9002             brcs2   bcc brcs3
06a3 : b003                     bcs brcs4
06a5 :                  brcs3
                                trap            ;branch carry/no carry
06a5 : 4ca506          >        jmp *           ;failed anyway
                        
06a8 : 3002             brcs4   bmi brcs5
06aa : 1003                     bpl brcs6
06ac :                  brcs5
                                trap            ;branch minus/plus
06ac : 4cac06          >        jmp *           ;failed anyway
                        
06af : 7002             brcs6   bvs brcs7
06b1 : 5003                     bvc brcs8
06b3 :                  brcs7
                                trap            ;branch overflow/no overflow
06b3 : 4cb306          >        jmp *           ;failed anyway
                        
                        
06b6 :                  brcs8
                                set_stat minus
                       >            load_flag minus
06b6 : a980            >            lda #minus             ;allow test to change I-flag (no mask)
                       >
06b8 : 48              >            pha         ;use stack to load status
06b9 : 28              >            plp
                        
06ba : f002                     beq brmi1
06bc : d003                     bne brmi2
06be :                  brmi1
                                trap            ;branch zero/non zero
06be : 4cbe06          >        jmp *           ;failed anyway
                        
06c1 : b002             brmi2   bcs brmi3
06c3 : 9003                     bcc brmi4
06c5 :                  brmi3
                                trap            ;branch carry/no carry
06c5 : 4cc506          >        jmp *           ;failed anyway
                        
06c8 : 1002             brmi4   bpl brmi5
06ca : 3003                     bmi brmi6
06cc :                  brmi5
                                trap            ;branch minus/plus
06cc : 4ccc06          >        jmp *           ;failed anyway
                        
06cf : 7002             brmi6   bvs brmi7
06d1 : 5003                     bvc brmi8
06d3 :                  brmi7
                                trap            ;branch overflow/no overflow
06d3 : 4cd306          >        jmp *           ;failed anyway
                        
06d6 :                  brmi8
                                set_stat overfl
                       >            load_flag overfl
06d6 : a940            >            lda #overfl             ;allow test to change I-flag (no mask)
                       >
06d8 : 48              >            pha         ;use stack to load status
06d9 : 28              >            plp
                        
06da : f002                     beq brvs1
06dc : d003                     bne brvs2
06de :                  brvs1
                                trap            ;branch zero/non zero
06de : 4cde06          >        jmp *           ;failed anyway
                        
06e1 : b002             brvs2   bcs brvs3
06e3 : 9003                     bcc brvs4
06e5 :                  brvs3
                                trap            ;branch carry/no carry
06e5 : 4ce506          >        jmp *           ;failed anyway
                        
06e8 : 3002             brvs4   bmi brvs5
06ea : 1003                     bpl brvs6
06ec :                  brvs5
                                trap            ;branch minus/plus
06ec : 4cec06          >        jmp *           ;failed anyway
                        
06ef : 5002             brvs6   bvc brvs7
06f1 : 7003                     bvs brvs8
06f3 :                  brvs7
                                trap            ;branch overflow/no overflow
06f3 : 4cf306          >        jmp *           ;failed anyway
                        
06f6 :                  brvs8
                                set_stat $ff-zero
                       >            load_flag $ff-zero
06f6 : a9fd            >            lda #$ff-zero             ;allow test to change I-flag (no mask)
                       >
06f8 : 48              >            pha         ;use stack to load status
06f9 : 28              >            plp
                        
06fa : f002                     beq brzc1
06fc : d003                     bne brzc2
06fe :                  brzc1
                                trap            ;branch zero/non zero
06fe : 4cfe06          >        jmp *           ;failed anyway
                        
0701 : 9002             brzc2   bcc brzc3
0703 : b003                     bcs brzc4
0705 :                  brzc3
                                trap            ;branch carry/no carry
0705 : 4c0507          >        jmp *           ;failed anyway
                        
0708 : 1002             brzc4   bpl brzc5
070a : 3003                     bmi brzc6
070c :                  brzc5
                                trap            ;branch minus/plus
070c : 4c0c07          >        jmp *           ;failed anyway
                        
070f : 5002             brzc6   bvc brzc7
0711 : 7003                     bvs brzc8
0713 :                  brzc7
                                trap            ;branch overflow/no overflow
0713 : 4c1307          >        jmp *           ;failed anyway
                        
0716 :                  brzc8
                                set_stat $ff-carry
                       >            load_flag $ff-carry
0716 : a9fe            >            lda #$ff-carry             ;allow test to change I-flag (no mask)
                       >
0718 : 48              >            pha         ;use stack to load status
0719 : 28              >            plp
                        
071a : d002                     bne brcc1
071c : f003                     beq brcc2
071e :                  brcc1
                                trap            ;branch zero/non zero
071e : 4c1e07          >        jmp *           ;failed anyway
                        
0721 : b002             brcc2   bcs brcc3
0723 : 9003                     bcc brcc4
0725 :                  brcc3
                                trap            ;branch carry/no carry
0725 : 4c2507          >        jmp *           ;failed anyway
                        
0728 : 1002             brcc4   bpl brcc5
072a : 3003                     bmi brcc6
072c :                  brcc5
                                trap            ;branch minus/plus
072c : 4c2c07          >        jmp *           ;failed anyway
                        
072f : 5002             brcc6   bvc brcc7
0731 : 7003                     bvs brcc8
0733 :                  brcc7
                                trap            ;branch overflow/no overflow
0733 : 4c3307          >        jmp *           ;failed anyway
                        
0736 :                  brcc8
                                set_stat $ff-minus
                       >            load_flag $ff-minus
0736 : a97f            >            lda #$ff-minus             ;allow test to change I-flag (no mask)
                       >
0738 : 48              >            pha         ;use stack to load status
0739 : 28              >            plp
                        
073a : d002                     bne brpl1
073c : f003                     beq brpl2
073e :                  brpl1
                                trap            ;branch zero/non zero
073e : 4c3e07          >        jmp *           ;failed anyway
                        
0741 : 9002             brpl2   bcc brpl3
0743 : b003                     bcs brpl4
0745 :                  brpl3
                                trap            ;branch carry/no carry
0745 : 4c4507          >        jmp *           ;failed anyway
                        
0748 : 3002             brpl4   bmi brpl5
074a : 1003                     bpl brpl6
074c :                  brpl5
                                trap            ;branch minus/plus
074c : 4c4c07          >        jmp *           ;failed anyway
                        
074f : 5002             brpl6   bvc brpl7
0751 : 7003                     bvs brpl8
0753 :                  brpl7
                                trap            ;branch overflow/no overflow
0753 : 4c5307          >        jmp *           ;failed anyway
                        
0756 :                  brpl8
                                set_stat $ff-overfl
                       >            load_flag $ff-overfl
0756 : a9bf            >            lda #$ff-overfl             ;allow test to change I-flag (no mask)
                       >
0758 : 48              >            pha         ;use stack to load status
0759 : 28              >            plp
                        
075a : d002                     bne brvc1
075c : f003                     beq brvc2
075e :                  brvc1
                                trap            ;branch zero/non zero
075e : 4c5e07          >        jmp *           ;failed anyway
                        
0761 : 9002             brvc2   bcc brvc3
0763 : b003                     bcs brvc4
0765 :                  brvc3
                                trap            ;branch carry/no carry
0765 : 4c6507          >        jmp *           ;failed anyway
                        
0768 : 1002             brvc4   bpl brvc5
076a : 3003                     bmi brvc6
076c :                  brvc5
                                trap            ;branch minus/plus
076c : 4c6c07          >        jmp *           ;failed anyway
                        
076f : 7002             brvc6   bvs brvc7
0771 : 5003                     bvc brvc8
0773 :                  brvc7
                                trap            ;branch overflow/no overflow
0773 : 4c7307          >        jmp *           ;failed anyway
                        
0776 :                  brvc8
                                next_test
0776 : ad0002          >            lda test_case   ;previous test
0779 : c904            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
077b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0005 =                 >test_num = test_num + 1
077d : a905            >            lda #test_num   ;*** next tests' number
077f : 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
0782 : a255                     ldx #$55        ;x & y protected
0784 : a0aa                     ldy #$aa
                                set_a 1,$ff     ;push
                       >            load_flag $ff     
0786 : a9ff            >            lda #$ff                  ;allow test to change I-flag (no mask)
                       >
0788 : 48              >            pha         ;use stack to load status
0789 : a901            >            lda #1     ;precharge accu
078b : 28              >            plp
                        
078c : 48                       pha
                                tst_a 1,$ff
078d : 08              >            php         ;save flags
078e : c901            >            cmp #1     ;test result
                       >            trap_ne
0790 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0792 : 68              >            pla         ;load status
0793 : 48              >            pha
                       >            cmp_flag $ff
0794 : c9ff            >            cmp #($ff|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0796 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0798 : 28              >            plp         ;restore status
                        
                                set_a 0,0
                       >            load_flag 0
0799 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
079b : 48              >            pha         ;use stack to load status
079c : a900            >            lda #0     ;precharge accu
079e : 28              >            plp
                        
079f : 48                       pha
                                tst_a 0,0
07a0 : 08              >            php         ;save flags
07a1 : c900            >            cmp #0     ;test result
                       >            trap_ne
07a3 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
07a5 : 68              >            pla         ;load status
07a6 : 48              >            pha
                       >            cmp_flag 0
07a7 : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
07a9 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
07ab : 28              >            plp         ;restore status
                        
                                set_a $ff,$ff
                       >            load_flag $ff
07ac : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
07ae : 48              >            pha         ;use stack to load status
07af : a9ff            >            lda #$ff     ;precharge accu
07b1 : 28              >            plp
                        
07b2 : 48                       pha
                                tst_a $ff,$ff
07b3 : 08              >            php         ;save flags
07b4 : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
07b6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
07b8 : 68              >            pla         ;load status
07b9 : 48              >            pha
                       >            cmp_flag $ff
07ba : c9ff            >            cmp #($ff|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
07bc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
07be : 28              >            plp         ;restore status
                        
                                set_a 1,0
                       >            load_flag 0
07bf : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
07c1 : 48              >            pha         ;use stack to load status
07c2 : a901            >            lda #1     ;precharge accu
07c4 : 28              >            plp
                        
07c5 : 48                       pha
                                tst_a 1,0
07c6 : 08              >            php         ;save flags
07c7 : c901            >            cmp #1     ;test result
                       >            trap_ne
07c9 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
07cb : 68              >            pla         ;load status
07cc : 48              >            pha
                       >            cmp_flag 0
07cd : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
07cf : d0fe            >        bne *           ;failed not equal (non zero)
                       >
07d1 : 28              >            plp         ;restore status
                        
                                set_a 0,$ff
                       >            load_flag $ff
07d2 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
07d4 : 48              >            pha         ;use stack to load status
07d5 : a900            >            lda #0     ;precharge accu
07d7 : 28              >            plp
                        
07d8 : 48                       pha
                                tst_a 0,$ff
07d9 : 08              >            php         ;save flags
07da : c900            >            cmp #0     ;test result
                       >            trap_ne
07dc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
07de : 68              >            pla         ;load status
07df : 48              >            pha
                       >            cmp_flag $ff
07e0 : c9ff            >            cmp #($ff|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
07e2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
07e4 : 28              >            plp         ;restore status
                        
                                set_a $ff,0
                       >            load_flag 0
07e5 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
07e7 : 48              >            pha         ;use stack to load status
07e8 : a9ff            >            lda #$ff     ;precharge accu
07ea : 28              >            plp
                        
07eb : 48                       pha
                                tst_a $ff,0
07ec : 08              >            php         ;save flags
07ed : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
07ef : d0fe            >        bne *           ;failed not equal (non zero)
                       >
07f1 : 68              >            pla         ;load status
07f2 : 48              >            pha
                       >            cmp_flag 0
07f3 : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
07f5 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
07f7 : 28              >            plp         ;restore status
                        
                                set_a 0,$ff     ;pull
                       >            load_flag $ff     
07f8 : a9ff            >            lda #$ff                  ;allow test to change I-flag (no mask)
                       >
07fa : 48              >            pha         ;use stack to load status
07fb : a900            >            lda #0     ;precharge accu
07fd : 28              >            plp
                        
07fe : 68                       pla
                                tst_a $ff,$ff-zero
07ff : 08              >            php         ;save flags
0800 : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
0802 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0804 : 68              >            pla         ;load status
0805 : 48              >            pha
                       >            cmp_flag $ff-zero
0806 : c9fd            >            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0808 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
080a : 28              >            plp         ;restore status
                        
                                set_a $ff,0
                       >            load_flag 0
080b : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
080d : 48              >            pha         ;use stack to load status
080e : a9ff            >            lda #$ff     ;precharge accu
0810 : 28              >            plp
                        
0811 : 68                       pla
                                tst_a 0,zero
0812 : 08              >            php         ;save flags
0813 : c900            >            cmp #0     ;test result
                       >            trap_ne
0815 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0817 : 68              >            pla         ;load status
0818 : 48              >            pha
                       >            cmp_flag zero
0819 : c932            >            cmp #(zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
081b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
081d : 28              >            plp         ;restore status
                        
                                set_a $fe,$ff
                       >            load_flag $ff
081e : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0820 : 48              >            pha         ;use stack to load status
0821 : a9fe            >            lda #$fe     ;precharge accu
0823 : 28              >            plp
                        
0824 : 68                       pla
                                tst_a 1,$ff-zero-minus
0825 : 08              >            php         ;save flags
0826 : c901            >            cmp #1     ;test result
                       >            trap_ne
0828 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
082a : 68              >            pla         ;load status
082b : 48              >            pha
                       >            cmp_flag $ff-zero-minus
082c : c97d            >            cmp #($ff-zero-minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
082e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0830 : 28              >            plp         ;restore status
                        
                                set_a 0,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 : a900            >            lda #0     ;precharge accu
0836 : 28              >            plp
                        
0837 : 68                       pla
                                tst_a $ff,minus
0838 : 08              >            php         ;save flags
0839 : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
083b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
083d : 68              >            pla         ;load status
083e : 48              >            pha
                       >            cmp_flag minus
083f : c9b0            >            cmp #(minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0841 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0843 : 28              >            plp         ;restore status
                        
                                set_a $ff,$ff
                       >            load_flag $ff
0844 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0846 : 48              >            pha         ;use stack to load status
0847 : a9ff            >            lda #$ff     ;precharge accu
0849 : 28              >            plp
                        
084a : 68                       pla
                                tst_a 0,$ff-minus
084b : 08              >            php         ;save flags
084c : c900            >            cmp #0     ;test result
                       >            trap_ne
084e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0850 : 68              >            pla         ;load status
0851 : 48              >            pha
                       >            cmp_flag $ff-minus
0852 : c97f            >            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0854 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0856 : 28              >            plp         ;restore status
                        
                                set_a $fe,0
                       >            load_flag 0
0857 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0859 : 48              >            pha         ;use stack to load status
085a : a9fe            >            lda #$fe     ;precharge accu
085c : 28              >            plp
                        
085d : 68                       pla
                                tst_a 1,0
085e : 08              >            php         ;save flags
085f : c901            >            cmp #1     ;test result
                       >            trap_ne
0861 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0863 : 68              >            pla         ;load status
0864 : 48              >            pha
                       >            cmp_flag 0
0865 : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0867 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0869 : 28              >            plp         ;restore status
                        
086a : e055                     cpx #$55        ;x & y unchanged?
                                trap_ne
086c : d0fe            >        bne *           ;failed not equal (non zero)
                        
086e : c0aa                     cpy #$aa
                                trap_ne
0870 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                next_test
0872 : ad0002          >            lda test_case   ;previous test
0875 : c905            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
0877 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0006 =                 >test_num = test_num + 1
0879 : a906            >            lda #test_num   ;*** next tests' number
087b : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                         
                        ; partial pretest EOR #
                                set_a $3c,0
                       >            load_flag 0
087e : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0880 : 48              >            pha         ;use stack to load status
0881 : a93c            >            lda #$3c     ;precharge accu
0883 : 28              >            plp
                        
0884 : 49c3                     eor #$c3
                                tst_a $ff,fn
0886 : 08              >            php         ;save flags
0887 : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
0889 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
088b : 68              >            pla         ;load status
088c : 48              >            pha
                       >            cmp_flag fn
088d : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
088f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0891 : 28              >            plp         ;restore status
                        
                                set_a $c3,0
                       >            load_flag 0
0892 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0894 : 48              >            pha         ;use stack to load status
0895 : a9c3            >            lda #$c3     ;precharge accu
0897 : 28              >            plp
                        
0898 : 49c3                     eor #$c3
                                tst_a 0,fz
089a : 08              >            php         ;save flags
089b : c900            >            cmp #0     ;test result
                       >            trap_ne
089d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
089f : 68              >            pla         ;load status
08a0 : 48              >            pha
                       >            cmp_flag fz
08a1 : c932            >            cmp #(fz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
08a3 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
08a5 : 28              >            plp         ;restore status
                        
                                next_test
08a6 : ad0002          >            lda test_case   ;previous test
08a9 : c906            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
08ab : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0007 =                 >test_num = test_num + 1
08ad : a907            >            lda #test_num   ;*** next tests' number
08af : 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
08b2 : a224                     ldx #$24
08b4 : a042                     ldy #$42
                                set_a $18,0
                       >            load_flag 0
08b6 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
08b8 : 48              >            pha         ;use stack to load status
08b9 : a918            >            lda #$18     ;precharge accu
08bb : 28              >            plp
                        
08bc : ea                       nop
                                tst_a $18,0
08bd : 08              >            php         ;save flags
08be : c918            >            cmp #$18     ;test result
                       >            trap_ne
08c0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
08c2 : 68              >            pla         ;load status
08c3 : 48              >            pha
                       >            cmp_flag 0
08c4 : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
08c6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
08c8 : 28              >            plp         ;restore status
                        
08c9 : e024                     cpx #$24
                                trap_ne
08cb : d0fe            >        bne *           ;failed not equal (non zero)
                        
08cd : c042                     cpy #$42
                                trap_ne
08cf : d0fe            >        bne *           ;failed not equal (non zero)
                        
08d1 : a2db                     ldx #$db
08d3 : a0bd                     ldy #$bd
                                set_a $e7,$ff
                       >            load_flag $ff
08d5 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
08d7 : 48              >            pha         ;use stack to load status
08d8 : a9e7            >            lda #$e7     ;precharge accu
08da : 28              >            plp
                        
08db : ea                       nop
                                tst_a $e7,$ff
08dc : 08              >            php         ;save flags
08dd : c9e7            >            cmp #$e7     ;test result
                       >            trap_ne
08df : d0fe            >        bne *           ;failed not equal (non zero)
                       >
08e1 : 68              >            pla         ;load status
08e2 : 48              >            pha
                       >            cmp_flag $ff
08e3 : c9ff            >            cmp #($ff|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
08e5 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
08e7 : 28              >            plp         ;restore status
                        
08e8 : e0db                     cpx #$db
                                trap_ne
08ea : d0fe            >        bne *           ;failed not equal (non zero)
                        
08ec : c0bd                     cpy #$bd
                                trap_ne
08ee : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                next_test
08f0 : ad0002          >            lda test_case   ;previous test
08f3 : c907            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
08f5 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0008 =                 >test_num = test_num + 1
08f7 : a908            >            lda #test_num   ;*** next tests' number
08f9 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                                
                        ; jump absolute
                                set_stat $0
                       >            load_flag $0
08fc : a900            >            lda #$0             ;allow test to change I-flag (no mask)
                       >
08fe : 48              >            pha         ;use stack to load status
08ff : 28              >            plp
                        
0900 : a946                     lda #'F'
0902 : a241                     ldx #'A'
0904 : a052                     ldy #'R'        ;N=0, V=0, Z=0, C=0
0906 : 4cef36                   jmp test_far
0909 : ea                       nop
090a : ea                       nop
                                trap_ne         ;runover protection
090b : d0fe            >        bne *           ;failed not equal (non zero)
                        
090d : e8                       inx
090e : e8                       inx
090f :                  far_ret 
                                trap_eq         ;returned flags OK?
090f : f0fe            >        beq *           ;failed equal (zero)
                        
                                trap_pl
0911 : 10fe            >        bpl *           ;failed plus (bit 7 clear)
                        
                                trap_cc
0913 : 90fe            >        bcc *           ;failed carry clear
                        
                                trap_vc
0915 : 50fe            >        bvc *           ;failed overflow clear
                        
0917 : c9ec                     cmp #('F'^$aa)  ;returned registers OK?
                                trap_ne
0919 : d0fe            >        bne *           ;failed not equal (non zero)
                        
091b : e042                     cpx #('A'+1)
                                trap_ne
091d : d0fe            >        bne *           ;failed not equal (non zero)
                        
091f : c04f                     cpy #('R'-3)
                                trap_ne
0921 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0923 : ca                       dex
0924 : c8                       iny
0925 : c8                       iny
0926 : c8                       iny
0927 : 49aa                     eor #$aa        ;N=0, V=1, Z=0, C=1
0929 : 4c3209                   jmp test_near
092c : ea                       nop
092d : ea                       nop
                                trap_ne         ;runover protection
092e : d0fe            >        bne *           ;failed not equal (non zero)
                        
0930 : e8                       inx
0931 : e8                       inx
0932 :                  test_near
                                trap_eq         ;passed flags OK?
0932 : f0fe            >        beq *           ;failed equal (zero)
                        
                                trap_mi
0934 : 30fe            >        bmi *           ;failed minus (bit 7 set)
                        
                                trap_cc
0936 : 90fe            >        bcc *           ;failed carry clear
                        
                                trap_vc
0938 : 50fe            >        bvc *           ;failed overflow clear
                        
093a : c946                     cmp #'F'        ;passed registers OK?
                                trap_ne
093c : d0fe            >        bne *           ;failed not equal (non zero)
                        
093e : e041                     cpx #'A'
                                trap_ne
0940 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0942 : c052                     cpy #'R'
                                trap_ne
0944 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                next_test
0946 : ad0002          >            lda test_case   ;previous test
0949 : c908            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
094b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0009 =                 >test_num = test_num + 1
094d : a909            >            lda #test_num   ;*** next tests' number
094f : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                                
                        ; jump indirect
                                set_stat 0
                       >            load_flag 0
0952 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0954 : 48              >            pha         ;use stack to load status
0955 : 28              >            plp
                        
0956 : a949                     lda #'I'
0958 : a24e                     ldx #'N'
095a : a044                     ldy #'D'        ;N=0, V=0, Z=0, C=0
095c : 6c1e37                   jmp (ptr_tst_ind)
095f : ea                       nop
                                trap_ne         ;runover protection
0960 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0962 : 88                       dey
0963 : 88                       dey
0964 :                  ind_ret 
0964 : 08                       php             ;either SP or Y count will fail, if we do not hit
0965 : 88                       dey
0966 : 88                       dey
0967 : 88                       dey
0968 : 28                       plp
                                trap_eq         ;returned flags OK?
0969 : f0fe            >        beq *           ;failed equal (zero)
                        
                                trap_pl
096b : 10fe            >        bpl *           ;failed plus (bit 7 clear)
                        
                                trap_cc
096d : 90fe            >        bcc *           ;failed carry clear
                        
                                trap_vc
096f : 50fe            >        bvc *           ;failed overflow clear
                        
0971 : c9e3                     cmp #('I'^$aa)  ;returned registers OK?
                                trap_ne
0973 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0975 : e04f                     cpx #('N'+1)
                                trap_ne
0977 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0979 : c03e                     cpy #('D'-6)
                                trap_ne
097b : d0fe            >        bne *           ;failed not equal (non zero)
                        
097d : ba                       tsx             ;SP check
097e : e0ff                     cpx #$ff
                                trap_ne
0980 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                next_test
0982 : ad0002          >            lda test_case   ;previous test
0985 : c909            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
0987 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
000a =                 >test_num = test_num + 1
0989 : a90a            >            lda #test_num   ;*** next tests' number
098b : 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
098e : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0990 : 48              >            pha         ;use stack to load status
0991 : 28              >            plp
                        
0992 : a94a                     lda #'J'
0994 : a253                     ldx #'S'
0996 : a052                     ldy #'R'        ;N=0, V=0, Z=0, C=0
0998 : 205d37                   jsr test_jsr
099a =                  jsr_ret = *-1           ;last address of jsr = return address
099b : 08                       php             ;either SP or Y count will fail, if we do not hit
099c : 88                       dey
099d : 88                       dey
099e : 88                       dey
099f : 28                       plp
                                trap_eq         ;returned flags OK?
09a0 : f0fe            >        beq *           ;failed equal (zero)
                        
                                trap_pl
09a2 : 10fe            >        bpl *           ;failed plus (bit 7 clear)
                        
                                trap_cc
09a4 : 90fe            >        bcc *           ;failed carry clear
                        
                                trap_vc
09a6 : 50fe            >        bvc *           ;failed overflow clear
                        
09a8 : c9e0                     cmp #('J'^$aa)  ;returned registers OK?
                                trap_ne
09aa : d0fe            >        bne *           ;failed not equal (non zero)
                        
09ac : e054                     cpx #('S'+1)
                                trap_ne
09ae : d0fe            >        bne *           ;failed not equal (non zero)
                        
09b0 : c04c                     cpy #('R'-6)
                                trap_ne
09b2 : d0fe            >        bne *           ;failed not equal (non zero)
                        
09b4 : ba                       tsx             ;sp?
09b5 : e0ff                     cpx #$ff
                                trap_ne
09b7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                next_test
09b9 : ad0002          >            lda test_case   ;previous test
09bc : c90a            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
09be : d0fe            >        bne *           ;failed not equal (non zero)
                       >
000b =                 >test_num = test_num + 1
09c0 : a90b            >            lda #test_num   ;*** next tests' number
09c2 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; break & return from interrupt
                            if ROM_vectors = 1
                                load_flag 0     ;with interrupts enabled if allowed!
09c5 : a900            >            lda #0                  ;allow test to change I-flag (no mask)
                        
09c7 : 48                       pha
09c8 : a942                     lda #'B'
09ca : a252                     ldx #'R'
09cc : a04b                     ldy #'K'
09ce : 28                       plp             ;N=0, V=0, Z=0, C=0
09cf : 00                       brk
                            else
                                lda #hi brk_ret0 ;emulated break
                                pha
                                lda #lo brk_ret0
                                pha
                                load_flag fao    ;set break & unused on stack
                                pha
                                load_flag intdis ;during interrupt
                                pha
                                lda #'B'
                                ldx #'R'
                                ldy #'K'
                                plp             ;N=0, V=0, Z=0, C=0
                                jmp irq_trap
                            endif
09d0 : 88                       dey             ;should not be executed
09d1 :                  brk_ret0                ;address of break return
09d1 : 08                       php             ;either SP or Y count will fail, if we do not hit
09d2 : 88                       dey
09d3 : 88                       dey
09d4 : 88                       dey
09d5 : c9e8                     cmp #'B'^$aa    ;returned registers OK?
                                ;the IRQ vector was never executed if A & X stay unmodified
                                trap_ne
09d7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
09d9 : e053                     cpx #'R'+1
                                trap_ne
09db : d0fe            >        bne *           ;failed not equal (non zero)
                        
09dd : c045                     cpy #'K'-6
                                trap_ne
09df : d0fe            >        bne *           ;failed not equal (non zero)
                        
09e1 : 68                       pla             ;returned flags OK (unchanged)?
                                cmp_flag 0
09e2 : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
09e4 : d0fe            >        bne *           ;failed not equal (non zero)
                        
09e6 : ba                       tsx             ;sp?
09e7 : e0ff                     cpx #$ff
                                trap_ne
09e9 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                            if ROM_vectors = 1
                                load_flag $ff   ;with interrupts disabled if allowed!
09eb : a9ff            >            lda #$ff                ;allow test to change I-flag (no mask)
                        
09ed : 48                       pha
09ee : a9bd                     lda #$ff-'B'
09f0 : a2ad                     ldx #$ff-'R'
09f2 : a0b4                     ldy #$ff-'K'
09f4 : 28                       plp             ;N=1, V=1, Z=1, C=1
09f5 : 00                       brk
                            else
                                lda #hi brk_ret1 ;emulated break
                                pha
                                lda #lo brk_ret1
                                pha
                                load_flag $ff
                                pha             ;set break & unused on stack
                                pha             ;actual flags
                                lda #$ff-'B'
                                ldx #$ff-'R'
                                ldy #$ff-'K'
                                plp             ;N=1, V=1, Z=1, C=1
                                jmp irq_trap
                            endif
09f6 : 88                       dey             ;should not be executed
09f7 :                  brk_ret1                ;address of break return
09f7 : 08                       php             ;either SP or Y count will fail, if we do not hit
09f8 : 88                       dey
09f9 : 88                       dey
09fa : 88                       dey
09fb : c917                     cmp #($ff-'B')^$aa  ;returned registers OK?
                                ;the IRQ vector was never executed if A & X stay unmodified
                                trap_ne
09fd : d0fe            >        bne *           ;failed not equal (non zero)
                        
09ff : e0ae                     cpx #$ff-'R'+1
                                trap_ne
0a01 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0a03 : c0ae                     cpy #$ff-'K'-6
                                trap_ne
0a05 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0a07 : 68                       pla             ;returned flags OK (unchanged)?
                                cmp_flag $ff
0a08 : c9ff            >            cmp #($ff|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0a0a : d0fe            >        bne *           ;failed not equal (non zero)
                        
0a0c : ba                       tsx             ;sp?
0a0d : e0ff                     cpx #$ff
                                trap_ne
0a0f : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                next_test
0a11 : ad0002          >            lda test_case   ;previous test
0a14 : c90b            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
0a16 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
000c =                 >test_num = test_num + 1
0a18 : a90c            >            lda #test_num   ;*** next tests' number
0a1a : 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
0a1d : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0a1f : 48              >            pha         ;use stack to load status
0a20 : 28              >            plp
                        
0a21 : 18                       clc
                                tst_stat $ff-carry
0a22 : 08              >            php         ;save status
0a23 : 68              >            pla         ;use stack to retrieve status
0a24 : 48              >            pha
                       >            cmp_flag $ff-carry
0a25 : c9fe            >            cmp #($ff-carry|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a27 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a29 : 28              >            plp         ;restore status
                        
0a2a : 38                       sec
                                tst_stat $ff
0a2b : 08              >            php         ;save status
0a2c : 68              >            pla         ;use stack to retrieve status
0a2d : 48              >            pha
                       >            cmp_flag $ff
0a2e : c9ff            >            cmp #($ff|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a30 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a32 : 28              >            plp         ;restore status
                        
                            if I_flag = 3
0a33 : 58                       cli
                                tst_stat $ff-intdis
0a34 : 08              >            php         ;save status
0a35 : 68              >            pla         ;use stack to retrieve status
0a36 : 48              >            pha
                       >            cmp_flag $ff-intdis
0a37 : c9fb            >            cmp #($ff-intdis|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a39 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a3b : 28              >            plp         ;restore status
                        
0a3c : 78                       sei
                                tst_stat $ff
0a3d : 08              >            php         ;save status
0a3e : 68              >            pla         ;use stack to retrieve status
0a3f : 48              >            pha
                       >            cmp_flag $ff
0a40 : c9ff            >            cmp #($ff|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a42 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a44 : 28              >            plp         ;restore status
                        
                            endif
0a45 : d8                       cld
                                tst_stat $ff-decmode
0a46 : 08              >            php         ;save status
0a47 : 68              >            pla         ;use stack to retrieve status
0a48 : 48              >            pha
                       >            cmp_flag $ff-decmode
0a49 : c9f7            >            cmp #($ff-decmode|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a4b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a4d : 28              >            plp         ;restore status
                        
0a4e : f8                       sed
                                tst_stat $ff
0a4f : 08              >            php         ;save status
0a50 : 68              >            pla         ;use stack to retrieve status
0a51 : 48              >            pha
                       >            cmp_flag $ff
0a52 : c9ff            >            cmp #($ff|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a54 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a56 : 28              >            plp         ;restore status
                        
0a57 : b8                       clv
                                tst_stat $ff-overfl
0a58 : 08              >            php         ;save status
0a59 : 68              >            pla         ;use stack to retrieve status
0a5a : 48              >            pha
                       >            cmp_flag $ff-overfl
0a5b : c9bf            >            cmp #($ff-overfl|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a5d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a5f : 28              >            plp         ;restore status
                        
                                set_stat 0
                       >            load_flag 0
0a60 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0a62 : 48              >            pha         ;use stack to load status
0a63 : 28              >            plp
                        
                                tst_stat 0
0a64 : 08              >            php         ;save status
0a65 : 68              >            pla         ;use stack to retrieve status
0a66 : 48              >            pha
                       >            cmp_flag 0
0a67 : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a69 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a6b : 28              >            plp         ;restore status
                        
0a6c : 38                       sec
                                tst_stat carry
0a6d : 08              >            php         ;save status
0a6e : 68              >            pla         ;use stack to retrieve status
0a6f : 48              >            pha
                       >            cmp_flag carry
0a70 : c931            >            cmp #(carry|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a72 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a74 : 28              >            plp         ;restore status
                        
0a75 : 18                       clc
                                tst_stat 0  
0a76 : 08              >            php         ;save status
0a77 : 68              >            pla         ;use stack to retrieve status
0a78 : 48              >            pha
                       >            cmp_flag 0  
0a79 : c930            >            cmp #(0  |fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a7b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a7d : 28              >            plp         ;restore status
                        
                            if I_flag = 3
0a7e : 78                       sei
                                tst_stat intdis
0a7f : 08              >            php         ;save status
0a80 : 68              >            pla         ;use stack to retrieve status
0a81 : 48              >            pha
                       >            cmp_flag intdis
0a82 : c934            >            cmp #(intdis|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a84 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a86 : 28              >            plp         ;restore status
                        
0a87 : 58                       cli
                                tst_stat 0
0a88 : 08              >            php         ;save status
0a89 : 68              >            pla         ;use stack to retrieve status
0a8a : 48              >            pha
                       >            cmp_flag 0
0a8b : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a8d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a8f : 28              >            plp         ;restore status
                        
                            endif  
0a90 : f8                       sed
                                tst_stat decmode
0a91 : 08              >            php         ;save status
0a92 : 68              >            pla         ;use stack to retrieve status
0a93 : 48              >            pha
                       >            cmp_flag decmode
0a94 : c938            >            cmp #(decmode|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a96 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0a98 : 28              >            plp         ;restore status
                        
0a99 : d8                       cld
                                tst_stat 0  
0a9a : 08              >            php         ;save status
0a9b : 68              >            pla         ;use stack to retrieve status
0a9c : 48              >            pha
                       >            cmp_flag 0  
0a9d : c930            >            cmp #(0  |fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0a9f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0aa1 : 28              >            plp         ;restore status
                        
                                set_stat overfl
                       >            load_flag overfl
0aa2 : a940            >            lda #overfl             ;allow test to change I-flag (no mask)
                       >
0aa4 : 48              >            pha         ;use stack to load status
0aa5 : 28              >            plp
                        
                                tst_stat overfl
0aa6 : 08              >            php         ;save status
0aa7 : 68              >            pla         ;use stack to retrieve status
0aa8 : 48              >            pha
                       >            cmp_flag overfl
0aa9 : c970            >            cmp #(overfl|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0aab : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0aad : 28              >            plp         ;restore status
                        
0aae : b8                       clv
                                tst_stat 0
0aaf : 08              >            php         ;save status
0ab0 : 68              >            pla         ;use stack to retrieve status
0ab1 : 48              >            pha
                       >            cmp_flag 0
0ab2 : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0ab4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0ab6 : 28              >            plp         ;restore status
                        
                                next_test
0ab7 : ad0002          >            lda test_case   ;previous test
0aba : c90c            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
0abc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
000d =                 >test_num = test_num + 1
0abe : a90d            >            lda #test_num   ;*** next tests' number
0ac0 : 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 
0ac3 : a2fe                     ldx #$fe
                                set_stat $ff
                       >            load_flag $ff
0ac5 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0ac7 : 48              >            pha         ;use stack to load status
0ac8 : 28              >            plp
                        
0ac9 : e8                       inx             ;ff
                                tst_x $ff,$ff-zero
0aca : 08              >            php         ;save flags
0acb : e0ff            >            cpx #$ff     ;test result
                       >            trap_ne
0acd : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0acf : 68              >            pla         ;load status
0ad0 : 48              >            pha
                       >            cmp_flag $ff-zero
0ad1 : c9fd            >            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0ad3 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0ad5 : 28              >            plp         ;restore status
                        
0ad6 : e8                       inx             ;00
                                tst_x 0,$ff-minus
0ad7 : 08              >            php         ;save flags
0ad8 : e000            >            cpx #0     ;test result
                       >            trap_ne
0ada : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0adc : 68              >            pla         ;load status
0add : 48              >            pha
                       >            cmp_flag $ff-minus
0ade : c97f            >            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0ae0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0ae2 : 28              >            plp         ;restore status
                        
0ae3 : e8                       inx             ;01
                                tst_x 1,$ff-minus-zero
0ae4 : 08              >            php         ;save flags
0ae5 : e001            >            cpx #1     ;test result
                       >            trap_ne
0ae7 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0ae9 : 68              >            pla         ;load status
0aea : 48              >            pha
                       >            cmp_flag $ff-minus-zero
0aeb : c97d            >            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0aed : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0aef : 28              >            plp         ;restore status
                        
0af0 : ca                       dex             ;00
                                tst_x 0,$ff-minus
0af1 : 08              >            php         ;save flags
0af2 : e000            >            cpx #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 : ca                       dex             ;ff
                                tst_x $ff,$ff-zero
0afe : 08              >            php         ;save flags
0aff : e0ff            >            cpx #$ff     ;test result
                       >            trap_ne
0b01 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b03 : 68              >            pla         ;load status
0b04 : 48              >            pha
                       >            cmp_flag $ff-zero
0b05 : c9fd            >            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0b07 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b09 : 28              >            plp         ;restore status
                        
0b0a : ca                       dex             ;fe
                                set_stat 0
                       >            load_flag 0
0b0b : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0b0d : 48              >            pha         ;use stack to load status
0b0e : 28              >            plp
                        
0b0f : e8                       inx             ;ff
                                tst_x $ff,minus
0b10 : 08              >            php         ;save flags
0b11 : e0ff            >            cpx #$ff     ;test result
                       >            trap_ne
0b13 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b15 : 68              >            pla         ;load status
0b16 : 48              >            pha
                       >            cmp_flag minus
0b17 : c9b0            >            cmp #(minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0b19 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b1b : 28              >            plp         ;restore status
                        
0b1c : e8                       inx             ;00
                                tst_x 0,zero
0b1d : 08              >            php         ;save flags
0b1e : e000            >            cpx #0     ;test result
                       >            trap_ne
0b20 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b22 : 68              >            pla         ;load status
0b23 : 48              >            pha
                       >            cmp_flag zero
0b24 : c932            >            cmp #(zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0b26 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b28 : 28              >            plp         ;restore status
                        
0b29 : e8                       inx             ;01
                                tst_x 1,0
0b2a : 08              >            php         ;save flags
0b2b : e001            >            cpx #1     ;test result
                       >            trap_ne
0b2d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b2f : 68              >            pla         ;load status
0b30 : 48              >            pha
                       >            cmp_flag 0
0b31 : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0b33 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b35 : 28              >            plp         ;restore status
                        
0b36 : ca                       dex             ;00
                                tst_x 0,zero
0b37 : 08              >            php         ;save flags
0b38 : e000            >            cpx #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 : ca                       dex             ;ff
                                tst_x $ff,minus
0b44 : 08              >            php         ;save flags
0b45 : e0ff            >            cpx #$ff     ;test result
                       >            trap_ne
0b47 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b49 : 68              >            pla         ;load status
0b4a : 48              >            pha
                       >            cmp_flag minus
0b4b : c9b0            >            cmp #(minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0b4d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b4f : 28              >            plp         ;restore status
                        
                        
0b50 : a0fe                     ldy #$fe
                                set_stat $ff
                       >            load_flag $ff
0b52 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0b54 : 48              >            pha         ;use stack to load status
0b55 : 28              >            plp
                        
0b56 : c8                       iny             ;ff
                                tst_y $ff,$ff-zero
0b57 : 08              >            php         ;save flags
0b58 : c0ff            >            cpy #$ff     ;test result
                       >            trap_ne
0b5a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b5c : 68              >            pla         ;load status
0b5d : 48              >            pha
                       >            cmp_flag $ff-zero
0b5e : c9fd            >            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0b60 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b62 : 28              >            plp         ;restore status
                        
0b63 : c8                       iny             ;00
                                tst_y 0,$ff-minus
0b64 : 08              >            php         ;save flags
0b65 : c000            >            cpy #0     ;test result
                       >            trap_ne
0b67 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b69 : 68              >            pla         ;load status
0b6a : 48              >            pha
                       >            cmp_flag $ff-minus
0b6b : c97f            >            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0b6d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b6f : 28              >            plp         ;restore status
                        
0b70 : c8                       iny             ;01
                                tst_y 1,$ff-minus-zero
0b71 : 08              >            php         ;save flags
0b72 : c001            >            cpy #1     ;test result
                       >            trap_ne
0b74 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b76 : 68              >            pla         ;load status
0b77 : 48              >            pha
                       >            cmp_flag $ff-minus-zero
0b78 : c97d            >            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0b7a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b7c : 28              >            plp         ;restore status
                        
0b7d : 88                       dey             ;00
                                tst_y 0,$ff-minus
0b7e : 08              >            php         ;save flags
0b7f : c000            >            cpy #0     ;test result
                       >            trap_ne
0b81 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b83 : 68              >            pla         ;load status
0b84 : 48              >            pha
                       >            cmp_flag $ff-minus
0b85 : c97f            >            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0b87 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b89 : 28              >            plp         ;restore status
                        
0b8a : 88                       dey             ;ff
                                tst_y $ff,$ff-zero
0b8b : 08              >            php         ;save flags
0b8c : c0ff            >            cpy #$ff     ;test result
                       >            trap_ne
0b8e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b90 : 68              >            pla         ;load status
0b91 : 48              >            pha
                       >            cmp_flag $ff-zero
0b92 : c9fd            >            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0b94 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0b96 : 28              >            plp         ;restore status
                        
0b97 : 88                       dey             ;fe
                                set_stat 0
                       >            load_flag 0
0b98 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0b9a : 48              >            pha         ;use stack to load status
0b9b : 28              >            plp
                        
0b9c : c8                       iny             ;ff
                                tst_y $ff,0+minus
0b9d : 08              >            php         ;save flags
0b9e : c0ff            >            cpy #$ff     ;test result
                       >            trap_ne
0ba0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0ba2 : 68              >            pla         ;load status
0ba3 : 48              >            pha
                       >            cmp_flag 0+minus
0ba4 : c9b0            >            cmp #(0+minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0ba6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0ba8 : 28              >            plp         ;restore status
                        
0ba9 : c8                       iny             ;00
                                tst_y 0,zero
0baa : 08              >            php         ;save flags
0bab : c000            >            cpy #0     ;test result
                       >            trap_ne
0bad : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0baf : 68              >            pla         ;load status
0bb0 : 48              >            pha
                       >            cmp_flag zero
0bb1 : c932            >            cmp #(zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0bb3 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0bb5 : 28              >            plp         ;restore status
                        
0bb6 : c8                       iny             ;01
                                tst_y 1,0
0bb7 : 08              >            php         ;save flags
0bb8 : c001            >            cpy #1     ;test result
                       >            trap_ne
0bba : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0bbc : 68              >            pla         ;load status
0bbd : 48              >            pha
                       >            cmp_flag 0
0bbe : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0bc0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0bc2 : 28              >            plp         ;restore status
                        
0bc3 : 88                       dey             ;00
                                tst_y 0,zero
0bc4 : 08              >            php         ;save flags
0bc5 : c000            >            cpy #0     ;test result
                       >            trap_ne
0bc7 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0bc9 : 68              >            pla         ;load status
0bca : 48              >            pha
                       >            cmp_flag zero
0bcb : c932            >            cmp #(zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0bcd : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0bcf : 28              >            plp         ;restore status
                        
0bd0 : 88                       dey             ;ff
                                tst_y $ff,minus
0bd1 : 08              >            php         ;save flags
0bd2 : c0ff            >            cpy #$ff     ;test result
                       >            trap_ne
0bd4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0bd6 : 68              >            pla         ;load status
0bd7 : 48              >            pha
                       >            cmp_flag minus
0bd8 : c9b0            >            cmp #(minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0bda : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0bdc : 28              >            plp         ;restore status
                        
                                        
0bdd : a2ff                     ldx #$ff
                                set_stat $ff
                       >            load_flag $ff
0bdf : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0be1 : 48              >            pha         ;use stack to load status
0be2 : 28              >            plp
                        
0be3 : 8a                       txa
                                tst_a $ff,$ff-zero
0be4 : 08              >            php         ;save flags
0be5 : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
0be7 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0be9 : 68              >            pla         ;load status
0bea : 48              >            pha
                       >            cmp_flag $ff-zero
0beb : c9fd            >            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0bed : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0bef : 28              >            plp         ;restore status
                        
0bf0 : 08                       php
0bf1 : e8                       inx             ;00
0bf2 : 28                       plp
0bf3 : 8a                       txa
                                tst_a 0,$ff-minus
0bf4 : 08              >            php         ;save flags
0bf5 : c900            >            cmp #0     ;test result
                       >            trap_ne
0bf7 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0bf9 : 68              >            pla         ;load status
0bfa : 48              >            pha
                       >            cmp_flag $ff-minus
0bfb : c97f            >            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0bfd : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0bff : 28              >            plp         ;restore status
                        
0c00 : 08                       php
0c01 : e8                       inx             ;01
0c02 : 28                       plp
0c03 : 8a                       txa
                                tst_a 1,$ff-minus-zero
0c04 : 08              >            php         ;save flags
0c05 : c901            >            cmp #1     ;test result
                       >            trap_ne
0c07 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c09 : 68              >            pla         ;load status
0c0a : 48              >            pha
                       >            cmp_flag $ff-minus-zero
0c0b : c97d            >            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0c0d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c0f : 28              >            plp         ;restore status
                        
                                set_stat 0
                       >            load_flag 0
0c10 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0c12 : 48              >            pha         ;use stack to load status
0c13 : 28              >            plp
                        
0c14 : 8a                       txa
                                tst_a 1,0
0c15 : 08              >            php         ;save flags
0c16 : c901            >            cmp #1     ;test result
                       >            trap_ne
0c18 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c1a : 68              >            pla         ;load status
0c1b : 48              >            pha
                       >            cmp_flag 0
0c1c : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0c1e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c20 : 28              >            plp         ;restore status
                        
0c21 : 08                       php
0c22 : ca                       dex             ;00
0c23 : 28                       plp
0c24 : 8a                       txa
                                tst_a 0,zero
0c25 : 08              >            php         ;save flags
0c26 : c900            >            cmp #0     ;test result
                       >            trap_ne
0c28 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c2a : 68              >            pla         ;load status
0c2b : 48              >            pha
                       >            cmp_flag zero
0c2c : c932            >            cmp #(zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0c2e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c30 : 28              >            plp         ;restore status
                        
0c31 : 08                       php
0c32 : ca                       dex             ;ff
0c33 : 28                       plp
0c34 : 8a                       txa
                                tst_a $ff,minus
0c35 : 08              >            php         ;save flags
0c36 : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
0c38 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c3a : 68              >            pla         ;load status
0c3b : 48              >            pha
                       >            cmp_flag minus
0c3c : c9b0            >            cmp #(minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0c3e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c40 : 28              >            plp         ;restore status
                        
                                                
0c41 : a0ff                     ldy #$ff
                                set_stat $ff
                       >            load_flag $ff
0c43 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0c45 : 48              >            pha         ;use stack to load status
0c46 : 28              >            plp
                        
0c47 : 98                       tya
                                tst_a $ff,$ff-zero
0c48 : 08              >            php         ;save flags
0c49 : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
0c4b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c4d : 68              >            pla         ;load status
0c4e : 48              >            pha
                       >            cmp_flag $ff-zero
0c4f : c9fd            >            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0c51 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c53 : 28              >            plp         ;restore status
                        
0c54 : 08                       php
0c55 : c8                       iny             ;00
0c56 : 28                       plp
0c57 : 98                       tya
                                tst_a 0,$ff-minus
0c58 : 08              >            php         ;save flags
0c59 : c900            >            cmp #0     ;test result
                       >            trap_ne
0c5b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c5d : 68              >            pla         ;load status
0c5e : 48              >            pha
                       >            cmp_flag $ff-minus
0c5f : c97f            >            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0c61 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c63 : 28              >            plp         ;restore status
                        
0c64 : 08                       php
0c65 : c8                       iny             ;01
0c66 : 28                       plp
0c67 : 98                       tya
                                tst_a 1,$ff-minus-zero
0c68 : 08              >            php         ;save flags
0c69 : c901            >            cmp #1     ;test result
                       >            trap_ne
0c6b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c6d : 68              >            pla         ;load status
0c6e : 48              >            pha
                       >            cmp_flag $ff-minus-zero
0c6f : c97d            >            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0c71 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c73 : 28              >            plp         ;restore status
                        
                                set_stat 0
                       >            load_flag 0
0c74 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0c76 : 48              >            pha         ;use stack to load status
0c77 : 28              >            plp
                        
0c78 : 98                       tya
                                tst_a 1,0
0c79 : 08              >            php         ;save flags
0c7a : c901            >            cmp #1     ;test result
                       >            trap_ne
0c7c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c7e : 68              >            pla         ;load status
0c7f : 48              >            pha
                       >            cmp_flag 0
0c80 : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0c82 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c84 : 28              >            plp         ;restore status
                        
0c85 : 08                       php
0c86 : 88                       dey             ;00
0c87 : 28                       plp
0c88 : 98                       tya
                                tst_a 0,zero
0c89 : 08              >            php         ;save flags
0c8a : c900            >            cmp #0     ;test result
                       >            trap_ne
0c8c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c8e : 68              >            pla         ;load status
0c8f : 48              >            pha
                       >            cmp_flag zero
0c90 : c932            >            cmp #(zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0c92 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c94 : 28              >            plp         ;restore status
                        
0c95 : 08                       php
0c96 : 88                       dey             ;ff
0c97 : 28                       plp
0c98 : 98                       tya
                                tst_a $ff,minus
0c99 : 08              >            php         ;save flags
0c9a : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
0c9c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0c9e : 68              >            pla         ;load status
0c9f : 48              >            pha
                       >            cmp_flag minus
0ca0 : c9b0            >            cmp #(minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0ca2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0ca4 : 28              >            plp         ;restore status
                        
                        
                                load_flag $ff
0ca5 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                        
0ca7 : 48                       pha
0ca8 : a2ff                     ldx #$ff        ;ff
0caa : 8a                       txa
0cab : 28                       plp             
0cac : a8                       tay
                                tst_y $ff,$ff-zero
0cad : 08              >            php         ;save flags
0cae : c0ff            >            cpy #$ff     ;test result
                       >            trap_ne
0cb0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0cb2 : 68              >            pla         ;load status
0cb3 : 48              >            pha
                       >            cmp_flag $ff-zero
0cb4 : c9fd            >            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0cb6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0cb8 : 28              >            plp         ;restore status
                        
0cb9 : 08                       php
0cba : e8                       inx             ;00
0cbb : 8a                       txa
0cbc : 28                       plp
0cbd : a8                       tay
                                tst_y 0,$ff-minus
0cbe : 08              >            php         ;save flags
0cbf : c000            >            cpy #0     ;test result
                       >            trap_ne
0cc1 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0cc3 : 68              >            pla         ;load status
0cc4 : 48              >            pha
                       >            cmp_flag $ff-minus
0cc5 : c97f            >            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0cc7 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0cc9 : 28              >            plp         ;restore status
                        
0cca : 08                       php
0ccb : e8                       inx             ;01
0ccc : 8a                       txa
0ccd : 28                       plp
0cce : a8                       tay
                                tst_y 1,$ff-minus-zero
0ccf : 08              >            php         ;save flags
0cd0 : c001            >            cpy #1     ;test result
                       >            trap_ne
0cd2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0cd4 : 68              >            pla         ;load status
0cd5 : 48              >            pha
                       >            cmp_flag $ff-minus-zero
0cd6 : c97d            >            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0cd8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0cda : 28              >            plp         ;restore status
                        
                                load_flag 0
0cdb : a900            >            lda #0             ;allow test to change I-flag (no mask)
                        
0cdd : 48                       pha
0cde : a900                     lda #0
0ce0 : 8a                       txa
0ce1 : 28                       plp
0ce2 : a8                       tay
                                tst_y 1,0
0ce3 : 08              >            php         ;save flags
0ce4 : c001            >            cpy #1     ;test result
                       >            trap_ne
0ce6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0ce8 : 68              >            pla         ;load status
0ce9 : 48              >            pha
                       >            cmp_flag 0
0cea : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0cec : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0cee : 28              >            plp         ;restore status
                        
0cef : 08                       php
0cf0 : ca                       dex             ;00
0cf1 : 8a                       txa
0cf2 : 28                       plp
0cf3 : a8                       tay
                                tst_y 0,zero
0cf4 : 08              >            php         ;save flags
0cf5 : c000            >            cpy #0     ;test result
                       >            trap_ne
0cf7 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0cf9 : 68              >            pla         ;load status
0cfa : 48              >            pha
                       >            cmp_flag zero
0cfb : c932            >            cmp #(zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0cfd : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0cff : 28              >            plp         ;restore status
                        
0d00 : 08                       php
0d01 : ca                       dex             ;ff
0d02 : 8a                       txa
0d03 : 28                       plp
0d04 : a8                       tay
                                tst_y $ff,minus
0d05 : 08              >            php         ;save flags
0d06 : c0ff            >            cpy #$ff     ;test result
                       >            trap_ne
0d08 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d0a : 68              >            pla         ;load status
0d0b : 48              >            pha
                       >            cmp_flag minus
0d0c : c9b0            >            cmp #(minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0d0e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d10 : 28              >            plp         ;restore status
                        
                        
                        
                                load_flag $ff
0d11 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                        
0d13 : 48                       pha
0d14 : a0ff                     ldy #$ff        ;ff
0d16 : 98                       tya
0d17 : 28                       plp
0d18 : aa                       tax
                                tst_x $ff,$ff-zero
0d19 : 08              >            php         ;save flags
0d1a : e0ff            >            cpx #$ff     ;test result
                       >            trap_ne
0d1c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d1e : 68              >            pla         ;load status
0d1f : 48              >            pha
                       >            cmp_flag $ff-zero
0d20 : c9fd            >            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0d22 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d24 : 28              >            plp         ;restore status
                        
0d25 : 08                       php
0d26 : c8                       iny             ;00
0d27 : 98                       tya
0d28 : 28                       plp
0d29 : aa                       tax
                                tst_x 0,$ff-minus
0d2a : 08              >            php         ;save flags
0d2b : e000            >            cpx #0     ;test result
                       >            trap_ne
0d2d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d2f : 68              >            pla         ;load status
0d30 : 48              >            pha
                       >            cmp_flag $ff-minus
0d31 : c97f            >            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0d33 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d35 : 28              >            plp         ;restore status
                        
0d36 : 08                       php
0d37 : c8                       iny             ;01
0d38 : 98                       tya
0d39 : 28                       plp
0d3a : aa                       tax
                                tst_x 1,$ff-minus-zero
0d3b : 08              >            php         ;save flags
0d3c : e001            >            cpx #1     ;test result
                       >            trap_ne
0d3e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d40 : 68              >            pla         ;load status
0d41 : 48              >            pha
                       >            cmp_flag $ff-minus-zero
0d42 : c97d            >            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0d44 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d46 : 28              >            plp         ;restore status
                        
                                load_flag 0
0d47 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                        
0d49 : 48                       pha
0d4a : a900                     lda #0          ;preset status
0d4c : 98                       tya
0d4d : 28                       plp
0d4e : aa                       tax
                                tst_x 1,0
0d4f : 08              >            php         ;save flags
0d50 : e001            >            cpx #1     ;test result
                       >            trap_ne
0d52 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d54 : 68              >            pla         ;load status
0d55 : 48              >            pha
                       >            cmp_flag 0
0d56 : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0d58 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d5a : 28              >            plp         ;restore status
                        
0d5b : 08                       php
0d5c : 88                       dey             ;00
0d5d : 98                       tya
0d5e : 28                       plp
0d5f : aa                       tax
                                tst_x 0,zero
0d60 : 08              >            php         ;save flags
0d61 : e000            >            cpx #0     ;test result
                       >            trap_ne
0d63 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d65 : 68              >            pla         ;load status
0d66 : 48              >            pha
                       >            cmp_flag zero
0d67 : c932            >            cmp #(zero|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0d69 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d6b : 28              >            plp         ;restore status
                        
0d6c : 08                       php
0d6d : 88                       dey             ;ff
0d6e : 98                       tya
0d6f : 28                       plp
0d70 : aa                       tax
                                tst_x $ff,minus
0d71 : 08              >            php         ;save flags
0d72 : e0ff            >            cpx #$ff     ;test result
                       >            trap_ne
0d74 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d76 : 68              >            pla         ;load status
0d77 : 48              >            pha
                       >            cmp_flag minus
0d78 : c9b0            >            cmp #(minus|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
0d7a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0d7c : 28              >            plp         ;restore status
                        
                                next_test
0d7d : ad0002          >            lda test_case   ;previous test
0d80 : c90d            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
0d82 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
000e =                 >test_num = test_num + 1
0d84 : a90e            >            lda #test_num   ;*** next tests' number
0d86 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                             
                        ;TSX sets NZ - TXS does not
                        ;  This section also tests for proper stack wrap around.
0d89 : a201                     ldx #1          ;01
                                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 : 9a                       txs
0d90 : 08                       php
0d91 : ad0101                   lda $101
                                cmp_flag $ff
0d94 : c9ff            >            cmp #($ff|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0d96 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
0d98 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0d9a : 48              >            pha         ;use stack to load status
0d9b : 28              >            plp
                        
0d9c : 9a                       txs
0d9d : 08                       php
0d9e : ad0101                   lda $101
                                cmp_flag 0
0da1 : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0da3 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0da5 : ca                       dex             ;00
                                set_stat $ff
                       >            load_flag $ff
0da6 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0da8 : 48              >            pha         ;use stack to load status
0da9 : 28              >            plp
                        
0daa : 9a                       txs
0dab : 08                       php
0dac : ad0001                   lda $100
                                cmp_flag $ff
0daf : c9ff            >            cmp #($ff|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0db1 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
0db3 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0db5 : 48              >            pha         ;use stack to load status
0db6 : 28              >            plp
                        
0db7 : 9a                       txs
0db8 : 08                       php
0db9 : ad0001                   lda $100
                                cmp_flag 0
0dbc : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0dbe : d0fe            >        bne *           ;failed not equal (non zero)
                        
0dc0 : ca                       dex             ;ff
                                set_stat $ff
                       >            load_flag $ff
0dc1 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0dc3 : 48              >            pha         ;use stack to load status
0dc4 : 28              >            plp
                        
0dc5 : 9a                       txs
0dc6 : 08                       php
0dc7 : adff01                   lda $1ff
                                cmp_flag $ff
0dca : c9ff            >            cmp #($ff|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0dcc : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
0dce : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0dd0 : 48              >            pha         ;use stack to load status
0dd1 : 28              >            plp
                        
0dd2 : 9a                       txs
0dd3 : 08                       php
0dd4 : adff01                   lda $1ff
                                cmp_flag 0
0dd7 : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                        
                                
0dd9 : a201                     ldx #1
0ddb : 9a                       txs             ;sp=01
                                set_stat $ff
                       >            load_flag $ff
0ddc : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0dde : 48              >            pha         ;use stack to load status
0ddf : 28              >            plp
                        
0de0 : ba                       tsx             ;clears Z, N
0de1 : 08                       php             ;sp=00
0de2 : e001                     cpx #1
                                trap_ne
0de4 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0de6 : ad0101                   lda $101
                                cmp_flag $ff-minus-zero
0de9 : c97d            >            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0deb : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
0ded : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0def : 48              >            pha         ;use stack to load status
0df0 : 28              >            plp
                        
0df1 : ba                       tsx             ;clears N, sets Z
0df2 : 08                       php             ;sp=ff
0df3 : e000                     cpx #0
                                trap_ne
0df5 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0df7 : ad0001                   lda $100
                                cmp_flag $ff-minus
0dfa : c97f            >            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0dfc : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
0dfe : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0e00 : 48              >            pha         ;use stack to load status
0e01 : 28              >            plp
                        
0e02 : ba                       tsx             ;clears N, sets Z
0e03 : 08                       php             ;sp=fe
0e04 : e0ff                     cpx #$ff
                                trap_ne
0e06 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0e08 : adff01                   lda $1ff
                                cmp_flag $ff-zero
0e0b : c9fd            >            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0e0d : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                
0e0f : a201                     ldx #1
0e11 : 9a                       txs             ;sp=01
                                set_stat 0
                       >            load_flag 0
0e12 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0e14 : 48              >            pha         ;use stack to load status
0e15 : 28              >            plp
                        
0e16 : ba                       tsx             ;clears Z, N
0e17 : 08                       php             ;sp=00
0e18 : e001                     cpx #1
                                trap_ne
0e1a : d0fe            >        bne *           ;failed not equal (non zero)
                        
0e1c : ad0101                   lda $101
                                cmp_flag 0
0e1f : c930            >            cmp #(0|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0e21 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
0e23 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0e25 : 48              >            pha         ;use stack to load status
0e26 : 28              >            plp
                        
0e27 : ba                       tsx             ;clears N, sets Z
0e28 : 08                       php             ;sp=ff
0e29 : e000                     cpx #0
                                trap_ne
0e2b : d0fe            >        bne *           ;failed not equal (non zero)
                        
0e2d : ad0001                   lda $100
                                cmp_flag zero
0e30 : c932            >            cmp #(zero|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0e32 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
0e34 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0e36 : 48              >            pha         ;use stack to load status
0e37 : 28              >            plp
                        
0e38 : ba                       tsx             ;clears N, sets Z
0e39 : 08                       php             ;sp=fe
0e3a : e0ff                     cpx #$ff
                                trap_ne
0e3c : d0fe            >        bne *           ;failed not equal (non zero)
                        
0e3e : adff01                   lda $1ff
                                cmp_flag minus
0e41 : c9b0            >            cmp #(minus|fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
0e43 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0e45 : 68                       pla             ;sp=ff
                                next_test
0e46 : ad0002          >            lda test_case   ;previous test
0e49 : c90e            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
0e4b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
000f =                 >test_num = test_num + 1
0e4d : a90f            >            lda #test_num   ;*** next tests' number
0e4f : 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
0e52 : a003                     ldy #3
0e54 :                  tldx    
                                set_stat 0
                       >            load_flag 0
0e54 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0e56 : 48              >            pha         ;use stack to load status
0e57 : 28              >            plp
                        
0e58 : b60b                     ldx zp1,y
0e5a : 08                       php         ;test stores do not alter flags
0e5b : 8a                       txa
0e5c : 49c3                     eor #$c3
0e5e : 28                       plp
0e5f : 990302                   sta abst,y
0e62 : 08                       php         ;flags after load/store sequence
0e63 : 49c3                     eor #$c3
0e65 : d91802                   cmp abs1,y  ;test result
                                trap_ne
0e68 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0e6a : 68                       pla         ;load status
                                eor_flag 0
0e6b : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
0e6d : d91d02                   cmp fLDx,y  ;test flags
                                trap_ne
0e70 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0e72 : 88                       dey
0e73 : 10df                     bpl tldx                  
                        
0e75 : a003                     ldy #3
0e77 :                  tldx1   
                                set_stat $ff
                       >            load_flag $ff
0e77 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0e79 : 48              >            pha         ;use stack to load status
0e7a : 28              >            plp
                        
0e7b : b60b                     ldx zp1,y
0e7d : 08                       php         ;test stores do not alter flags
0e7e : 8a                       txa
0e7f : 49c3                     eor #$c3
0e81 : 28                       plp
0e82 : 990302                   sta abst,y
0e85 : 08                       php         ;flags after load/store sequence
0e86 : 49c3                     eor #$c3
0e88 : d91802                   cmp abs1,y  ;test result
                                trap_ne
0e8b : d0fe            >        bne *           ;failed not equal (non zero)
                        
0e8d : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
0e8e : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
0e90 : d91d02                   cmp fLDx,y  ;test flags
                                trap_ne
0e93 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0e95 : 88                       dey
0e96 : 10df                     bpl tldx1                  
                        
0e98 : a003                     ldy #3
0e9a :                  tldx2   
                                set_stat 0
                       >            load_flag 0
0e9a : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0e9c : 48              >            pha         ;use stack to load status
0e9d : 28              >            plp
                        
0e9e : be1802                   ldx abs1,y
0ea1 : 08                       php         ;test stores do not alter flags
0ea2 : 8a                       txa
0ea3 : 49c3                     eor #$c3
0ea5 : aa                       tax
0ea6 : 28                       plp
0ea7 : 9602                     stx zpt,y
0ea9 : 08                       php         ;flags after load/store sequence
0eaa : 49c3                     eor #$c3
0eac : d90b00                   cmp zp1,y   ;test result
                                trap_ne
0eaf : d0fe            >        bne *           ;failed not equal (non zero)
                        
0eb1 : 68                       pla         ;load status
                                eor_flag 0
0eb2 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
0eb4 : d91d02                   cmp fLDx,y  ;test flags
                                trap_ne
0eb7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0eb9 : 88                       dey
0eba : 10de                     bpl tldx2                  
                        
0ebc : a003                     ldy #3
0ebe :                  tldx3   
                                set_stat $ff
                       >            load_flag $ff
0ebe : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0ec0 : 48              >            pha         ;use stack to load status
0ec1 : 28              >            plp
                        
0ec2 : be1802                   ldx abs1,y
0ec5 : 08                       php         ;test stores do not alter flags
0ec6 : 8a                       txa
0ec7 : 49c3                     eor #$c3
0ec9 : aa                       tax
0eca : 28                       plp
0ecb : 9602                     stx zpt,y
0ecd : 08                       php         ;flags after load/store sequence
0ece : 49c3                     eor #$c3
0ed0 : d90b00                   cmp zp1,y   ;test result
                                trap_ne
0ed3 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0ed5 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
0ed6 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
0ed8 : d91d02                   cmp fLDx,y  ;test flags
                                trap_ne
0edb : d0fe            >        bne *           ;failed not equal (non zero)
                        
0edd : 88                       dey
0ede : 10de                     bpl tldx3
                                
0ee0 : a003                     ldy #3      ;testing store result
0ee2 : a200                     ldx #0
0ee4 : b90200           tstx    lda zpt,y
0ee7 : 49c3                     eor #$c3
0ee9 : d90b00                   cmp zp1,y
                                trap_ne     ;store to zp data
0eec : d0fe            >        bne *           ;failed not equal (non zero)
                        
0eee : 9602                     stx zpt,y   ;clear                
0ef0 : b90302                   lda abst,y
0ef3 : 49c3                     eor #$c3
0ef5 : d91802                   cmp abs1,y
                                trap_ne     ;store to abs data
0ef8 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0efa : 8a                       txa
0efb : 990302                   sta abst,y  ;clear                
0efe : 88                       dey
0eff : 10e3                     bpl tstx
                                next_test
0f01 : ad0002          >            lda test_case   ;previous test
0f04 : c90f            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
0f06 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0010 =                 >test_num = test_num + 1
0f08 : a910            >            lda #test_num   ;*** next tests' number
0f0a : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                                
                        ; indexed wraparound test (only zp should wrap)
0f0d : a0fd                     ldy #3+$fa
0f0f : b611             tldx4   ldx zp1-$fa&$ff,y   ;wrap on indexed zp
0f11 : 8a                       txa
0f12 : 990901                   sta abst-$fa,y      ;no STX abs,y!
0f15 : 88                       dey
0f16 : c0fa                     cpy #$fa
0f18 : b0f5                     bcs tldx4                  
0f1a : a0fd                     ldy #3+$fa
0f1c : be1e01           tldx5   ldx abs1-$fa,y      ;no wrap on indexed abs
0f1f : 9608                     stx zpt-$fa&$ff,y
0f21 : 88                       dey
0f22 : c0fa                     cpy #$fa
0f24 : b0f6                     bcs tldx5                  
0f26 : a003                     ldy #3      ;testing wraparound result
0f28 : a200                     ldx #0
0f2a : b90200           tstx1   lda zpt,y
0f2d : d90b00                   cmp zp1,y
                                trap_ne     ;store to zp data
0f30 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0f32 : 9602                     stx zpt,y   ;clear                
0f34 : b90302                   lda abst,y
0f37 : d91802                   cmp abs1,y
                                trap_ne     ;store to abs data
0f3a : d0fe            >        bne *           ;failed not equal (non zero)
                        
0f3c : 8a                       txa
0f3d : 990302                   sta abst,y  ;clear                
0f40 : 88                       dey
0f41 : 10e7                     bpl tstx1
                                next_test
0f43 : ad0002          >            lda test_case   ;previous test
0f46 : c910            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
0f48 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0011 =                 >test_num = test_num + 1
0f4a : a911            >            lda #test_num   ;*** next tests' number
0f4c : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                                
                        ; LDY / STY - zp,x / abs,x
0f4f : a203                     ldx #3
0f51 :                  tldy    
                                set_stat 0
                       >            load_flag 0
0f51 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0f53 : 48              >            pha         ;use stack to load status
0f54 : 28              >            plp
                        
0f55 : b40b                     ldy zp1,x
0f57 : 08                       php         ;test stores do not alter flags
0f58 : 98                       tya
0f59 : 49c3                     eor #$c3
0f5b : 28                       plp
0f5c : 9d0302                   sta abst,x
0f5f : 08                       php         ;flags after load/store sequence
0f60 : 49c3                     eor #$c3
0f62 : dd1802                   cmp abs1,x  ;test result
                                trap_ne
0f65 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0f67 : 68                       pla         ;load status
                                eor_flag 0
0f68 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
0f6a : dd1d02                   cmp fLDx,x  ;test flags
                                trap_ne
0f6d : d0fe            >        bne *           ;failed not equal (non zero)
                        
0f6f : ca                       dex
0f70 : 10df                     bpl tldy                  
                        
0f72 : a203                     ldx #3
0f74 :                  tldy1   
                                set_stat $ff
                       >            load_flag $ff
0f74 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0f76 : 48              >            pha         ;use stack to load status
0f77 : 28              >            plp
                        
0f78 : b40b                     ldy zp1,x
0f7a : 08                       php         ;test stores do not alter flags
0f7b : 98                       tya
0f7c : 49c3                     eor #$c3
0f7e : 28                       plp
0f7f : 9d0302                   sta abst,x
0f82 : 08                       php         ;flags after load/store sequence
0f83 : 49c3                     eor #$c3
0f85 : dd1802                   cmp abs1,x  ;test result
                                trap_ne
0f88 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0f8a : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
0f8b : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
0f8d : dd1d02                   cmp fLDx,x  ;test flags
                                trap_ne
0f90 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0f92 : ca                       dex
0f93 : 10df                     bpl tldy1                  
                        
0f95 : a203                     ldx #3
0f97 :                  tldy2   
                                set_stat 0
                       >            load_flag 0
0f97 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
0f99 : 48              >            pha         ;use stack to load status
0f9a : 28              >            plp
                        
0f9b : bc1802                   ldy abs1,x
0f9e : 08                       php         ;test stores do not alter flags
0f9f : 98                       tya
0fa0 : 49c3                     eor #$c3
0fa2 : a8                       tay
0fa3 : 28                       plp
0fa4 : 9402                     sty zpt,x
0fa6 : 08                       php         ;flags after load/store sequence
0fa7 : 49c3                     eor #$c3
0fa9 : d50b                     cmp zp1,x   ;test result
                                trap_ne
0fab : d0fe            >        bne *           ;failed not equal (non zero)
                        
0fad : 68                       pla         ;load status
                                eor_flag 0
0fae : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
0fb0 : dd1d02                   cmp fLDx,x  ;test flags
                                trap_ne
0fb3 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0fb5 : ca                       dex
0fb6 : 10df                     bpl tldy2                  
                        
0fb8 : a203                     ldx #3
0fba :                  tldy3
                                set_stat $ff
                       >            load_flag $ff
0fba : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
0fbc : 48              >            pha         ;use stack to load status
0fbd : 28              >            plp
                        
0fbe : bc1802                   ldy abs1,x
0fc1 : 08                       php         ;test stores do not alter flags
0fc2 : 98                       tya
0fc3 : 49c3                     eor #$c3
0fc5 : a8                       tay
0fc6 : 28                       plp
0fc7 : 9402                     sty zpt,x
0fc9 : 08                       php         ;flags after load/store sequence
0fca : 49c3                     eor #$c3
0fcc : d50b                     cmp zp1,x   ;test result
                                trap_ne
0fce : d0fe            >        bne *           ;failed not equal (non zero)
                        
0fd0 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
0fd1 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
0fd3 : dd1d02                   cmp fLDx,x  ;test flags
                                trap_ne
0fd6 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0fd8 : ca                       dex
0fd9 : 10df                     bpl tldy3
                        
0fdb : a203                     ldx #3      ;testing store result
0fdd : a000                     ldy #0
0fdf : b502             tsty    lda zpt,x
0fe1 : 49c3                     eor #$c3
0fe3 : d50b                     cmp zp1,x
                                trap_ne     ;store to zp,x data
0fe5 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0fe7 : 9402                     sty zpt,x   ;clear                
0fe9 : bd0302                   lda abst,x
0fec : 49c3                     eor #$c3
0fee : dd1802                   cmp abs1,x
                                trap_ne     ;store to abs,x data
0ff1 : d0fe            >        bne *           ;failed not equal (non zero)
                        
0ff3 : 8a                       txa
0ff4 : 9d0302                   sta abst,x  ;clear                
0ff7 : ca                       dex
0ff8 : 10e5                     bpl tsty
                                next_test
0ffa : ad0002          >            lda test_case   ;previous test
0ffd : c911            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
0fff : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0012 =                 >test_num = test_num + 1
1001 : a912            >            lda #test_num   ;*** next tests' number
1003 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; indexed wraparound test (only zp should wrap)
1006 : a2fd                     ldx #3+$fa
1008 : b411             tldy4   ldy zp1-$fa&$ff,x   ;wrap on indexed zp
100a : 98                       tya
100b : 9d0901                   sta abst-$fa,x      ;no STX abs,x!
100e : ca                       dex
100f : e0fa                     cpx #$fa
1011 : b0f5                     bcs tldy4                  
1013 : a2fd                     ldx #3+$fa
1015 : bc1e01           tldy5   ldy abs1-$fa,x      ;no wrap on indexed abs
1018 : 9408                     sty zpt-$fa&$ff,x
101a : ca                       dex
101b : e0fa                     cpx #$fa
101d : b0f6                     bcs tldy5                  
101f : a203                     ldx #3      ;testing wraparound result
1021 : a000                     ldy #0
1023 : b502             tsty1   lda zpt,x
1025 : d50b                     cmp zp1,x
                                trap_ne     ;store to zp,x data
1027 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1029 : 9402                     sty zpt,x   ;clear                
102b : bd0302                   lda abst,x
102e : dd1802                   cmp abs1,x
                                trap_ne     ;store to abs,x data
1031 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1033 : 8a                       txa
1034 : 9d0302                   sta abst,x  ;clear                
1037 : ca                       dex
1038 : 10e9                     bpl tsty1
                                next_test
103a : ad0002          >            lda test_case   ;previous test
103d : c912            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
103f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0013 =                 >test_num = test_num + 1
1041 : a913            >            lda #test_num   ;*** next tests' number
1043 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; LDX / STX - zp / abs / #
                                set_stat 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 : 28              >            plp
                        
104a : a60b                     ldx zp1
104c : 08                       php         ;test stores do not alter flags
104d : 8a                       txa
104e : 49c3                     eor #$c3
1050 : aa                       tax
1051 : 28                       plp
1052 : 8e0302                   stx abst
1055 : 08                       php         ;flags after load/store sequence
1056 : 49c3                     eor #$c3
1058 : aa                       tax
1059 : e0c3                     cpx #$c3    ;test result
                                trap_ne
105b : d0fe            >        bne *           ;failed not equal (non zero)
                        
105d : 68                       pla         ;load status
                                eor_flag 0
105e : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1060 : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
1063 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1065 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1067 : 48              >            pha         ;use stack to load status
1068 : 28              >            plp
                        
1069 : a60c                     ldx zp1+1
106b : 08                       php         ;test stores do not alter flags
106c : 8a                       txa
106d : 49c3                     eor #$c3
106f : aa                       tax
1070 : 28                       plp
1071 : 8e0402                   stx abst+1
1074 : 08                       php         ;flags after load/store sequence
1075 : 49c3                     eor #$c3
1077 : aa                       tax
1078 : e082                     cpx #$82    ;test result
                                trap_ne
107a : d0fe            >        bne *           ;failed not equal (non zero)
                        
107c : 68                       pla         ;load status
                                eor_flag 0
107d : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
107f : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
1082 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1084 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1086 : 48              >            pha         ;use stack to load status
1087 : 28              >            plp
                        
1088 : a60d                     ldx zp1+2
108a : 08                       php         ;test stores do not alter flags
108b : 8a                       txa
108c : 49c3                     eor #$c3
108e : aa                       tax
108f : 28                       plp
1090 : 8e0502                   stx abst+2
1093 : 08                       php         ;flags after load/store sequence
1094 : 49c3                     eor #$c3
1096 : aa                       tax
1097 : e041                     cpx #$41    ;test result
                                trap_ne
1099 : d0fe            >        bne *           ;failed not equal (non zero)
                        
109b : 68                       pla         ;load status
                                eor_flag 0
109c : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
109e : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
10a1 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
10a3 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
10a5 : 48              >            pha         ;use stack to load status
10a6 : 28              >            plp
                        
10a7 : a60e                     ldx zp1+3
10a9 : 08                       php         ;test stores do not alter flags
10aa : 8a                       txa
10ab : 49c3                     eor #$c3
10ad : aa                       tax
10ae : 28                       plp
10af : 8e0602                   stx abst+3
10b2 : 08                       php         ;flags after load/store sequence
10b3 : 49c3                     eor #$c3
10b5 : aa                       tax
10b6 : e000                     cpx #0      ;test result
                                trap_ne
10b8 : d0fe            >        bne *           ;failed not equal (non zero)
                        
10ba : 68                       pla         ;load status
                                eor_flag 0
10bb : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
10bd : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
10c0 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                        
                                set_stat $ff
                       >            load_flag $ff
10c2 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
10c4 : 48              >            pha         ;use stack to load status
10c5 : 28              >            plp
                        
10c6 : a60b                     ldx zp1  
10c8 : 08                       php         ;test stores do not alter flags
10c9 : 8a                       txa
10ca : 49c3                     eor #$c3
10cc : aa                       tax
10cd : 28                       plp
10ce : 8e0302                   stx abst  
10d1 : 08                       php         ;flags after load/store sequence
10d2 : 49c3                     eor #$c3
10d4 : aa                       tax
10d5 : e0c3                     cpx #$c3    ;test result
                                trap_ne     ;
10d7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
10d9 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
10da : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
10dc : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
10df : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
10e1 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
10e3 : 48              >            pha         ;use stack to load status
10e4 : 28              >            plp
                        
10e5 : a60c                     ldx zp1+1
10e7 : 08                       php         ;test stores do not alter flags
10e8 : 8a                       txa
10e9 : 49c3                     eor #$c3
10eb : aa                       tax
10ec : 28                       plp
10ed : 8e0402                   stx abst+1
10f0 : 08                       php         ;flags after load/store sequence
10f1 : 49c3                     eor #$c3
10f3 : aa                       tax
10f4 : e082                     cpx #$82    ;test result
                                trap_ne
10f6 : d0fe            >        bne *           ;failed not equal (non zero)
                        
10f8 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
10f9 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
10fb : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
10fe : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1100 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1102 : 48              >            pha         ;use stack to load status
1103 : 28              >            plp
                        
1104 : a60d                     ldx zp1+2
1106 : 08                       php         ;test stores do not alter flags
1107 : 8a                       txa
1108 : 49c3                     eor #$c3
110a : aa                       tax
110b : 28                       plp
110c : 8e0502                   stx abst+2
110f : 08                       php         ;flags after load/store sequence
1110 : 49c3                     eor #$c3
1112 : aa                       tax
1113 : e041                     cpx #$41    ;test result
                                trap_ne     ;
1115 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1117 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1118 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
111a : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
111d : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
111f : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1121 : 48              >            pha         ;use stack to load status
1122 : 28              >            plp
                        
1123 : a60e                     ldx zp1+3
1125 : 08                       php         ;test stores do not alter flags
1126 : 8a                       txa
1127 : 49c3                     eor #$c3
1129 : aa                       tax
112a : 28                       plp
112b : 8e0602                   stx abst+3
112e : 08                       php         ;flags after load/store sequence
112f : 49c3                     eor #$c3
1131 : aa                       tax
1132 : e000                     cpx #0      ;test result
                                trap_ne
1134 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1136 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1137 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1139 : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
113c : d0fe            >        bne *           ;failed not equal (non zero)
                        
                        
                                set_stat 0
                       >            load_flag 0
113e : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1140 : 48              >            pha         ;use stack to load status
1141 : 28              >            plp
                        
1142 : ae1802                   ldx abs1  
1145 : 08                       php         ;test stores do not alter flags
1146 : 8a                       txa
1147 : 49c3                     eor #$c3
1149 : aa                       tax
114a : 28                       plp
114b : 8602                     stx zpt  
114d : 08                       php         ;flags after load/store sequence
114e : 49c3                     eor #$c3
1150 : c50b                     cmp zp1     ;test result
                                trap_ne
1152 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1154 : 68                       pla         ;load status
                                eor_flag 0
1155 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1157 : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
115a : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
115c : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
115e : 48              >            pha         ;use stack to load status
115f : 28              >            plp
                        
1160 : ae1902                   ldx abs1+1
1163 : 08                       php         ;test stores do not alter flags
1164 : 8a                       txa
1165 : 49c3                     eor #$c3
1167 : aa                       tax
1168 : 28                       plp
1169 : 8603                     stx zpt+1
116b : 08                       php         ;flags after load/store sequence
116c : 49c3                     eor #$c3
116e : c50c                     cmp zp1+1   ;test result
                                trap_ne
1170 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1172 : 68                       pla         ;load status
                                eor_flag 0
1173 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1175 : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
1178 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
117a : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
117c : 48              >            pha         ;use stack to load status
117d : 28              >            plp
                        
117e : ae1a02                   ldx abs1+2
1181 : 08                       php         ;test stores do not alter flags
1182 : 8a                       txa
1183 : 49c3                     eor #$c3
1185 : aa                       tax
1186 : 28                       plp
1187 : 8604                     stx zpt+2
1189 : 08                       php         ;flags after load/store sequence
118a : 49c3                     eor #$c3
118c : c50d                     cmp zp1+2   ;test result
                                trap_ne
118e : d0fe            >        bne *           ;failed not equal (non zero)
                        
1190 : 68                       pla         ;load status
                                eor_flag 0
1191 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1193 : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
1196 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1198 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
119a : 48              >            pha         ;use stack to load status
119b : 28              >            plp
                        
119c : ae1b02                   ldx abs1+3
119f : 08                       php         ;test stores do not alter flags
11a0 : 8a                       txa
11a1 : 49c3                     eor #$c3
11a3 : aa                       tax
11a4 : 28                       plp
11a5 : 8605                     stx zpt+3
11a7 : 08                       php         ;flags after load/store sequence
11a8 : 49c3                     eor #$c3
11aa : c50e                     cmp zp1+3   ;test result
                                trap_ne
11ac : d0fe            >        bne *           ;failed not equal (non zero)
                        
11ae : 68                       pla         ;load status
                                eor_flag 0
11af : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
11b1 : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
11b4 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                        
                                set_stat $ff
                       >            load_flag $ff
11b6 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
11b8 : 48              >            pha         ;use stack to load status
11b9 : 28              >            plp
                        
11ba : ae1802                   ldx abs1  
11bd : 08                       php         ;test stores do not alter flags
11be : 8a                       txa
11bf : 49c3                     eor #$c3
11c1 : aa                       tax
11c2 : 28                       plp
11c3 : 8602                     stx zpt  
11c5 : 08                       php         ;flags after load/store sequence
11c6 : 49c3                     eor #$c3
11c8 : aa                       tax
11c9 : e40b                     cpx zp1     ;test result
                                trap_ne
11cb : d0fe            >        bne *           ;failed not equal (non zero)
                        
11cd : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
11ce : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
11d0 : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
11d3 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
11d5 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
11d7 : 48              >            pha         ;use stack to load status
11d8 : 28              >            plp
                        
11d9 : ae1902                   ldx abs1+1
11dc : 08                       php         ;test stores do not alter flags
11dd : 8a                       txa
11de : 49c3                     eor #$c3
11e0 : aa                       tax
11e1 : 28                       plp
11e2 : 8603                     stx zpt+1
11e4 : 08                       php         ;flags after load/store sequence
11e5 : 49c3                     eor #$c3
11e7 : aa                       tax
11e8 : e40c                     cpx zp1+1   ;test result
                                trap_ne
11ea : d0fe            >        bne *           ;failed not equal (non zero)
                        
11ec : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
11ed : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
11ef : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
11f2 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
11f4 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
11f6 : 48              >            pha         ;use stack to load status
11f7 : 28              >            plp
                        
11f8 : ae1a02                   ldx abs1+2
11fb : 08                       php         ;test stores do not alter flags
11fc : 8a                       txa
11fd : 49c3                     eor #$c3
11ff : aa                       tax
1200 : 28                       plp
1201 : 8604                     stx zpt+2
1203 : 08                       php         ;flags after load/store sequence
1204 : 49c3                     eor #$c3
1206 : aa                       tax
1207 : e40d                     cpx zp1+2   ;test result
                                trap_ne
1209 : d0fe            >        bne *           ;failed not equal (non zero)
                        
120b : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
120c : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
120e : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
1211 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1213 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1215 : 48              >            pha         ;use stack to load status
1216 : 28              >            plp
                        
1217 : ae1b02                   ldx abs1+3
121a : 08                       php         ;test stores do not alter flags
121b : 8a                       txa
121c : 49c3                     eor #$c3
121e : aa                       tax
121f : 28                       plp
1220 : 8605                     stx zpt+3
1222 : 08                       php         ;flags after load/store sequence
1223 : 49c3                     eor #$c3
1225 : aa                       tax
1226 : e40e                     cpx zp1+3   ;test result
                                trap_ne
1228 : d0fe            >        bne *           ;failed not equal (non zero)
                        
122a : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
122b : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
122d : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
1230 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                        
                                set_stat 0  
                       >            load_flag 0  
1232 : a900            >            lda #0               ;allow test to change I-flag (no mask)
                       >
1234 : 48              >            pha         ;use stack to load status
1235 : 28              >            plp
                        
1236 : a2c3                     ldx #$c3
1238 : 08                       php
1239 : ec1802                   cpx abs1    ;test result
                                trap_ne
123c : d0fe            >        bne *           ;failed not equal (non zero)
                        
123e : 68                       pla         ;load status
                                eor_flag 0
123f : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1241 : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
1244 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1246 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1248 : 48              >            pha         ;use stack to load status
1249 : 28              >            plp
                        
124a : a282                     ldx #$82
124c : 08                       php
124d : ec1902                   cpx abs1+1  ;test result
                                trap_ne
1250 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1252 : 68                       pla         ;load status
                                eor_flag 0
1253 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1255 : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
1258 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
125a : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
125c : 48              >            pha         ;use stack to load status
125d : 28              >            plp
                        
125e : a241                     ldx #$41
1260 : 08                       php
1261 : ec1a02                   cpx abs1+2  ;test result
                                trap_ne
1264 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1266 : 68                       pla         ;load status
                                eor_flag 0
1267 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1269 : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
126c : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
126e : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1270 : 48              >            pha         ;use stack to load status
1271 : 28              >            plp
                        
1272 : a200                     ldx #0
1274 : 08                       php
1275 : ec1b02                   cpx abs1+3  ;test result
                                trap_ne
1278 : d0fe            >        bne *           ;failed not equal (non zero)
                        
127a : 68                       pla         ;load status
                                eor_flag 0
127b : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
127d : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
1280 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                        
                                set_stat $ff
                       >            load_flag $ff
1282 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1284 : 48              >            pha         ;use stack to load status
1285 : 28              >            plp
                        
1286 : a2c3                     ldx #$c3  
1288 : 08                       php
1289 : ec1802                   cpx abs1    ;test result
                                trap_ne
128c : d0fe            >        bne *           ;failed not equal (non zero)
                        
128e : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
128f : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1291 : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
1294 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1296 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1298 : 48              >            pha         ;use stack to load status
1299 : 28              >            plp
                        
129a : a282                     ldx #$82
129c : 08                       php
129d : ec1902                   cpx abs1+1  ;test result
                                trap_ne
12a0 : d0fe            >        bne *           ;failed not equal (non zero)
                        
12a2 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
12a3 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
12a5 : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
12a8 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
12aa : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
12ac : 48              >            pha         ;use stack to load status
12ad : 28              >            plp
                        
12ae : a241                     ldx #$41
12b0 : 08                       php
12b1 : ec1a02                   cpx abs1+2  ;test result
                                trap_ne
12b4 : d0fe            >        bne *           ;failed not equal (non zero)
                        
12b6 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
12b7 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
12b9 : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
12bc : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
12be : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
12c0 : 48              >            pha         ;use stack to load status
12c1 : 28              >            plp
                        
12c2 : a200                     ldx #0
12c4 : 08                       php
12c5 : ec1b02                   cpx abs1+3  ;test result
                                trap_ne
12c8 : d0fe            >        bne *           ;failed not equal (non zero)
                        
12ca : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
12cb : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
12cd : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
12d0 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                        
12d2 : a200                     ldx #0
12d4 : a502                     lda zpt  
12d6 : 49c3                     eor #$c3
12d8 : c50b                     cmp zp1  
                                trap_ne     ;store to zp data
12da : d0fe            >        bne *           ;failed not equal (non zero)
                        
12dc : 8602                     stx zpt     ;clear                
12de : ad0302                   lda abst  
12e1 : 49c3                     eor #$c3
12e3 : cd1802                   cmp abs1  
                                trap_ne     ;store to abs data
12e6 : d0fe            >        bne *           ;failed not equal (non zero)
                        
12e8 : 8e0302                   stx abst    ;clear                
12eb : a503                     lda zpt+1
12ed : 49c3                     eor #$c3
12ef : c50c                     cmp zp1+1
                                trap_ne     ;store to zp data
12f1 : d0fe            >        bne *           ;failed not equal (non zero)
                        
12f3 : 8603                     stx zpt+1   ;clear                
12f5 : ad0402                   lda abst+1
12f8 : 49c3                     eor #$c3
12fa : cd1902                   cmp abs1+1
                                trap_ne     ;store to abs data
12fd : d0fe            >        bne *           ;failed not equal (non zero)
                        
12ff : 8e0402                   stx abst+1  ;clear                
1302 : a504                     lda zpt+2
1304 : 49c3                     eor #$c3
1306 : c50d                     cmp zp1+2
                                trap_ne     ;store to zp data
1308 : d0fe            >        bne *           ;failed not equal (non zero)
                        
130a : 8604                     stx zpt+2   ;clear                
130c : ad0502                   lda abst+2
130f : 49c3                     eor #$c3
1311 : cd1a02                   cmp abs1+2
                                trap_ne     ;store to abs data
1314 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1316 : 8e0502                   stx abst+2  ;clear                
1319 : a505                     lda zpt+3
131b : 49c3                     eor #$c3
131d : c50e                     cmp zp1+3
                                trap_ne     ;store to zp data
131f : d0fe            >        bne *           ;failed not equal (non zero)
                        
1321 : 8605                     stx zpt+3   ;clear                
1323 : ad0602                   lda abst+3
1326 : 49c3                     eor #$c3
1328 : cd1b02                   cmp abs1+3
                                trap_ne     ;store to abs data
132b : d0fe            >        bne *           ;failed not equal (non zero)
                        
132d : 8e0602                   stx abst+3  ;clear                
                                next_test
1330 : ad0002          >            lda test_case   ;previous test
1333 : c913            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
1335 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0014 =                 >test_num = test_num + 1
1337 : a914            >            lda #test_num   ;*** next tests' number
1339 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; LDY / STY - zp / abs / #
                                set_stat 0
                       >            load_flag 0
133c : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
133e : 48              >            pha         ;use stack to load status
133f : 28              >            plp
                        
1340 : a40b                     ldy zp1  
1342 : 08                       php         ;test stores do not alter flags
1343 : 98                       tya
1344 : 49c3                     eor #$c3
1346 : a8                       tay
1347 : 28                       plp
1348 : 8c0302                   sty abst  
134b : 08                       php         ;flags after load/store sequence
134c : 49c3                     eor #$c3
134e : a8                       tay
134f : c0c3                     cpy #$c3    ;test result
                                trap_ne
1351 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1353 : 68                       pla         ;load status
                                eor_flag 0
1354 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1356 : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
1359 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
135b : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
135d : 48              >            pha         ;use stack to load status
135e : 28              >            plp
                        
135f : a40c                     ldy zp1+1
1361 : 08                       php         ;test stores do not alter flags
1362 : 98                       tya
1363 : 49c3                     eor #$c3
1365 : a8                       tay
1366 : 28                       plp
1367 : 8c0402                   sty abst+1
136a : 08                       php         ;flags after load/store sequence
136b : 49c3                     eor #$c3
136d : a8                       tay
136e : c082                     cpy #$82    ;test result
                                trap_ne
1370 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1372 : 68                       pla         ;load status
                                eor_flag 0
1373 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1375 : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
1378 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
137a : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
137c : 48              >            pha         ;use stack to load status
137d : 28              >            plp
                        
137e : a40d                     ldy zp1+2
1380 : 08                       php         ;test stores do not alter flags
1381 : 98                       tya
1382 : 49c3                     eor #$c3
1384 : a8                       tay
1385 : 28                       plp
1386 : 8c0502                   sty abst+2
1389 : 08                       php         ;flags after load/store sequence
138a : 49c3                     eor #$c3
138c : a8                       tay
138d : c041                     cpy #$41    ;test result
                                trap_ne
138f : d0fe            >        bne *           ;failed not equal (non zero)
                        
1391 : 68                       pla         ;load status
                                eor_flag 0
1392 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1394 : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
1397 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1399 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
139b : 48              >            pha         ;use stack to load status
139c : 28              >            plp
                        
139d : a40e                     ldy zp1+3
139f : 08                       php         ;test stores do not alter flags
13a0 : 98                       tya
13a1 : 49c3                     eor #$c3
13a3 : a8                       tay
13a4 : 28                       plp
13a5 : 8c0602                   sty abst+3
13a8 : 08                       php         ;flags after load/store sequence
13a9 : 49c3                     eor #$c3
13ab : a8                       tay
13ac : c000                     cpy #0      ;test result
                                trap_ne
13ae : d0fe            >        bne *           ;failed not equal (non zero)
                        
13b0 : 68                       pla         ;load status
                                eor_flag 0
13b1 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
13b3 : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
13b6 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                        
                                set_stat $ff
                       >            load_flag $ff
13b8 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
13ba : 48              >            pha         ;use stack to load status
13bb : 28              >            plp
                        
13bc : a40b                     ldy zp1  
13be : 08                       php         ;test stores do not alter flags
13bf : 98                       tya
13c0 : 49c3                     eor #$c3
13c2 : a8                       tay
13c3 : 28                       plp
13c4 : 8c0302                   sty abst  
13c7 : 08                       php         ;flags after load/store sequence
13c8 : 49c3                     eor #$c3
13ca : a8                       tay
13cb : c0c3                     cpy #$c3    ;test result
                                trap_ne
13cd : d0fe            >        bne *           ;failed not equal (non zero)
                        
13cf : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
13d0 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
13d2 : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
13d5 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
13d7 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
13d9 : 48              >            pha         ;use stack to load status
13da : 28              >            plp
                        
13db : a40c                     ldy zp1+1
13dd : 08                       php         ;test stores do not alter flags
13de : 98                       tya
13df : 49c3                     eor #$c3
13e1 : a8                       tay
13e2 : 28                       plp
13e3 : 8c0402                   sty abst+1
13e6 : 08                       php         ;flags after load/store sequence
13e7 : 49c3                     eor #$c3
13e9 : a8                       tay
13ea : c082                     cpy #$82   ;test result
                                trap_ne
13ec : d0fe            >        bne *           ;failed not equal (non zero)
                        
13ee : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
13ef : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
13f1 : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
13f4 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
13f6 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
13f8 : 48              >            pha         ;use stack to load status
13f9 : 28              >            plp
                        
13fa : a40d                     ldy zp1+2
13fc : 08                       php         ;test stores do not alter flags
13fd : 98                       tya
13fe : 49c3                     eor #$c3
1400 : a8                       tay
1401 : 28                       plp
1402 : 8c0502                   sty abst+2
1405 : 08                       php         ;flags after load/store sequence
1406 : 49c3                     eor #$c3
1408 : a8                       tay
1409 : c041                     cpy #$41    ;test result
                                trap_ne
140b : d0fe            >        bne *           ;failed not equal (non zero)
                        
140d : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
140e : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1410 : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
1413 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1415 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1417 : 48              >            pha         ;use stack to load status
1418 : 28              >            plp
                        
1419 : a40e                     ldy zp1+3
141b : 08                       php         ;test stores do not alter flags
141c : 98                       tya
141d : 49c3                     eor #$c3
141f : a8                       tay
1420 : 28                       plp
1421 : 8c0602                   sty abst+3
1424 : 08                       php         ;flags after load/store sequence
1425 : 49c3                     eor #$c3
1427 : a8                       tay
1428 : c000                     cpy #0      ;test result
                                trap_ne
142a : d0fe            >        bne *           ;failed not equal (non zero)
                        
142c : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
142d : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
142f : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
1432 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                
                                set_stat 0
                       >            load_flag 0
1434 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1436 : 48              >            pha         ;use stack to load status
1437 : 28              >            plp
                        
1438 : ac1802                   ldy abs1  
143b : 08                       php         ;test stores do not alter flags
143c : 98                       tya
143d : 49c3                     eor #$c3
143f : a8                       tay
1440 : 28                       plp
1441 : 8402                     sty zpt  
1443 : 08                       php         ;flags after load/store sequence
1444 : 49c3                     eor #$c3
1446 : a8                       tay
1447 : c40b                     cpy zp1     ;test result
                                trap_ne
1449 : d0fe            >        bne *           ;failed not equal (non zero)
                        
144b : 68                       pla         ;load status
                                eor_flag 0
144c : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
144e : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
1451 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1453 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1455 : 48              >            pha         ;use stack to load status
1456 : 28              >            plp
                        
1457 : ac1902                   ldy abs1+1
145a : 08                       php         ;test stores do not alter flags
145b : 98                       tya
145c : 49c3                     eor #$c3
145e : a8                       tay
145f : 28                       plp
1460 : 8403                     sty zpt+1
1462 : 08                       php         ;flags after load/store sequence
1463 : 49c3                     eor #$c3
1465 : a8                       tay
1466 : c40c                     cpy zp1+1   ;test result
                                trap_ne
1468 : d0fe            >        bne *           ;failed not equal (non zero)
                        
146a : 68                       pla         ;load status
                                eor_flag 0
146b : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
146d : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
1470 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1472 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1474 : 48              >            pha         ;use stack to load status
1475 : 28              >            plp
                        
1476 : ac1a02                   ldy abs1+2
1479 : 08                       php         ;test stores do not alter flags
147a : 98                       tya
147b : 49c3                     eor #$c3
147d : a8                       tay
147e : 28                       plp
147f : 8404                     sty zpt+2
1481 : 08                       php         ;flags after load/store sequence
1482 : 49c3                     eor #$c3
1484 : a8                       tay
1485 : c40d                     cpy zp1+2   ;test result
                                trap_ne
1487 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1489 : 68                       pla         ;load status
                                eor_flag 0
148a : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
148c : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
148f : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1491 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1493 : 48              >            pha         ;use stack to load status
1494 : 28              >            plp
                        
1495 : ac1b02                   ldy abs1+3
1498 : 08                       php         ;test stores do not alter flags
1499 : 98                       tya
149a : 49c3                     eor #$c3
149c : a8                       tay
149d : 28                       plp
149e : 8405                     sty zpt+3
14a0 : 08                       php         ;flags after load/store sequence
14a1 : 49c3                     eor #$c3
14a3 : a8                       tay
14a4 : c40e                     cpy zp1+3   ;test result
                                trap_ne
14a6 : d0fe            >        bne *           ;failed not equal (non zero)
                        
14a8 : 68                       pla         ;load status
                                eor_flag 0
14a9 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
14ab : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
14ae : d0fe            >        bne *           ;failed not equal (non zero)
                        
                        
                                set_stat $ff
                       >            load_flag $ff
14b0 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
14b2 : 48              >            pha         ;use stack to load status
14b3 : 28              >            plp
                        
14b4 : ac1802                   ldy abs1  
14b7 : 08                       php         ;test stores do not alter flags
14b8 : 98                       tya
14b9 : 49c3                     eor #$c3
14bb : a8                       tay
14bc : 28                       plp
14bd : 8402                     sty zpt  
14bf : 08                       php         ;flags after load/store sequence
14c0 : 49c3                     eor #$c3
14c2 : a8                       tay
14c3 : c50b                     cmp zp1     ;test result
                                trap_ne
14c5 : d0fe            >        bne *           ;failed not equal (non zero)
                        
14c7 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
14c8 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
14ca : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
14cd : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $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 : 28              >            plp
                        
14d3 : ac1902                   ldy abs1+1
14d6 : 08                       php         ;test stores do not alter flags
14d7 : 98                       tya
14d8 : 49c3                     eor #$c3
14da : a8                       tay
14db : 28                       plp
14dc : 8403                     sty zpt+1
14de : 08                       php         ;flags after load/store sequence
14df : 49c3                     eor #$c3
14e1 : a8                       tay
14e2 : c50c                     cmp zp1+1   ;test result
                                trap_ne
14e4 : d0fe            >        bne *           ;failed not equal (non zero)
                        
14e6 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
14e7 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
14e9 : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
14ec : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
14ee : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
14f0 : 48              >            pha         ;use stack to load status
14f1 : 28              >            plp
                        
14f2 : ac1a02                   ldy abs1+2
14f5 : 08                       php         ;test stores do not alter flags
14f6 : 98                       tya
14f7 : 49c3                     eor #$c3
14f9 : a8                       tay
14fa : 28                       plp
14fb : 8404                     sty zpt+2
14fd : 08                       php         ;flags after load/store sequence
14fe : 49c3                     eor #$c3
1500 : a8                       tay
1501 : c50d                     cmp zp1+2   ;test result
                                trap_ne
1503 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1505 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1506 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1508 : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
150b : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
150d : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
150f : 48              >            pha         ;use stack to load status
1510 : 28              >            plp
                        
1511 : ac1b02                   ldy abs1+3
1514 : 08                       php         ;test stores do not alter flags
1515 : 98                       tya
1516 : 49c3                     eor #$c3
1518 : a8                       tay
1519 : 28                       plp
151a : 8405                     sty zpt+3
151c : 08                       php         ;flags after load/store sequence
151d : 49c3                     eor #$c3
151f : a8                       tay
1520 : c50e                     cmp zp1+3   ;test result
                                trap_ne
1522 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1524 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1525 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1527 : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
152a : d0fe            >        bne *           ;failed not equal (non zero)
                        
                        
                        
                                set_stat 0
                       >            load_flag 0
152c : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
152e : 48              >            pha         ;use stack to load status
152f : 28              >            plp
                        
1530 : a0c3                     ldy #$c3  
1532 : 08                       php
1533 : cc1802                   cpy abs1    ;test result
                                trap_ne
1536 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1538 : 68                       pla         ;load status
                                eor_flag 0
1539 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
153b : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
153e : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1540 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1542 : 48              >            pha         ;use stack to load status
1543 : 28              >            plp
                        
1544 : a082                     ldy #$82
1546 : 08                       php
1547 : cc1902                   cpy abs1+1  ;test result
                                trap_ne
154a : d0fe            >        bne *           ;failed not equal (non zero)
                        
154c : 68                       pla         ;load status
                                eor_flag 0
154d : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
154f : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
1552 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1554 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1556 : 48              >            pha         ;use stack to load status
1557 : 28              >            plp
                        
1558 : a041                     ldy #$41
155a : 08                       php
155b : cc1a02                   cpy abs1+2  ;test result
                                trap_ne
155e : d0fe            >        bne *           ;failed not equal (non zero)
                        
1560 : 68                       pla         ;load status
                                eor_flag 0
1561 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1563 : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
1566 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1568 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
156a : 48              >            pha         ;use stack to load status
156b : 28              >            plp
                        
156c : a000                     ldy #0
156e : 08                       php
156f : cc1b02                   cpy abs1+3  ;test result
                                trap_ne
1572 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1574 : 68                       pla         ;load status
                                eor_flag 0
1575 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1577 : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
157a : d0fe            >        bne *           ;failed not equal (non zero)
                        
                        
                                set_stat $ff
                       >            load_flag $ff
157c : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
157e : 48              >            pha         ;use stack to load status
157f : 28              >            plp
                        
1580 : a0c3                     ldy #$c3  
1582 : 08                       php
1583 : cc1802                   cpy abs1    ;test result
                                trap_ne
1586 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1588 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1589 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
158b : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
158e : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1590 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1592 : 48              >            pha         ;use stack to load status
1593 : 28              >            plp
                        
1594 : a082                     ldy #$82
1596 : 08                       php
1597 : cc1902                   cpy abs1+1  ;test result
                                trap_ne
159a : d0fe            >        bne *           ;failed not equal (non zero)
                        
159c : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
159d : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
159f : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
15a2 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
15a4 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
15a6 : 48              >            pha         ;use stack to load status
15a7 : 28              >            plp
                        
15a8 : a041                     ldy #$41
15aa : 08                       php
15ab : cc1a02                   cpy abs1+2   ;test result
                                trap_ne
15ae : d0fe            >        bne *           ;failed not equal (non zero)
                        
15b0 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
15b1 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
15b3 : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
15b6 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
15b8 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
15ba : 48              >            pha         ;use stack to load status
15bb : 28              >            plp
                        
15bc : a000                     ldy #0
15be : 08                       php
15bf : cc1b02                   cpy abs1+3  ;test result
                                trap_ne
15c2 : d0fe            >        bne *           ;failed not equal (non zero)
                        
15c4 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
15c5 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
15c7 : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
15ca : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                
15cc : a000                     ldy #0
15ce : a502                     lda zpt  
15d0 : 49c3                     eor #$c3
15d2 : c50b                     cmp zp1  
                                trap_ne     ;store to zp   data
15d4 : d0fe            >        bne *           ;failed not equal (non zero)
                        
15d6 : 8402                     sty zpt     ;clear                
15d8 : ad0302                   lda abst  
15db : 49c3                     eor #$c3
15dd : cd1802                   cmp abs1  
                                trap_ne     ;store to abs   data
15e0 : d0fe            >        bne *           ;failed not equal (non zero)
                        
15e2 : 8c0302                   sty abst    ;clear                
15e5 : a503                     lda zpt+1
15e7 : 49c3                     eor #$c3
15e9 : c50c                     cmp zp1+1
                                trap_ne     ;store to zp+1 data
15eb : d0fe            >        bne *           ;failed not equal (non zero)
                        
15ed : 8403                     sty zpt+1   ;clear                
15ef : ad0402                   lda abst+1
15f2 : 49c3                     eor #$c3
15f4 : cd1902                   cmp abs1+1
                                trap_ne     ;store to abs+1 data
15f7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
15f9 : 8c0402                   sty abst+1  ;clear                
15fc : a504                     lda zpt+2
15fe : 49c3                     eor #$c3
1600 : c50d                     cmp zp1+2
                                trap_ne     ;store to zp+2 data
1602 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1604 : 8404                     sty zpt+2   ;clear                
1606 : ad0502                   lda abst+2
1609 : 49c3                     eor #$c3
160b : cd1a02                   cmp abs1+2
                                trap_ne     ;store to abs+2 data
160e : d0fe            >        bne *           ;failed not equal (non zero)
                        
1610 : 8c0502                   sty abst+2  ;clear                
1613 : a505                     lda zpt+3
1615 : 49c3                     eor #$c3
1617 : c50e                     cmp zp1+3
                                trap_ne     ;store to zp+3 data
1619 : d0fe            >        bne *           ;failed not equal (non zero)
                        
161b : 8405                     sty zpt+3   ;clear                
161d : ad0602                   lda abst+3
1620 : 49c3                     eor #$c3
1622 : cd1b02                   cmp abs1+3
                                trap_ne     ;store to abs+3 data
1625 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1627 : 8c0602                   sty abst+3  ;clear                
                                next_test
162a : ad0002          >            lda test_case   ;previous test
162d : c914            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
162f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0015 =                 >test_num = test_num + 1
1631 : a915            >            lda #test_num   ;*** next tests' number
1633 : 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
1636 : a203                     ldx #3
1638 :                  tldax    
                                set_stat 0
                       >            load_flag 0
1638 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
163a : 48              >            pha         ;use stack to load status
163b : 28              >            plp
                        
163c : b50b                     lda zp1,x
163e : 08                       php         ;test stores do not alter flags
163f : 49c3                     eor #$c3
1641 : 28                       plp
1642 : 9d0302                   sta abst,x
1645 : 08                       php         ;flags after load/store sequence
1646 : 49c3                     eor #$c3
1648 : dd1802                   cmp abs1,x  ;test result
                                trap_ne
164b : d0fe            >        bne *           ;failed not equal (non zero)
                        
164d : 68                       pla         ;load status
                                eor_flag 0
164e : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1650 : dd1d02                   cmp fLDx,x  ;test flags
                                trap_ne
1653 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1655 : ca                       dex
1656 : 10e0                     bpl tldax                  
                        
1658 : a203                     ldx #3
165a :                  tldax1   
                                set_stat $ff
                       >            load_flag $ff
165a : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
165c : 48              >            pha         ;use stack to load status
165d : 28              >            plp
                        
165e : b50b                     lda zp1,x
1660 : 08                       php         ;test stores do not alter flags
1661 : 49c3                     eor #$c3
1663 : 28                       plp
1664 : 9d0302                   sta abst,x
1667 : 08                       php         ;flags after load/store sequence
1668 : 49c3                     eor #$c3
166a : dd1802                   cmp abs1,x   ;test result
                                trap_ne
166d : d0fe            >        bne *           ;failed not equal (non zero)
                        
166f : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1670 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1672 : dd1d02                   cmp fLDx,x  ;test flags
                                trap_ne
1675 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1677 : ca                       dex
1678 : 10e0                     bpl tldax1                  
                        
167a : a203                     ldx #3
167c :                  tldax2   
                                set_stat 0
                       >            load_flag 0
167c : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
167e : 48              >            pha         ;use stack to load status
167f : 28              >            plp
                        
1680 : bd1802                   lda abs1,x
1683 : 08                       php         ;test stores do not alter flags
1684 : 49c3                     eor #$c3
1686 : 28                       plp
1687 : 9502                     sta zpt,x
1689 : 08                       php         ;flags after load/store sequence
168a : 49c3                     eor #$c3
168c : d50b                     cmp zp1,x   ;test result
                                trap_ne
168e : d0fe            >        bne *           ;failed not equal (non zero)
                        
1690 : 68                       pla         ;load status
                                eor_flag 0
1691 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1693 : dd1d02                   cmp fLDx,x  ;test flags
                                trap_ne
1696 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1698 : ca                       dex
1699 : 10e1                     bpl tldax2                  
                        
169b : a203                     ldx #3
169d :                  tldax3
                                set_stat $ff
                       >            load_flag $ff
169d : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
169f : 48              >            pha         ;use stack to load status
16a0 : 28              >            plp
                        
16a1 : bd1802                   lda abs1,x
16a4 : 08                       php         ;test stores do not alter flags
16a5 : 49c3                     eor #$c3
16a7 : 28                       plp
16a8 : 9502                     sta zpt,x
16aa : 08                       php         ;flags after load/store sequence
16ab : 49c3                     eor #$c3
16ad : d50b                     cmp zp1,x   ;test result
                                trap_ne
16af : d0fe            >        bne *           ;failed not equal (non zero)
                        
16b1 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
16b2 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
16b4 : dd1d02                   cmp fLDx,x  ;test flags
                                trap_ne
16b7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
16b9 : ca                       dex
16ba : 10e1                     bpl tldax3
                        
16bc : a203                     ldx #3      ;testing store result
16be : a000                     ldy #0
16c0 : b502             tstax   lda zpt,x
16c2 : 49c3                     eor #$c3
16c4 : d50b                     cmp zp1,x
                                trap_ne     ;store to zp,x data
16c6 : d0fe            >        bne *           ;failed not equal (non zero)
                        
16c8 : 9402                     sty zpt,x   ;clear                
16ca : bd0302                   lda abst,x
16cd : 49c3                     eor #$c3
16cf : dd1802                   cmp abs1,x
                                trap_ne     ;store to abs,x data
16d2 : d0fe            >        bne *           ;failed not equal (non zero)
                        
16d4 : 8a                       txa
16d5 : 9d0302                   sta abst,x  ;clear                
16d8 : ca                       dex
16d9 : 10e5                     bpl tstax
                                next_test
16db : ad0002          >            lda test_case   ;previous test
16de : c915            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
16e0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0016 =                 >test_num = test_num + 1
16e2 : a916            >            lda #test_num   ;*** next tests' number
16e4 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; LDA / STA - (zp),y / abs,y / (zp,x)
16e7 : a003                     ldy #3
16e9 :                  tlday    
                                set_stat 0
                       >            load_flag 0
16e9 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
16eb : 48              >            pha         ;use stack to load status
16ec : 28              >            plp
                        
16ed : b11c                     lda (ind1),y
16ef : 08                       php         ;test stores do not alter flags
16f0 : 49c3                     eor #$c3
16f2 : 28                       plp
16f3 : 990302                   sta abst,y
16f6 : 08                       php         ;flags after load/store sequence
16f7 : 49c3                     eor #$c3
16f9 : d91802                   cmp abs1,y  ;test result
                                trap_ne
16fc : d0fe            >        bne *           ;failed not equal (non zero)
                        
16fe : 68                       pla         ;load status
                                eor_flag 0
16ff : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1701 : d91d02                   cmp fLDx,y  ;test flags
                                trap_ne
1704 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1706 : 88                       dey
1707 : 10e0                     bpl tlday                  
                        
1709 : a003                     ldy #3
170b :                  tlday1   
                                set_stat $ff
                       >            load_flag $ff
170b : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
170d : 48              >            pha         ;use stack to load status
170e : 28              >            plp
                        
170f : b11c                     lda (ind1),y
1711 : 08                       php         ;test stores do not alter flags
1712 : 49c3                     eor #$c3
1714 : 28                       plp
1715 : 990302                   sta abst,y
1718 : 08                       php         ;flags after load/store sequence
1719 : 49c3                     eor #$c3
171b : d91802                   cmp abs1,y  ;test result
                                trap_ne
171e : d0fe            >        bne *           ;failed not equal (non zero)
                        
1720 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1721 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1723 : d91d02                   cmp fLDx,y  ;test flags
                                trap_ne
1726 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1728 : 88                       dey
1729 : 10e0                     bpl tlday1                  
                        
172b : a003                     ldy #3      ;testing store result
172d : a200                     ldx #0
172f : b90302           tstay   lda abst,y
1732 : 49c3                     eor #$c3
1734 : d91802                   cmp abs1,y
                                trap_ne     ;store to abs data
1737 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1739 : 8a                       txa
173a : 990302                   sta abst,y  ;clear                
173d : 88                       dey
173e : 10ef                     bpl tstay
                        
1740 : a003                     ldy #3
1742 :                  tlday2   
                                set_stat 0
                       >            load_flag 0
1742 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1744 : 48              >            pha         ;use stack to load status
1745 : 28              >            plp
                        
1746 : b91802                   lda abs1,y
1749 : 08                       php         ;test stores do not alter flags
174a : 49c3                     eor #$c3
174c : 28                       plp
174d : 9128                     sta (indt),y
174f : 08                       php         ;flags after load/store sequence
1750 : 49c3                     eor #$c3
1752 : d11c                     cmp (ind1),y    ;test result
                                trap_ne
1754 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1756 : 68                       pla         ;load status
                                eor_flag 0
1757 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1759 : d91d02                   cmp fLDx,y  ;test flags
                                trap_ne
175c : d0fe            >        bne *           ;failed not equal (non zero)
                        
175e : 88                       dey
175f : 10e1                     bpl tlday2                  
                        
1761 : a003                     ldy #3
1763 :                  tlday3   
                                set_stat $ff
                       >            load_flag $ff
1763 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1765 : 48              >            pha         ;use stack to load status
1766 : 28              >            plp
                        
1767 : b91802                   lda abs1,y
176a : 08                       php         ;test stores do not alter flags
176b : 49c3                     eor #$c3
176d : 28                       plp
176e : 9128                     sta (indt),y
1770 : 08                       php         ;flags after load/store sequence
1771 : 49c3                     eor #$c3
1773 : d11c                     cmp (ind1),y   ;test result
                                trap_ne
1775 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1777 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1778 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
177a : d91d02                   cmp fLDx,y  ;test flags
                                trap_ne
177d : d0fe            >        bne *           ;failed not equal (non zero)
                        
177f : 88                       dey
1780 : 10e1                     bpl tlday3
                                
1782 : a003                     ldy #3      ;testing store result
1784 : a200                     ldx #0
1786 : b90302           tstay1  lda abst,y
1789 : 49c3                     eor #$c3
178b : d91802                   cmp abs1,y
                                trap_ne     ;store to abs data
178e : d0fe            >        bne *           ;failed not equal (non zero)
                        
1790 : 8a                       txa
1791 : 990302                   sta abst,y  ;clear                
1794 : 88                       dey
1795 : 10ef                     bpl tstay1
                                
1797 : a206                     ldx #6
1799 : a003                     ldy #3
179b :                  tldax4   
                                set_stat 0
                       >            load_flag 0
179b : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
179d : 48              >            pha         ;use stack to load status
179e : 28              >            plp
                        
179f : a11c                     lda (ind1,x)
17a1 : 08                       php         ;test stores do not alter flags
17a2 : 49c3                     eor #$c3
17a4 : 28                       plp
17a5 : 8128                     sta (indt,x)
17a7 : 08                       php         ;flags after load/store sequence
17a8 : 49c3                     eor #$c3
17aa : d91802                   cmp abs1,y  ;test result
                                trap_ne
17ad : d0fe            >        bne *           ;failed not equal (non zero)
                        
17af : 68                       pla         ;load status
                                eor_flag 0
17b0 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
17b2 : d91d02                   cmp fLDx,y  ;test flags
                                trap_ne
17b5 : d0fe            >        bne *           ;failed not equal (non zero)
                        
17b7 : ca                       dex
17b8 : ca                       dex
17b9 : 88                       dey
17ba : 10df                     bpl tldax4                  
                        
17bc : a206                     ldx #6
17be : a003                     ldy #3
17c0 :                  tldax5
                                set_stat $ff
                       >            load_flag $ff
17c0 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
17c2 : 48              >            pha         ;use stack to load status
17c3 : 28              >            plp
                        
17c4 : a11c                     lda (ind1,x)
17c6 : 08                       php         ;test stores do not alter flags
17c7 : 49c3                     eor #$c3
17c9 : 28                       plp
17ca : 8128                     sta (indt,x)
17cc : 08                       php         ;flags after load/store sequence
17cd : 49c3                     eor #$c3
17cf : d91802                   cmp abs1,y  ;test result
                                trap_ne
17d2 : d0fe            >        bne *           ;failed not equal (non zero)
                        
17d4 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
17d5 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
17d7 : d91d02                   cmp fLDx,y  ;test flags
                                trap_ne
17da : d0fe            >        bne *           ;failed not equal (non zero)
                        
17dc : ca                       dex
17dd : ca                       dex
17de : 88                       dey
17df : 10df                     bpl tldax5
                        
17e1 : a003                     ldy #3      ;testing store result
17e3 : a200                     ldx #0
17e5 : b90302           tstay2  lda abst,y
17e8 : 49c3                     eor #$c3
17ea : d91802                   cmp abs1,y
                                trap_ne     ;store to abs data
17ed : d0fe            >        bne *           ;failed not equal (non zero)
                        
17ef : 8a                       txa
17f0 : 990302                   sta abst,y  ;clear                
17f3 : 88                       dey
17f4 : 10ef                     bpl tstay2
                                next_test
17f6 : ad0002          >            lda test_case   ;previous test
17f9 : c916            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
17fb : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0017 =                 >test_num = test_num + 1
17fd : a917            >            lda #test_num   ;*** next tests' number
17ff : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; indexed wraparound test (only zp should wrap)
1802 : a2fd                     ldx #3+$fa
1804 : b511             tldax6  lda zp1-$fa&$ff,x   ;wrap on indexed zp
1806 : 9d0901                   sta abst-$fa,x      ;no STX abs,x!
1809 : ca                       dex
180a : e0fa                     cpx #$fa
180c : b0f6                     bcs tldax6                  
180e : a2fd                     ldx #3+$fa
1810 : bd1e01           tldax7  lda abs1-$fa,x      ;no wrap on indexed abs
1813 : 9508                     sta zpt-$fa&$ff,x
1815 : ca                       dex
1816 : e0fa                     cpx #$fa
1818 : b0f6                     bcs tldax7
                                                  
181a : a203                     ldx #3      ;testing wraparound result
181c : a000                     ldy #0
181e : b502             tstax1  lda zpt,x
1820 : d50b                     cmp zp1,x
                                trap_ne     ;store to zp,x data
1822 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1824 : 9402                     sty zpt,x   ;clear                
1826 : bd0302                   lda abst,x
1829 : dd1802                   cmp abs1,x
                                trap_ne     ;store to abs,x data
182c : d0fe            >        bne *           ;failed not equal (non zero)
                        
182e : 8a                       txa
182f : 9d0302                   sta abst,x  ;clear                
1832 : ca                       dex
1833 : 10e9                     bpl tstax1
                        
1835 : a0fb                     ldy #3+$f8
1837 : a2fe                     ldx #6+$f8
1839 : a124             tlday4  lda (ind1-$f8&$ff,x) ;wrap on indexed zp indirect
183b : 990b01                   sta abst-$f8,y
183e : ca                       dex
183f : ca                       dex
1840 : 88                       dey
1841 : c0f8                     cpy #$f8
1843 : b0f4                     bcs tlday4
1845 : a003                     ldy #3      ;testing wraparound result
1847 : a200                     ldx #0
1849 : b90302           tstay4  lda abst,y
184c : d91802                   cmp abs1,y
                                trap_ne     ;store to abs data
184f : d0fe            >        bne *           ;failed not equal (non zero)
                        
1851 : 8a                       txa
1852 : 990302                   sta abst,y  ;clear                
1855 : 88                       dey
1856 : 10f1                     bpl tstay4
                                
1858 : a0fb                     ldy #3+$f8
185a : b92001           tlday5  lda abs1-$f8,y  ;no wrap on indexed abs
185d : 9130                     sta (inwt),y
185f : 88                       dey
1860 : c0f8                     cpy #$f8
1862 : b0f6                     bcs tlday5                  
1864 : a003                     ldy #3      ;testing wraparound result
1866 : a200                     ldx #0
1868 : b90302           tstay5  lda abst,y
186b : d91802                   cmp abs1,y
                                trap_ne     ;store to abs data
186e : d0fe            >        bne *           ;failed not equal (non zero)
                        
1870 : 8a                       txa
1871 : 990302                   sta abst,y  ;clear                
1874 : 88                       dey
1875 : 10f1                     bpl tstay5
                        
1877 : a0fb                     ldy #3+$f8
1879 : a2fe                     ldx #6+$f8
187b : b126             tlday6  lda (inw1),y    ;no wrap on zp indirect indexed 
187d : 8130                     sta (indt-$f8&$ff,x)
187f : ca                       dex
1880 : ca                       dex
1881 : 88                       dey
1882 : c0f8                     cpy #$f8
1884 : b0f5                     bcs tlday6
1886 : a003                     ldy #3      ;testing wraparound result
1888 : a200                     ldx #0
188a : b90302           tstay6  lda abst,y
188d : d91802                   cmp abs1,y
                                trap_ne     ;store to abs data
1890 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1892 : 8a                       txa
1893 : 990302                   sta abst,y  ;clear                
1896 : 88                       dey
1897 : 10f1                     bpl tstay6
                                next_test
1899 : ad0002          >            lda test_case   ;previous test
189c : c917            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
189e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0018 =                 >test_num = test_num + 1
18a0 : a918            >            lda #test_num   ;*** next tests' number
18a2 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; LDA / STA - zp / abs / #
                                set_stat 0  
                       >            load_flag 0  
18a5 : a900            >            lda #0               ;allow test to change I-flag (no mask)
                       >
18a7 : 48              >            pha         ;use stack to load status
18a8 : 28              >            plp
                        
18a9 : a50b                     lda zp1
18ab : 08                       php         ;test stores do not alter flags
18ac : 49c3                     eor #$c3
18ae : 28                       plp
18af : 8d0302                   sta abst
18b2 : 08                       php         ;flags after load/store sequence
18b3 : 49c3                     eor #$c3
18b5 : c9c3                     cmp #$c3    ;test result
                                trap_ne
18b7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
18b9 : 68                       pla         ;load status
                                eor_flag 0
18ba : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
18bc : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
18bf : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
18c1 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
18c3 : 48              >            pha         ;use stack to load status
18c4 : 28              >            plp
                        
18c5 : a50c                     lda zp1+1
18c7 : 08                       php         ;test stores do not alter flags
18c8 : 49c3                     eor #$c3
18ca : 28                       plp
18cb : 8d0402                   sta abst+1
18ce : 08                       php         ;flags after load/store sequence
18cf : 49c3                     eor #$c3
18d1 : c982                     cmp #$82    ;test result
                                trap_ne
18d3 : d0fe            >        bne *           ;failed not equal (non zero)
                        
18d5 : 68                       pla         ;load status
                                eor_flag 0
18d6 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
18d8 : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
18db : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
18dd : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
18df : 48              >            pha         ;use stack to load status
18e0 : 28              >            plp
                        
18e1 : a50d                     lda zp1+2
18e3 : 08                       php         ;test stores do not alter flags
18e4 : 49c3                     eor #$c3
18e6 : 28                       plp
18e7 : 8d0502                   sta abst+2
18ea : 08                       php         ;flags after load/store sequence
18eb : 49c3                     eor #$c3
18ed : c941                     cmp #$41    ;test result
                                trap_ne
18ef : d0fe            >        bne *           ;failed not equal (non zero)
                        
18f1 : 68                       pla         ;load status
                                eor_flag 0
18f2 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
18f4 : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
18f7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
18f9 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
18fb : 48              >            pha         ;use stack to load status
18fc : 28              >            plp
                        
18fd : a50e                     lda zp1+3
18ff : 08                       php         ;test stores do not alter flags
1900 : 49c3                     eor #$c3
1902 : 28                       plp
1903 : 8d0602                   sta abst+3
1906 : 08                       php         ;flags after load/store sequence
1907 : 49c3                     eor #$c3
1909 : c900                     cmp #0      ;test result
                                trap_ne
190b : d0fe            >        bne *           ;failed not equal (non zero)
                        
190d : 68                       pla         ;load status
                                eor_flag 0
190e : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1910 : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
1913 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1915 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1917 : 48              >            pha         ;use stack to load status
1918 : 28              >            plp
                        
1919 : a50b                     lda zp1  
191b : 08                       php         ;test stores do not alter flags
191c : 49c3                     eor #$c3
191e : 28                       plp
191f : 8d0302                   sta abst  
1922 : 08                       php         ;flags after load/store sequence
1923 : 49c3                     eor #$c3
1925 : c9c3                     cmp #$c3    ;test result
                                trap_ne
1927 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1929 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
192a : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
192c : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
192f : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1931 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1933 : 48              >            pha         ;use stack to load status
1934 : 28              >            plp
                        
1935 : a50c                     lda zp1+1
1937 : 08                       php         ;test stores do not alter flags
1938 : 49c3                     eor #$c3
193a : 28                       plp
193b : 8d0402                   sta abst+1
193e : 08                       php         ;flags after load/store sequence
193f : 49c3                     eor #$c3
1941 : c982                     cmp #$82    ;test result
                                trap_ne
1943 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1945 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1946 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1948 : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
194b : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
194d : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
194f : 48              >            pha         ;use stack to load status
1950 : 28              >            plp
                        
1951 : a50d                     lda zp1+2
1953 : 08                       php         ;test stores do not alter flags
1954 : 49c3                     eor #$c3
1956 : 28                       plp
1957 : 8d0502                   sta abst+2
195a : 08                       php         ;flags after load/store sequence
195b : 49c3                     eor #$c3
195d : c941                     cmp #$41    ;test result
                                trap_ne
195f : d0fe            >        bne *           ;failed not equal (non zero)
                        
1961 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1962 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1964 : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
1967 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1969 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
196b : 48              >            pha         ;use stack to load status
196c : 28              >            plp
                        
196d : a50e                     lda zp1+3
196f : 08                       php         ;test stores do not alter flags
1970 : 49c3                     eor #$c3
1972 : 28                       plp
1973 : 8d0602                   sta abst+3
1976 : 08                       php         ;flags after load/store sequence
1977 : 49c3                     eor #$c3
1979 : c900                     cmp #0      ;test result
                                trap_ne
197b : d0fe            >        bne *           ;failed not equal (non zero)
                        
197d : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
197e : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1980 : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
1983 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1985 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1987 : 48              >            pha         ;use stack to load status
1988 : 28              >            plp
                        
1989 : ad1802                   lda abs1  
198c : 08                       php         ;test stores do not alter flags
198d : 49c3                     eor #$c3
198f : 28                       plp
1990 : 8502                     sta zpt  
1992 : 08                       php         ;flags after load/store sequence
1993 : 49c3                     eor #$c3
1995 : c50b                     cmp zp1     ;test result
                                trap_ne
1997 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1999 : 68                       pla         ;load status
                                eor_flag 0
199a : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
199c : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
199f : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
19a1 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
19a3 : 48              >            pha         ;use stack to load status
19a4 : 28              >            plp
                        
19a5 : ad1902                   lda abs1+1
19a8 : 08                       php         ;test stores do not alter flags
19a9 : 49c3                     eor #$c3
19ab : 28                       plp
19ac : 8503                     sta zpt+1
19ae : 08                       php         ;flags after load/store sequence
19af : 49c3                     eor #$c3
19b1 : c50c                     cmp zp1+1   ;test result
                                trap_ne
19b3 : d0fe            >        bne *           ;failed not equal (non zero)
                        
19b5 : 68                       pla         ;load status
                                eor_flag 0
19b6 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
19b8 : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
19bb : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
19bd : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
19bf : 48              >            pha         ;use stack to load status
19c0 : 28              >            plp
                        
19c1 : ad1a02                   lda abs1+2
19c4 : 08                       php         ;test stores do not alter flags
19c5 : 49c3                     eor #$c3
19c7 : 28                       plp
19c8 : 8504                     sta zpt+2
19ca : 08                       php         ;flags after load/store sequence
19cb : 49c3                     eor #$c3
19cd : c50d                     cmp zp1+2   ;test result
                                trap_ne
19cf : d0fe            >        bne *           ;failed not equal (non zero)
                        
19d1 : 68                       pla         ;load status
                                eor_flag 0
19d2 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
19d4 : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
19d7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
19d9 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
19db : 48              >            pha         ;use stack to load status
19dc : 28              >            plp
                        
19dd : ad1b02                   lda abs1+3
19e0 : 08                       php         ;test stores do not alter flags
19e1 : 49c3                     eor #$c3
19e3 : 28                       plp
19e4 : 8505                     sta zpt+3
19e6 : 08                       php         ;flags after load/store sequence
19e7 : 49c3                     eor #$c3
19e9 : c50e                     cmp zp1+3   ;test result
                                trap_ne
19eb : d0fe            >        bne *           ;failed not equal (non zero)
                        
19ed : 68                       pla         ;load status
                                eor_flag 0
19ee : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
19f0 : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
19f3 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
19f5 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
19f7 : 48              >            pha         ;use stack to load status
19f8 : 28              >            plp
                        
19f9 : ad1802                   lda abs1  
19fc : 08                       php         ;test stores do not alter flags
19fd : 49c3                     eor #$c3
19ff : 28                       plp
1a00 : 8502                     sta zpt  
1a02 : 08                       php         ;flags after load/store sequence
1a03 : 49c3                     eor #$c3
1a05 : c50b                     cmp zp1     ;test result
                                trap_ne
1a07 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1a09 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1a0a : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1a0c : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
1a0f : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1a11 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1a13 : 48              >            pha         ;use stack to load status
1a14 : 28              >            plp
                        
1a15 : ad1902                   lda abs1+1
1a18 : 08                       php         ;test stores do not alter flags
1a19 : 49c3                     eor #$c3
1a1b : 28                       plp
1a1c : 8503                     sta zpt+1
1a1e : 08                       php         ;flags after load/store sequence
1a1f : 49c3                     eor #$c3
1a21 : c50c                     cmp zp1+1   ;test result
                                trap_ne
1a23 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1a25 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1a26 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1a28 : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
1a2b : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1a2d : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1a2f : 48              >            pha         ;use stack to load status
1a30 : 28              >            plp
                        
1a31 : ad1a02                   lda abs1+2
1a34 : 08                       php         ;test stores do not alter flags
1a35 : 49c3                     eor #$c3
1a37 : 28                       plp
1a38 : 8504                     sta zpt+2
1a3a : 08                       php         ;flags after load/store sequence
1a3b : 49c3                     eor #$c3
1a3d : c50d                     cmp zp1+2   ;test result
                                trap_ne
1a3f : d0fe            >        bne *           ;failed not equal (non zero)
                        
1a41 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1a42 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1a44 : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
1a47 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1a49 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1a4b : 48              >            pha         ;use stack to load status
1a4c : 28              >            plp
                        
1a4d : ad1b02                   lda abs1+3
1a50 : 08                       php         ;test stores do not alter flags
1a51 : 49c3                     eor #$c3
1a53 : 28                       plp
1a54 : 8505                     sta zpt+3
1a56 : 08                       php         ;flags after load/store sequence
1a57 : 49c3                     eor #$c3
1a59 : c50e                     cmp zp1+3   ;test result
                                trap_ne
1a5b : d0fe            >        bne *           ;failed not equal (non zero)
                        
1a5d : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1a5e : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1a60 : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
1a63 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0  
                       >            load_flag 0  
1a65 : a900            >            lda #0               ;allow test to change I-flag (no mask)
                       >
1a67 : 48              >            pha         ;use stack to load status
1a68 : 28              >            plp
                        
1a69 : a9c3                     lda #$c3
1a6b : 08                       php
1a6c : cd1802                   cmp abs1    ;test result
                                trap_ne
1a6f : d0fe            >        bne *           ;failed not equal (non zero)
                        
1a71 : 68                       pla         ;load status
                                eor_flag 0
1a72 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1a74 : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
1a77 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1a79 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1a7b : 48              >            pha         ;use stack to load status
1a7c : 28              >            plp
                        
1a7d : a982                     lda #$82
1a7f : 08                       php
1a80 : cd1902                   cmp abs1+1  ;test result
                                trap_ne
1a83 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1a85 : 68                       pla         ;load status
                                eor_flag 0
1a86 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1a88 : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
1a8b : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1a8d : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1a8f : 48              >            pha         ;use stack to load status
1a90 : 28              >            plp
                        
1a91 : a941                     lda #$41
1a93 : 08                       php
1a94 : cd1a02                   cmp abs1+2  ;test result
                                trap_ne
1a97 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1a99 : 68                       pla         ;load status
                                eor_flag 0
1a9a : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1a9c : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
1a9f : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat 0
                       >            load_flag 0
1aa1 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1aa3 : 48              >            pha         ;use stack to load status
1aa4 : 28              >            plp
                        
1aa5 : a900                     lda #0
1aa7 : 08                       php
1aa8 : cd1b02                   cmp abs1+3  ;test result
                                trap_ne
1aab : d0fe            >        bne *           ;failed not equal (non zero)
                        
1aad : 68                       pla         ;load status
                                eor_flag 0
1aae : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                        
1ab0 : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
1ab3 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                        
                                set_stat $ff
                       >            load_flag $ff
1ab5 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1ab7 : 48              >            pha         ;use stack to load status
1ab8 : 28              >            plp
                        
1ab9 : a9c3                     lda #$c3  
1abb : 08                       php
1abc : cd1802                   cmp abs1    ;test result
                                trap_ne
1abf : d0fe            >        bne *           ;failed not equal (non zero)
                        
1ac1 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1ac2 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1ac4 : cd1d02                   cmp fLDx    ;test flags
                                trap_ne
1ac7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1ac9 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1acb : 48              >            pha         ;use stack to load status
1acc : 28              >            plp
                        
1acd : a982                     lda #$82
1acf : 08                       php
1ad0 : cd1902                   cmp abs1+1  ;test result
                                trap_ne
1ad3 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1ad5 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1ad6 : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1ad8 : cd1e02                   cmp fLDx+1  ;test flags
                                trap_ne
1adb : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1add : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1adf : 48              >            pha         ;use stack to load status
1ae0 : 28              >            plp
                        
1ae1 : a941                     lda #$41
1ae3 : 08                       php
1ae4 : cd1a02                   cmp abs1+2  ;test result
                                trap_ne
1ae7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1ae9 : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1aea : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1aec : cd1f02                   cmp fLDx+2  ;test flags
                                trap_ne
1aef : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
1af1 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1af3 : 48              >            pha         ;use stack to load status
1af4 : 28              >            plp
                        
1af5 : a900                     lda #0
1af7 : 08                       php
1af8 : cd1b02                   cmp abs1+3  ;test result
                                trap_ne
1afb : d0fe            >        bne *           ;failed not equal (non zero)
                        
1afd : 68                       pla         ;load status
                                eor_flag lo~fnz ;mask bits not altered
1afe : 497d            >            eor #lo~fnz |fao         ;invert expected flags + always on bits
                        
1b00 : cd2002                   cmp fLDx+3  ;test flags
                                trap_ne
1b03 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                        
1b05 : a200                     ldx #0
1b07 : a502                     lda zpt  
1b09 : 49c3                     eor #$c3
1b0b : c50b                     cmp zp1  
                                trap_ne     ;store to zp data
1b0d : d0fe            >        bne *           ;failed not equal (non zero)
                        
1b0f : 8602                     stx zpt     ;clear                
1b11 : ad0302                   lda abst  
1b14 : 49c3                     eor #$c3
1b16 : cd1802                   cmp abs1  
                                trap_ne     ;store to abs data
1b19 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1b1b : 8e0302                   stx abst    ;clear                
1b1e : a503                     lda zpt+1
1b20 : 49c3                     eor #$c3
1b22 : c50c                     cmp zp1+1
                                trap_ne     ;store to zp data
1b24 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1b26 : 8603                     stx zpt+1   ;clear                
1b28 : ad0402                   lda abst+1
1b2b : 49c3                     eor #$c3
1b2d : cd1902                   cmp abs1+1
                                trap_ne     ;store to abs data
1b30 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1b32 : 8e0402                   stx abst+1  ;clear                
1b35 : a504                     lda zpt+2
1b37 : 49c3                     eor #$c3
1b39 : c50d                     cmp zp1+2
                                trap_ne     ;store to zp data
1b3b : d0fe            >        bne *           ;failed not equal (non zero)
                        
1b3d : 8604                     stx zpt+2   ;clear                
1b3f : ad0502                   lda abst+2
1b42 : 49c3                     eor #$c3
1b44 : cd1a02                   cmp abs1+2
                                trap_ne     ;store to abs data
1b47 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1b49 : 8e0502                   stx abst+2  ;clear                
1b4c : a505                     lda zpt+3
1b4e : 49c3                     eor #$c3
1b50 : c50e                     cmp zp1+3
                                trap_ne     ;store to zp data
1b52 : d0fe            >        bne *           ;failed not equal (non zero)
                        
1b54 : 8605                     stx zpt+3   ;clear                
1b56 : ad0602                   lda abst+3
1b59 : 49c3                     eor #$c3
1b5b : cd1b02                   cmp abs1+3
                                trap_ne     ;store to abs data
1b5e : d0fe            >        bne *           ;failed not equal (non zero)
                        
1b60 : 8e0602                   stx abst+3  ;clear                
                                next_test
1b63 : ad0002          >            lda test_case   ;previous test
1b66 : c918            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
1b68 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0019 =                 >test_num = test_num + 1
1b6a : a919            >            lda #test_num   ;*** next tests' number
1b6c : 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
1b6f : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1b71 : 48              >            pha         ;use stack to load status
1b72 : a9ff            >            lda #$ff     ;precharge accu
1b74 : 28              >            plp
                        
1b75 : 240e                     bit zp1+3   ;00 - should set Z / clear  NV
                                tst_a $ff,fz 
1b77 : 08              >            php         ;save flags
1b78 : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
1b7a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1b7c : 68              >            pla         ;load status
1b7d : 48              >            pha
                       >            cmp_flag fz 
1b7e : c932            >            cmp #(fz |fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1b80 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1b82 : 28              >            plp         ;restore status
                        
                                set_a 1,0
                       >            load_flag 0
1b83 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1b85 : 48              >            pha         ;use stack to load status
1b86 : a901            >            lda #1     ;precharge accu
1b88 : 28              >            plp
                        
1b89 : 240d                     bit zp1+2   ;41 - should set V (M6) / clear NZ
                                tst_a 1,fv
1b8b : 08              >            php         ;save flags
1b8c : c901            >            cmp #1     ;test result
                       >            trap_ne
1b8e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1b90 : 68              >            pla         ;load status
1b91 : 48              >            pha
                       >            cmp_flag fv
1b92 : c970            >            cmp #(fv|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1b94 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1b96 : 28              >            plp         ;restore status
                        
                                set_a 1,0
                       >            load_flag 0
1b97 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1b99 : 48              >            pha         ;use stack to load status
1b9a : a901            >            lda #1     ;precharge accu
1b9c : 28              >            plp
                        
1b9d : 240c                     bit zp1+1   ;82 - should set N (M7) & Z / clear V
                                tst_a 1,fnz
1b9f : 08              >            php         ;save flags
1ba0 : c901            >            cmp #1     ;test result
                       >            trap_ne
1ba2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1ba4 : 68              >            pla         ;load status
1ba5 : 48              >            pha
                       >            cmp_flag fnz
1ba6 : c9b2            >            cmp #(fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1ba8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1baa : 28              >            plp         ;restore status
                        
                                set_a 1,0
                       >            load_flag 0
1bab : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1bad : 48              >            pha         ;use stack to load status
1bae : a901            >            lda #1     ;precharge accu
1bb0 : 28              >            plp
                        
1bb1 : 240b                     bit zp1     ;c3 - should set N (M7) & V (M6) / clear Z
                                tst_a 1,fnv
1bb3 : 08              >            php         ;save flags
1bb4 : c901            >            cmp #1     ;test result
                       >            trap_ne
1bb6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1bb8 : 68              >            pla         ;load status
1bb9 : 48              >            pha
                       >            cmp_flag fnv
1bba : c9f0            >            cmp #(fnv|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1bbc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1bbe : 28              >            plp         ;restore status
                        
                                
                                set_a $ff,$ff
                       >            load_flag $ff
1bbf : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1bc1 : 48              >            pha         ;use stack to load status
1bc2 : a9ff            >            lda #$ff     ;precharge accu
1bc4 : 28              >            plp
                        
1bc5 : 240e                     bit zp1+3   ;00 - should set Z / clear  NV
                                tst_a $ff,~fnv 
1bc7 : 08              >            php         ;save flags
1bc8 : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
1bca : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1bcc : 68              >            pla         ;load status
1bcd : 48              >            pha
                       >            cmp_flag ~fnv 
1bce : c93f            >            cmp #(~fnv |fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1bd0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1bd2 : 28              >            plp         ;restore status
                        
                                set_a 1,$ff
                       >            load_flag $ff
1bd3 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1bd5 : 48              >            pha         ;use stack to load status
1bd6 : a901            >            lda #1     ;precharge accu
1bd8 : 28              >            plp
                        
1bd9 : 240d                     bit zp1+2   ;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
                        
                                set_a 1,$ff
                       >            load_flag $ff
1be7 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1be9 : 48              >            pha         ;use stack to load status
1bea : a901            >            lda #1     ;precharge accu
1bec : 28              >            plp
                        
1bed : 240c                     bit zp1+1   ;82 - should set N (M7) & Z / clear V
                                tst_a 1,~fv
1bef : 08              >            php         ;save flags
1bf0 : c901            >            cmp #1     ;test result
                       >            trap_ne
1bf2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1bf4 : 68              >            pla         ;load status
1bf5 : 48              >            pha
                       >            cmp_flag ~fv
1bf6 : c9bf            >            cmp #(~fv|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1bf8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1bfa : 28              >            plp         ;restore status
                        
                                set_a 1,$ff
                       >            load_flag $ff
1bfb : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1bfd : 48              >            pha         ;use stack to load status
1bfe : a901            >            lda #1     ;precharge accu
1c00 : 28              >            plp
                        
1c01 : 240b                     bit zp1     ;c3 - should set N (M7) & V (M6) / clear Z
                                tst_a 1,~fz
1c03 : 08              >            php         ;save flags
1c04 : c901            >            cmp #1     ;test result
                       >            trap_ne
1c06 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c08 : 68              >            pla         ;load status
1c09 : 48              >            pha
                       >            cmp_flag ~fz
1c0a : c9fd            >            cmp #(~fz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1c0c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c0e : 28              >            plp         ;restore status
                        
                                
                                set_a $ff,0
                       >            load_flag 0
1c0f : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1c11 : 48              >            pha         ;use stack to load status
1c12 : a9ff            >            lda #$ff     ;precharge accu
1c14 : 28              >            plp
                        
1c15 : 2c1b02                   bit abs1+3  ;00 - should set Z / clear  NV
                                tst_a $ff,fz 
1c18 : 08              >            php         ;save flags
1c19 : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
1c1b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c1d : 68              >            pla         ;load status
1c1e : 48              >            pha
                       >            cmp_flag fz 
1c1f : c932            >            cmp #(fz |fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1c21 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c23 : 28              >            plp         ;restore status
                        
                                set_a 1,0
                       >            load_flag 0
1c24 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1c26 : 48              >            pha         ;use stack to load status
1c27 : a901            >            lda #1     ;precharge accu
1c29 : 28              >            plp
                        
1c2a : 2c1a02                   bit abs1+2  ;41 - should set V (M6) / clear NZ
                                tst_a 1,fv
1c2d : 08              >            php         ;save flags
1c2e : c901            >            cmp #1     ;test result
                       >            trap_ne
1c30 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c32 : 68              >            pla         ;load status
1c33 : 48              >            pha
                       >            cmp_flag fv
1c34 : c970            >            cmp #(fv|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1c36 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c38 : 28              >            plp         ;restore status
                        
                                set_a 1,0
                       >            load_flag 0
1c39 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1c3b : 48              >            pha         ;use stack to load status
1c3c : a901            >            lda #1     ;precharge accu
1c3e : 28              >            plp
                        
1c3f : 2c1902                   bit abs1+1  ;82 - should set N (M7) & Z / clear V
                                tst_a 1,fnz
1c42 : 08              >            php         ;save flags
1c43 : c901            >            cmp #1     ;test result
                       >            trap_ne
1c45 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c47 : 68              >            pla         ;load status
1c48 : 48              >            pha
                       >            cmp_flag fnz
1c49 : c9b2            >            cmp #(fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1c4b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c4d : 28              >            plp         ;restore status
                        
                                set_a 1,0
                       >            load_flag 0
1c4e : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1c50 : 48              >            pha         ;use stack to load status
1c51 : a901            >            lda #1     ;precharge accu
1c53 : 28              >            plp
                        
1c54 : 2c1802                   bit abs1    ;c3 - should set N (M7) & V (M6) / clear Z
                                tst_a 1,fnv
1c57 : 08              >            php         ;save flags
1c58 : c901            >            cmp #1     ;test result
                       >            trap_ne
1c5a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c5c : 68              >            pla         ;load status
1c5d : 48              >            pha
                       >            cmp_flag fnv
1c5e : c9f0            >            cmp #(fnv|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1c60 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c62 : 28              >            plp         ;restore status
                        
                                
                                set_a $ff,$ff
                       >            load_flag $ff
1c63 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1c65 : 48              >            pha         ;use stack to load status
1c66 : a9ff            >            lda #$ff     ;precharge accu
1c68 : 28              >            plp
                        
1c69 : 2c1b02                   bit abs1+3  ;00 - should set Z / clear  NV
                                tst_a $ff,~fnv 
1c6c : 08              >            php         ;save flags
1c6d : c9ff            >            cmp #$ff     ;test result
                       >            trap_ne
1c6f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c71 : 68              >            pla         ;load status
1c72 : 48              >            pha
                       >            cmp_flag ~fnv 
1c73 : c93f            >            cmp #(~fnv |fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1c75 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c77 : 28              >            plp         ;restore status
                        
                                set_a 1,$ff
                       >            load_flag $ff
1c78 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1c7a : 48              >            pha         ;use stack to load status
1c7b : a901            >            lda #1     ;precharge accu
1c7d : 28              >            plp
                        
1c7e : 2c1a02                   bit abs1+2  ;41 - should set V (M6) / clear NZ
                                tst_a 1,~fnz
1c81 : 08              >            php         ;save flags
1c82 : c901            >            cmp #1     ;test result
                       >            trap_ne
1c84 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c86 : 68              >            pla         ;load status
1c87 : 48              >            pha
                       >            cmp_flag ~fnz
1c88 : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1c8a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c8c : 28              >            plp         ;restore status
                        
                                set_a 1,$ff
                       >            load_flag $ff
1c8d : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1c8f : 48              >            pha         ;use stack to load status
1c90 : a901            >            lda #1     ;precharge accu
1c92 : 28              >            plp
                        
1c93 : 2c1902                   bit abs1+1  ;82 - should set N (M7) & Z / clear V
                                tst_a 1,~fv
1c96 : 08              >            php         ;save flags
1c97 : c901            >            cmp #1     ;test result
                       >            trap_ne
1c99 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1c9b : 68              >            pla         ;load status
1c9c : 48              >            pha
                       >            cmp_flag ~fv
1c9d : c9bf            >            cmp #(~fv|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1c9f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1ca1 : 28              >            plp         ;restore status
                        
                                set_a 1,$ff
                       >            load_flag $ff
1ca2 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1ca4 : 48              >            pha         ;use stack to load status
1ca5 : a901            >            lda #1     ;precharge accu
1ca7 : 28              >            plp
                        
1ca8 : 2c1802                   bit abs1    ;c3 - should set N (M7) & V (M6) / clear Z
                                tst_a 1,~fz
1cab : 08              >            php         ;save flags
1cac : c901            >            cmp #1     ;test result
                       >            trap_ne
1cae : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1cb0 : 68              >            pla         ;load status
1cb1 : 48              >            pha
                       >            cmp_flag ~fz
1cb2 : c9fd            >            cmp #(~fz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1cb4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1cb6 : 28              >            plp         ;restore status
                        
                                next_test
1cb7 : ad0002          >            lda test_case   ;previous test
1cba : c919            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
1cbc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
001a =                 >test_num = test_num + 1
1cbe : a91a            >            lda #test_num   ;*** next tests' number
1cc0 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                                
                        ; CPX - zp / abs / #         
                                set_x $80,0
                       >            load_flag 0
1cc3 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1cc5 : 48              >            pha         ;use stack to load status
1cc6 : a280            >            ldx #$80     ;precharge index x
1cc8 : 28              >            plp
                        
1cc9 : e40f                     cpx zp7f
                                tst_stat fc
1ccb : 08              >            php         ;save status
1ccc : 68              >            pla         ;use stack to retrieve status
1ccd : 48              >            pha
                       >            cmp_flag fc
1cce : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1cd0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1cd2 : 28              >            plp         ;restore status
                        
1cd3 : ca                       dex
1cd4 : e40f                     cpx zp7f
                                tst_stat fzc
1cd6 : 08              >            php         ;save status
1cd7 : 68              >            pla         ;use stack to retrieve status
1cd8 : 48              >            pha
                       >            cmp_flag fzc
1cd9 : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1cdb : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1cdd : 28              >            plp         ;restore status
                        
1cde : ca                       dex
1cdf : e40f                     cpx zp7f
                                tst_x $7e,fn
1ce1 : 08              >            php         ;save flags
1ce2 : e07e            >            cpx #$7e     ;test result
                       >            trap_ne
1ce4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1ce6 : 68              >            pla         ;load status
1ce7 : 48              >            pha
                       >            cmp_flag fn
1ce8 : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1cea : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1cec : 28              >            plp         ;restore status
                        
                                set_x $80,$ff
                       >            load_flag $ff
1ced : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1cef : 48              >            pha         ;use stack to load status
1cf0 : a280            >            ldx #$80     ;precharge index x
1cf2 : 28              >            plp
                        
1cf3 : e40f                     cpx zp7f
                                tst_stat ~fnz
1cf5 : 08              >            php         ;save status
1cf6 : 68              >            pla         ;use stack to retrieve status
1cf7 : 48              >            pha
                       >            cmp_flag ~fnz
1cf8 : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1cfa : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1cfc : 28              >            plp         ;restore status
                        
1cfd : ca                       dex
1cfe : e40f                     cpx zp7f
                                tst_stat ~fn
1d00 : 08              >            php         ;save status
1d01 : 68              >            pla         ;use stack to retrieve status
1d02 : 48              >            pha
                       >            cmp_flag ~fn
1d03 : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1d05 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d07 : 28              >            plp         ;restore status
                        
1d08 : ca                       dex
1d09 : e40f                     cpx zp7f
                                tst_x $7e,~fzc
1d0b : 08              >            php         ;save flags
1d0c : e07e            >            cpx #$7e     ;test result
                       >            trap_ne
1d0e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d10 : 68              >            pla         ;load status
1d11 : 48              >            pha
                       >            cmp_flag ~fzc
1d12 : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1d14 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d16 : 28              >            plp         ;restore status
                        
                        
                                set_x $80,0
                       >            load_flag 0
1d17 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1d19 : 48              >            pha         ;use stack to load status
1d1a : a280            >            ldx #$80     ;precharge index x
1d1c : 28              >            plp
                        
1d1d : ec1c02                   cpx abs7f
                                tst_stat fc
1d20 : 08              >            php         ;save status
1d21 : 68              >            pla         ;use stack to retrieve status
1d22 : 48              >            pha
                       >            cmp_flag fc
1d23 : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1d25 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d27 : 28              >            plp         ;restore status
                        
1d28 : ca                       dex
1d29 : ec1c02                   cpx abs7f
                                tst_stat fzc
1d2c : 08              >            php         ;save status
1d2d : 68              >            pla         ;use stack to retrieve status
1d2e : 48              >            pha
                       >            cmp_flag fzc
1d2f : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1d31 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d33 : 28              >            plp         ;restore status
                        
1d34 : ca                       dex
1d35 : ec1c02                   cpx abs7f
                                tst_x $7e,fn
1d38 : 08              >            php         ;save flags
1d39 : e07e            >            cpx #$7e     ;test result
                       >            trap_ne
1d3b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d3d : 68              >            pla         ;load status
1d3e : 48              >            pha
                       >            cmp_flag fn
1d3f : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1d41 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d43 : 28              >            plp         ;restore status
                        
                                set_x $80,$ff
                       >            load_flag $ff
1d44 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1d46 : 48              >            pha         ;use stack to load status
1d47 : a280            >            ldx #$80     ;precharge index x
1d49 : 28              >            plp
                        
1d4a : ec1c02                   cpx abs7f
                                tst_stat ~fnz
1d4d : 08              >            php         ;save status
1d4e : 68              >            pla         ;use stack to retrieve status
1d4f : 48              >            pha
                       >            cmp_flag ~fnz
1d50 : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1d52 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d54 : 28              >            plp         ;restore status
                        
1d55 : ca                       dex
1d56 : ec1c02                   cpx abs7f
                                tst_stat ~fn
1d59 : 08              >            php         ;save status
1d5a : 68              >            pla         ;use stack to retrieve status
1d5b : 48              >            pha
                       >            cmp_flag ~fn
1d5c : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1d5e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d60 : 28              >            plp         ;restore status
                        
1d61 : ca                       dex
1d62 : ec1c02                   cpx abs7f
                                tst_x $7e,~fzc
1d65 : 08              >            php         ;save flags
1d66 : e07e            >            cpx #$7e     ;test result
                       >            trap_ne
1d68 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d6a : 68              >            pla         ;load status
1d6b : 48              >            pha
                       >            cmp_flag ~fzc
1d6c : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1d6e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d70 : 28              >            plp         ;restore status
                        
                        
                                set_x $80,0
                       >            load_flag 0
1d71 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1d73 : 48              >            pha         ;use stack to load status
1d74 : a280            >            ldx #$80     ;precharge index x
1d76 : 28              >            plp
                        
1d77 : e07f                     cpx #$7f
                                tst_stat fc
1d79 : 08              >            php         ;save status
1d7a : 68              >            pla         ;use stack to retrieve status
1d7b : 48              >            pha
                       >            cmp_flag fc
1d7c : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1d7e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d80 : 28              >            plp         ;restore status
                        
1d81 : ca                       dex
1d82 : e07f                     cpx #$7f
                                tst_stat fzc
1d84 : 08              >            php         ;save status
1d85 : 68              >            pla         ;use stack to retrieve status
1d86 : 48              >            pha
                       >            cmp_flag fzc
1d87 : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1d89 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d8b : 28              >            plp         ;restore status
                        
1d8c : ca                       dex
1d8d : e07f                     cpx #$7f
                                tst_x $7e,fn
1d8f : 08              >            php         ;save flags
1d90 : e07e            >            cpx #$7e     ;test result
                       >            trap_ne
1d92 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d94 : 68              >            pla         ;load status
1d95 : 48              >            pha
                       >            cmp_flag fn
1d96 : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1d98 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1d9a : 28              >            plp         ;restore status
                        
                                set_x $80,$ff
                       >            load_flag $ff
1d9b : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1d9d : 48              >            pha         ;use stack to load status
1d9e : a280            >            ldx #$80     ;precharge index x
1da0 : 28              >            plp
                        
1da1 : e07f                     cpx #$7f
                                tst_stat ~fnz
1da3 : 08              >            php         ;save status
1da4 : 68              >            pla         ;use stack to retrieve status
1da5 : 48              >            pha
                       >            cmp_flag ~fnz
1da6 : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1da8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1daa : 28              >            plp         ;restore status
                        
1dab : ca                       dex
1dac : e07f                     cpx #$7f
                                tst_stat ~fn
1dae : 08              >            php         ;save status
1daf : 68              >            pla         ;use stack to retrieve status
1db0 : 48              >            pha
                       >            cmp_flag ~fn
1db1 : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1db3 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1db5 : 28              >            plp         ;restore status
                        
1db6 : ca                       dex
1db7 : e07f                     cpx #$7f
                                tst_x $7e,~fzc
1db9 : 08              >            php         ;save flags
1dba : e07e            >            cpx #$7e     ;test result
                       >            trap_ne
1dbc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1dbe : 68              >            pla         ;load status
1dbf : 48              >            pha
                       >            cmp_flag ~fzc
1dc0 : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1dc2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1dc4 : 28              >            plp         ;restore status
                        
                                next_test
1dc5 : ad0002          >            lda test_case   ;previous test
1dc8 : c91a            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
1dca : d0fe            >        bne *           ;failed not equal (non zero)
                       >
001b =                 >test_num = test_num + 1
1dcc : a91b            >            lda #test_num   ;*** next tests' number
1dce : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; CPY - zp / abs / #         
                                set_y $80,0
                       >            load_flag 0
1dd1 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1dd3 : 48              >            pha         ;use stack to load status
1dd4 : a080            >            ldy #$80     ;precharge index y
1dd6 : 28              >            plp
                        
1dd7 : c40f                     cpy zp7f
                                tst_stat fc
1dd9 : 08              >            php         ;save status
1dda : 68              >            pla         ;use stack to retrieve status
1ddb : 48              >            pha
                       >            cmp_flag fc
1ddc : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1dde : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1de0 : 28              >            plp         ;restore status
                        
1de1 : 88                       dey
1de2 : c40f                     cpy zp7f
                                tst_stat fzc
1de4 : 08              >            php         ;save status
1de5 : 68              >            pla         ;use stack to retrieve status
1de6 : 48              >            pha
                       >            cmp_flag fzc
1de7 : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1de9 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1deb : 28              >            plp         ;restore status
                        
1dec : 88                       dey
1ded : c40f                     cpy zp7f
                                tst_y $7e,fn
1def : 08              >            php         ;save flags
1df0 : c07e            >            cpy #$7e     ;test result
                       >            trap_ne
1df2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1df4 : 68              >            pla         ;load status
1df5 : 48              >            pha
                       >            cmp_flag fn
1df6 : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1df8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1dfa : 28              >            plp         ;restore status
                        
                                set_y $80,$ff
                       >            load_flag $ff
1dfb : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1dfd : 48              >            pha         ;use stack to load status
1dfe : a080            >            ldy #$80     ;precharge index y
1e00 : 28              >            plp
                        
1e01 : c40f                     cpy zp7f
                                tst_stat ~fnz
1e03 : 08              >            php         ;save status
1e04 : 68              >            pla         ;use stack to retrieve status
1e05 : 48              >            pha
                       >            cmp_flag ~fnz
1e06 : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1e08 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e0a : 28              >            plp         ;restore status
                        
1e0b : 88                       dey
1e0c : c40f                     cpy zp7f
                                tst_stat ~fn
1e0e : 08              >            php         ;save status
1e0f : 68              >            pla         ;use stack to retrieve status
1e10 : 48              >            pha
                       >            cmp_flag ~fn
1e11 : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1e13 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e15 : 28              >            plp         ;restore status
                        
1e16 : 88                       dey
1e17 : c40f                     cpy zp7f
                                tst_y $7e,~fzc
1e19 : 08              >            php         ;save flags
1e1a : c07e            >            cpy #$7e     ;test result
                       >            trap_ne
1e1c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e1e : 68              >            pla         ;load status
1e1f : 48              >            pha
                       >            cmp_flag ~fzc
1e20 : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1e22 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e24 : 28              >            plp         ;restore status
                        
                        
                                set_y $80,0
                       >            load_flag 0
1e25 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1e27 : 48              >            pha         ;use stack to load status
1e28 : a080            >            ldy #$80     ;precharge index y
1e2a : 28              >            plp
                        
1e2b : cc1c02                   cpy abs7f
                                tst_stat fc
1e2e : 08              >            php         ;save status
1e2f : 68              >            pla         ;use stack to retrieve status
1e30 : 48              >            pha
                       >            cmp_flag fc
1e31 : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1e33 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e35 : 28              >            plp         ;restore status
                        
1e36 : 88                       dey
1e37 : cc1c02                   cpy abs7f
                                tst_stat fzc
1e3a : 08              >            php         ;save status
1e3b : 68              >            pla         ;use stack to retrieve status
1e3c : 48              >            pha
                       >            cmp_flag fzc
1e3d : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1e3f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e41 : 28              >            plp         ;restore status
                        
1e42 : 88                       dey
1e43 : cc1c02                   cpy abs7f
                                tst_y $7e,fn
1e46 : 08              >            php         ;save flags
1e47 : c07e            >            cpy #$7e     ;test result
                       >            trap_ne
1e49 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e4b : 68              >            pla         ;load status
1e4c : 48              >            pha
                       >            cmp_flag fn
1e4d : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1e4f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e51 : 28              >            plp         ;restore status
                        
                                set_y $80,$ff
                       >            load_flag $ff
1e52 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1e54 : 48              >            pha         ;use stack to load status
1e55 : a080            >            ldy #$80     ;precharge index y
1e57 : 28              >            plp
                        
1e58 : cc1c02                   cpy abs7f
                                tst_stat ~fnz
1e5b : 08              >            php         ;save status
1e5c : 68              >            pla         ;use stack to retrieve status
1e5d : 48              >            pha
                       >            cmp_flag ~fnz
1e5e : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1e60 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e62 : 28              >            plp         ;restore status
                        
1e63 : 88                       dey
1e64 : cc1c02                   cpy abs7f
                                tst_stat ~fn
1e67 : 08              >            php         ;save status
1e68 : 68              >            pla         ;use stack to retrieve status
1e69 : 48              >            pha
                       >            cmp_flag ~fn
1e6a : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1e6c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e6e : 28              >            plp         ;restore status
                        
1e6f : 88                       dey
1e70 : cc1c02                   cpy abs7f
                                tst_y $7e,~fzc
1e73 : 08              >            php         ;save flags
1e74 : c07e            >            cpy #$7e     ;test result
                       >            trap_ne
1e76 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e78 : 68              >            pla         ;load status
1e79 : 48              >            pha
                       >            cmp_flag ~fzc
1e7a : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1e7c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e7e : 28              >            plp         ;restore status
                        
                        
                                set_y $80,0
                       >            load_flag 0
1e7f : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1e81 : 48              >            pha         ;use stack to load status
1e82 : a080            >            ldy #$80     ;precharge index y
1e84 : 28              >            plp
                        
1e85 : c07f                     cpy #$7f
                                tst_stat fc
1e87 : 08              >            php         ;save status
1e88 : 68              >            pla         ;use stack to retrieve status
1e89 : 48              >            pha
                       >            cmp_flag fc
1e8a : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1e8c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e8e : 28              >            plp         ;restore status
                        
1e8f : 88                       dey
1e90 : c07f                     cpy #$7f
                                tst_stat fzc
1e92 : 08              >            php         ;save status
1e93 : 68              >            pla         ;use stack to retrieve status
1e94 : 48              >            pha
                       >            cmp_flag fzc
1e95 : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1e97 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1e99 : 28              >            plp         ;restore status
                        
1e9a : 88                       dey
1e9b : c07f                     cpy #$7f
                                tst_y $7e,fn
1e9d : 08              >            php         ;save flags
1e9e : c07e            >            cpy #$7e     ;test result
                       >            trap_ne
1ea0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1ea2 : 68              >            pla         ;load status
1ea3 : 48              >            pha
                       >            cmp_flag fn
1ea4 : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1ea6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1ea8 : 28              >            plp         ;restore status
                        
                                set_y $80,$ff
                       >            load_flag $ff
1ea9 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1eab : 48              >            pha         ;use stack to load status
1eac : a080            >            ldy #$80     ;precharge index y
1eae : 28              >            plp
                        
1eaf : c07f                     cpy #$7f
                                tst_stat ~fnz
1eb1 : 08              >            php         ;save status
1eb2 : 68              >            pla         ;use stack to retrieve status
1eb3 : 48              >            pha
                       >            cmp_flag ~fnz
1eb4 : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1eb6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1eb8 : 28              >            plp         ;restore status
                        
1eb9 : 88                       dey
1eba : c07f                     cpy #$7f
                                tst_stat ~fn
1ebc : 08              >            php         ;save status
1ebd : 68              >            pla         ;use stack to retrieve status
1ebe : 48              >            pha
                       >            cmp_flag ~fn
1ebf : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1ec1 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1ec3 : 28              >            plp         ;restore status
                        
1ec4 : 88                       dey
1ec5 : c07f                     cpy #$7f
                                tst_y $7e,~fzc
1ec7 : 08              >            php         ;save flags
1ec8 : c07e            >            cpy #$7e     ;test result
                       >            trap_ne
1eca : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1ecc : 68              >            pla         ;load status
1ecd : 48              >            pha
                       >            cmp_flag ~fzc
1ece : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1ed0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1ed2 : 28              >            plp         ;restore status
                        
                                next_test
1ed3 : ad0002          >            lda test_case   ;previous test
1ed6 : c91b            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
1ed8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
001c =                 >test_num = test_num + 1
1eda : a91c            >            lda #test_num   ;*** next tests' number
1edc : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; CMP - zp / abs / #         
                                set_a $80,0
                       >            load_flag 0
1edf : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1ee1 : 48              >            pha         ;use stack to load status
1ee2 : a980            >            lda #$80     ;precharge accu
1ee4 : 28              >            plp
                        
1ee5 : c50f                     cmp zp7f
                                tst_a $80,fc
1ee7 : 08              >            php         ;save flags
1ee8 : c980            >            cmp #$80     ;test result
                       >            trap_ne
1eea : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1eec : 68              >            pla         ;load status
1eed : 48              >            pha
                       >            cmp_flag fc
1eee : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1ef0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1ef2 : 28              >            plp         ;restore status
                        
                                set_a $7f,0
                       >            load_flag 0
1ef3 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1ef5 : 48              >            pha         ;use stack to load status
1ef6 : a97f            >            lda #$7f     ;precharge accu
1ef8 : 28              >            plp
                        
1ef9 : c50f                     cmp zp7f
                                tst_a $7f,fzc
1efb : 08              >            php         ;save flags
1efc : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
1efe : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f00 : 68              >            pla         ;load status
1f01 : 48              >            pha
                       >            cmp_flag fzc
1f02 : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1f04 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f06 : 28              >            plp         ;restore status
                        
                                set_a $7e,0
                       >            load_flag 0
1f07 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1f09 : 48              >            pha         ;use stack to load status
1f0a : a97e            >            lda #$7e     ;precharge accu
1f0c : 28              >            plp
                        
1f0d : c50f                     cmp zp7f
                                tst_a $7e,fn
1f0f : 08              >            php         ;save flags
1f10 : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
1f12 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f14 : 68              >            pla         ;load status
1f15 : 48              >            pha
                       >            cmp_flag fn
1f16 : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1f18 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f1a : 28              >            plp         ;restore status
                        
                                set_a $80,$ff
                       >            load_flag $ff
1f1b : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1f1d : 48              >            pha         ;use stack to load status
1f1e : a980            >            lda #$80     ;precharge accu
1f20 : 28              >            plp
                        
1f21 : c50f                     cmp zp7f
                                tst_a $80,~fnz
1f23 : 08              >            php         ;save flags
1f24 : c980            >            cmp #$80     ;test result
                       >            trap_ne
1f26 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f28 : 68              >            pla         ;load status
1f29 : 48              >            pha
                       >            cmp_flag ~fnz
1f2a : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1f2c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f2e : 28              >            plp         ;restore status
                        
                                set_a $7f,$ff
                       >            load_flag $ff
1f2f : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1f31 : 48              >            pha         ;use stack to load status
1f32 : a97f            >            lda #$7f     ;precharge accu
1f34 : 28              >            plp
                        
1f35 : c50f                     cmp zp7f
                                tst_a $7f,~fn
1f37 : 08              >            php         ;save flags
1f38 : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
1f3a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f3c : 68              >            pla         ;load status
1f3d : 48              >            pha
                       >            cmp_flag ~fn
1f3e : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1f40 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f42 : 28              >            plp         ;restore status
                        
                                set_a $7e,$ff
                       >            load_flag $ff
1f43 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1f45 : 48              >            pha         ;use stack to load status
1f46 : a97e            >            lda #$7e     ;precharge accu
1f48 : 28              >            plp
                        
1f49 : c50f                     cmp zp7f
                                tst_a $7e,~fzc
1f4b : 08              >            php         ;save flags
1f4c : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
1f4e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f50 : 68              >            pla         ;load status
1f51 : 48              >            pha
                       >            cmp_flag ~fzc
1f52 : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1f54 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f56 : 28              >            plp         ;restore status
                        
                        
                                set_a $80,0
                       >            load_flag 0
1f57 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1f59 : 48              >            pha         ;use stack to load status
1f5a : a980            >            lda #$80     ;precharge accu
1f5c : 28              >            plp
                        
1f5d : cd1c02                   cmp abs7f
                                tst_a $80,fc
1f60 : 08              >            php         ;save flags
1f61 : c980            >            cmp #$80     ;test result
                       >            trap_ne
1f63 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f65 : 68              >            pla         ;load status
1f66 : 48              >            pha
                       >            cmp_flag fc
1f67 : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1f69 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f6b : 28              >            plp         ;restore status
                        
                                set_a $7f,0
                       >            load_flag 0
1f6c : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1f6e : 48              >            pha         ;use stack to load status
1f6f : a97f            >            lda #$7f     ;precharge accu
1f71 : 28              >            plp
                        
1f72 : cd1c02                   cmp abs7f
                                tst_a $7f,fzc
1f75 : 08              >            php         ;save flags
1f76 : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
1f78 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f7a : 68              >            pla         ;load status
1f7b : 48              >            pha
                       >            cmp_flag fzc
1f7c : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1f7e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f80 : 28              >            plp         ;restore status
                        
                                set_a $7e,0
                       >            load_flag 0
1f81 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1f83 : 48              >            pha         ;use stack to load status
1f84 : a97e            >            lda #$7e     ;precharge accu
1f86 : 28              >            plp
                        
1f87 : cd1c02                   cmp abs7f
                                tst_a $7e,fn
1f8a : 08              >            php         ;save flags
1f8b : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
1f8d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f8f : 68              >            pla         ;load status
1f90 : 48              >            pha
                       >            cmp_flag fn
1f91 : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1f93 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1f95 : 28              >            plp         ;restore status
                        
                                set_a $80,$ff
                       >            load_flag $ff
1f96 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1f98 : 48              >            pha         ;use stack to load status
1f99 : a980            >            lda #$80     ;precharge accu
1f9b : 28              >            plp
                        
1f9c : cd1c02                   cmp abs7f
                                tst_a $80,~fnz
1f9f : 08              >            php         ;save flags
1fa0 : c980            >            cmp #$80     ;test result
                       >            trap_ne
1fa2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1fa4 : 68              >            pla         ;load status
1fa5 : 48              >            pha
                       >            cmp_flag ~fnz
1fa6 : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1fa8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1faa : 28              >            plp         ;restore status
                        
                                set_a $7f,$ff
                       >            load_flag $ff
1fab : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1fad : 48              >            pha         ;use stack to load status
1fae : a97f            >            lda #$7f     ;precharge accu
1fb0 : 28              >            plp
                        
1fb1 : cd1c02                   cmp abs7f
                                tst_a $7f,~fn
1fb4 : 08              >            php         ;save flags
1fb5 : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
1fb7 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1fb9 : 68              >            pla         ;load status
1fba : 48              >            pha
                       >            cmp_flag ~fn
1fbb : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1fbd : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1fbf : 28              >            plp         ;restore status
                        
                                set_a $7e,$ff
                       >            load_flag $ff
1fc0 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
1fc2 : 48              >            pha         ;use stack to load status
1fc3 : a97e            >            lda #$7e     ;precharge accu
1fc5 : 28              >            plp
                        
1fc6 : cd1c02                   cmp abs7f
                                tst_a $7e,~fzc
1fc9 : 08              >            php         ;save flags
1fca : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
1fcc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1fce : 68              >            pla         ;load status
1fcf : 48              >            pha
                       >            cmp_flag ~fzc
1fd0 : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1fd2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1fd4 : 28              >            plp         ;restore status
                        
                        
                                set_a $80,0
                       >            load_flag 0
1fd5 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1fd7 : 48              >            pha         ;use stack to load status
1fd8 : a980            >            lda #$80     ;precharge accu
1fda : 28              >            plp
                        
1fdb : c97f                     cmp #$7f
                                tst_a $80,fc
1fdd : 08              >            php         ;save flags
1fde : c980            >            cmp #$80     ;test result
                       >            trap_ne
1fe0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1fe2 : 68              >            pla         ;load status
1fe3 : 48              >            pha
                       >            cmp_flag fc
1fe4 : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1fe6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1fe8 : 28              >            plp         ;restore status
                        
                                set_a $7f,0
                       >            load_flag 0
1fe9 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1feb : 48              >            pha         ;use stack to load status
1fec : a97f            >            lda #$7f     ;precharge accu
1fee : 28              >            plp
                        
1fef : c97f                     cmp #$7f
                                tst_a $7f,fzc
1ff1 : 08              >            php         ;save flags
1ff2 : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
1ff4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1ff6 : 68              >            pla         ;load status
1ff7 : 48              >            pha
                       >            cmp_flag fzc
1ff8 : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
1ffa : d0fe            >        bne *           ;failed not equal (non zero)
                       >
1ffc : 28              >            plp         ;restore status
                        
                                set_a $7e,0
                       >            load_flag 0
1ffd : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
1fff : 48              >            pha         ;use stack to load status
2000 : a97e            >            lda #$7e     ;precharge accu
2002 : 28              >            plp
                        
2003 : c97f                     cmp #$7f
                                tst_a $7e,fn
2005 : 08              >            php         ;save flags
2006 : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
2008 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
200a : 68              >            pla         ;load status
200b : 48              >            pha
                       >            cmp_flag fn
200c : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
200e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2010 : 28              >            plp         ;restore status
                        
                                set_a $80,$ff
                       >            load_flag $ff
2011 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2013 : 48              >            pha         ;use stack to load status
2014 : a980            >            lda #$80     ;precharge accu
2016 : 28              >            plp
                        
2017 : c97f                     cmp #$7f
                                tst_a $80,~fnz
2019 : 08              >            php         ;save flags
201a : c980            >            cmp #$80     ;test result
                       >            trap_ne
201c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
201e : 68              >            pla         ;load status
201f : 48              >            pha
                       >            cmp_flag ~fnz
2020 : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2022 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2024 : 28              >            plp         ;restore status
                        
                                set_a $7f,$ff
                       >            load_flag $ff
2025 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2027 : 48              >            pha         ;use stack to load status
2028 : a97f            >            lda #$7f     ;precharge accu
202a : 28              >            plp
                        
202b : c97f                     cmp #$7f
                                tst_a $7f,~fn
202d : 08              >            php         ;save flags
202e : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
2030 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2032 : 68              >            pla         ;load status
2033 : 48              >            pha
                       >            cmp_flag ~fn
2034 : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2036 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2038 : 28              >            plp         ;restore status
                        
                                set_a $7e,$ff
                       >            load_flag $ff
2039 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
203b : 48              >            pha         ;use stack to load status
203c : a97e            >            lda #$7e     ;precharge accu
203e : 28              >            plp
                        
203f : c97f                     cmp #$7f
                                tst_a $7e,~fzc
2041 : 08              >            php         ;save flags
2042 : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
2044 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2046 : 68              >            pla         ;load status
2047 : 48              >            pha
                       >            cmp_flag ~fzc
2048 : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
204a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
204c : 28              >            plp         ;restore status
                        
                        
204d : a204                     ldx #4          ;with indexing by X
                                set_a $80,0
                       >            load_flag 0
204f : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2051 : 48              >            pha         ;use stack to load status
2052 : a980            >            lda #$80     ;precharge accu
2054 : 28              >            plp
                        
2055 : d50b                     cmp zp1,x
                                tst_a $80,fc
2057 : 08              >            php         ;save flags
2058 : c980            >            cmp #$80     ;test result
                       >            trap_ne
205a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
205c : 68              >            pla         ;load status
205d : 48              >            pha
                       >            cmp_flag fc
205e : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2060 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2062 : 28              >            plp         ;restore status
                        
                                set_a $7f,0
                       >            load_flag 0
2063 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2065 : 48              >            pha         ;use stack to load status
2066 : a97f            >            lda #$7f     ;precharge accu
2068 : 28              >            plp
                        
2069 : d50b                     cmp zp1,x
                                tst_a $7f,fzc
206b : 08              >            php         ;save flags
206c : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
206e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2070 : 68              >            pla         ;load status
2071 : 48              >            pha
                       >            cmp_flag fzc
2072 : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2074 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2076 : 28              >            plp         ;restore status
                        
                                set_a $7e,0
                       >            load_flag 0
2077 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2079 : 48              >            pha         ;use stack to load status
207a : a97e            >            lda #$7e     ;precharge accu
207c : 28              >            plp
                        
207d : d50b                     cmp zp1,x
                                tst_a $7e,fn
207f : 08              >            php         ;save flags
2080 : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
2082 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2084 : 68              >            pla         ;load status
2085 : 48              >            pha
                       >            cmp_flag fn
2086 : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2088 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
208a : 28              >            plp         ;restore status
                        
                                set_a $80,$ff
                       >            load_flag $ff
208b : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
208d : 48              >            pha         ;use stack to load status
208e : a980            >            lda #$80     ;precharge accu
2090 : 28              >            plp
                        
2091 : d50b                     cmp zp1,x
                                tst_a $80,~fnz
2093 : 08              >            php         ;save flags
2094 : c980            >            cmp #$80     ;test result
                       >            trap_ne
2096 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2098 : 68              >            pla         ;load status
2099 : 48              >            pha
                       >            cmp_flag ~fnz
209a : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
209c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
209e : 28              >            plp         ;restore status
                        
                                set_a $7f,$ff
                       >            load_flag $ff
209f : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
20a1 : 48              >            pha         ;use stack to load status
20a2 : a97f            >            lda #$7f     ;precharge accu
20a4 : 28              >            plp
                        
20a5 : d50b                     cmp zp1,x
                                tst_a $7f,~fn
20a7 : 08              >            php         ;save flags
20a8 : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
20aa : d0fe            >        bne *           ;failed not equal (non zero)
                       >
20ac : 68              >            pla         ;load status
20ad : 48              >            pha
                       >            cmp_flag ~fn
20ae : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
20b0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
20b2 : 28              >            plp         ;restore status
                        
                                set_a $7e,$ff
                       >            load_flag $ff
20b3 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
20b5 : 48              >            pha         ;use stack to load status
20b6 : a97e            >            lda #$7e     ;precharge accu
20b8 : 28              >            plp
                        
20b9 : d50b                     cmp zp1,x
                                tst_a $7e,~fzc
20bb : 08              >            php         ;save flags
20bc : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
20be : d0fe            >        bne *           ;failed not equal (non zero)
                       >
20c0 : 68              >            pla         ;load status
20c1 : 48              >            pha
                       >            cmp_flag ~fzc
20c2 : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
20c4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
20c6 : 28              >            plp         ;restore status
                        
                        
                                set_a $80,0
                       >            load_flag 0
20c7 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
20c9 : 48              >            pha         ;use stack to load status
20ca : a980            >            lda #$80     ;precharge accu
20cc : 28              >            plp
                        
20cd : dd1802                   cmp abs1,x
                                tst_a $80,fc
20d0 : 08              >            php         ;save flags
20d1 : c980            >            cmp #$80     ;test result
                       >            trap_ne
20d3 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
20d5 : 68              >            pla         ;load status
20d6 : 48              >            pha
                       >            cmp_flag fc
20d7 : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
20d9 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
20db : 28              >            plp         ;restore status
                        
                                set_a $7f,0
                       >            load_flag 0
20dc : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
20de : 48              >            pha         ;use stack to load status
20df : a97f            >            lda #$7f     ;precharge accu
20e1 : 28              >            plp
                        
20e2 : dd1802                   cmp abs1,x
                                tst_a $7f,fzc
20e5 : 08              >            php         ;save flags
20e6 : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
20e8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
20ea : 68              >            pla         ;load status
20eb : 48              >            pha
                       >            cmp_flag fzc
20ec : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
20ee : d0fe            >        bne *           ;failed not equal (non zero)
                       >
20f0 : 28              >            plp         ;restore status
                        
                                set_a $7e,0
                       >            load_flag 0
20f1 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
20f3 : 48              >            pha         ;use stack to load status
20f4 : a97e            >            lda #$7e     ;precharge accu
20f6 : 28              >            plp
                        
20f7 : dd1802                   cmp abs1,x
                                tst_a $7e,fn
20fa : 08              >            php         ;save flags
20fb : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
20fd : d0fe            >        bne *           ;failed not equal (non zero)
                       >
20ff : 68              >            pla         ;load status
2100 : 48              >            pha
                       >            cmp_flag fn
2101 : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2103 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2105 : 28              >            plp         ;restore status
                        
                                set_a $80,$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 : a980            >            lda #$80     ;precharge accu
210b : 28              >            plp
                        
210c : dd1802                   cmp abs1,x
                                tst_a $80,~fnz
210f : 08              >            php         ;save flags
2110 : c980            >            cmp #$80     ;test result
                       >            trap_ne
2112 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2114 : 68              >            pla         ;load status
2115 : 48              >            pha
                       >            cmp_flag ~fnz
2116 : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2118 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
211a : 28              >            plp         ;restore status
                        
                                set_a $7f,$ff
                       >            load_flag $ff
211b : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
211d : 48              >            pha         ;use stack to load status
211e : a97f            >            lda #$7f     ;precharge accu
2120 : 28              >            plp
                        
2121 : dd1802                   cmp abs1,x
                                tst_a $7f,~fn
2124 : 08              >            php         ;save flags
2125 : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
2127 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2129 : 68              >            pla         ;load status
212a : 48              >            pha
                       >            cmp_flag ~fn
212b : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
212d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
212f : 28              >            plp         ;restore status
                        
                                set_a $7e,$ff
                       >            load_flag $ff
2130 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2132 : 48              >            pha         ;use stack to load status
2133 : a97e            >            lda #$7e     ;precharge accu
2135 : 28              >            plp
                        
2136 : dd1802                   cmp abs1,x
                                tst_a $7e,~fzc
2139 : 08              >            php         ;save flags
213a : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
213c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
213e : 68              >            pla         ;load status
213f : 48              >            pha
                       >            cmp_flag ~fzc
2140 : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2142 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2144 : 28              >            plp         ;restore status
                        
                        
2145 : a004                     ldy #4          ;with indexing by Y
2147 : a208                     ldx #8          ;with indexed indirect
                                set_a $80,0
                       >            load_flag 0
2149 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
214b : 48              >            pha         ;use stack to load status
214c : a980            >            lda #$80     ;precharge accu
214e : 28              >            plp
                        
214f : d91802                   cmp abs1,y
                                tst_a $80,fc
2152 : 08              >            php         ;save flags
2153 : c980            >            cmp #$80     ;test result
                       >            trap_ne
2155 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2157 : 68              >            pla         ;load status
2158 : 48              >            pha
                       >            cmp_flag fc
2159 : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
215b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
215d : 28              >            plp         ;restore status
                        
                                set_a $7f,0
                       >            load_flag 0
215e : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2160 : 48              >            pha         ;use stack to load status
2161 : a97f            >            lda #$7f     ;precharge accu
2163 : 28              >            plp
                        
2164 : d91802                   cmp abs1,y
                                tst_a $7f,fzc
2167 : 08              >            php         ;save flags
2168 : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
216a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
216c : 68              >            pla         ;load status
216d : 48              >            pha
                       >            cmp_flag fzc
216e : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2170 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2172 : 28              >            plp         ;restore status
                        
                                set_a $7e,0
                       >            load_flag 0
2173 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2175 : 48              >            pha         ;use stack to load status
2176 : a97e            >            lda #$7e     ;precharge accu
2178 : 28              >            plp
                        
2179 : d91802                   cmp abs1,y
                                tst_a $7e,fn
217c : 08              >            php         ;save flags
217d : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
217f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2181 : 68              >            pla         ;load status
2182 : 48              >            pha
                       >            cmp_flag fn
2183 : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2185 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2187 : 28              >            plp         ;restore status
                        
                                set_a $80,$ff
                       >            load_flag $ff
2188 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
218a : 48              >            pha         ;use stack to load status
218b : a980            >            lda #$80     ;precharge accu
218d : 28              >            plp
                        
218e : d91802                   cmp abs1,y
                                tst_a $80,~fnz
2191 : 08              >            php         ;save flags
2192 : c980            >            cmp #$80     ;test result
                       >            trap_ne
2194 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2196 : 68              >            pla         ;load status
2197 : 48              >            pha
                       >            cmp_flag ~fnz
2198 : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
219a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
219c : 28              >            plp         ;restore status
                        
                                set_a $7f,$ff
                       >            load_flag $ff
219d : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
219f : 48              >            pha         ;use stack to load status
21a0 : a97f            >            lda #$7f     ;precharge accu
21a2 : 28              >            plp
                        
21a3 : d91802                   cmp abs1,y
                                tst_a $7f,~fn
21a6 : 08              >            php         ;save flags
21a7 : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
21a9 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
21ab : 68              >            pla         ;load status
21ac : 48              >            pha
                       >            cmp_flag ~fn
21ad : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
21af : d0fe            >        bne *           ;failed not equal (non zero)
                       >
21b1 : 28              >            plp         ;restore status
                        
                                set_a $7e,$ff
                       >            load_flag $ff
21b2 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
21b4 : 48              >            pha         ;use stack to load status
21b5 : a97e            >            lda #$7e     ;precharge accu
21b7 : 28              >            plp
                        
21b8 : d91802                   cmp abs1,y
                                tst_a $7e,~fzc
21bb : 08              >            php         ;save flags
21bc : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
21be : d0fe            >        bne *           ;failed not equal (non zero)
                       >
21c0 : 68              >            pla         ;load status
21c1 : 48              >            pha
                       >            cmp_flag ~fzc
21c2 : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
21c4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
21c6 : 28              >            plp         ;restore status
                        
                        
                                set_a $80,0
                       >            load_flag 0
21c7 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
21c9 : 48              >            pha         ;use stack to load status
21ca : a980            >            lda #$80     ;precharge accu
21cc : 28              >            plp
                        
21cd : c11c                     cmp (ind1,x)
                                tst_a $80,fc
21cf : 08              >            php         ;save flags
21d0 : c980            >            cmp #$80     ;test result
                       >            trap_ne
21d2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
21d4 : 68              >            pla         ;load status
21d5 : 48              >            pha
                       >            cmp_flag fc
21d6 : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
21d8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
21da : 28              >            plp         ;restore status
                        
                                set_a $7f,0
                       >            load_flag 0
21db : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
21dd : 48              >            pha         ;use stack to load status
21de : a97f            >            lda #$7f     ;precharge accu
21e0 : 28              >            plp
                        
21e1 : c11c                     cmp (ind1,x)
                                tst_a $7f,fzc
21e3 : 08              >            php         ;save flags
21e4 : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
21e6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
21e8 : 68              >            pla         ;load status
21e9 : 48              >            pha
                       >            cmp_flag fzc
21ea : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
21ec : d0fe            >        bne *           ;failed not equal (non zero)
                       >
21ee : 28              >            plp         ;restore status
                        
                                set_a $7e,0
                       >            load_flag 0
21ef : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
21f1 : 48              >            pha         ;use stack to load status
21f2 : a97e            >            lda #$7e     ;precharge accu
21f4 : 28              >            plp
                        
21f5 : c11c                     cmp (ind1,x)
                                tst_a $7e,fn
21f7 : 08              >            php         ;save flags
21f8 : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
21fa : d0fe            >        bne *           ;failed not equal (non zero)
                       >
21fc : 68              >            pla         ;load status
21fd : 48              >            pha
                       >            cmp_flag fn
21fe : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2200 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2202 : 28              >            plp         ;restore status
                        
                                set_a $80,$ff
                       >            load_flag $ff
2203 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2205 : 48              >            pha         ;use stack to load status
2206 : a980            >            lda #$80     ;precharge accu
2208 : 28              >            plp
                        
2209 : c11c                     cmp (ind1,x)
                                tst_a $80,~fnz
220b : 08              >            php         ;save flags
220c : c980            >            cmp #$80     ;test result
                       >            trap_ne
220e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2210 : 68              >            pla         ;load status
2211 : 48              >            pha
                       >            cmp_flag ~fnz
2212 : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2214 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2216 : 28              >            plp         ;restore status
                        
                                set_a $7f,$ff
                       >            load_flag $ff
2217 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2219 : 48              >            pha         ;use stack to load status
221a : a97f            >            lda #$7f     ;precharge accu
221c : 28              >            plp
                        
221d : c11c                     cmp (ind1,x)
                                tst_a $7f,~fn
221f : 08              >            php         ;save flags
2220 : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
2222 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2224 : 68              >            pla         ;load status
2225 : 48              >            pha
                       >            cmp_flag ~fn
2226 : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2228 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
222a : 28              >            plp         ;restore status
                        
                                set_a $7e,$ff
                       >            load_flag $ff
222b : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
222d : 48              >            pha         ;use stack to load status
222e : a97e            >            lda #$7e     ;precharge accu
2230 : 28              >            plp
                        
2231 : c11c                     cmp (ind1,x)
                                tst_a $7e,~fzc
2233 : 08              >            php         ;save flags
2234 : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
2236 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2238 : 68              >            pla         ;load status
2239 : 48              >            pha
                       >            cmp_flag ~fzc
223a : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
223c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
223e : 28              >            plp         ;restore status
                        
                        
                                set_a $80,0
                       >            load_flag 0
223f : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2241 : 48              >            pha         ;use stack to load status
2242 : a980            >            lda #$80     ;precharge accu
2244 : 28              >            plp
                        
2245 : d11c                     cmp (ind1),y
                                tst_a $80,fc
2247 : 08              >            php         ;save flags
2248 : c980            >            cmp #$80     ;test result
                       >            trap_ne
224a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
224c : 68              >            pla         ;load status
224d : 48              >            pha
                       >            cmp_flag fc
224e : c931            >            cmp #(fc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2250 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2252 : 28              >            plp         ;restore status
                        
                                set_a $7f,0
                       >            load_flag 0
2253 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2255 : 48              >            pha         ;use stack to load status
2256 : a97f            >            lda #$7f     ;precharge accu
2258 : 28              >            plp
                        
2259 : d11c                     cmp (ind1),y
                                tst_a $7f,fzc
225b : 08              >            php         ;save flags
225c : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
225e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2260 : 68              >            pla         ;load status
2261 : 48              >            pha
                       >            cmp_flag fzc
2262 : c933            >            cmp #(fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2264 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2266 : 28              >            plp         ;restore status
                        
                                set_a $7e,0
                       >            load_flag 0
2267 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2269 : 48              >            pha         ;use stack to load status
226a : a97e            >            lda #$7e     ;precharge accu
226c : 28              >            plp
                        
226d : d11c                     cmp (ind1),y
                                tst_a $7e,fn
226f : 08              >            php         ;save flags
2270 : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
2272 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2274 : 68              >            pla         ;load status
2275 : 48              >            pha
                       >            cmp_flag fn
2276 : c9b0            >            cmp #(fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
2278 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
227a : 28              >            plp         ;restore status
                        
                                set_a $80,$ff
                       >            load_flag $ff
227b : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
227d : 48              >            pha         ;use stack to load status
227e : a980            >            lda #$80     ;precharge accu
2280 : 28              >            plp
                        
2281 : d11c                     cmp (ind1),y
                                tst_a $80,~fnz
2283 : 08              >            php         ;save flags
2284 : c980            >            cmp #$80     ;test result
                       >            trap_ne
2286 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2288 : 68              >            pla         ;load status
2289 : 48              >            pha
                       >            cmp_flag ~fnz
228a : c97d            >            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
228c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
228e : 28              >            plp         ;restore status
                        
                                set_a $7f,$ff
                       >            load_flag $ff
228f : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2291 : 48              >            pha         ;use stack to load status
2292 : a97f            >            lda #$7f     ;precharge accu
2294 : 28              >            plp
                        
2295 : d11c                     cmp (ind1),y
                                tst_a $7f,~fn
2297 : 08              >            php         ;save flags
2298 : c97f            >            cmp #$7f     ;test result
                       >            trap_ne
229a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
229c : 68              >            pla         ;load status
229d : 48              >            pha
                       >            cmp_flag ~fn
229e : c97f            >            cmp #(~fn|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
22a0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
22a2 : 28              >            plp         ;restore status
                        
                                set_a $7e,$ff
                       >            load_flag $ff
22a3 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
22a5 : 48              >            pha         ;use stack to load status
22a6 : a97e            >            lda #$7e     ;precharge accu
22a8 : 28              >            plp
                        
22a9 : d11c                     cmp (ind1),y
                                tst_a $7e,~fzc
22ab : 08              >            php         ;save flags
22ac : c97e            >            cmp #$7e     ;test result
                       >            trap_ne
22ae : d0fe            >        bne *           ;failed not equal (non zero)
                       >
22b0 : 68              >            pla         ;load status
22b1 : 48              >            pha
                       >            cmp_flag ~fzc
22b2 : c9fc            >            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
                       >
                       >            trap_ne
22b4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
22b6 : 28              >            plp         ;restore status
                        
                                next_test
22b7 : ad0002          >            lda test_case   ;previous test
22ba : c91c            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
22bc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
001d =                 >test_num = test_num + 1
22be : a91d            >            lda #test_num   ;*** next tests' number
22c0 : 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
22c3 : a205                     ldx #5
22c5 :                  tasl
                                set_ax zps,0
                       >            load_flag 0
22c5 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
22c7 : 48              >            pha         ;use stack to load status
22c8 : b509            >            lda zps,x    ;precharge accu
22ca : 28              >            plp
                        
22cb : 0a                       asl a
                                tst_ax rASL,fASL,0
22cc : 08              >            php         ;save flags
22cd : dd2102          >            cmp rASL,x    ;test result
                       >            trap_ne
22d0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
22d2 : 68              >            pla         ;load status
                       >            eor_flag 0
22d3 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
22d5 : dd3902          >            cmp fASL,x    ;test flags
                       >            trap_ne     ;
22d8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
22da : ca                       dex
22db : 10e8                     bpl tasl
22dd : a205                     ldx #5
22df :                  tasl1
                                set_ax zps,$ff
                       >            load_flag $ff
22df : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
22e1 : 48              >            pha         ;use stack to load status
22e2 : b509            >            lda zps,x    ;precharge accu
22e4 : 28              >            plp
                        
22e5 : 0a                       asl a
                                tst_ax rASL,fASL,$ff-fnzc
22e6 : 08              >            php         ;save flags
22e7 : dd2102          >            cmp rASL,x    ;test result
                       >            trap_ne
22ea : d0fe            >        bne *           ;failed not equal (non zero)
                       >
22ec : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
22ed : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
22ef : dd3902          >            cmp fASL,x    ;test flags
                       >            trap_ne     ;
22f2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
22f4 : ca                       dex
22f5 : 10e8                     bpl tasl1
                        
22f7 : a205                     ldx #5
22f9 :                  tlsr
                                set_ax zps,0
                       >            load_flag 0
22f9 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
22fb : 48              >            pha         ;use stack to load status
22fc : b509            >            lda zps,x    ;precharge accu
22fe : 28              >            plp
                        
22ff : 4a                       lsr a
                                tst_ax rLSR,fLSR,0
2300 : 08              >            php         ;save flags
2301 : dd2d02          >            cmp rLSR,x    ;test result
                       >            trap_ne
2304 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2306 : 68              >            pla         ;load status
                       >            eor_flag 0
2307 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2309 : dd4502          >            cmp fLSR,x    ;test flags
                       >            trap_ne     ;
230c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
230e : ca                       dex
230f : 10e8                     bpl tlsr
2311 : a205                     ldx #5
2313 :                  tlsr1
                                set_ax zps,$ff
                       >            load_flag $ff
2313 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2315 : 48              >            pha         ;use stack to load status
2316 : b509            >            lda zps,x    ;precharge accu
2318 : 28              >            plp
                        
2319 : 4a                       lsr a
                                tst_ax rLSR,fLSR,$ff-fnzc
231a : 08              >            php         ;save flags
231b : dd2d02          >            cmp rLSR,x    ;test result
                       >            trap_ne
231e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2320 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2321 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
2323 : dd4502          >            cmp fLSR,x    ;test flags
                       >            trap_ne     ;
2326 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2328 : ca                       dex
2329 : 10e8                     bpl tlsr1
                        
232b : a205                     ldx #5
232d :                  trol
                                set_ax zps,0
                       >            load_flag 0
232d : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
232f : 48              >            pha         ;use stack to load status
2330 : b509            >            lda zps,x    ;precharge accu
2332 : 28              >            plp
                        
2333 : 2a                       rol a
                                tst_ax rROL,fROL,0
2334 : 08              >            php         ;save flags
2335 : dd2102          >            cmp rROL,x    ;test result
                       >            trap_ne
2338 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
233a : 68              >            pla         ;load status
                       >            eor_flag 0
233b : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
233d : dd3902          >            cmp fROL,x    ;test flags
                       >            trap_ne     ;
2340 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2342 : ca                       dex
2343 : 10e8                     bpl trol
2345 : a205                     ldx #5
2347 :                  trol1
                                set_ax zps,$ff-fc
                       >            load_flag $ff-fc
2347 : a9fe            >            lda #$ff-fc             ;allow test to change I-flag (no mask)
                       >
2349 : 48              >            pha         ;use stack to load status
234a : b509            >            lda zps,x    ;precharge accu
234c : 28              >            plp
                        
234d : 2a                       rol a
                                tst_ax rROL,fROL,$ff-fnzc
234e : 08              >            php         ;save flags
234f : dd2102          >            cmp rROL,x    ;test result
                       >            trap_ne
2352 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2354 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2355 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
2357 : dd3902          >            cmp fROL,x    ;test flags
                       >            trap_ne     ;
235a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
235c : ca                       dex
235d : 10e8                     bpl trol1
                        
235f : a205                     ldx #5
2361 :                  trolc
                                set_ax zps,fc
                       >            load_flag fc
2361 : a901            >            lda #fc             ;allow test to change I-flag (no mask)
                       >
2363 : 48              >            pha         ;use stack to load status
2364 : b509            >            lda zps,x    ;precharge accu
2366 : 28              >            plp
                        
2367 : 2a                       rol a
                                tst_ax rROLc,fROLc,0
2368 : 08              >            php         ;save flags
2369 : dd2702          >            cmp rROLc,x    ;test result
                       >            trap_ne
236c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
236e : 68              >            pla         ;load status
                       >            eor_flag 0
236f : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2371 : dd3f02          >            cmp fROLc,x    ;test flags
                       >            trap_ne     ;
2374 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2376 : ca                       dex
2377 : 10e8                     bpl trolc
2379 : a205                     ldx #5
237b :                  trolc1
                                set_ax zps,$ff
                       >            load_flag $ff
237b : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
237d : 48              >            pha         ;use stack to load status
237e : b509            >            lda zps,x    ;precharge accu
2380 : 28              >            plp
                        
2381 : 2a                       rol a
                                tst_ax rROLc,fROLc,$ff-fnzc
2382 : 08              >            php         ;save flags
2383 : dd2702          >            cmp rROLc,x    ;test result
                       >            trap_ne
2386 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2388 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2389 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
238b : dd3f02          >            cmp fROLc,x    ;test flags
                       >            trap_ne     ;
238e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2390 : ca                       dex
2391 : 10e8                     bpl trolc1
                        
2393 : a205                     ldx #5
2395 :                  tror
                                set_ax zps,0
                       >            load_flag 0
2395 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2397 : 48              >            pha         ;use stack to load status
2398 : b509            >            lda zps,x    ;precharge accu
239a : 28              >            plp
                        
239b : 6a                       ror a
                                tst_ax rROR,fROR,0
239c : 08              >            php         ;save flags
239d : dd2d02          >            cmp rROR,x    ;test result
                       >            trap_ne
23a0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
23a2 : 68              >            pla         ;load status
                       >            eor_flag 0
23a3 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
23a5 : dd4502          >            cmp fROR,x    ;test flags
                       >            trap_ne     ;
23a8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
23aa : ca                       dex
23ab : 10e8                     bpl tror
23ad : a205                     ldx #5
23af :                  tror1
                                set_ax zps,$ff-fc
                       >            load_flag $ff-fc
23af : a9fe            >            lda #$ff-fc             ;allow test to change I-flag (no mask)
                       >
23b1 : 48              >            pha         ;use stack to load status
23b2 : b509            >            lda zps,x    ;precharge accu
23b4 : 28              >            plp
                        
23b5 : 6a                       ror a
                                tst_ax rROR,fROR,$ff-fnzc
23b6 : 08              >            php         ;save flags
23b7 : dd2d02          >            cmp rROR,x    ;test result
                       >            trap_ne
23ba : d0fe            >        bne *           ;failed not equal (non zero)
                       >
23bc : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
23bd : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
23bf : dd4502          >            cmp fROR,x    ;test flags
                       >            trap_ne     ;
23c2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
23c4 : ca                       dex
23c5 : 10e8                     bpl tror1
                        
23c7 : a205                     ldx #5
23c9 :                  trorc
                                set_ax zps,fc
                       >            load_flag fc
23c9 : a901            >            lda #fc             ;allow test to change I-flag (no mask)
                       >
23cb : 48              >            pha         ;use stack to load status
23cc : b509            >            lda zps,x    ;precharge accu
23ce : 28              >            plp
                        
23cf : 6a                       ror a
                                tst_ax rRORc,fRORc,0
23d0 : 08              >            php         ;save flags
23d1 : dd3302          >            cmp rRORc,x    ;test result
                       >            trap_ne
23d4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
23d6 : 68              >            pla         ;load status
                       >            eor_flag 0
23d7 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
23d9 : dd4b02          >            cmp fRORc,x    ;test flags
                       >            trap_ne     ;
23dc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
23de : ca                       dex
23df : 10e8                     bpl trorc
23e1 : a205                     ldx #5
23e3 :                  trorc1
                                set_ax zps,$ff
                       >            load_flag $ff
23e3 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
23e5 : 48              >            pha         ;use stack to load status
23e6 : b509            >            lda zps,x    ;precharge accu
23e8 : 28              >            plp
                        
23e9 : 6a                       ror a
                                tst_ax rRORc,fRORc,$ff-fnzc
23ea : 08              >            php         ;save flags
23eb : dd3302          >            cmp rRORc,x    ;test result
                       >            trap_ne
23ee : d0fe            >        bne *           ;failed not equal (non zero)
                       >
23f0 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
23f1 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
23f3 : dd4b02          >            cmp fRORc,x    ;test flags
                       >            trap_ne     ;
23f6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
23f8 : ca                       dex
23f9 : 10e8                     bpl trorc1
                                next_test
23fb : ad0002          >            lda test_case   ;previous test
23fe : c91d            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
2400 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
001e =                 >test_num = test_num + 1
2402 : a91e            >            lda #test_num   ;*** next tests' number
2404 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; shifts - zeropage
2407 : a205                     ldx #5
2409 :                  tasl2
                                set_z zps,0
                       >            load_flag 0
2409 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
240b : 48              >            pha         ;use stack to load status
240c : b509            >            lda zps,x    ;load to zeropage
240e : 8502            >            sta zpt
2410 : 28              >            plp
                        
2411 : 0602                     asl zpt
                                tst_z rASL,fASL,0
2413 : 08              >            php         ;save flags
2414 : a502            >            lda zpt
2416 : dd2102          >            cmp rASL,x    ;test result
                       >            trap_ne
2419 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
241b : 68              >            pla         ;load status
                       >            eor_flag 0
241c : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
241e : dd3902          >            cmp fASL,x    ;test flags
                       >            trap_ne
2421 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2423 : ca                       dex
2424 : 10e3                     bpl tasl2
2426 : a205                     ldx #5
2428 :                  tasl3
                                set_z zps,$ff
                       >            load_flag $ff
2428 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
242a : 48              >            pha         ;use stack to load status
242b : b509            >            lda zps,x    ;load to zeropage
242d : 8502            >            sta zpt
242f : 28              >            plp
                        
2430 : 0602                     asl zpt
                                tst_z rASL,fASL,$ff-fnzc
2432 : 08              >            php         ;save flags
2433 : a502            >            lda zpt
2435 : dd2102          >            cmp rASL,x    ;test result
                       >            trap_ne
2438 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
243a : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
243b : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
243d : dd3902          >            cmp fASL,x    ;test flags
                       >            trap_ne
2440 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2442 : ca                       dex
2443 : 10e3                     bpl tasl3
                        
2445 : a205                     ldx #5
2447 :                  tlsr2
                                set_z zps,0
                       >            load_flag 0
2447 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2449 : 48              >            pha         ;use stack to load status
244a : b509            >            lda zps,x    ;load to zeropage
244c : 8502            >            sta zpt
244e : 28              >            plp
                        
244f : 4602                     lsr zpt
                                tst_z rLSR,fLSR,0
2451 : 08              >            php         ;save flags
2452 : a502            >            lda zpt
2454 : dd2d02          >            cmp rLSR,x    ;test result
                       >            trap_ne
2457 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2459 : 68              >            pla         ;load status
                       >            eor_flag 0
245a : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
245c : dd4502          >            cmp fLSR,x    ;test flags
                       >            trap_ne
245f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2461 : ca                       dex
2462 : 10e3                     bpl tlsr2
2464 : a205                     ldx #5
2466 :                  tlsr3
                                set_z zps,$ff
                       >            load_flag $ff
2466 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2468 : 48              >            pha         ;use stack to load status
2469 : b509            >            lda zps,x    ;load to zeropage
246b : 8502            >            sta zpt
246d : 28              >            plp
                        
246e : 4602                     lsr zpt
                                tst_z rLSR,fLSR,$ff-fnzc
2470 : 08              >            php         ;save flags
2471 : a502            >            lda zpt
2473 : dd2d02          >            cmp rLSR,x    ;test result
                       >            trap_ne
2476 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2478 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2479 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
247b : dd4502          >            cmp fLSR,x    ;test flags
                       >            trap_ne
247e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2480 : ca                       dex
2481 : 10e3                     bpl tlsr3
                        
2483 : a205                     ldx #5
2485 :                  trol2
                                set_z zps,0
                       >            load_flag 0
2485 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2487 : 48              >            pha         ;use stack to load status
2488 : b509            >            lda zps,x    ;load to zeropage
248a : 8502            >            sta zpt
248c : 28              >            plp
                        
248d : 2602                     rol zpt
                                tst_z rROL,fROL,0
248f : 08              >            php         ;save flags
2490 : a502            >            lda zpt
2492 : dd2102          >            cmp rROL,x    ;test result
                       >            trap_ne
2495 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2497 : 68              >            pla         ;load status
                       >            eor_flag 0
2498 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
249a : dd3902          >            cmp fROL,x    ;test flags
                       >            trap_ne
249d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
249f : ca                       dex
24a0 : 10e3                     bpl trol2
24a2 : a205                     ldx #5
24a4 :                  trol3
                                set_z zps,$ff-fc
                       >            load_flag $ff-fc
24a4 : a9fe            >            lda #$ff-fc             ;allow test to change I-flag (no mask)
                       >
24a6 : 48              >            pha         ;use stack to load status
24a7 : b509            >            lda zps,x    ;load to zeropage
24a9 : 8502            >            sta zpt
24ab : 28              >            plp
                        
24ac : 2602                     rol zpt
                                tst_z rROL,fROL,$ff-fnzc
24ae : 08              >            php         ;save flags
24af : a502            >            lda zpt
24b1 : dd2102          >            cmp rROL,x    ;test result
                       >            trap_ne
24b4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
24b6 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
24b7 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
24b9 : dd3902          >            cmp fROL,x    ;test flags
                       >            trap_ne
24bc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
24be : ca                       dex
24bf : 10e3                     bpl trol3
                        
24c1 : a205                     ldx #5
24c3 :                  trolc2
                                set_z zps,fc
                       >            load_flag fc
24c3 : a901            >            lda #fc             ;allow test to change I-flag (no mask)
                       >
24c5 : 48              >            pha         ;use stack to load status
24c6 : b509            >            lda zps,x    ;load to zeropage
24c8 : 8502            >            sta zpt
24ca : 28              >            plp
                        
24cb : 2602                     rol zpt
                                tst_z rROLc,fROLc,0
24cd : 08              >            php         ;save flags
24ce : a502            >            lda zpt
24d0 : dd2702          >            cmp rROLc,x    ;test result
                       >            trap_ne
24d3 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
24d5 : 68              >            pla         ;load status
                       >            eor_flag 0
24d6 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
24d8 : dd3f02          >            cmp fROLc,x    ;test flags
                       >            trap_ne
24db : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
24dd : ca                       dex
24de : 10e3                     bpl trolc2
24e0 : a205                     ldx #5
24e2 :                  trolc3
                                set_z zps,$ff
                       >            load_flag $ff
24e2 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
24e4 : 48              >            pha         ;use stack to load status
24e5 : b509            >            lda zps,x    ;load to zeropage
24e7 : 8502            >            sta zpt
24e9 : 28              >            plp
                        
24ea : 2602                     rol zpt
                                tst_z rROLc,fROLc,$ff-fnzc
24ec : 08              >            php         ;save flags
24ed : a502            >            lda zpt
24ef : dd2702          >            cmp rROLc,x    ;test result
                       >            trap_ne
24f2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
24f4 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
24f5 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
24f7 : dd3f02          >            cmp fROLc,x    ;test flags
                       >            trap_ne
24fa : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
24fc : ca                       dex
24fd : 10e3                     bpl trolc3
                        
24ff : a205                     ldx #5
2501 :                  tror2
                                set_z zps,0
                       >            load_flag 0
2501 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2503 : 48              >            pha         ;use stack to load status
2504 : b509            >            lda zps,x    ;load to zeropage
2506 : 8502            >            sta zpt
2508 : 28              >            plp
                        
2509 : 6602                     ror zpt
                                tst_z rROR,fROR,0
250b : 08              >            php         ;save flags
250c : a502            >            lda zpt
250e : dd2d02          >            cmp rROR,x    ;test result
                       >            trap_ne
2511 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2513 : 68              >            pla         ;load status
                       >            eor_flag 0
2514 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2516 : dd4502          >            cmp fROR,x    ;test flags
                       >            trap_ne
2519 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
251b : ca                       dex
251c : 10e3                     bpl tror2
251e : a205                     ldx #5
2520 :                  tror3
                                set_z zps,$ff-fc
                       >            load_flag $ff-fc
2520 : a9fe            >            lda #$ff-fc             ;allow test to change I-flag (no mask)
                       >
2522 : 48              >            pha         ;use stack to load status
2523 : b509            >            lda zps,x    ;load to zeropage
2525 : 8502            >            sta zpt
2527 : 28              >            plp
                        
2528 : 6602                     ror zpt
                                tst_z rROR,fROR,$ff-fnzc
252a : 08              >            php         ;save flags
252b : a502            >            lda zpt
252d : dd2d02          >            cmp rROR,x    ;test result
                       >            trap_ne
2530 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2532 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2533 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
2535 : dd4502          >            cmp fROR,x    ;test flags
                       >            trap_ne
2538 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
253a : ca                       dex
253b : 10e3                     bpl tror3
                        
253d : a205                     ldx #5
253f :                  trorc2
                                set_z zps,fc
                       >            load_flag fc
253f : a901            >            lda #fc             ;allow test to change I-flag (no mask)
                       >
2541 : 48              >            pha         ;use stack to load status
2542 : b509            >            lda zps,x    ;load to zeropage
2544 : 8502            >            sta zpt
2546 : 28              >            plp
                        
2547 : 6602                     ror zpt
                                tst_z rRORc,fRORc,0
2549 : 08              >            php         ;save flags
254a : a502            >            lda zpt
254c : dd3302          >            cmp rRORc,x    ;test result
                       >            trap_ne
254f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2551 : 68              >            pla         ;load status
                       >            eor_flag 0
2552 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2554 : dd4b02          >            cmp fRORc,x    ;test flags
                       >            trap_ne
2557 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2559 : ca                       dex
255a : 10e3                     bpl trorc2
255c : a205                     ldx #5
255e :                  trorc3
                                set_z zps,$ff
                       >            load_flag $ff
255e : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2560 : 48              >            pha         ;use stack to load status
2561 : b509            >            lda zps,x    ;load to zeropage
2563 : 8502            >            sta zpt
2565 : 28              >            plp
                        
2566 : 6602                     ror zpt
                                tst_z rRORc,fRORc,$ff-fnzc
2568 : 08              >            php         ;save flags
2569 : a502            >            lda zpt
256b : dd3302          >            cmp rRORc,x    ;test result
                       >            trap_ne
256e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2570 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2571 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
2573 : dd4b02          >            cmp fRORc,x    ;test flags
                       >            trap_ne
2576 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2578 : ca                       dex
2579 : 10e3                     bpl trorc3
                                next_test
257b : ad0002          >            lda test_case   ;previous test
257e : c91e            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
2580 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
001f =                 >test_num = test_num + 1
2582 : a91f            >            lda #test_num   ;*** next tests' number
2584 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; shifts - absolute
2587 : a205                     ldx #5
2589 :                  tasl4
                                set_abs zps,0
                       >            load_flag 0
2589 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
258b : 48              >            pha         ;use stack to load status
258c : b509            >            lda zps,x    ;load to memory
258e : 8d0302          >            sta abst
2591 : 28              >            plp
                        
2592 : 0e0302                   asl abst
                                tst_abs rASL,fASL,0
2595 : 08              >            php         ;save flags
2596 : ad0302          >            lda abst
2599 : dd2102          >            cmp rASL,x    ;test result
                       >            trap_ne
259c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
259e : 68              >            pla         ;load status
                       >            eor_flag 0
259f : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
25a1 : dd3902          >            cmp fASL,x    ;test flags
                       >            trap_ne
25a4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
25a6 : ca                       dex
25a7 : 10e0                     bpl tasl4
25a9 : a205                     ldx #5
25ab :                  tasl5
                                set_abs zps,$ff
                       >            load_flag $ff
25ab : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
25ad : 48              >            pha         ;use stack to load status
25ae : b509            >            lda zps,x    ;load to memory
25b0 : 8d0302          >            sta abst
25b3 : 28              >            plp
                        
25b4 : 0e0302                   asl abst
                                tst_abs rASL,fASL,$ff-fnzc
25b7 : 08              >            php         ;save flags
25b8 : ad0302          >            lda abst
25bb : dd2102          >            cmp rASL,x    ;test result
                       >            trap_ne
25be : d0fe            >        bne *           ;failed not equal (non zero)
                       >
25c0 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
25c1 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
25c3 : dd3902          >            cmp fASL,x    ;test flags
                       >            trap_ne
25c6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
25c8 : ca                       dex
25c9 : 10e0                     bpl tasl5
                        
25cb : a205                     ldx #5
25cd :                  tlsr4
                                set_abs zps,0
                       >            load_flag 0
25cd : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
25cf : 48              >            pha         ;use stack to load status
25d0 : b509            >            lda zps,x    ;load to memory
25d2 : 8d0302          >            sta abst
25d5 : 28              >            plp
                        
25d6 : 4e0302                   lsr abst
                                tst_abs rLSR,fLSR,0
25d9 : 08              >            php         ;save flags
25da : ad0302          >            lda abst
25dd : dd2d02          >            cmp rLSR,x    ;test result
                       >            trap_ne
25e0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
25e2 : 68              >            pla         ;load status
                       >            eor_flag 0
25e3 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
25e5 : dd4502          >            cmp fLSR,x    ;test flags
                       >            trap_ne
25e8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
25ea : ca                       dex
25eb : 10e0                     bpl tlsr4
25ed : a205                     ldx #5
25ef :                  tlsr5
                                set_abs zps,$ff
                       >            load_flag $ff
25ef : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
25f1 : 48              >            pha         ;use stack to load status
25f2 : b509            >            lda zps,x    ;load to memory
25f4 : 8d0302          >            sta abst
25f7 : 28              >            plp
                        
25f8 : 4e0302                   lsr abst
                                tst_abs rLSR,fLSR,$ff-fnzc
25fb : 08              >            php         ;save flags
25fc : ad0302          >            lda abst
25ff : dd2d02          >            cmp rLSR,x    ;test result
                       >            trap_ne
2602 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2604 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2605 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
2607 : dd4502          >            cmp fLSR,x    ;test flags
                       >            trap_ne
260a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
260c : ca                       dex
260d : 10e0                     bpl tlsr5
                        
260f : a205                     ldx #5
2611 :                  trol4
                                set_abs zps,0
                       >            load_flag 0
2611 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2613 : 48              >            pha         ;use stack to load status
2614 : b509            >            lda zps,x    ;load to memory
2616 : 8d0302          >            sta abst
2619 : 28              >            plp
                        
261a : 2e0302                   rol abst
                                tst_abs rROL,fROL,0
261d : 08              >            php         ;save flags
261e : ad0302          >            lda abst
2621 : dd2102          >            cmp rROL,x    ;test result
                       >            trap_ne
2624 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2626 : 68              >            pla         ;load status
                       >            eor_flag 0
2627 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2629 : dd3902          >            cmp fROL,x    ;test flags
                       >            trap_ne
262c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
262e : ca                       dex
262f : 10e0                     bpl trol4
2631 : a205                     ldx #5
2633 :                  trol5
                                set_abs zps,$ff-fc
                       >            load_flag $ff-fc
2633 : a9fe            >            lda #$ff-fc             ;allow test to change I-flag (no mask)
                       >
2635 : 48              >            pha         ;use stack to load status
2636 : b509            >            lda zps,x    ;load to memory
2638 : 8d0302          >            sta abst
263b : 28              >            plp
                        
263c : 2e0302                   rol abst
                                tst_abs rROL,fROL,$ff-fnzc
263f : 08              >            php         ;save flags
2640 : ad0302          >            lda abst
2643 : dd2102          >            cmp rROL,x    ;test result
                       >            trap_ne
2646 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2648 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2649 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
264b : dd3902          >            cmp fROL,x    ;test flags
                       >            trap_ne
264e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2650 : ca                       dex
2651 : 10e0                     bpl trol5
                        
2653 : a205                     ldx #5
2655 :                  trolc4
                                set_abs zps,fc
                       >            load_flag fc
2655 : a901            >            lda #fc             ;allow test to change I-flag (no mask)
                       >
2657 : 48              >            pha         ;use stack to load status
2658 : b509            >            lda zps,x    ;load to memory
265a : 8d0302          >            sta abst
265d : 28              >            plp
                        
265e : 2e0302                   rol abst
                                tst_abs rROLc,fROLc,0
2661 : 08              >            php         ;save flags
2662 : ad0302          >            lda abst
2665 : dd2702          >            cmp rROLc,x    ;test result
                       >            trap_ne
2668 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
266a : 68              >            pla         ;load status
                       >            eor_flag 0
266b : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
266d : dd3f02          >            cmp fROLc,x    ;test flags
                       >            trap_ne
2670 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2672 : ca                       dex
2673 : 10e0                     bpl trolc4
2675 : a205                     ldx #5
2677 :                  trolc5
                                set_abs zps,$ff
                       >            load_flag $ff
2677 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2679 : 48              >            pha         ;use stack to load status
267a : b509            >            lda zps,x    ;load to memory
267c : 8d0302          >            sta abst
267f : 28              >            plp
                        
2680 : 2e0302                   rol abst
                                tst_abs rROLc,fROLc,$ff-fnzc
2683 : 08              >            php         ;save flags
2684 : ad0302          >            lda abst
2687 : dd2702          >            cmp rROLc,x    ;test result
                       >            trap_ne
268a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
268c : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
268d : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
268f : dd3f02          >            cmp fROLc,x    ;test flags
                       >            trap_ne
2692 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2694 : ca                       dex
2695 : 10e0                     bpl trolc5
                        
2697 : a205                     ldx #5
2699 :                  tror4
                                set_abs zps,0
                       >            load_flag 0
2699 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
269b : 48              >            pha         ;use stack to load status
269c : b509            >            lda zps,x    ;load to memory
269e : 8d0302          >            sta abst
26a1 : 28              >            plp
                        
26a2 : 6e0302                   ror abst
                                tst_abs rROR,fROR,0
26a5 : 08              >            php         ;save flags
26a6 : ad0302          >            lda abst
26a9 : dd2d02          >            cmp rROR,x    ;test result
                       >            trap_ne
26ac : d0fe            >        bne *           ;failed not equal (non zero)
                       >
26ae : 68              >            pla         ;load status
                       >            eor_flag 0
26af : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
26b1 : dd4502          >            cmp fROR,x    ;test flags
                       >            trap_ne
26b4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
26b6 : ca                       dex
26b7 : 10e0                     bpl tror4
26b9 : a205                     ldx #5
26bb :                  tror5
                                set_abs zps,$ff-fc
                       >            load_flag $ff-fc
26bb : a9fe            >            lda #$ff-fc             ;allow test to change I-flag (no mask)
                       >
26bd : 48              >            pha         ;use stack to load status
26be : b509            >            lda zps,x    ;load to memory
26c0 : 8d0302          >            sta abst
26c3 : 28              >            plp
                        
26c4 : 6e0302                   ror abst
                                tst_abs rROR,fROR,$ff-fnzc
26c7 : 08              >            php         ;save flags
26c8 : ad0302          >            lda abst
26cb : dd2d02          >            cmp rROR,x    ;test result
                       >            trap_ne
26ce : d0fe            >        bne *           ;failed not equal (non zero)
                       >
26d0 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
26d1 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
26d3 : dd4502          >            cmp fROR,x    ;test flags
                       >            trap_ne
26d6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
26d8 : ca                       dex
26d9 : 10e0                     bpl tror5
                        
26db : a205                     ldx #5
26dd :                  trorc4
                                set_abs zps,fc
                       >            load_flag fc
26dd : a901            >            lda #fc             ;allow test to change I-flag (no mask)
                       >
26df : 48              >            pha         ;use stack to load status
26e0 : b509            >            lda zps,x    ;load to memory
26e2 : 8d0302          >            sta abst
26e5 : 28              >            plp
                        
26e6 : 6e0302                   ror abst
                                tst_abs rRORc,fRORc,0
26e9 : 08              >            php         ;save flags
26ea : ad0302          >            lda abst
26ed : dd3302          >            cmp rRORc,x    ;test result
                       >            trap_ne
26f0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
26f2 : 68              >            pla         ;load status
                       >            eor_flag 0
26f3 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
26f5 : dd4b02          >            cmp fRORc,x    ;test flags
                       >            trap_ne
26f8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
26fa : ca                       dex
26fb : 10e0                     bpl trorc4
26fd : a205                     ldx #5
26ff :                  trorc5
                                set_abs zps,$ff
                       >            load_flag $ff
26ff : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2701 : 48              >            pha         ;use stack to load status
2702 : b509            >            lda zps,x    ;load to memory
2704 : 8d0302          >            sta abst
2707 : 28              >            plp
                        
2708 : 6e0302                   ror abst
                                tst_abs rRORc,fRORc,$ff-fnzc
270b : 08              >            php         ;save flags
270c : ad0302          >            lda abst
270f : dd3302          >            cmp rRORc,x    ;test result
                       >            trap_ne
2712 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2714 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2715 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
2717 : dd4b02          >            cmp fRORc,x    ;test flags
                       >            trap_ne
271a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
271c : ca                       dex
271d : 10e0                     bpl trorc5
                                next_test
271f : ad0002          >            lda test_case   ;previous test
2722 : c91f            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
2724 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0020 =                 >test_num = test_num + 1
2726 : a920            >            lda #test_num   ;*** next tests' number
2728 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; shifts - zp indexed
272b : a205                     ldx #5
272d :                  tasl6
                                set_zx zps,0
                       >            load_flag 0
272d : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
272f : 48              >            pha         ;use stack to load status
2730 : b509            >            lda zps,x    ;load to indexed zeropage
2732 : 9502            >            sta zpt,x
2734 : 28              >            plp
                        
2735 : 1602                     asl zpt,x
                                tst_zx rASL,fASL,0
2737 : 08              >            php         ;save flags
2738 : b502            >            lda zpt,x
273a : dd2102          >            cmp rASL,x    ;test result
                       >            trap_ne
273d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
273f : 68              >            pla         ;load status
                       >            eor_flag 0
2740 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2742 : dd3902          >            cmp fASL,x    ;test flags
                       >            trap_ne
2745 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2747 : ca                       dex
2748 : 10e3                     bpl tasl6
274a : a205                     ldx #5
274c :                  tasl7
                                set_zx zps,$ff
                       >            load_flag $ff
274c : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
274e : 48              >            pha         ;use stack to load status
274f : b509            >            lda zps,x    ;load to indexed zeropage
2751 : 9502            >            sta zpt,x
2753 : 28              >            plp
                        
2754 : 1602                     asl zpt,x
                                tst_zx rASL,fASL,$ff-fnzc
2756 : 08              >            php         ;save flags
2757 : b502            >            lda zpt,x
2759 : dd2102          >            cmp rASL,x    ;test result
                       >            trap_ne
275c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
275e : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
275f : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
2761 : dd3902          >            cmp fASL,x    ;test flags
                       >            trap_ne
2764 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2766 : ca                       dex
2767 : 10e3                     bpl tasl7
                        
2769 : a205                     ldx #5
276b :                  tlsr6
                                set_zx zps,0
                       >            load_flag 0
276b : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
276d : 48              >            pha         ;use stack to load status
276e : b509            >            lda zps,x    ;load to indexed zeropage
2770 : 9502            >            sta zpt,x
2772 : 28              >            plp
                        
2773 : 5602                     lsr zpt,x
                                tst_zx rLSR,fLSR,0
2775 : 08              >            php         ;save flags
2776 : b502            >            lda zpt,x
2778 : dd2d02          >            cmp rLSR,x    ;test result
                       >            trap_ne
277b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
277d : 68              >            pla         ;load status
                       >            eor_flag 0
277e : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2780 : dd4502          >            cmp fLSR,x    ;test flags
                       >            trap_ne
2783 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2785 : ca                       dex
2786 : 10e3                     bpl tlsr6
2788 : a205                     ldx #5
278a :                  tlsr7
                                set_zx zps,$ff
                       >            load_flag $ff
278a : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
278c : 48              >            pha         ;use stack to load status
278d : b509            >            lda zps,x    ;load to indexed zeropage
278f : 9502            >            sta zpt,x
2791 : 28              >            plp
                        
2792 : 5602                     lsr zpt,x
                                tst_zx rLSR,fLSR,$ff-fnzc
2794 : 08              >            php         ;save flags
2795 : b502            >            lda zpt,x
2797 : dd2d02          >            cmp rLSR,x    ;test result
                       >            trap_ne
279a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
279c : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
279d : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
279f : dd4502          >            cmp fLSR,x    ;test flags
                       >            trap_ne
27a2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
27a4 : ca                       dex
27a5 : 10e3                     bpl tlsr7
                        
27a7 : a205                     ldx #5
27a9 :                  trol6
                                set_zx zps,0
                       >            load_flag 0
27a9 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
27ab : 48              >            pha         ;use stack to load status
27ac : b509            >            lda zps,x    ;load to indexed zeropage
27ae : 9502            >            sta zpt,x
27b0 : 28              >            plp
                        
27b1 : 3602                     rol zpt,x
                                tst_zx rROL,fROL,0
27b3 : 08              >            php         ;save flags
27b4 : b502            >            lda zpt,x
27b6 : dd2102          >            cmp rROL,x    ;test result
                       >            trap_ne
27b9 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
27bb : 68              >            pla         ;load status
                       >            eor_flag 0
27bc : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
27be : dd3902          >            cmp fROL,x    ;test flags
                       >            trap_ne
27c1 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
27c3 : ca                       dex
27c4 : 10e3                     bpl trol6
27c6 : a205                     ldx #5
27c8 :                  trol7
                                set_zx zps,$ff-fc
                       >            load_flag $ff-fc
27c8 : a9fe            >            lda #$ff-fc             ;allow test to change I-flag (no mask)
                       >
27ca : 48              >            pha         ;use stack to load status
27cb : b509            >            lda zps,x    ;load to indexed zeropage
27cd : 9502            >            sta zpt,x
27cf : 28              >            plp
                        
27d0 : 3602                     rol zpt,x
                                tst_zx rROL,fROL,$ff-fnzc
27d2 : 08              >            php         ;save flags
27d3 : b502            >            lda zpt,x
27d5 : dd2102          >            cmp rROL,x    ;test result
                       >            trap_ne
27d8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
27da : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
27db : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
27dd : dd3902          >            cmp fROL,x    ;test flags
                       >            trap_ne
27e0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
27e2 : ca                       dex
27e3 : 10e3                     bpl trol7
                        
27e5 : a205                     ldx #5
27e7 :                  trolc6
                                set_zx zps,fc
                       >            load_flag fc
27e7 : a901            >            lda #fc             ;allow test to change I-flag (no mask)
                       >
27e9 : 48              >            pha         ;use stack to load status
27ea : b509            >            lda zps,x    ;load to indexed zeropage
27ec : 9502            >            sta zpt,x
27ee : 28              >            plp
                        
27ef : 3602                     rol zpt,x
                                tst_zx rROLc,fROLc,0
27f1 : 08              >            php         ;save flags
27f2 : b502            >            lda zpt,x
27f4 : dd2702          >            cmp rROLc,x    ;test result
                       >            trap_ne
27f7 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
27f9 : 68              >            pla         ;load status
                       >            eor_flag 0
27fa : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
27fc : dd3f02          >            cmp fROLc,x    ;test flags
                       >            trap_ne
27ff : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2801 : ca                       dex
2802 : 10e3                     bpl trolc6
2804 : a205                     ldx #5
2806 :                  trolc7
                                set_zx zps,$ff
                       >            load_flag $ff
2806 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2808 : 48              >            pha         ;use stack to load status
2809 : b509            >            lda zps,x    ;load to indexed zeropage
280b : 9502            >            sta zpt,x
280d : 28              >            plp
                        
280e : 3602                     rol zpt,x
                                tst_zx rROLc,fROLc,$ff-fnzc
2810 : 08              >            php         ;save flags
2811 : b502            >            lda zpt,x
2813 : dd2702          >            cmp rROLc,x    ;test result
                       >            trap_ne
2816 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2818 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2819 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
281b : dd3f02          >            cmp fROLc,x    ;test flags
                       >            trap_ne
281e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2820 : ca                       dex
2821 : 10e3                     bpl trolc7
                        
2823 : a205                     ldx #5
2825 :                  tror6
                                set_zx zps,0
                       >            load_flag 0
2825 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2827 : 48              >            pha         ;use stack to load status
2828 : b509            >            lda zps,x    ;load to indexed zeropage
282a : 9502            >            sta zpt,x
282c : 28              >            plp
                        
282d : 7602                     ror zpt,x
                                tst_zx rROR,fROR,0
282f : 08              >            php         ;save flags
2830 : b502            >            lda zpt,x
2832 : dd2d02          >            cmp rROR,x    ;test result
                       >            trap_ne
2835 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2837 : 68              >            pla         ;load status
                       >            eor_flag 0
2838 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
283a : dd4502          >            cmp fROR,x    ;test flags
                       >            trap_ne
283d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
283f : ca                       dex
2840 : 10e3                     bpl tror6
2842 : a205                     ldx #5
2844 :                  tror7
                                set_zx zps,$ff-fc
                       >            load_flag $ff-fc
2844 : a9fe            >            lda #$ff-fc             ;allow test to change I-flag (no mask)
                       >
2846 : 48              >            pha         ;use stack to load status
2847 : b509            >            lda zps,x    ;load to indexed zeropage
2849 : 9502            >            sta zpt,x
284b : 28              >            plp
                        
284c : 7602                     ror zpt,x
                                tst_zx rROR,fROR,$ff-fnzc
284e : 08              >            php         ;save flags
284f : b502            >            lda zpt,x
2851 : dd2d02          >            cmp rROR,x    ;test result
                       >            trap_ne
2854 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2856 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2857 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
2859 : dd4502          >            cmp fROR,x    ;test flags
                       >            trap_ne
285c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
285e : ca                       dex
285f : 10e3                     bpl tror7
                        
2861 : a205                     ldx #5
2863 :                  trorc6
                                set_zx zps,fc
                       >            load_flag fc
2863 : a901            >            lda #fc             ;allow test to change I-flag (no mask)
                       >
2865 : 48              >            pha         ;use stack to load status
2866 : b509            >            lda zps,x    ;load to indexed zeropage
2868 : 9502            >            sta zpt,x
286a : 28              >            plp
                        
286b : 7602                     ror zpt,x
                                tst_zx rRORc,fRORc,0
286d : 08              >            php         ;save flags
286e : b502            >            lda zpt,x
2870 : dd3302          >            cmp rRORc,x    ;test result
                       >            trap_ne
2873 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2875 : 68              >            pla         ;load status
                       >            eor_flag 0
2876 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2878 : dd4b02          >            cmp fRORc,x    ;test flags
                       >            trap_ne
287b : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
287d : ca                       dex
287e : 10e3                     bpl trorc6
2880 : a205                     ldx #5
2882 :                  trorc7
                                set_zx zps,$ff
                       >            load_flag $ff
2882 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2884 : 48              >            pha         ;use stack to load status
2885 : b509            >            lda zps,x    ;load to indexed zeropage
2887 : 9502            >            sta zpt,x
2889 : 28              >            plp
                        
288a : 7602                     ror zpt,x
                                tst_zx rRORc,fRORc,$ff-fnzc
288c : 08              >            php         ;save flags
288d : b502            >            lda zpt,x
288f : dd3302          >            cmp rRORc,x    ;test result
                       >            trap_ne
2892 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2894 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2895 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
2897 : dd4b02          >            cmp fRORc,x    ;test flags
                       >            trap_ne
289a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
289c : ca                       dex
289d : 10e3                     bpl trorc7
                                next_test
289f : ad0002          >            lda test_case   ;previous test
28a2 : c920            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
28a4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0021 =                 >test_num = test_num + 1
28a6 : a921            >            lda #test_num   ;*** next tests' number
28a8 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                                
                        ; shifts - abs indexed
28ab : a205                     ldx #5
28ad :                  tasl8
                                set_absx zps,0
                       >            load_flag 0
28ad : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
28af : 48              >            pha         ;use stack to load status
28b0 : b509            >            lda zps,x    ;load to indexed memory
28b2 : 9d0302          >            sta abst,x
28b5 : 28              >            plp
                        
28b6 : 1e0302                   asl abst,x
                                tst_absx rASL,fASL,0
28b9 : 08              >            php         ;save flags
28ba : bd0302          >            lda abst,x
28bd : dd2102          >            cmp rASL,x    ;test result
                       >            trap_ne
28c0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
28c2 : 68              >            pla         ;load status
                       >            eor_flag 0
28c3 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
28c5 : dd3902          >            cmp fASL,x    ;test flags
                       >            trap_ne
28c8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
28ca : ca                       dex
28cb : 10e0                     bpl tasl8
28cd : a205                     ldx #5
28cf :                  tasl9
                                set_absx zps,$ff
                       >            load_flag $ff
28cf : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
28d1 : 48              >            pha         ;use stack to load status
28d2 : b509            >            lda zps,x    ;load to indexed memory
28d4 : 9d0302          >            sta abst,x
28d7 : 28              >            plp
                        
28d8 : 1e0302                   asl abst,x
                                tst_absx rASL,fASL,$ff-fnzc
28db : 08              >            php         ;save flags
28dc : bd0302          >            lda abst,x
28df : dd2102          >            cmp rASL,x    ;test result
                       >            trap_ne
28e2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
28e4 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
28e5 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
28e7 : dd3902          >            cmp fASL,x    ;test flags
                       >            trap_ne
28ea : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
28ec : ca                       dex
28ed : 10e0                     bpl tasl9
                        
28ef : a205                     ldx #5
28f1 :                  tlsr8
                                set_absx zps,0
                       >            load_flag 0
28f1 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
28f3 : 48              >            pha         ;use stack to load status
28f4 : b509            >            lda zps,x    ;load to indexed memory
28f6 : 9d0302          >            sta abst,x
28f9 : 28              >            plp
                        
28fa : 5e0302                   lsr abst,x
                                tst_absx rLSR,fLSR,0
28fd : 08              >            php         ;save flags
28fe : bd0302          >            lda abst,x
2901 : dd2d02          >            cmp rLSR,x    ;test result
                       >            trap_ne
2904 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2906 : 68              >            pla         ;load status
                       >            eor_flag 0
2907 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2909 : dd4502          >            cmp fLSR,x    ;test flags
                       >            trap_ne
290c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
290e : ca                       dex
290f : 10e0                     bpl tlsr8
2911 : a205                     ldx #5
2913 :                  tlsr9
                                set_absx zps,$ff
                       >            load_flag $ff
2913 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2915 : 48              >            pha         ;use stack to load status
2916 : b509            >            lda zps,x    ;load to indexed memory
2918 : 9d0302          >            sta abst,x
291b : 28              >            plp
                        
291c : 5e0302                   lsr abst,x
                                tst_absx rLSR,fLSR,$ff-fnzc
291f : 08              >            php         ;save flags
2920 : bd0302          >            lda abst,x
2923 : dd2d02          >            cmp rLSR,x    ;test result
                       >            trap_ne
2926 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2928 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2929 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
292b : dd4502          >            cmp fLSR,x    ;test flags
                       >            trap_ne
292e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2930 : ca                       dex
2931 : 10e0                     bpl tlsr9
                        
2933 : a205                     ldx #5
2935 :                  trol8
                                set_absx zps,0
                       >            load_flag 0
2935 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2937 : 48              >            pha         ;use stack to load status
2938 : b509            >            lda zps,x    ;load to indexed memory
293a : 9d0302          >            sta abst,x
293d : 28              >            plp
                        
293e : 3e0302                   rol abst,x
                                tst_absx rROL,fROL,0
2941 : 08              >            php         ;save flags
2942 : bd0302          >            lda abst,x
2945 : dd2102          >            cmp rROL,x    ;test result
                       >            trap_ne
2948 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
294a : 68              >            pla         ;load status
                       >            eor_flag 0
294b : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
294d : dd3902          >            cmp fROL,x    ;test flags
                       >            trap_ne
2950 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2952 : ca                       dex
2953 : 10e0                     bpl trol8
2955 : a205                     ldx #5
2957 :                  trol9
                                set_absx zps,$ff-fc
                       >            load_flag $ff-fc
2957 : a9fe            >            lda #$ff-fc             ;allow test to change I-flag (no mask)
                       >
2959 : 48              >            pha         ;use stack to load status
295a : b509            >            lda zps,x    ;load to indexed memory
295c : 9d0302          >            sta abst,x
295f : 28              >            plp
                        
2960 : 3e0302                   rol abst,x
                                tst_absx rROL,fROL,$ff-fnzc
2963 : 08              >            php         ;save flags
2964 : bd0302          >            lda abst,x
2967 : dd2102          >            cmp rROL,x    ;test result
                       >            trap_ne
296a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
296c : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
296d : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
296f : dd3902          >            cmp fROL,x    ;test flags
                       >            trap_ne
2972 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2974 : ca                       dex
2975 : 10e0                     bpl trol9
                        
2977 : a205                     ldx #5
2979 :                  trolc8
                                set_absx zps,fc
                       >            load_flag fc
2979 : a901            >            lda #fc             ;allow test to change I-flag (no mask)
                       >
297b : 48              >            pha         ;use stack to load status
297c : b509            >            lda zps,x    ;load to indexed memory
297e : 9d0302          >            sta abst,x
2981 : 28              >            plp
                        
2982 : 3e0302                   rol abst,x
                                tst_absx rROLc,fROLc,0
2985 : 08              >            php         ;save flags
2986 : bd0302          >            lda abst,x
2989 : dd2702          >            cmp rROLc,x    ;test result
                       >            trap_ne
298c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
298e : 68              >            pla         ;load status
                       >            eor_flag 0
298f : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2991 : dd3f02          >            cmp fROLc,x    ;test flags
                       >            trap_ne
2994 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2996 : ca                       dex
2997 : 10e0                     bpl trolc8
2999 : a205                     ldx #5
299b :                  trolc9
                                set_absx zps,$ff
                       >            load_flag $ff
299b : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
299d : 48              >            pha         ;use stack to load status
299e : b509            >            lda zps,x    ;load to indexed memory
29a0 : 9d0302          >            sta abst,x
29a3 : 28              >            plp
                        
29a4 : 3e0302                   rol abst,x
                                tst_absx rROLc,fROLc,$ff-fnzc
29a7 : 08              >            php         ;save flags
29a8 : bd0302          >            lda abst,x
29ab : dd2702          >            cmp rROLc,x    ;test result
                       >            trap_ne
29ae : d0fe            >        bne *           ;failed not equal (non zero)
                       >
29b0 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
29b1 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
29b3 : dd3f02          >            cmp fROLc,x    ;test flags
                       >            trap_ne
29b6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
29b8 : ca                       dex
29b9 : 10e0                     bpl trolc9
                        
29bb : a205                     ldx #5
29bd :                  tror8
                                set_absx zps,0
                       >            load_flag 0
29bd : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
29bf : 48              >            pha         ;use stack to load status
29c0 : b509            >            lda zps,x    ;load to indexed memory
29c2 : 9d0302          >            sta abst,x
29c5 : 28              >            plp
                        
29c6 : 7e0302                   ror abst,x
                                tst_absx rROR,fROR,0
29c9 : 08              >            php         ;save flags
29ca : bd0302          >            lda abst,x
29cd : dd2d02          >            cmp rROR,x    ;test result
                       >            trap_ne
29d0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
29d2 : 68              >            pla         ;load status
                       >            eor_flag 0
29d3 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
29d5 : dd4502          >            cmp fROR,x    ;test flags
                       >            trap_ne
29d8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
29da : ca                       dex
29db : 10e0                     bpl tror8
29dd : a205                     ldx #5
29df :                  tror9
                                set_absx zps,$ff-fc
                       >            load_flag $ff-fc
29df : a9fe            >            lda #$ff-fc             ;allow test to change I-flag (no mask)
                       >
29e1 : 48              >            pha         ;use stack to load status
29e2 : b509            >            lda zps,x    ;load to indexed memory
29e4 : 9d0302          >            sta abst,x
29e7 : 28              >            plp
                        
29e8 : 7e0302                   ror abst,x
                                tst_absx rROR,fROR,$ff-fnzc
29eb : 08              >            php         ;save flags
29ec : bd0302          >            lda abst,x
29ef : dd2d02          >            cmp rROR,x    ;test result
                       >            trap_ne
29f2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
29f4 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
29f5 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
29f7 : dd4502          >            cmp fROR,x    ;test flags
                       >            trap_ne
29fa : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
29fc : ca                       dex
29fd : 10e0                     bpl tror9
                        
29ff : a205                     ldx #5
2a01 :                  trorc8
                                set_absx zps,fc
                       >            load_flag fc
2a01 : a901            >            lda #fc             ;allow test to change I-flag (no mask)
                       >
2a03 : 48              >            pha         ;use stack to load status
2a04 : b509            >            lda zps,x    ;load to indexed memory
2a06 : 9d0302          >            sta abst,x
2a09 : 28              >            plp
                        
2a0a : 7e0302                   ror abst,x
                                tst_absx rRORc,fRORc,0
2a0d : 08              >            php         ;save flags
2a0e : bd0302          >            lda abst,x
2a11 : dd3302          >            cmp rRORc,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 : dd4b02          >            cmp fRORc,x    ;test flags
                       >            trap_ne
2a1c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2a1e : ca                       dex
2a1f : 10e0                     bpl trorc8
2a21 : a205                     ldx #5
2a23 :                  trorc9
                                set_absx zps,$ff
                       >            load_flag $ff
2a23 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2a25 : 48              >            pha         ;use stack to load status
2a26 : b509            >            lda zps,x    ;load to indexed memory
2a28 : 9d0302          >            sta abst,x
2a2b : 28              >            plp
                        
2a2c : 7e0302                   ror abst,x
                                tst_absx rRORc,fRORc,$ff-fnzc
2a2f : 08              >            php         ;save flags
2a30 : bd0302          >            lda abst,x
2a33 : dd3302          >            cmp rRORc,x    ;test result
                       >            trap_ne
2a36 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2a38 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnzc
2a39 : 497c            >            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
                       >
2a3b : dd4b02          >            cmp fRORc,x    ;test flags
                       >            trap_ne
2a3e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2a40 : ca                       dex
2a41 : 10e0                     bpl trorc9
                                next_test
2a43 : ad0002          >            lda test_case   ;previous test
2a46 : c921            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
2a48 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0022 =                 >test_num = test_num + 1
2a4a : a922            >            lda #test_num   ;*** next tests' number
2a4c : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; testing memory increment/decrement - INC DEC all addressing modes
                        ; zeropage
2a4f : a200                     ldx #0
2a51 : a97e                     lda #$7e
2a53 : 8502                     sta zpt
2a55 :                  tinc    
                                set_stat 0
                       >            load_flag 0
2a55 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2a57 : 48              >            pha         ;use stack to load status
2a58 : 28              >            plp
                        
2a59 : e602                     inc zpt
                                tst_z rINC,fINC,0
2a5b : 08              >            php         ;save flags
2a5c : a502            >            lda zpt
2a5e : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2a61 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2a63 : 68              >            pla         ;load status
                       >            eor_flag 0
2a64 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2a66 : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2a69 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2a6b : e8                       inx
2a6c : e002                     cpx #2
2a6e : d004                     bne tinc1
2a70 : a9fe                     lda #$fe
2a72 : 8502                     sta zpt
2a74 : e005             tinc1   cpx #5
2a76 : d0dd                     bne tinc
2a78 : ca                       dex
2a79 : e602                     inc zpt
2a7b :                  tdec    
                                set_stat 0
                       >            load_flag 0
2a7b : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2a7d : 48              >            pha         ;use stack to load status
2a7e : 28              >            plp
                        
2a7f : c602                     dec zpt
                                tst_z rINC,fINC,0
2a81 : 08              >            php         ;save flags
2a82 : a502            >            lda zpt
2a84 : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2a87 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2a89 : 68              >            pla         ;load status
                       >            eor_flag 0
2a8a : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2a8c : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2a8f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2a91 : ca                       dex
2a92 : 300a                     bmi tdec1
2a94 : e001                     cpx #1
2a96 : d0e3                     bne tdec
2a98 : a981                     lda #$81
2a9a : 8502                     sta zpt
2a9c : d0dd                     bne tdec
2a9e :                  tdec1
2a9e : a200                     ldx #0
2aa0 : a97e                     lda #$7e
2aa2 : 8502                     sta zpt
2aa4 :                  tinc10    
                                set_stat $ff
                       >            load_flag $ff
2aa4 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2aa6 : 48              >            pha         ;use stack to load status
2aa7 : 28              >            plp
                        
2aa8 : e602                     inc zpt
                                tst_z rINC,fINC,$ff-fnz
2aaa : 08              >            php         ;save flags
2aab : a502            >            lda zpt
2aad : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2ab0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2ab2 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2ab3 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2ab5 : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2ab8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2aba : e8                       inx
2abb : e002                     cpx #2
2abd : d004                     bne tinc11
2abf : a9fe                     lda #$fe
2ac1 : 8502                     sta zpt
2ac3 : e005             tinc11  cpx #5
2ac5 : d0dd                     bne tinc10
2ac7 : ca                       dex
2ac8 : e602                     inc zpt
2aca :                  tdec10    
                                set_stat $ff
                       >            load_flag $ff
2aca : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2acc : 48              >            pha         ;use stack to load status
2acd : 28              >            plp
                        
2ace : c602                     dec zpt
                                tst_z rINC,fINC,$ff-fnz
2ad0 : 08              >            php         ;save flags
2ad1 : a502            >            lda zpt
2ad3 : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2ad6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2ad8 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2ad9 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2adb : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2ade : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2ae0 : ca                       dex
2ae1 : 300a                     bmi tdec11
2ae3 : e001                     cpx #1
2ae5 : d0e3                     bne tdec10
2ae7 : a981                     lda #$81
2ae9 : 8502                     sta zpt
2aeb : d0dd                     bne tdec10
2aed :                  tdec11
                                next_test
2aed : ad0002          >            lda test_case   ;previous test
2af0 : c922            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
2af2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0023 =                 >test_num = test_num + 1
2af4 : a923            >            lda #test_num   ;*** next tests' number
2af6 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; absolute memory
2af9 : a200                     ldx #0
2afb : a97e                     lda #$7e
2afd : 8d0302                   sta abst
2b00 :                  tinc2    
                                set_stat 0
                       >            load_flag 0
2b00 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2b02 : 48              >            pha         ;use stack to load status
2b03 : 28              >            plp
                        
2b04 : ee0302                   inc abst
                                tst_abs rINC,fINC,0
2b07 : 08              >            php         ;save flags
2b08 : ad0302          >            lda abst
2b0b : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2b0e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2b10 : 68              >            pla         ;load status
                       >            eor_flag 0
2b11 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2b13 : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2b16 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2b18 : e8                       inx
2b19 : e002                     cpx #2
2b1b : d005                     bne tinc3
2b1d : a9fe                     lda #$fe
2b1f : 8d0302                   sta abst
2b22 : e005             tinc3   cpx #5
2b24 : d0da                     bne tinc2
2b26 : ca                       dex
2b27 : ee0302                   inc abst
2b2a :                  tdec2    
                                set_stat 0
                       >            load_flag 0
2b2a : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2b2c : 48              >            pha         ;use stack to load status
2b2d : 28              >            plp
                        
2b2e : ce0302                   dec abst
                                tst_abs rINC,fINC,0
2b31 : 08              >            php         ;save flags
2b32 : ad0302          >            lda abst
2b35 : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2b38 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2b3a : 68              >            pla         ;load status
                       >            eor_flag 0
2b3b : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2b3d : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2b40 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2b42 : ca                       dex
2b43 : 300b                     bmi tdec3
2b45 : e001                     cpx #1
2b47 : d0e1                     bne tdec2
2b49 : a981                     lda #$81
2b4b : 8d0302                   sta abst
2b4e : d0da                     bne tdec2
2b50 :                  tdec3
2b50 : a200                     ldx #0
2b52 : a97e                     lda #$7e
2b54 : 8d0302                   sta abst
2b57 :                  tinc12    
                                set_stat $ff
                       >            load_flag $ff
2b57 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2b59 : 48              >            pha         ;use stack to load status
2b5a : 28              >            plp
                        
2b5b : ee0302                   inc abst
                                tst_abs rINC,fINC,$ff-fnz
2b5e : 08              >            php         ;save flags
2b5f : ad0302          >            lda abst
2b62 : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2b65 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2b67 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2b68 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2b6a : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2b6d : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2b6f : e8                       inx
2b70 : e002                     cpx #2
2b72 : d005                     bne tinc13
2b74 : a9fe                     lda #$fe
2b76 : 8d0302                   sta abst
2b79 : e005             tinc13   cpx #5
2b7b : d0da                     bne tinc12
2b7d : ca                       dex
2b7e : ee0302                   inc abst
2b81 :                  tdec12    
                                set_stat $ff
                       >            load_flag $ff
2b81 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2b83 : 48              >            pha         ;use stack to load status
2b84 : 28              >            plp
                        
2b85 : ce0302                   dec abst
                                tst_abs rINC,fINC,$ff-fnz
2b88 : 08              >            php         ;save flags
2b89 : ad0302          >            lda abst
2b8c : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2b8f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2b91 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2b92 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2b94 : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2b97 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2b99 : ca                       dex
2b9a : 300b                     bmi tdec13
2b9c : e001                     cpx #1
2b9e : d0e1                     bne tdec12
2ba0 : a981                     lda #$81
2ba2 : 8d0302                   sta abst
2ba5 : d0da                     bne tdec12
2ba7 :                  tdec13
                                next_test
2ba7 : ad0002          >            lda test_case   ;previous test
2baa : c923            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
2bac : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0024 =                 >test_num = test_num + 1
2bae : a924            >            lda #test_num   ;*** next tests' number
2bb0 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; zeropage indexed
2bb3 : a200                     ldx #0
2bb5 : a97e                     lda #$7e
2bb7 : 9502             tinc4   sta zpt,x
                                set_stat 0
                       >            load_flag 0
2bb9 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2bbb : 48              >            pha         ;use stack to load status
2bbc : 28              >            plp
                        
2bbd : f602                     inc zpt,x
                                tst_zx rINC,fINC,0
2bbf : 08              >            php         ;save flags
2bc0 : b502            >            lda zpt,x
2bc2 : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2bc5 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2bc7 : 68              >            pla         ;load status
                       >            eor_flag 0
2bc8 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2bca : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2bcd : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2bcf : b502                     lda zpt,x
2bd1 : e8                       inx
2bd2 : e002                     cpx #2
2bd4 : d002                     bne tinc5
2bd6 : a9fe                     lda #$fe
2bd8 : e005             tinc5   cpx #5
2bda : d0db                     bne tinc4
2bdc : ca                       dex
2bdd : a902                     lda #2
2bdf : 9502             tdec4   sta zpt,x 
                                set_stat 0
                       >            load_flag 0
2be1 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2be3 : 48              >            pha         ;use stack to load status
2be4 : 28              >            plp
                        
2be5 : d602                     dec zpt,x
                                tst_zx rINC,fINC,0
2be7 : 08              >            php         ;save flags
2be8 : b502            >            lda zpt,x
2bea : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2bed : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2bef : 68              >            pla         ;load status
                       >            eor_flag 0
2bf0 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2bf2 : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2bf5 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2bf7 : b502                     lda zpt,x
2bf9 : ca                       dex
2bfa : 3008                     bmi tdec5
2bfc : e001                     cpx #1
2bfe : d0df                     bne tdec4
2c00 : a981                     lda #$81
2c02 : d0db                     bne tdec4
2c04 :                  tdec5
2c04 : a200                     ldx #0
2c06 : a97e                     lda #$7e
2c08 : 9502             tinc14  sta zpt,x
                                set_stat $ff
                       >            load_flag $ff
2c0a : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2c0c : 48              >            pha         ;use stack to load status
2c0d : 28              >            plp
                        
2c0e : f602                     inc zpt,x
                                tst_zx rINC,fINC,$ff-fnz
2c10 : 08              >            php         ;save flags
2c11 : b502            >            lda zpt,x
2c13 : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2c16 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2c18 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2c19 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2c1b : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2c1e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2c20 : b502                     lda zpt,x
2c22 : e8                       inx
2c23 : e002                     cpx #2
2c25 : d002                     bne tinc15
2c27 : a9fe                     lda #$fe
2c29 : e005             tinc15  cpx #5
2c2b : d0db                     bne tinc14
2c2d : ca                       dex
2c2e : a902                     lda #2
2c30 : 9502             tdec14  sta zpt,x 
                                set_stat $ff
                       >            load_flag $ff
2c32 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2c34 : 48              >            pha         ;use stack to load status
2c35 : 28              >            plp
                        
2c36 : d602                     dec zpt,x
                                tst_zx rINC,fINC,$ff-fnz
2c38 : 08              >            php         ;save flags
2c39 : b502            >            lda zpt,x
2c3b : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2c3e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2c40 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2c41 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2c43 : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2c46 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2c48 : b502                     lda zpt,x
2c4a : ca                       dex
2c4b : 3008                     bmi tdec15
2c4d : e001                     cpx #1
2c4f : d0df                     bne tdec14
2c51 : a981                     lda #$81
2c53 : d0db                     bne tdec14
2c55 :                  tdec15
                                next_test
2c55 : ad0002          >            lda test_case   ;previous test
2c58 : c924            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
2c5a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0025 =                 >test_num = test_num + 1
2c5c : a925            >            lda #test_num   ;*** next tests' number
2c5e : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; memory indexed
2c61 : a200                     ldx #0
2c63 : a97e                     lda #$7e
2c65 : 9d0302           tinc6   sta abst,x
                                set_stat 0
                       >            load_flag 0
2c68 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2c6a : 48              >            pha         ;use stack to load status
2c6b : 28              >            plp
                        
2c6c : fe0302                   inc abst,x
                                tst_absx rINC,fINC,0
2c6f : 08              >            php         ;save flags
2c70 : bd0302          >            lda abst,x
2c73 : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2c76 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2c78 : 68              >            pla         ;load status
                       >            eor_flag 0
2c79 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2c7b : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2c7e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2c80 : bd0302                   lda abst,x
2c83 : e8                       inx
2c84 : e002                     cpx #2
2c86 : d002                     bne tinc7
2c88 : a9fe                     lda #$fe
2c8a : e005             tinc7   cpx #5
2c8c : d0d7                     bne tinc6
2c8e : ca                       dex
2c8f : a902                     lda #2
2c91 : 9d0302           tdec6   sta abst,x 
                                set_stat 0
                       >            load_flag 0
2c94 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2c96 : 48              >            pha         ;use stack to load status
2c97 : 28              >            plp
                        
2c98 : de0302                   dec abst,x
                                tst_absx rINC,fINC,0
2c9b : 08              >            php         ;save flags
2c9c : bd0302          >            lda abst,x
2c9f : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2ca2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2ca4 : 68              >            pla         ;load status
                       >            eor_flag 0
2ca5 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2ca7 : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2caa : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2cac : bd0302                   lda abst,x
2caf : ca                       dex
2cb0 : 3008                     bmi tdec7
2cb2 : e001                     cpx #1
2cb4 : d0db                     bne tdec6
2cb6 : a981                     lda #$81
2cb8 : d0d7                     bne tdec6
2cba :                  tdec7
2cba : a200                     ldx #0
2cbc : a97e                     lda #$7e
2cbe : 9d0302           tinc16  sta abst,x
                                set_stat $ff
                       >            load_flag $ff
2cc1 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2cc3 : 48              >            pha         ;use stack to load status
2cc4 : 28              >            plp
                        
2cc5 : fe0302                   inc abst,x
                                tst_absx rINC,fINC,$ff-fnz
2cc8 : 08              >            php         ;save flags
2cc9 : bd0302          >            lda abst,x
2ccc : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2ccf : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2cd1 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2cd2 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2cd4 : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2cd7 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2cd9 : bd0302                   lda abst,x
2cdc : e8                       inx
2cdd : e002                     cpx #2
2cdf : d002                     bne tinc17
2ce1 : a9fe                     lda #$fe
2ce3 : e005             tinc17  cpx #5
2ce5 : d0d7                     bne tinc16
2ce7 : ca                       dex
2ce8 : a902                     lda #2
2cea : 9d0302           tdec16  sta abst,x 
                                set_stat $ff
                       >            load_flag $ff
2ced : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2cef : 48              >            pha         ;use stack to load status
2cf0 : 28              >            plp
                        
2cf1 : de0302                   dec abst,x
                                tst_absx rINC,fINC,$ff-fnz
2cf4 : 08              >            php         ;save flags
2cf5 : bd0302          >            lda abst,x
2cf8 : dd5102          >            cmp rINC,x    ;test result
                       >            trap_ne
2cfb : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2cfd : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2cfe : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2d00 : dd5602          >            cmp fINC,x    ;test flags
                       >            trap_ne
2d03 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2d05 : bd0302                   lda abst,x
2d08 : ca                       dex
2d09 : 3008                     bmi tdec17
2d0b : e001                     cpx #1
2d0d : d0db                     bne tdec16
2d0f : a981                     lda #$81
2d11 : d0d7                     bne tdec16
2d13 :                  tdec17
                                next_test
2d13 : ad0002          >            lda test_case   ;previous test
2d16 : c925            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
2d18 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0026 =                 >test_num = test_num + 1
2d1a : a926            >            lda #test_num   ;*** next tests' number
2d1c : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; testing logical instructions - AND EOR ORA all addressing modes
                        ; AND
2d1f : a203                     ldx #3          ;immediate
2d21 : b514             tand    lda zpAN,x
2d23 : 8d0a02                   sta ex_andi+1   ;set AND # operand
                                set_ax  absANa,0
                       >            load_flag 0
2d26 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2d28 : 48              >            pha         ;use stack to load status
2d29 : bd6b02          >            lda absANa,x    ;precharge accu
2d2c : 28              >            plp
                        
2d2d : 200902                   jsr ex_andi     ;execute AND # in RAM
                                tst_ax  absrlo,absflo,0
2d30 : 08              >            php         ;save flags
2d31 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2d34 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2d36 : 68              >            pla         ;load status
                       >            eor_flag 0
2d37 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2d39 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2d3c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2d3e : ca                       dex
2d3f : 10e0                     bpl tand
2d41 : a203                     ldx #3
2d43 : b514             tand1   lda zpAN,x
2d45 : 8d0a02                   sta ex_andi+1   ;set AND # operand
                                set_ax  absANa,$ff
                       >            load_flag $ff
2d48 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2d4a : 48              >            pha         ;use stack to load status
2d4b : bd6b02          >            lda absANa,x    ;precharge accu
2d4e : 28              >            plp
                        
2d4f : 200902                   jsr ex_andi     ;execute AND # in RAM
                                tst_ax  absrlo,absflo,$ff-fnz
2d52 : 08              >            php         ;save flags
2d53 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2d56 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2d58 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2d59 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2d5b : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2d5e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2d60 : ca                       dex
2d61 : 10e0                     bpl tand1
                            
2d63 : a203                     ldx #3      ;zp
2d65 : b514             tand2   lda zpAN,x
2d67 : 8502                     sta zpt
                                set_ax  absANa,0
                       >            load_flag 0
2d69 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2d6b : 48              >            pha         ;use stack to load status
2d6c : bd6b02          >            lda absANa,x    ;precharge accu
2d6f : 28              >            plp
                        
2d70 : 2502                     and zpt
                                tst_ax  absrlo,absflo,0
2d72 : 08              >            php         ;save flags
2d73 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2d76 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2d78 : 68              >            pla         ;load status
                       >            eor_flag 0
2d79 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2d7b : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2d7e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2d80 : ca                       dex
2d81 : 10e2                     bpl tand2
2d83 : a203                     ldx #3
2d85 : b514             tand3   lda zpAN,x
2d87 : 8502                     sta zpt
                                set_ax  absANa,$ff
                       >            load_flag $ff
2d89 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2d8b : 48              >            pha         ;use stack to load status
2d8c : bd6b02          >            lda absANa,x    ;precharge accu
2d8f : 28              >            plp
                        
2d90 : 2502                     and zpt
                                tst_ax  absrlo,absflo,$ff-fnz
2d92 : 08              >            php         ;save flags
2d93 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2d96 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2d98 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2d99 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2d9b : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2d9e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2da0 : ca                       dex
2da1 : 10e2                     bpl tand3
                        
2da3 : a203                     ldx #3      ;abs
2da5 : b514             tand4   lda zpAN,x
2da7 : 8d0302                   sta abst
                                set_ax  absANa,0
                       >            load_flag 0
2daa : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2dac : 48              >            pha         ;use stack to load status
2dad : bd6b02          >            lda absANa,x    ;precharge accu
2db0 : 28              >            plp
                        
2db1 : 2d0302                   and abst
                                tst_ax  absrlo,absflo,0
2db4 : 08              >            php         ;save flags
2db5 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2db8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2dba : 68              >            pla         ;load status
                       >            eor_flag 0
2dbb : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2dbd : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2dc0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2dc2 : ca                       dex
2dc3 : 10e0                     bpl tand4
2dc5 : a203                     ldx #3
2dc7 : b514             tand5   lda zpAN,x
2dc9 : 8d0302                   sta abst
                                set_ax  absANa,$ff
                       >            load_flag $ff
2dcc : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2dce : 48              >            pha         ;use stack to load status
2dcf : bd6b02          >            lda absANa,x    ;precharge accu
2dd2 : 28              >            plp
                        
2dd3 : 2d0302                   and abst
                                tst_ax  absrlo,absflo,$ff-fnz
2dd6 : 08              >            php         ;save flags
2dd7 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2dda : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2ddc : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2ddd : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2ddf : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2de2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2de4 : ca                       dex
2de5 : 1002                     bpl tand6
                        
2de7 : a203                     ldx #3      ;zp,x
2de9 :                  tand6
                                set_ax  absANa,0
                       >            load_flag 0
2de9 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2deb : 48              >            pha         ;use stack to load status
2dec : bd6b02          >            lda absANa,x    ;precharge accu
2def : 28              >            plp
                        
2df0 : 3514                     and zpAN,x
                                tst_ax  absrlo,absflo,0
2df2 : 08              >            php         ;save flags
2df3 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2df6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2df8 : 68              >            pla         ;load status
                       >            eor_flag 0
2df9 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2dfb : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2dfe : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2e00 : ca                       dex
2e01 : 10e6                     bpl tand6
2e03 : a203                     ldx #3
2e05 :                  tand7
                                set_ax  absANa,$ff
                       >            load_flag $ff
2e05 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2e07 : 48              >            pha         ;use stack to load status
2e08 : bd6b02          >            lda absANa,x    ;precharge accu
2e0b : 28              >            plp
                        
2e0c : 3514                     and zpAN,x
                                tst_ax  absrlo,absflo,$ff-fnz
2e0e : 08              >            php         ;save flags
2e0f : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2e12 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2e14 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2e15 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2e17 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2e1a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2e1c : ca                       dex
2e1d : 10e6                     bpl tand7
                        
2e1f : a203                     ldx #3      ;abs,x
2e21 :                  tand8
                                set_ax  absANa,0
                       >            load_flag 0
2e21 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2e23 : 48              >            pha         ;use stack to load status
2e24 : bd6b02          >            lda absANa,x    ;precharge accu
2e27 : 28              >            plp
                        
2e28 : 3d5f02                   and absAN,x
                                tst_ax  absrlo,absflo,0
2e2b : 08              >            php         ;save flags
2e2c : dd7302          >            cmp absrlo,x    ;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 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2e37 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2e39 : ca                       dex
2e3a : 10e5                     bpl tand8
2e3c : a203                     ldx #3
2e3e :                  tand9
                                set_ax  absANa,$ff
                       >            load_flag $ff
2e3e : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2e40 : 48              >            pha         ;use stack to load status
2e41 : bd6b02          >            lda absANa,x    ;precharge accu
2e44 : 28              >            plp
                        
2e45 : 3d5f02                   and absAN,x
                                tst_ax  absrlo,absflo,$ff-fnz
2e48 : 08              >            php         ;save flags
2e49 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2e4c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2e4e : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2e4f : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2e51 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2e54 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2e56 : ca                       dex
2e57 : 10e5                     bpl tand9
                        
2e59 : a003                     ldy #3      ;abs,y
2e5b :                  tand10
                                set_ay  absANa,0
                       >            load_flag 0
2e5b : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2e5d : 48              >            pha         ;use stack to load status
2e5e : b96b02          >            lda absANa,y    ;precharge accu
2e61 : 28              >            plp
                        
2e62 : 395f02                   and absAN,y
                                tst_ay  absrlo,absflo,0
2e65 : 08              >            php         ;save flags
2e66 : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
2e69 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2e6b : 68              >            pla         ;load status
                       >            eor_flag 0
2e6c : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2e6e : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
2e71 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2e73 : 88                       dey
2e74 : 10e5                     bpl tand10
2e76 : a003                     ldy #3
2e78 :                  tand11
                                set_ay  absANa,$ff
                       >            load_flag $ff
2e78 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2e7a : 48              >            pha         ;use stack to load status
2e7b : b96b02          >            lda absANa,y    ;precharge accu
2e7e : 28              >            plp
                        
2e7f : 395f02                   and absAN,y
                                tst_ay  absrlo,absflo,$ff-fnz
2e82 : 08              >            php         ;save flags
2e83 : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
2e86 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2e88 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2e89 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2e8b : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
2e8e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2e90 : 88                       dey
2e91 : 10e5                     bpl tand11
                        
2e93 : a206                     ldx #6      ;(zp,x)
2e95 : a003                     ldy #3
2e97 :                  tand12
                                set_ay  absANa,0
                       >            load_flag 0
2e97 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2e99 : 48              >            pha         ;use stack to load status
2e9a : b96b02          >            lda absANa,y    ;precharge accu
2e9d : 28              >            plp
                        
2e9e : 2132                     and (indAN,x)
                                tst_ay  absrlo,absflo,0
2ea0 : 08              >            php         ;save flags
2ea1 : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
2ea4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2ea6 : 68              >            pla         ;load status
                       >            eor_flag 0
2ea7 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2ea9 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
2eac : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2eae : ca                       dex
2eaf : ca                       dex
2eb0 : 88                       dey
2eb1 : 10e4                     bpl tand12
2eb3 : a206                     ldx #6
2eb5 : a003                     ldy #3
2eb7 :                  tand13
                                set_ay  absANa,$ff
                       >            load_flag $ff
2eb7 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2eb9 : 48              >            pha         ;use stack to load status
2eba : b96b02          >            lda absANa,y    ;precharge accu
2ebd : 28              >            plp
                        
2ebe : 2132                     and (indAN,x)
                                tst_ay  absrlo,absflo,$ff-fnz
2ec0 : 08              >            php         ;save flags
2ec1 : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
2ec4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2ec6 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2ec7 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2ec9 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
2ecc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2ece : ca                       dex
2ecf : ca                       dex
2ed0 : 88                       dey
2ed1 : 10e4                     bpl tand13
                        
2ed3 : a003                     ldy #3      ;(zp),y
2ed5 :                  tand14
                                set_ay  absANa,0
                       >            load_flag 0
2ed5 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2ed7 : 48              >            pha         ;use stack to load status
2ed8 : b96b02          >            lda absANa,y    ;precharge accu
2edb : 28              >            plp
                        
2edc : 3132                     and (indAN),y
                                tst_ay  absrlo,absflo,0
2ede : 08              >            php         ;save flags
2edf : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
2ee2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2ee4 : 68              >            pla         ;load status
                       >            eor_flag 0
2ee5 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2ee7 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
2eea : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2eec : 88                       dey
2eed : 10e6                     bpl tand14
2eef : a003                     ldy #3
2ef1 :                  tand15
                                set_ay  absANa,$ff
                       >            load_flag $ff
2ef1 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2ef3 : 48              >            pha         ;use stack to load status
2ef4 : b96b02          >            lda absANa,y    ;precharge accu
2ef7 : 28              >            plp
                        
2ef8 : 3132                     and (indAN),y
                                tst_ay  absrlo,absflo,$ff-fnz
2efa : 08              >            php         ;save flags
2efb : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
2efe : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2f00 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2f01 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2f03 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
2f06 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2f08 : 88                       dey
2f09 : 10e6                     bpl tand15
                                next_test
2f0b : ad0002          >            lda test_case   ;previous test
2f0e : c926            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
2f10 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0027 =                 >test_num = test_num + 1
2f12 : a927            >            lda #test_num   ;*** next tests' number
2f14 : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; EOR
2f17 : a203                     ldx #3          ;immediate - self modifying code
2f19 : b518             teor    lda zpEO,x
2f1b : 8d0d02                   sta ex_eori+1   ;set EOR # operand
                                set_ax  absEOa,0
                       >            load_flag 0
2f1e : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2f20 : 48              >            pha         ;use stack to load status
2f21 : bd6f02          >            lda absEOa,x    ;precharge accu
2f24 : 28              >            plp
                        
2f25 : 200c02                   jsr ex_eori     ;execute EOR # in RAM
                                tst_ax  absrlo,absflo,0
2f28 : 08              >            php         ;save flags
2f29 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2f2c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2f2e : 68              >            pla         ;load status
                       >            eor_flag 0
2f2f : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2f31 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2f34 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2f36 : ca                       dex
2f37 : 10e0                     bpl teor
2f39 : a203                     ldx #3
2f3b : b518             teor1   lda zpEO,x
2f3d : 8d0d02                   sta ex_eori+1   ;set EOR # operand
                                set_ax  absEOa,$ff
                       >            load_flag $ff
2f40 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2f42 : 48              >            pha         ;use stack to load status
2f43 : bd6f02          >            lda absEOa,x    ;precharge accu
2f46 : 28              >            plp
                        
2f47 : 200c02                   jsr ex_eori     ;execute EOR # in RAM
                                tst_ax  absrlo,absflo,$ff-fnz
2f4a : 08              >            php         ;save flags
2f4b : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2f4e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2f50 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2f51 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2f53 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2f56 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2f58 : ca                       dex
2f59 : 10e0                     bpl teor1
                            
2f5b : a203                     ldx #3      ;zp
2f5d : b518             teor2    lda zpEO,x
2f5f : 8502                     sta zpt
                                set_ax  absEOa,0
                       >            load_flag 0
2f61 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2f63 : 48              >            pha         ;use stack to load status
2f64 : bd6f02          >            lda absEOa,x    ;precharge accu
2f67 : 28              >            plp
                        
2f68 : 4502                     eor zpt
                                tst_ax  absrlo,absflo,0
2f6a : 08              >            php         ;save flags
2f6b : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2f6e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2f70 : 68              >            pla         ;load status
                       >            eor_flag 0
2f71 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2f73 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2f76 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2f78 : ca                       dex
2f79 : 10e2                     bpl teor2
2f7b : a203                     ldx #3
2f7d : b518             teor3   lda zpEO,x
2f7f : 8502                     sta zpt
                                set_ax  absEOa,$ff
                       >            load_flag $ff
2f81 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2f83 : 48              >            pha         ;use stack to load status
2f84 : bd6f02          >            lda absEOa,x    ;precharge accu
2f87 : 28              >            plp
                        
2f88 : 4502                     eor zpt
                                tst_ax  absrlo,absflo,$ff-fnz
2f8a : 08              >            php         ;save flags
2f8b : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2f8e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2f90 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2f91 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2f93 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2f96 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2f98 : ca                       dex
2f99 : 10e2                     bpl teor3
                        
2f9b : a203                     ldx #3      ;abs
2f9d : b518             teor4   lda zpEO,x
2f9f : 8d0302                   sta abst
                                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 : bd6f02          >            lda absEOa,x    ;precharge accu
2fa8 : 28              >            plp
                        
2fa9 : 4d0302                   eor abst
                                tst_ax  absrlo,absflo,0
2fac : 08              >            php         ;save flags
2fad : dd7302          >            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 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2fb8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2fba : ca                       dex
2fbb : 10e0                     bpl teor4
2fbd : a203                     ldx #3
2fbf : b518             teor5   lda zpEO,x
2fc1 : 8d0302                   sta abst
                                set_ax  absEOa,$ff
                       >            load_flag $ff
2fc4 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2fc6 : 48              >            pha         ;use stack to load status
2fc7 : bd6f02          >            lda absEOa,x    ;precharge accu
2fca : 28              >            plp
                        
2fcb : 4d0302                   eor abst
                                tst_ax  absrlo,absflo,$ff-fnz
2fce : 08              >            php         ;save flags
2fcf : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2fd2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2fd4 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
2fd5 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
2fd7 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2fda : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2fdc : ca                       dex
2fdd : 1002                     bpl teor6
                        
2fdf : a203                     ldx #3      ;zp,x
2fe1 :                  teor6
                                set_ax  absEOa,0
                       >            load_flag 0
2fe1 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
2fe3 : 48              >            pha         ;use stack to load status
2fe4 : bd6f02          >            lda absEOa,x    ;precharge accu
2fe7 : 28              >            plp
                        
2fe8 : 5518                     eor zpEO,x
                                tst_ax  absrlo,absflo,0
2fea : 08              >            php         ;save flags
2feb : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
2fee : d0fe            >        bne *           ;failed not equal (non zero)
                       >
2ff0 : 68              >            pla         ;load status
                       >            eor_flag 0
2ff1 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
2ff3 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
2ff6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
2ff8 : ca                       dex
2ff9 : 10e6                     bpl teor6
2ffb : a203                     ldx #3
2ffd :                  teor7
                                set_ax  absEOa,$ff
                       >            load_flag $ff
2ffd : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
2fff : 48              >            pha         ;use stack to load status
3000 : bd6f02          >            lda absEOa,x    ;precharge accu
3003 : 28              >            plp
                        
3004 : 5518                     eor zpEO,x
                                tst_ax  absrlo,absflo,$ff-fnz
3006 : 08              >            php         ;save flags
3007 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
300a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
300c : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
300d : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
300f : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
3012 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
3014 : ca                       dex
3015 : 10e6                     bpl teor7
                        
3017 : a203                     ldx #3      ;abs,x
3019 :                  teor8
                                set_ax  absEOa,0
                       >            load_flag 0
3019 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
301b : 48              >            pha         ;use stack to load status
301c : bd6f02          >            lda absEOa,x    ;precharge accu
301f : 28              >            plp
                        
3020 : 5d6302                   eor absEO,x
                                tst_ax  absrlo,absflo,0
3023 : 08              >            php         ;save flags
3024 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
3027 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
3029 : 68              >            pla         ;load status
                       >            eor_flag 0
302a : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
302c : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
302f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
3031 : ca                       dex
3032 : 10e5                     bpl teor8
3034 : a203                     ldx #3
3036 :                  teor9
                                set_ax  absEOa,$ff
                       >            load_flag $ff
3036 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
3038 : 48              >            pha         ;use stack to load status
3039 : bd6f02          >            lda absEOa,x    ;precharge accu
303c : 28              >            plp
                        
303d : 5d6302                   eor absEO,x
                                tst_ax  absrlo,absflo,$ff-fnz
3040 : 08              >            php         ;save flags
3041 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
3044 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
3046 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
3047 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
3049 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
304c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
304e : ca                       dex
304f : 10e5                     bpl teor9
                        
3051 : a003                     ldy #3      ;abs,y
3053 :                  teor10
                                set_ay  absEOa,0
                       >            load_flag 0
3053 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
3055 : 48              >            pha         ;use stack to load status
3056 : b96f02          >            lda absEOa,y    ;precharge accu
3059 : 28              >            plp
                        
305a : 596302                   eor absEO,y
                                tst_ay  absrlo,absflo,0
305d : 08              >            php         ;save flags
305e : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
3061 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
3063 : 68              >            pla         ;load status
                       >            eor_flag 0
3064 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
3066 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
3069 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
306b : 88                       dey
306c : 10e5                     bpl teor10
306e : a003                     ldy #3
3070 :                  teor11
                                set_ay  absEOa,$ff
                       >            load_flag $ff
3070 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
3072 : 48              >            pha         ;use stack to load status
3073 : b96f02          >            lda absEOa,y    ;precharge accu
3076 : 28              >            plp
                        
3077 : 596302                   eor absEO,y
                                tst_ay  absrlo,absflo,$ff-fnz
307a : 08              >            php         ;save flags
307b : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
307e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
3080 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
3081 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
3083 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
3086 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
3088 : 88                       dey
3089 : 10e5                     bpl teor11
                        
308b : a206                     ldx #6      ;(zp,x)
308d : a003                     ldy #3
308f :                  teor12
                                set_ay  absEOa,0
                       >            load_flag 0
308f : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
3091 : 48              >            pha         ;use stack to load status
3092 : b96f02          >            lda absEOa,y    ;precharge accu
3095 : 28              >            plp
                        
3096 : 413a                     eor (indEO,x)
                                tst_ay  absrlo,absflo,0
3098 : 08              >            php         ;save flags
3099 : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
309c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
309e : 68              >            pla         ;load status
                       >            eor_flag 0
309f : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
30a1 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
30a4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
30a6 : ca                       dex
30a7 : ca                       dex
30a8 : 88                       dey
30a9 : 10e4                     bpl teor12
30ab : a206                     ldx #6
30ad : a003                     ldy #3
30af :                  teor13
                                set_ay  absEOa,$ff
                       >            load_flag $ff
30af : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
30b1 : 48              >            pha         ;use stack to load status
30b2 : b96f02          >            lda absEOa,y    ;precharge accu
30b5 : 28              >            plp
                        
30b6 : 413a                     eor (indEO,x)
                                tst_ay  absrlo,absflo,$ff-fnz
30b8 : 08              >            php         ;save flags
30b9 : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
30bc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
30be : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
30bf : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
30c1 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
30c4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
30c6 : ca                       dex
30c7 : ca                       dex
30c8 : 88                       dey
30c9 : 10e4                     bpl teor13
                        
30cb : a003                     ldy #3      ;(zp),y
30cd :                  teor14
                                set_ay  absEOa,0
                       >            load_flag 0
30cd : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
30cf : 48              >            pha         ;use stack to load status
30d0 : b96f02          >            lda absEOa,y    ;precharge accu
30d3 : 28              >            plp
                        
30d4 : 513a                     eor (indEO),y
                                tst_ay  absrlo,absflo,0
30d6 : 08              >            php         ;save flags
30d7 : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
30da : d0fe            >        bne *           ;failed not equal (non zero)
                       >
30dc : 68              >            pla         ;load status
                       >            eor_flag 0
30dd : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
30df : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
30e2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
30e4 : 88                       dey
30e5 : 10e6                     bpl teor14
30e7 : a003                     ldy #3
30e9 :                  teor15
                                set_ay  absEOa,$ff
                       >            load_flag $ff
30e9 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
30eb : 48              >            pha         ;use stack to load status
30ec : b96f02          >            lda absEOa,y    ;precharge accu
30ef : 28              >            plp
                        
30f0 : 513a                     eor (indEO),y
                                tst_ay  absrlo,absflo,$ff-fnz
30f2 : 08              >            php         ;save flags
30f3 : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
30f6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
30f8 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
30f9 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
30fb : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
30fe : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
3100 : 88                       dey
3101 : 10e6                     bpl teor15
                                next_test
3103 : ad0002          >            lda test_case   ;previous test
3106 : c927            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
3108 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0028 =                 >test_num = test_num + 1
310a : a928            >            lda #test_num   ;*** next tests' number
310c : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; OR
310f : a203                     ldx #3          ;immediate - self modifying code
3111 : b510             tora    lda zpOR,x
3113 : 8d1002                   sta ex_orai+1   ;set ORA # operand
                                set_ax  absORa,0
                       >            load_flag 0
3116 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
3118 : 48              >            pha         ;use stack to load status
3119 : bd6702          >            lda absORa,x    ;precharge accu
311c : 28              >            plp
                        
311d : 200f02                   jsr ex_orai     ;execute ORA # in RAM
                                tst_ax  absrlo,absflo,0
3120 : 08              >            php         ;save flags
3121 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
3124 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
3126 : 68              >            pla         ;load status
                       >            eor_flag 0
3127 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
3129 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
312c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
312e : ca                       dex
312f : 10e0                     bpl tora
3131 : a203                     ldx #3
3133 : b510             tora1   lda zpOR,x
3135 : 8d1002                   sta ex_orai+1   ;set ORA # operand
                                set_ax  absORa,$ff
                       >            load_flag $ff
3138 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
313a : 48              >            pha         ;use stack to load status
313b : bd6702          >            lda absORa,x    ;precharge accu
313e : 28              >            plp
                        
313f : 200f02                   jsr ex_orai     ;execute ORA # in RAM
                                tst_ax  absrlo,absflo,$ff-fnz
3142 : 08              >            php         ;save flags
3143 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
3146 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
3148 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
3149 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
314b : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
314e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
3150 : ca                       dex
3151 : 10e0                     bpl tora1
                            
3153 : a203                     ldx #3      ;zp
3155 : b510             tora2   lda zpOR,x
3157 : 8502                     sta zpt
                                set_ax  absORa,0
                       >            load_flag 0
3159 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
315b : 48              >            pha         ;use stack to load status
315c : bd6702          >            lda absORa,x    ;precharge accu
315f : 28              >            plp
                        
3160 : 0502                     ora zpt
                                tst_ax  absrlo,absflo,0
3162 : 08              >            php         ;save flags
3163 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
3166 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
3168 : 68              >            pla         ;load status
                       >            eor_flag 0
3169 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
316b : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
316e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
3170 : ca                       dex
3171 : 10e2                     bpl tora2
3173 : a203                     ldx #3
3175 : b510             tora3   lda zpOR,x
3177 : 8502                     sta zpt
                                set_ax  absORa,$ff
                       >            load_flag $ff
3179 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
317b : 48              >            pha         ;use stack to load status
317c : bd6702          >            lda absORa,x    ;precharge accu
317f : 28              >            plp
                        
3180 : 0502                     ora zpt
                                tst_ax  absrlo,absflo,$ff-fnz
3182 : 08              >            php         ;save flags
3183 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
3186 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
3188 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
3189 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
318b : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
318e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
3190 : ca                       dex
3191 : 10e2                     bpl tora3
                        
3193 : a203                     ldx #3      ;abs
3195 : b510             tora4   lda zpOR,x
3197 : 8d0302                   sta abst
                                set_ax  absORa,0
                       >            load_flag 0
319a : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
319c : 48              >            pha         ;use stack to load status
319d : bd6702          >            lda absORa,x    ;precharge accu
31a0 : 28              >            plp
                        
31a1 : 0d0302                   ora abst
                                tst_ax  absrlo,absflo,0
31a4 : 08              >            php         ;save flags
31a5 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
31a8 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
31aa : 68              >            pla         ;load status
                       >            eor_flag 0
31ab : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
31ad : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
31b0 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
31b2 : ca                       dex
31b3 : 10e0                     bpl tora4
31b5 : a203                     ldx #3
31b7 : b510             tora5   lda zpOR,x
31b9 : 8d0302                   sta abst
                                set_ax  absORa,$ff
                       >            load_flag $ff
31bc : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
31be : 48              >            pha         ;use stack to load status
31bf : bd6702          >            lda absORa,x    ;precharge accu
31c2 : 28              >            plp
                        
31c3 : 0d0302                   ora abst
                                tst_ax  absrlo,absflo,$ff-fnz
31c6 : 08              >            php         ;save flags
31c7 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
31ca : d0fe            >        bne *           ;failed not equal (non zero)
                       >
31cc : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
31cd : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
31cf : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
31d2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
31d4 : ca                       dex
31d5 : 1002                     bpl tora6
                        
31d7 : a203                     ldx #3      ;zp,x
31d9 :                  tora6
                                set_ax  absORa,0
                       >            load_flag 0
31d9 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
31db : 48              >            pha         ;use stack to load status
31dc : bd6702          >            lda absORa,x    ;precharge accu
31df : 28              >            plp
                        
31e0 : 1510                     ora zpOR,x
                                tst_ax  absrlo,absflo,0
31e2 : 08              >            php         ;save flags
31e3 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
31e6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
31e8 : 68              >            pla         ;load status
                       >            eor_flag 0
31e9 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
31eb : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
31ee : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
31f0 : ca                       dex
31f1 : 10e6                     bpl tora6
31f3 : a203                     ldx #3
31f5 :                  tora7
                                set_ax  absORa,$ff
                       >            load_flag $ff
31f5 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
31f7 : 48              >            pha         ;use stack to load status
31f8 : bd6702          >            lda absORa,x    ;precharge accu
31fb : 28              >            plp
                        
31fc : 1510                     ora zpOR,x
                                tst_ax  absrlo,absflo,$ff-fnz
31fe : 08              >            php         ;save flags
31ff : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
3202 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
3204 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
3205 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
3207 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
320a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
320c : ca                       dex
320d : 10e6                     bpl tora7
                        
320f : a203                     ldx #3      ;abs,x
3211 :                  tora8
                                set_ax  absORa,0
                       >            load_flag 0
3211 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
3213 : 48              >            pha         ;use stack to load status
3214 : bd6702          >            lda absORa,x    ;precharge accu
3217 : 28              >            plp
                        
3218 : 1d5b02                   ora absOR,x
                                tst_ax  absrlo,absflo,0
321b : 08              >            php         ;save flags
321c : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
321f : d0fe            >        bne *           ;failed not equal (non zero)
                       >
3221 : 68              >            pla         ;load status
                       >            eor_flag 0
3222 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
3224 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
3227 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
3229 : ca                       dex
322a : 10e5                     bpl tora8
322c : a203                     ldx #3
322e :                  tora9
                                set_ax  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 : bd6702          >            lda absORa,x    ;precharge accu
3234 : 28              >            plp
                        
3235 : 1d5b02                   ora absOR,x
                                tst_ax  absrlo,absflo,$ff-fnz
3238 : 08              >            php         ;save flags
3239 : dd7302          >            cmp absrlo,x    ;test result
                       >            trap_ne
323c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
323e : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
323f : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
3241 : dd7702          >            cmp absflo,x    ;test flags
                       >            trap_ne     ;
3244 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
3246 : ca                       dex
3247 : 10e5                     bpl tora9
                        
3249 : a003                     ldy #3      ;abs,y
324b :                  tora10
                                set_ay  absORa,0
                       >            load_flag 0
324b : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
324d : 48              >            pha         ;use stack to load status
324e : b96702          >            lda absORa,y    ;precharge accu
3251 : 28              >            plp
                        
3252 : 195b02                   ora absOR,y
                                tst_ay  absrlo,absflo,0
3255 : 08              >            php         ;save flags
3256 : d97302          >            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 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
3261 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
3263 : 88                       dey
3264 : 10e5                     bpl tora10
3266 : a003                     ldy #3
3268 :                  tora11
                                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 : b96702          >            lda absORa,y    ;precharge accu
326e : 28              >            plp
                        
326f : 195b02                   ora absOR,y
                                tst_ay  absrlo,absflo,$ff-fnz
3272 : 08              >            php         ;save flags
3273 : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
3276 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
3278 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
3279 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
327b : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
327e : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
3280 : 88                       dey
3281 : 10e5                     bpl tora11
                        
3283 : a206                     ldx #6      ;(zp,x)
3285 : a003                     ldy #3
3287 :                  tora12
                                set_ay  absORa,0
                       >            load_flag 0
3287 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
3289 : 48              >            pha         ;use stack to load status
328a : b96702          >            lda absORa,y    ;precharge accu
328d : 28              >            plp
                        
328e : 0142                     ora (indOR,x)
                                tst_ay  absrlo,absflo,0
3290 : 08              >            php         ;save flags
3291 : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
3294 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
3296 : 68              >            pla         ;load status
                       >            eor_flag 0
3297 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
3299 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
329c : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
329e : ca                       dex
329f : ca                       dex
32a0 : 88                       dey
32a1 : 10e4                     bpl tora12
32a3 : a206                     ldx #6
32a5 : a003                     ldy #3
32a7 :                  tora13
                                set_ay  absORa,$ff
                       >            load_flag $ff
32a7 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
32a9 : 48              >            pha         ;use stack to load status
32aa : b96702          >            lda absORa,y    ;precharge accu
32ad : 28              >            plp
                        
32ae : 0142                     ora (indOR,x)
                                tst_ay  absrlo,absflo,$ff-fnz
32b0 : 08              >            php         ;save flags
32b1 : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
32b4 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
32b6 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
32b7 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
32b9 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
32bc : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
32be : ca                       dex
32bf : ca                       dex
32c0 : 88                       dey
32c1 : 10e4                     bpl tora13
                        
32c3 : a003                     ldy #3      ;(zp),y
32c5 :                  tora14
                                set_ay  absORa,0
                       >            load_flag 0
32c5 : a900            >            lda #0             ;allow test to change I-flag (no mask)
                       >
32c7 : 48              >            pha         ;use stack to load status
32c8 : b96702          >            lda absORa,y    ;precharge accu
32cb : 28              >            plp
                        
32cc : 1142                     ora (indOR),y
                                tst_ay  absrlo,absflo,0
32ce : 08              >            php         ;save flags
32cf : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
32d2 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
32d4 : 68              >            pla         ;load status
                       >            eor_flag 0
32d5 : 4930            >            eor #0|fao         ;invert expected flags + always on bits
                       >
32d7 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
32da : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
32dc : 88                       dey
32dd : 10e6                     bpl tora14
32df : a003                     ldy #3
32e1 :                  tora15
                                set_ay  absORa,$ff
                       >            load_flag $ff
32e1 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
32e3 : 48              >            pha         ;use stack to load status
32e4 : b96702          >            lda absORa,y    ;precharge accu
32e7 : 28              >            plp
                        
32e8 : 1142                     ora (indOR),y
                                tst_ay  absrlo,absflo,$ff-fnz
32ea : 08              >            php         ;save flags
32eb : d97302          >            cmp absrlo,y    ;test result
                       >            trap_ne     ;
32ee : d0fe            >        bne *           ;failed not equal (non zero)
                       >
32f0 : 68              >            pla         ;load status
                       >            eor_flag $ff-fnz
32f1 : 497d            >            eor #$ff-fnz|fao         ;invert expected flags + always on bits
                       >
32f3 : d97702          >            cmp absflo,y    ;test flags
                       >            trap_ne
32f6 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
                        
32f8 : 88                       dey
32f9 : 10e6                     bpl tora15
                            if I_flag = 3
32fb : 58                       cli
                            endif                
                                next_test
32fc : ad0002          >            lda test_case   ;previous test
32ff : c928            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
3301 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
0029 =                 >test_num = test_num + 1
3303 : a929            >            lda #test_num   ;*** next tests' number
3305 : 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
3308 : d8                       cld
3309 : a204                     ldx #ad2        ;for indexed test
330b : a0ff                     ldy #$ff        ;max range
330d : a900                     lda #0          ;start with adding zeroes & no carry
330f : 8502                     sta adfc        ;carry in - for diag
3311 : 8503                     sta ad1         ;operand 1 - accumulator
3313 : 8504                     sta ad2         ;operand 2 - memory or immediate
3315 : 8d0302                   sta ada2        ;non zp
3318 : 8505                     sta adrl        ;expected result bits 0-7
331a : 8506                     sta adrh        ;expected result bit 8 (carry out)
331c : a9ff                     lda #$ff        ;complemented operand 2 for subtract
331e : 8508                     sta sb2
3320 : 8d0402                   sta sba2        ;non zp
3323 : a902                     lda #2          ;expected Z-flag
3325 : 8507                     sta adrf
3327 : 18               tadd    clc             ;test with carry clear
3328 : 20a235                   jsr chkadd
332b : e602                     inc adfc        ;now with carry
332d : e605                     inc adrl        ;result +1
332f : 08                       php             ;save N & Z from low result
3330 : 08                       php
3331 : 68                       pla             ;accu holds expected flags
3332 : 2982                     and #$82        ;mask N & Z
3334 : 28                       plp
3335 : d002                     bne tadd1
3337 : e606                     inc adrh        ;result bit 8 - carry
3339 : 0506             tadd1   ora adrh        ;merge C to expected flags
333b : 8507                     sta adrf        ;save expected flags except overflow
333d : 38                       sec             ;test with carry set
333e : 20a235                   jsr chkadd
3341 : c602                     dec adfc        ;same for operand +1 but no carry
3343 : e603                     inc ad1
3345 : d0e0                     bne tadd        ;iterate op1
3347 : a900                     lda #0          ;preset result to op2 when op1 = 0
3349 : 8506                     sta adrh
334b : ee0302                   inc ada2
334e : e604                     inc ad2
3350 : 08                       php             ;save NZ as operand 2 becomes the new result
3351 : 68                       pla
3352 : 2982                     and #$82        ;mask N00000Z0
3354 : 8507                     sta adrf        ;no need to check carry as we are adding to 0
3356 : c608                     dec sb2         ;complement subtract operand 2
3358 : ce0402                   dec sba2
335b : a504                     lda ad2         
335d : 8505                     sta adrl
335f : d0c6                     bne tadd        ;iterate op2
                            if disable_decimal < 1
                                next_test
3361 : ad0002          >            lda test_case   ;previous test
3364 : c929            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
3366 : d0fe            >        bne *           ;failed not equal (non zero)
                       >
002a =                 >test_num = test_num + 1
3368 : a92a            >            lda #test_num   ;*** next tests' number
336a : 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
336d : f8                       sed 
336e : a204                     ldx #ad2        ;for indexed test
3370 : a0ff                     ldy #$ff        ;max range
3372 : a999                     lda #$99        ;start with adding 99 to 99 with carry
3374 : 8503                     sta ad1         ;operand 1 - accumulator
3376 : 8504                     sta ad2         ;operand 2 - memory or immediate
3378 : 8d0302                   sta ada2        ;non zp
337b : 8505                     sta adrl        ;expected result bits 0-7
337d : a901                     lda #1          ;set carry in & out
337f : 8502                     sta adfc        ;carry in - for diag
3381 : 8506                     sta adrh        ;expected result bit 8 (carry out)
3383 : a900                     lda #0          ;complemented operand 2 for subtract
3385 : 8508                     sta sb2
3387 : 8d0402                   sta sba2        ;non zp
338a : 38               tdad    sec             ;test with carry set
338b : 206f34                   jsr chkdad
338e : c602                     dec adfc        ;now with carry clear
3390 : a505                     lda adrl        ;decimal adjust result
3392 : d008                     bne tdad1       ;skip clear carry & preset result 99 (9A-1)
3394 : c606                     dec adrh
3396 : a999                     lda #$99
3398 : 8505                     sta adrl
339a : d012                     bne tdad3
339c : 290f             tdad1   and #$f         ;lower nibble mask
339e : d00c                     bne tdad2       ;no decimal adjust needed
33a0 : c605                     dec adrl        ;decimal adjust (?0-6)
33a2 : c605                     dec adrl
33a4 : c605                     dec adrl
33a6 : c605                     dec adrl
33a8 : c605                     dec adrl
33aa : c605                     dec adrl
33ac : c605             tdad2   dec adrl        ;result -1
33ae : 18               tdad3   clc             ;test with carry clear
33af : 206f34                   jsr chkdad
33b2 : e602                     inc adfc        ;same for operand -1 but with carry
33b4 : a503                     lda ad1         ;decimal adjust operand 1
33b6 : f015                     beq tdad5       ;iterate operand 2
33b8 : 290f                     and #$f         ;lower nibble mask
33ba : d00c                     bne tdad4       ;skip decimal adjust
33bc : c603                     dec ad1         ;decimal adjust (?0-6)
33be : c603                     dec ad1
33c0 : c603                     dec ad1
33c2 : c603                     dec ad1
33c4 : c603                     dec ad1
33c6 : c603                     dec ad1
33c8 : c603             tdad4   dec ad1         ;operand 1 -1
33ca : 4c8a33                   jmp tdad        ;iterate op1
                        
33cd : a999             tdad5   lda #$99        ;precharge op1 max
33cf : 8503                     sta ad1
33d1 : a504                     lda ad2         ;decimal adjust operand 2
33d3 : f030                     beq tdad7       ;end of iteration
33d5 : 290f                     and #$f         ;lower nibble mask
33d7 : d018                     bne tdad6       ;skip decimal adjust
33d9 : c604                     dec ad2         ;decimal adjust (?0-6)
33db : c604                     dec ad2
33dd : c604                     dec ad2
33df : c604                     dec ad2
33e1 : c604                     dec ad2
33e3 : c604                     dec ad2
33e5 : e608                     inc sb2         ;complemented decimal adjust for subtract (?9+6)
33e7 : e608                     inc sb2
33e9 : e608                     inc sb2
33eb : e608                     inc sb2
33ed : e608                     inc sb2
33ef : e608                     inc sb2
33f1 : c604             tdad6   dec ad2         ;operand 2 -1
33f3 : e608                     inc sb2         ;complemented operand for subtract
33f5 : a508                     lda sb2
33f7 : 8d0402                   sta sba2        ;copy as non zp operand
33fa : a504                     lda ad2
33fc : 8d0302                   sta ada2        ;copy as non zp operand
33ff : 8505                     sta adrl        ;new result since op1+carry=00+carry +op2=op2
3401 : e606                     inc adrh        ;result carry
3403 : d085                     bne tdad        ;iterate op2
3405 :                  tdad7
                                next_test
3405 : ad0002          >            lda test_case   ;previous test
3408 : c92a            >            cmp #test_num
                       >            trap_ne         ;test is out of sequence
340a : d0fe            >        bne *           ;failed not equal (non zero)
                       >
002b =                 >test_num = test_num + 1
340c : a92b            >            lda #test_num   ;*** next tests' number
340e : 8d0002          >            sta test_case
                       >            ;check_ram       ;uncomment to find altered RAM after each test
                        
                        
                        ; decimal/binary switch test
                        ; tests CLD, SED, PLP, RTI to properly switch between decimal & binary opcode
                        ;   tables
3411 : 18                       clc
3412 : d8                       cld
3413 : 08                       php
3414 : a955                     lda #$55
3416 : 6955                     adc #$55
3418 : c9aa                     cmp #$aa
                                trap_ne         ;expected binary result after cld
341a : d0fe            >        bne *           ;failed not equal (non zero)
                        
341c : 18                       clc
341d : f8                       sed
341e : 08                       php
341f : a955                     lda #$55
3421 : 6955                     adc #$55
3423 : c910                     cmp #$10
                                trap_ne         ;expected decimal result after sed
3425 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3427 : d8                       cld
3428 : 28                       plp
3429 : a955                     lda #$55
342b : 6955                     adc #$55
342d : c910                     cmp #$10
                                trap_ne         ;expected decimal result after plp D=1
342f : d0fe            >        bne *           ;failed not equal (non zero)
                        
3431 : 28                       plp
3432 : a955                     lda #$55
3434 : 6955                     adc #$55
3436 : c9aa                     cmp #$aa
                                trap_ne         ;expected binary result after plp D=0
3438 : d0fe            >        bne *           ;failed not equal (non zero)
                        
343a : 18                       clc
343b : a934                     lda #hi bin_rti_ret ;emulated interrupt for rti
343d : 48                       pha
343e : a955                     lda #lo bin_rti_ret
3440 : 48                       pha
3441 : 08                       php
3442 : f8                       sed
3443 : a934                     lda #hi dec_rti_ret ;emulated interrupt for rti
3445 : 48                       pha
3446 : a94c                     lda #lo dec_rti_ret
3448 : 48                       pha
3449 : 08                       php
344a : d8                       cld
344b : 40                       rti
344c :                  dec_rti_ret
344c : a955                     lda #$55
344e : 6955                     adc #$55
3450 : c910                     cmp #$10
                                trap_ne         ;expected decimal result after rti D=1
3452 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3454 : 40                       rti
3455 :                  bin_rti_ret        
3455 : a955                     lda #$55
3457 : 6955                     adc #$55
3459 : c9aa                     cmp #$aa
                                trap_ne         ;expected binary result after rti D=0
345b : d0fe            >        bne *           ;failed not equal (non zero)
                        
                            endif
                            
345d : ad0002                   lda test_case
3460 : c92b                     cmp #test_num
                                trap_ne         ;previous test is out of sequence
3462 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3464 : a9f0                     lda #$f0        ;mark opcode testing complete
3466 : 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
3469 : 4c6934          >        jmp *           ;test passed, no errors
                        
                        ; -------------       
                        ; S U C C E S S ************************************************
346c : 4c0004                   jmp start       ;run again      
                        
                            if disable_decimal < 1
                        ; 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
346f :                  chkdad
                        ; decimal ADC / SBC zp
346f : 08                       php             ;save carry for subtract
3470 : a503                     lda ad1
3472 : 6504                     adc ad2         ;perform add
3474 : 08                       php          
3475 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3477 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3479 : 68                       pla             ;check flags
347a : 2901                     and #1          ;mask carry
347c : c506                     cmp adrh
                                trap_ne         ;bad carry
347e : d0fe            >        bne *           ;failed not equal (non zero)
                        
3480 : 28                       plp
3481 : 08                       php             ;save carry for next add
3482 : a503                     lda ad1
3484 : e508                     sbc sb2         ;perform subtract
3486 : 08                       php          
3487 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3489 : d0fe            >        bne *           ;failed not equal (non zero)
                        
348b : 68                       pla             ;check flags
348c : 2901                     and #1          ;mask carry
348e : c506                     cmp adrh
                                trap_ne         ;bad flags
3490 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3492 : 28                       plp
                        ; decimal ADC / SBC abs
3493 : 08                       php             ;save carry for subtract
3494 : a503                     lda ad1
3496 : 6d0302                   adc ada2        ;perform add
3499 : 08                       php          
349a : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
349c : d0fe            >        bne *           ;failed not equal (non zero)
                        
349e : 68                       pla             ;check flags
349f : 2901                     and #1          ;mask carry
34a1 : c506                     cmp adrh
                                trap_ne         ;bad carry
34a3 : d0fe            >        bne *           ;failed not equal (non zero)
                        
34a5 : 28                       plp
34a6 : 08                       php             ;save carry for next add
34a7 : a503                     lda ad1
34a9 : ed0402                   sbc sba2        ;perform subtract
34ac : 08                       php          
34ad : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
34af : d0fe            >        bne *           ;failed not equal (non zero)
                        
34b1 : 68                       pla             ;check flags
34b2 : 2901                     and #1          ;mask carry
34b4 : c506                     cmp adrh
                                trap_ne         ;bad carry
34b6 : d0fe            >        bne *           ;failed not equal (non zero)
                        
34b8 : 28                       plp
                        ; decimal ADC / SBC #
34b9 : 08                       php             ;save carry for subtract
34ba : a504                     lda ad2
34bc : 8d1302                   sta ex_adci+1   ;set ADC # operand
34bf : a503                     lda ad1
34c1 : 201202                   jsr ex_adci     ;execute ADC # in RAM
34c4 : 08                       php          
34c5 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
34c7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
34c9 : 68                       pla             ;check flags
34ca : 2901                     and #1          ;mask carry
34cc : c506                     cmp adrh
                                trap_ne         ;bad carry
34ce : d0fe            >        bne *           ;failed not equal (non zero)
                        
34d0 : 28                       plp
34d1 : 08                       php             ;save carry for next add
34d2 : a508                     lda sb2
34d4 : 8d1602                   sta ex_sbci+1   ;set SBC # operand
34d7 : a503                     lda ad1
34d9 : 201502                   jsr ex_sbci     ;execute SBC # in RAM
34dc : 08                       php          
34dd : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
34df : d0fe            >        bne *           ;failed not equal (non zero)
                        
34e1 : 68                       pla             ;check flags
34e2 : 2901                     and #1          ;mask carry
34e4 : c506                     cmp adrh
                                trap_ne         ;bad carry
34e6 : d0fe            >        bne *           ;failed not equal (non zero)
                        
34e8 : 28                       plp
                        ; decimal ADC / SBC zp,x
34e9 : 08                       php             ;save carry for subtract
34ea : a503                     lda ad1
34ec : 7500                     adc 0,x         ;perform add
34ee : 08                       php          
34ef : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
34f1 : d0fe            >        bne *           ;failed not equal (non zero)
                        
34f3 : 68                       pla             ;check flags
34f4 : 2901                     and #1          ;mask carry
34f6 : c506                     cmp adrh
                                trap_ne         ;bad carry
34f8 : d0fe            >        bne *           ;failed not equal (non zero)
                        
34fa : 28                       plp
34fb : 08                       php             ;save carry for next add
34fc : a503                     lda ad1
34fe : f504                     sbc sb2-ad2,x   ;perform subtract
3500 : 08                       php          
3501 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3503 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3505 : 68                       pla             ;check flags
3506 : 2901                     and #1          ;mask carry
3508 : c506                     cmp adrh
                                trap_ne         ;bad carry
350a : d0fe            >        bne *           ;failed not equal (non zero)
                        
350c : 28                       plp
                        ; decimal ADC / SBC abs,x
350d : 08                       php             ;save carry for subtract
350e : a503                     lda ad1
3510 : 7dff01                   adc ada2-ad2,x  ;perform add
3513 : 08                       php          
3514 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3516 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3518 : 68                       pla             ;check flags
3519 : 2901                     and #1          ;mask carry
351b : c506                     cmp adrh
                                trap_ne         ;bad carry
351d : d0fe            >        bne *           ;failed not equal (non zero)
                        
351f : 28                       plp
3520 : 08                       php             ;save carry for next add
3521 : a503                     lda ad1
3523 : fd0002                   sbc sba2-ad2,x  ;perform subtract
3526 : 08                       php          
3527 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3529 : d0fe            >        bne *           ;failed not equal (non zero)
                        
352b : 68                       pla             ;check flags
352c : 2901                     and #1          ;mask carry
352e : c506                     cmp adrh
                                trap_ne         ;bad carry
3530 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3532 : 28                       plp
                        ; decimal ADC / SBC abs,y
3533 : 08                       php             ;save carry for subtract
3534 : a503                     lda ad1
3536 : 790401                   adc ada2-$ff,y  ;perform add
3539 : 08                       php          
353a : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
353c : d0fe            >        bne *           ;failed not equal (non zero)
                        
353e : 68                       pla             ;check flags
353f : 2901                     and #1          ;mask carry
3541 : c506                     cmp adrh
                                trap_ne         ;bad carry
3543 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3545 : 28                       plp
3546 : 08                       php             ;save carry for next add
3547 : a503                     lda ad1
3549 : f90501                   sbc sba2-$ff,y  ;perform subtract
354c : 08                       php          
354d : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
354f : d0fe            >        bne *           ;failed not equal (non zero)
                        
3551 : 68                       pla             ;check flags
3552 : 2901                     and #1          ;mask carry
3554 : c506                     cmp adrh
                                trap_ne         ;bad carry
3556 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3558 : 28                       plp
                        ; decimal ADC / SBC (zp,x)
3559 : 08                       php             ;save carry for subtract
355a : a503                     lda ad1
355c : 6146                     adc (lo adi2-ad2,x) ;perform add
355e : 08                       php          
355f : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3561 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3563 : 68                       pla             ;check flags
3564 : 2901                     and #1          ;mask carry
3566 : c506                     cmp adrh
                                trap_ne         ;bad carry
3568 : d0fe            >        bne *           ;failed not equal (non zero)
                        
356a : 28                       plp
356b : 08                       php             ;save carry for next add
356c : a503                     lda ad1
356e : e148                     sbc (lo sbi2-ad2,x) ;perform subtract
3570 : 08                       php          
3571 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3573 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3575 : 68                       pla             ;check flags
3576 : 2901                     and #1          ;mask carry
3578 : c506                     cmp adrh
                                trap_ne         ;bad carry
357a : d0fe            >        bne *           ;failed not equal (non zero)
                        
357c : 28                       plp
                        ; decimal ADC / SBC (abs),y
357d : 08                       php             ;save carry for subtract
357e : a503                     lda ad1
3580 : 714e                     adc (adiy2),y   ;perform add
3582 : 08                       php          
3583 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3585 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3587 : 68                       pla             ;check flags
3588 : 2901                     and #1          ;mask carry
358a : c506                     cmp adrh
                                trap_ne         ;bad carry
358c : d0fe            >        bne *           ;failed not equal (non zero)
                        
358e : 28                       plp
358f : 08                       php             ;save carry for next add
3590 : a503                     lda ad1
3592 : f150                     sbc (sbiy2),y   ;perform subtract
3594 : 08                       php          
3595 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3597 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3599 : 68                       pla             ;check flags
359a : 2901                     and #1          ;mask carry
359c : c506                     cmp adrh
                                trap_ne         ;bad carry
359e : d0fe            >        bne *           ;failed not equal (non zero)
                        
35a0 : 28                       plp
35a1 : 60                       rts
                            endif
                        
                        ; 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
35a2 : a507             chkadd  lda adrf        ;add V-flag if overflow
35a4 : 2983                     and #$83        ;keep N-----ZC / clear V
35a6 : 48                       pha
35a7 : a503                     lda ad1         ;test sign unequal between operands
35a9 : 4504                     eor ad2
35ab : 300a                     bmi ckad1       ;no overflow possible - operands have different sign
35ad : a503                     lda ad1         ;test sign equal between operands and result
35af : 4505                     eor adrl
35b1 : 1004                     bpl ckad1       ;no overflow occured - operand and result have same sign
35b3 : 68                       pla
35b4 : 0940                     ora #$40        ;set V
35b6 : 48                       pha
35b7 : 68               ckad1   pla
35b8 : 8507                     sta adrf        ;save expected flags
                        ; binary ADC / SBC zp
35ba : 08                       php             ;save carry for subtract
35bb : a503                     lda ad1
35bd : 6504                     adc ad2         ;perform add
35bf : 08                       php          
35c0 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
35c2 : d0fe            >        bne *           ;failed not equal (non zero)
                        
35c4 : 68                       pla             ;check flags
35c5 : 29c3                     and #$c3        ;mask NV----ZC
35c7 : c507                     cmp adrf
                                trap_ne         ;bad flags
35c9 : d0fe            >        bne *           ;failed not equal (non zero)
                        
35cb : 28                       plp
35cc : 08                       php             ;save carry for next add
35cd : a503                     lda ad1
35cf : e508                     sbc sb2         ;perform subtract
35d1 : 08                       php          
35d2 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
35d4 : d0fe            >        bne *           ;failed not equal (non zero)
                        
35d6 : 68                       pla             ;check flags
35d7 : 29c3                     and #$c3        ;mask NV----ZC
35d9 : c507                     cmp adrf
                                trap_ne         ;bad flags
35db : d0fe            >        bne *           ;failed not equal (non zero)
                        
35dd : 28                       plp
                        ; binary ADC / SBC abs
35de : 08                       php             ;save carry for subtract
35df : a503                     lda ad1
35e1 : 6d0302                   adc ada2        ;perform add
35e4 : 08                       php          
35e5 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
35e7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
35e9 : 68                       pla             ;check flags
35ea : 29c3                     and #$c3        ;mask NV----ZC
35ec : c507                     cmp adrf
                                trap_ne         ;bad flags
35ee : d0fe            >        bne *           ;failed not equal (non zero)
                        
35f0 : 28                       plp
35f1 : 08                       php             ;save carry for next add
35f2 : a503                     lda ad1
35f4 : ed0402                   sbc sba2        ;perform subtract
35f7 : 08                       php          
35f8 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
35fa : d0fe            >        bne *           ;failed not equal (non zero)
                        
35fc : 68                       pla             ;check flags
35fd : 29c3                     and #$c3        ;mask NV----ZC
35ff : c507                     cmp adrf
                                trap_ne         ;bad flags
3601 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3603 : 28                       plp
                        ; binary ADC / SBC #
3604 : 08                       php             ;save carry for subtract
3605 : a504                     lda ad2
3607 : 8d1302                   sta ex_adci+1   ;set ADC # operand
360a : a503                     lda ad1
360c : 201202                   jsr ex_adci     ;execute ADC # in RAM
360f : 08                       php          
3610 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3612 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3614 : 68                       pla             ;check flags
3615 : 29c3                     and #$c3        ;mask NV----ZC
3617 : c507                     cmp adrf
                                trap_ne         ;bad flags
3619 : d0fe            >        bne *           ;failed not equal (non zero)
                        
361b : 28                       plp
361c : 08                       php             ;save carry for next add
361d : a508                     lda sb2
361f : 8d1602                   sta ex_sbci+1   ;set SBC # operand
3622 : a503                     lda ad1
3624 : 201502                   jsr ex_sbci     ;execute SBC # in RAM
3627 : 08                       php          
3628 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
362a : d0fe            >        bne *           ;failed not equal (non zero)
                        
362c : 68                       pla             ;check flags
362d : 29c3                     and #$c3        ;mask NV----ZC
362f : c507                     cmp adrf
                                trap_ne         ;bad flags
3631 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3633 : 28                       plp
                        ; binary ADC / SBC zp,x
3634 : 08                       php             ;save carry for subtract
3635 : a503                     lda ad1
3637 : 7500                     adc 0,x         ;perform add
3639 : 08                       php          
363a : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
363c : d0fe            >        bne *           ;failed not equal (non zero)
                        
363e : 68                       pla             ;check flags
363f : 29c3                     and #$c3        ;mask NV----ZC
3641 : c507                     cmp adrf
                                trap_ne         ;bad flags
3643 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3645 : 28                       plp
3646 : 08                       php             ;save carry for next add
3647 : a503                     lda ad1
3649 : f504                     sbc sb2-ad2,x   ;perform subtract
364b : 08                       php          
364c : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
364e : d0fe            >        bne *           ;failed not equal (non zero)
                        
3650 : 68                       pla             ;check flags
3651 : 29c3                     and #$c3        ;mask NV----ZC
3653 : c507                     cmp adrf
                                trap_ne         ;bad flags
3655 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3657 : 28                       plp
                        ; binary ADC / SBC abs,x
3658 : 08                       php             ;save carry for subtract
3659 : a503                     lda ad1
365b : 7dff01                   adc ada2-ad2,x  ;perform add
365e : 08                       php          
365f : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3661 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3663 : 68                       pla             ;check flags
3664 : 29c3                     and #$c3        ;mask NV----ZC
3666 : c507                     cmp adrf
                                trap_ne         ;bad flags
3668 : d0fe            >        bne *           ;failed not equal (non zero)
                        
366a : 28                       plp
366b : 08                       php             ;save carry for next add
366c : a503                     lda ad1
366e : fd0002                   sbc sba2-ad2,x  ;perform subtract
3671 : 08                       php          
3672 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3674 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3676 : 68                       pla             ;check flags
3677 : 29c3                     and #$c3        ;mask NV----ZC
3679 : c507                     cmp adrf
                                trap_ne         ;bad flags
367b : d0fe            >        bne *           ;failed not equal (non zero)
                        
367d : 28                       plp
                        ; binary ADC / SBC abs,y
367e : 08                       php             ;save carry for subtract
367f : a503                     lda ad1
3681 : 790401                   adc ada2-$ff,y  ;perform add
3684 : 08                       php          
3685 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
3687 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3689 : 68                       pla             ;check flags
368a : 29c3                     and #$c3        ;mask NV----ZC
368c : c507                     cmp adrf
                                trap_ne         ;bad flags
368e : d0fe            >        bne *           ;failed not equal (non zero)
                        
3690 : 28                       plp
3691 : 08                       php             ;save carry for next add
3692 : a503                     lda ad1
3694 : f90501                   sbc sba2-$ff,y  ;perform subtract
3697 : 08                       php          
3698 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
369a : d0fe            >        bne *           ;failed not equal (non zero)
                        
369c : 68                       pla             ;check flags
369d : 29c3                     and #$c3        ;mask NV----ZC
369f : c507                     cmp adrf
                                trap_ne         ;bad flags
36a1 : d0fe            >        bne *           ;failed not equal (non zero)
                        
36a3 : 28                       plp
                        ; binary ADC / SBC (zp,x)
36a4 : 08                       php             ;save carry for subtract
36a5 : a503                     lda ad1
36a7 : 6146                     adc (lo adi2-ad2,x) ;perform add
36a9 : 08                       php          
36aa : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
36ac : d0fe            >        bne *           ;failed not equal (non zero)
                        
36ae : 68                       pla             ;check flags
36af : 29c3                     and #$c3        ;mask NV----ZC
36b1 : c507                     cmp adrf
                                trap_ne         ;bad flags
36b3 : d0fe            >        bne *           ;failed not equal (non zero)
                        
36b5 : 28                       plp
36b6 : 08                       php             ;save carry for next add
36b7 : a503                     lda ad1
36b9 : e148                     sbc (lo sbi2-ad2,x) ;perform subtract
36bb : 08                       php          
36bc : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
36be : d0fe            >        bne *           ;failed not equal (non zero)
                        
36c0 : 68                       pla             ;check flags
36c1 : 29c3                     and #$c3        ;mask NV----ZC
36c3 : c507                     cmp adrf
                                trap_ne         ;bad flags
36c5 : d0fe            >        bne *           ;failed not equal (non zero)
                        
36c7 : 28                       plp
                        ; binary ADC / SBC (abs),y
36c8 : 08                       php             ;save carry for subtract
36c9 : a503                     lda ad1
36cb : 714e                     adc (adiy2),y   ;perform add
36cd : 08                       php          
36ce : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
36d0 : d0fe            >        bne *           ;failed not equal (non zero)
                        
36d2 : 68                       pla             ;check flags
36d3 : 29c3                     and #$c3        ;mask NV----ZC
36d5 : c507                     cmp adrf
                                trap_ne         ;bad flags
36d7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
36d9 : 28                       plp
36da : 08                       php             ;save carry for next add
36db : a503                     lda ad1
36dd : f150                     sbc (sbiy2),y   ;perform subtract
36df : 08                       php          
36e0 : c505                     cmp adrl        ;check result
                                trap_ne         ;bad result
36e2 : d0fe            >        bne *           ;failed not equal (non zero)
                        
36e4 : 68                       pla             ;check flags
36e5 : 29c3                     and #$c3        ;mask NV----ZC
36e7 : c507                     cmp adrf
                                trap_ne         ;bad flags
36e9 : d0fe            >        bne *           ;failed not equal (non zero)
                        
36eb : 28                       plp
36ec : 60                       rts
                        
                        ; target for the jump absolute test
36ed : 88                       dey
36ee : 88                       dey
36ef :                  test_far
36ef : 08                       php             ;either SP or Y count will fail, if we do not hit
36f0 : 88                       dey
36f1 : 88                       dey
36f2 : 88                       dey
36f3 : 28                       plp
                                trap_cs         ;flags loaded?
36f4 : b0fe            >        bcs *           ;failed carry set
                        
                                trap_vs
36f6 : 70fe            >        bvs *           ;failed overflow set
                        
                                trap_mi
36f8 : 30fe            >        bmi *           ;failed minus (bit 7 set)
                        
                                trap_eq 
36fa : f0fe            >        beq *           ;failed equal (zero)
                        
36fc : c946                     cmp #'F'        ;registers loaded?
                                trap_ne
36fe : d0fe            >        bne *           ;failed not equal (non zero)
                        
3700 : e041                     cpx #'A'
                                trap_ne        
3702 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3704 : c04f                     cpy #('R'-3)
                                trap_ne
3706 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3708 : 48                       pha             ;save a,x
3709 : 8a                       txa
370a : 48                       pha
370b : ba                       tsx
370c : e0fd                     cpx #$fd        ;check SP
                                trap_ne
370e : d0fe            >        bne *           ;failed not equal (non zero)
                        
3710 : 68                       pla             ;restore x
3711 : aa                       tax
                                set_stat $ff
                       >            load_flag $ff
3712 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
3714 : 48              >            pha         ;use stack to load status
3715 : 28              >            plp
                        
3716 : 68                       pla             ;restore a
3717 : e8                       inx             ;return registers with modifications
3718 : 49aa                     eor #$aa        ;N=1, V=1, Z=0, C=1
371a : 4c0f09                   jmp far_ret
                                
                        ; target for the jump indirect test
371d : 00                       align
371e : 2737             ptr_tst_ind dw test_ind
3720 : 6409             ptr_ind_ret dw ind_ret
                                trap            ;runover protection
3722 : 4c2237          >        jmp *           ;failed anyway
                        
3725 : 88                       dey
3726 : 88                       dey
3727 :                  test_ind
3727 : 08                       php             ;either SP or Y count will fail, if we do not hit
3728 : 88                       dey
3729 : 88                       dey
372a : 88                       dey
372b : 28                       plp
                                trap_cs         ;flags loaded?
372c : b0fe            >        bcs *           ;failed carry set
                        
                                trap_vs
372e : 70fe            >        bvs *           ;failed overflow set
                        
                                trap_mi
3730 : 30fe            >        bmi *           ;failed minus (bit 7 set)
                        
                                trap_eq 
3732 : f0fe            >        beq *           ;failed equal (zero)
                        
3734 : c949                     cmp #'I'        ;registers loaded?
                                trap_ne
3736 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3738 : e04e                     cpx #'N'
                                trap_ne        
373a : d0fe            >        bne *           ;failed not equal (non zero)
                        
373c : c041                     cpy #('D'-3)
                                trap_ne
373e : d0fe            >        bne *           ;failed not equal (non zero)
                        
3740 : 48                       pha             ;save a,x
3741 : 8a                       txa
3742 : 48                       pha
3743 : ba                       tsx
3744 : e0fd                     cpx #$fd        ;check SP
                                trap_ne
3746 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3748 : 68                       pla             ;restore x
3749 : aa                       tax
                                set_stat $ff
                       >            load_flag $ff
374a : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
374c : 48              >            pha         ;use stack to load status
374d : 28              >            plp
                        
374e : 68                       pla             ;restore a
374f : e8                       inx             ;return registers with modifications
3750 : 49aa                     eor #$aa        ;N=1, V=1, Z=0, C=1
3752 : 6c2037                   jmp (ptr_ind_ret)
                                trap            ;runover protection
3755 : 4c5537          >        jmp *           ;failed anyway
                        
3758 : 4c0004                   jmp start       ;catastrophic error - cannot continue
                        
                        ; target for the jump subroutine test
375b : 88                       dey
375c : 88                       dey
375d :                  test_jsr
375d : 08                       php             ;either SP or Y count will fail, if we do not hit
375e : 88                       dey
375f : 88                       dey
3760 : 88                       dey
3761 : 28                       plp
                                trap_cs         ;flags loaded?
3762 : b0fe            >        bcs *           ;failed carry set
                        
                                trap_vs
3764 : 70fe            >        bvs *           ;failed overflow set
                        
                                trap_mi
3766 : 30fe            >        bmi *           ;failed minus (bit 7 set)
                        
                                trap_eq 
3768 : f0fe            >        beq *           ;failed equal (zero)
                        
376a : c94a                     cmp #'J'        ;registers loaded?
                                trap_ne
376c : d0fe            >        bne *           ;failed not equal (non zero)
                        
376e : e053                     cpx #'S'
                                trap_ne        
3770 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3772 : c04f                     cpy #('R'-3)
                                trap_ne
3774 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3776 : 48                       pha             ;save a,x
3777 : 8a                       txa
3778 : 48                       pha       
3779 : ba                       tsx             ;sp -4? (return addr,a,x)
377a : e0fb                     cpx #$fb
                                trap_ne
377c : d0fe            >        bne *           ;failed not equal (non zero)
                        
377e : adff01                   lda $1ff        ;propper return on stack
3781 : c909                     cmp #hi(jsr_ret)
                                trap_ne
3783 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3785 : adfe01                   lda $1fe
3788 : c99a                     cmp #lo(jsr_ret)
                                trap_ne
378a : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                set_stat $ff
                       >            load_flag $ff
378c : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                       >
378e : 48              >            pha         ;use stack to load status
378f : 28              >            plp
                        
3790 : 68                       pla             ;pull x,a
3791 : aa                       tax
3792 : 68                       pla
3793 : e8                       inx             ;return registers with modifications
3794 : 49aa                     eor #$aa        ;N=1, V=1, Z=0, C=1
3796 : 60                       rts
                                trap            ;runover protection
3797 : 4c9737          >        jmp *           ;failed anyway
                        
379a : 4c0004                   jmp start       ;catastrophic error - cannot continue
                                
                        ;trap in case of unexpected IRQ, NMI, BRK, RESET - BRK test target
379d :                  nmi_trap
                                trap            ;check stack for conditions at NMI
379d : 4c9d37          >        jmp *           ;failed anyway
                        
37a0 : 4c0004                   jmp start       ;catastrophic error - cannot continue
37a3 :                  res_trap
                                trap            ;unexpected RESET
37a3 : 4ca337          >        jmp *           ;failed anyway
                        
37a6 : 4c0004                   jmp start       ;catastrophic error - cannot continue
                                
37a9 : 88                       dey
37aa : 88                       dey
37ab :                  irq_trap                ;BRK test or unextpected BRK or IRQ
37ab : 08                       php             ;either SP or Y count will fail, if we do not hit
37ac : 88                       dey
37ad : 88                       dey
37ae : 88                       dey
                                ;next traps could be caused by unexpected BRK or IRQ
                                ;check stack for BREAK and originating location
                                ;possible jump/branch into weeds (uninitialized space)
37af : c9bd                     cmp #$ff-'B'    ;BRK pass 2 registers loaded?
37b1 : f042                     beq break2
37b3 : c942                     cmp #'B'        ;BRK pass 1 registers loaded?
                                trap_ne
37b5 : d0fe            >        bne *           ;failed not equal (non zero)
                        
37b7 : e052                     cpx #'R'
                                trap_ne        
37b9 : d0fe            >        bne *           ;failed not equal (non zero)
                        
37bb : c048                     cpy #'K'-3
                                trap_ne
37bd : d0fe            >        bne *           ;failed not equal (non zero)
                        
37bf : 8500                     sta irq_a       ;save registers during break test
37c1 : 8601                     stx irq_x
37c3 : ba                       tsx             ;test break on stack
37c4 : bd0201                   lda $102,x
                                cmp_flag 0      ;break test should have B=1 & unused=1 on stack
37c7 : c930            >            cmp #(0      |fao)&m8    ;expected flags + always on bits
                        
                                trap_ne         ; - no break flag on stack
37c9 : d0fe            >        bne *           ;failed not equal (non zero)
                        
37cb : 68                       pla
                                cmp_flag intdis ;should have added interrupt disable
37cc : c934            >            cmp #(intdis |fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
37ce : d0fe            >        bne *           ;failed not equal (non zero)
                        
37d0 : ba                       tsx
37d1 : e0fc                     cpx #$fc        ;sp -3? (return addr, flags)
                                trap_ne
37d3 : d0fe            >        bne *           ;failed not equal (non zero)
                        
37d5 : adff01                   lda $1ff        ;propper return on stack
37d8 : c909                     cmp #hi(brk_ret0)
                                trap_ne
37da : d0fe            >        bne *           ;failed not equal (non zero)
                        
37dc : adfe01                   lda $1fe
37df : c9d1                     cmp #lo(brk_ret0)
                                trap_ne
37e1 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                load_flag $ff
37e3 : a9ff            >            lda #$ff             ;allow test to change I-flag (no mask)
                        
37e5 : 48                       pha
37e6 : a601                     ldx irq_x
37e8 : e8                       inx             ;return registers with modifications
37e9 : a500                     lda irq_a
37eb : 49aa                     eor #$aa
37ed : 28                       plp             ;N=1, V=1, Z=1, C=1 but original flags should be restored
37ee : 40                       rti
                                trap            ;runover protection
37ef : 4cef37          >        jmp *           ;failed anyway
                        
37f2 : 4c0004                   jmp start       ;catastrophic error - cannot continue
                                
37f5 :                  break2                  ;BRK pass 2        
37f5 : e0ad                     cpx #$ff-'R'
                                trap_ne        
37f7 : d0fe            >        bne *           ;failed not equal (non zero)
                        
37f9 : c0b1                     cpy #$ff-'K'-3
                                trap_ne
37fb : d0fe            >        bne *           ;failed not equal (non zero)
                        
37fd : 8500                     sta irq_a       ;save registers during break test
37ff : 8601                     stx irq_x
3801 : ba                       tsx             ;test break on stack
3802 : bd0201                   lda $102,x
                                cmp_flag $ff    ;break test should have B=1
3805 : c9ff            >            cmp #($ff    |fao)&m8    ;expected flags + always on bits
                        
                                trap_ne         ; - no break flag on stack
3807 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3809 : 68                       pla
380a : 0908                     ora #decmode    ;ignore decmode cleared if 65c02
                                cmp_flag $ff    ;actual passed flags
380c : c9ff            >            cmp #($ff    |fao)&m8    ;expected flags + always on bits
                        
                                trap_ne
380e : d0fe            >        bne *           ;failed not equal (non zero)
                        
3810 : ba                       tsx
3811 : e0fc                     cpx #$fc        ;sp -3? (return addr, flags)
                                trap_ne
3813 : d0fe            >        bne *           ;failed not equal (non zero)
                        
3815 : adff01                   lda $1ff        ;propper return on stack
3818 : c909                     cmp #hi(brk_ret1)
                                trap_ne
381a : d0fe            >        bne *           ;failed not equal (non zero)
                        
381c : adfe01                   lda $1fe
381f : c9f7                     cmp #lo(brk_ret1)
                                trap_ne
3821 : d0fe            >        bne *           ;failed not equal (non zero)
                        
                                load_flag intdis
3823 : a904            >            lda #intdis             ;allow test to change I-flag (no mask)
                        
3825 : 48                       pha      
3826 : a601                     ldx irq_x
3828 : e8                       inx             ;return registers with modifications
3829 : a500                     lda irq_a
382b : 49aa                     eor #$aa
382d : 28                       plp             ;N=0, V=0, Z=0, C=0 but original flags should be restored
382e : 40                       rti
                                trap            ;runover protection
382f : 4c2f38          >        jmp *           ;failed anyway
                        
3832 : 4c0004                   jmp start       ;catastrophic error - cannot continue
                        
                            if report = 1
                                include "report.i65"
                            endif
                                
                        ;copy of data to initialize BSS segment
                            if load_data_direct != 1
                        zp_init
                        zps_    db  $80,1           ;additional shift pattern to test zero result & flag
                        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
                        ex_and_ and #0              ;execute immediate opcodes
                                rts
                        ex_eor_ eor #0              ;execute immediate opcodes
                                rts
                        ex_ora_ ora #0              ;execute immediate opcodes
                                rts
                        ex_adc_ adc #0              ;execute immediate opcodes
                                rts
                        ex_sbc_ sbc #0              ;execute immediate opcodes
                                rts
                        ;zps    db  $80,1           ;additional shift patterns test zero result & flag
                        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  0,2,$86,$04,$82,0
                        rROLc_  db  1,3,$87,$05,$83,1       ;expected result ROL +carry
                        rLSR_                               ;expected result LSR & ROR -carry
                        rROR_   db  $40,0,$61,$41,$20,0
                        rRORc_  db  $c0,$80,$e1,$c1,$a0,$80 ;expected result ROR +carry
                        fASL_                               ;expected flags for shifts
                        fROL_   db  fzc,0,fnc,fc,fn,fz      ;no carry in
                        fROLc_  db  fc,0,fnc,fc,fn,0        ;carry in 
                        fLSR_
                        fROR_   db  0,fzc,fc,0,fc,fz        ;no carry in
                        fRORc_  db  fn,fnc,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 : 9d37                     dw  nmi_trap
fffc : a337                     dw  res_trap
fffe : ab37                     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).
