AS65 Assembler for R6502 [1.42]. Page 1 -------------------------- 6502_functional_test.asm -------------------------- 6010 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-2015 Klaus Dormann ; ; This program is free software: you can redistribute ; it under the terms of the GNU General Public License ; the Free Software Foundation, either version 3 of th ; (at your option) any later version. ; ; This program is distributed in the hope that it will ; but WITHOUT ANY WARRANTY; without even the implied w ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ; GNU General Public License for more details. ; ; You should have received a copy of the GNU General P ; along with this program. If not, see -1 check_ram macro cld lda #0 sta zpt ;set low byte of indirect 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 te 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 stx zpt+1 ldy #lo(abs1) ;data after write & execut 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 ju 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 altere endm if load_data_direct = 1 data else bss ;uninitialized segment, co endif 0000 = org 0 ;edited to load from 0x0000 (w 0000 : 00000000000000.. ds zero_page ;see above (this line added) ;break test interrupt save 000a : 00 irq_a ds 1 ;a register 000b : 00 irq_x ds 1 ;x register if I_flag = 2 ;masking for I bit in status flag_I_on ds 1 ;or mask to load flags flag_I_off ds 1 ;and mask to load flags endif 000c : zpt ;5 bytes store/modify test ;add/subtract operand generation and result/flag predi 000c : 00 adfc ds 1 ;carry flag before op 000d : 00 ad1 ds 1 ;operand 1 - accumulator 000e : 00 ad2 ds 1 ;operand 2 - memory / imme 000f : 00 adrl ds 1 ;expected result bits 0-7 0010 : 00 adrh ds 1 ;expected result bit 8 (ca 0011 : 00 adrf ds 1 ;expected flags NV0000ZC ( 0012 : 00 sb2 ds 1 ;operand 2 complemented fo 0013 : zp_bss 0013 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT 0017 : 7f zp7f db $7f ;test pattern for compare ;logical zeropage operands 0018 : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR 001c : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND 0020 : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR ;indirect addressing pointers 0024 : 1702 ind1 dw abs1 ;indirect pointer to patte 0026 : 1802 dw abs1+1 0028 : 1902 dw abs1+2 002a : 1a02 dw abs1+3 002c : 1b02 dw abs7f 002e : 1f01 inw1 dw abs1-$f8 ;indirect pointer for wrap 0030 : 0302 indt dw abst ;indirect pointer to store 0032 : 0402 dw abst+1 0034 : 0502 dw abst+2 0036 : 0602 dw abst+3 0038 : 0b01 inwt dw abst-$f8 ;indirect pointer for wrap 003a : 4e02 indAN dw absAN ;indirect pointer to AND p 003c : 4f02 dw absAN+1 003e : 5002 dw absAN+2 0040 : 5102 dw absAN+3 0042 : 5202 indEO dw absEO ;indirect pointer to EOR p 0044 : 5302 dw absEO+1 0046 : 5402 dw absEO+2 0048 : 5502 dw absEO+3 004a : 4a02 indOR dw absOR ;indirect pointer to OR pa 004c : 4b02 dw absOR+1 004e : 4c02 dw absOR+2 0050 : 4d02 dw absOR+3 ;add/subtract indirect pointers 0052 : 0302 adi2 dw ada2 ;indirect pointer to opera 0054 : 0402 sbi2 dw sba2 ;indirect pointer to compl 0056 : 0401 adiy2 dw ada2-$ff ;with offset for indirect 0058 : 0501 sbiy2 dw sba2-$ff 005a : zp_bss_end 0200 = org data_segment 0200 : 00 test_case ds 1 ;current test number 0201 : 0000 ram_chksm ds 2 ;checksum for RAM integrit ;add/subtract operand copy - abs tests write area 0203 : abst ;5 bytes store/modify test 0203 : 00 ada2 ds 1 ;operand 2 0204 : 00 sba2 ds 1 ;operand 2 complemented fo 0205 : 000000 ds 3 ;fill remaining bytes 0208 : data_bss if load_data_direct = 1 0208 : 2900 ex_andi and #0 ;execute immediate opcodes 020a : 60 rts 020b : 4900 ex_eori eor #0 ;execute immediate opcodes 020d : 60 rts 020e : 0900 ex_orai ora #0 ;execute immediate opcodes 0210 : 60 rts 0211 : 6900 ex_adci adc #0 ;execute immediate opcodes 0213 : 60 rts 0214 : e900 ex_sbci sbc #0 ;execute immediate opcodes 0216 : 60 rts else ex_andi ds 3 ex_eori ds 3 ex_orai ds 3 ex_adci ds 3 ex_sbci ds 3 endif 0217 : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT 021b : 7f abs7f db $7f ;test pattern for compare ;loads 021c : 80800002 fLDx db fn,fn,0,fz ;expected flags for load ;shifts 0220 : rASL ;expected result ASL & ROL 0220 : 86048200 rROL db $86,$04,$82,0 ; " 0224 : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carr 0228 : rLSR ;expected result LSR & ROR 0228 : 61412000 rROR db $61,$41,$20,0 ; " 022c : e1c1a080 rRORc db $e1,$c1,$a0,$80 ;expected result ROR +carr 0230 : fASL ;expected flags for shifts 0230 : 81018002 fROL db fnc,fc,fn,fz ;no carry in 0234 : 81018000 fROLc db fnc,fc,fn,0 ;carry in 0238 : fLSR 0238 : 01000102 fROR db fc,0,fc,fz ;no carry in 023c : 81808180 fRORc db fnc,fn,fnc,fn ;carry in ;increments (decrements) 0240 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/D 0245 : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DE ;logical memory operand 024a : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR 024e : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND 0252 : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR ;logical accu operand 0256 : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR 025a : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND 025e : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR ;logical results 0262 : 00ff7f80 absrlo db 0,$ff,$7f,$80 0266 : 02800080 absflo db fz,fn,0,fn 026a : 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 poin 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 a 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 poi stx zpt+1 ldy #lo(abs1) ;data after write & execute te 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 altere if disable_selfmod = 0 ;testing relative addressing with BEQ 0444 : a0fe ldy #$fe ;testing maximum range, not -1 0446 : range_loop 0446 : 88 dey ;next relative address 0447 : 98 tya 0448 : aa tax ;precharge count to end of loo 0449 : 1008 bpl range_fw ;calculate relative address 044b : 18 clc ;avoid branch self or to relat 044c : 6902 adc #2 044e : ea nop ;offset landing zone - tolerat 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 statu 045f : 4ce504 jmp range_op 0462 : ca dex ; offset landing zone - backwa 0463 : ca dex 0464 : ca dex 0465 : ca dex 0466 : ca dex ;relative address target field with branch und 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, 04e6 = range_adr = *+1 ;modifiable relative address 04e5 : f03e beq *+64 ;+64 if called without modific 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 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 - tolerat 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 altere ;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 altere ;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 sta 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 altere ;testing branch decisions BPL BMI BVC BVS BCC BCS BNE set_stat $ff ;all on > load_flag $ff 0608 : a9ff > lda #$ff ;allow test to ch > 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 + 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 ch > 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 (pushe 0672 : c930 > cmp #(0 |fao)&m8 ;expected flags + 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 chang > 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 chan > 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 chan > 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 cha > 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 c > 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 > 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 > 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 > 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 altere ; test PHA does not alter flags or accumulator but PLA 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 c > 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 + alw > > 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 > 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 + alway > > 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 > 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 + alw > > 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 > 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 + alway > > 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 > 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 + alw > > 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 > 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 + alway > > 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 c > 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 > > 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 > 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 + al > > 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 > 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 > > 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 > 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 + a > > 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 > 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 > > 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 > 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 + alway > > 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 altere ; partial pretest EOR # set_a $3c,0 > load_flag 0 087e : a900 > lda #0 ;allow test to change I > 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 + alwa > > 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 > 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 + alwa > > 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 altere ; PC modifying instructions except branches (NOP, JMP, ; 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 > 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 + alway > > 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 > 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 + alw > > 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 altere ; jump absolute set_stat $0 > load_flag $0 08fc : a900 > lda #$0 ;allow test to change > 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 : 4cc936 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 altere ; jump indirect set_stat 0 > load_flag 0 0952 : a900 > lda #0 ;allow test to change I > 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 : 6cf836 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 fai 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 altere ; jump subroutine & return from subroutine set_stat 0 > load_flag 0 098e : a900 > lda #0 ;allow test to change I > 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 : 203437 jsr test_jsr 099a = jsr_ret = *-1 ;last address of jsr = return 099b : 08 php ;either SP or Y count will fai 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 altere ; break & return from interrupt if ROM_vectors = 1 set_stat 0 > load_flag 0 09c5 : a900 > lda #0 ;allow test to change I > 09c7 : 48 > pha ;use stack to load status 09c8 : 28 > plp 09c9 : a942 lda #'B' 09cb : a252 ldx #'R' 09cd : a04b ldy #'K' ;N=0, V=0, Z=0, C=0 09cf : 00 brk else lda #hi brk_ret ;emulated break pha lda #lo brk_ret pha lda #fao ;set break & unused on stack pha set_stat intdis lda #'B' ldx #'R' ldy #'K' ;N=0, V=0, Z=0, C=0 jmp irq_trap endif 09d0 : 88 dey ;should not be executed 09d1 : brk_ret ;address of break return 09d1 : 08 php ;either SP or Y count will fai 09d2 : 88 dey 09d3 : 88 dey 09d4 : 88 dey 09d5 : c9e8 cmp #('B'^$aa) ;returned registers OK? 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 + alway 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) next_test 09eb : ad0002 > lda test_case ;previous test 09ee : c90b > cmp #test_num > trap_ne ;test is out of sequence 09f0 : d0fe > bne * ;failed not equal (non zero) > 000c = >test_num = test_num + 1 09f2 : a90c > lda #test_num ;*** next tests' number 09f4 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; test set and clear flags CLC CLI CLD CLV SEC SEI SED set_stat $ff > load_flag $ff 09f7 : a9ff > lda #$ff ;allow test to change > 09f9 : 48 > pha ;use stack to load status 09fa : 28 > plp 09fb : 18 clc tst_stat $ff-carry 09fc : 08 > php ;save status 09fd : 68 > pla ;use stack to retrieve status 09fe : 48 > pha > cmp_flag $ff-carry 09ff : c9fe > cmp #($ff-carry|fao)&m8 ;expected flags > > trap_ne 0a01 : d0fe > bne * ;failed not equal (non zero) > 0a03 : 28 > plp ;restore status 0a04 : 38 sec tst_stat $ff 0a05 : 08 > php ;save status 0a06 : 68 > pla ;use stack to retrieve status 0a07 : 48 > pha > cmp_flag $ff 0a08 : c9ff > cmp #($ff|fao)&m8 ;expected flags + alw > > trap_ne 0a0a : d0fe > bne * ;failed not equal (non zero) > 0a0c : 28 > plp ;restore status if I_flag = 3 0a0d : 58 cli tst_stat $ff-intdis 0a0e : 08 > php ;save status 0a0f : 68 > pla ;use stack to retrieve status 0a10 : 48 > pha > cmp_flag $ff-intdis 0a11 : c9fb > cmp #($ff-intdis|fao)&m8 ;expected flag > > trap_ne 0a13 : d0fe > bne * ;failed not equal (non zero) > 0a15 : 28 > plp ;restore status 0a16 : 78 sei tst_stat $ff 0a17 : 08 > php ;save status 0a18 : 68 > pla ;use stack to retrieve status 0a19 : 48 > pha > cmp_flag $ff 0a1a : c9ff > cmp #($ff|fao)&m8 ;expected flags + alw > > trap_ne 0a1c : d0fe > bne * ;failed not equal (non zero) > 0a1e : 28 > plp ;restore status endif 0a1f : d8 cld tst_stat $ff-decmode 0a20 : 08 > php ;save status 0a21 : 68 > pla ;use stack to retrieve status 0a22 : 48 > pha > cmp_flag $ff-decmode 0a23 : c9f7 > cmp #($ff-decmode|fao)&m8 ;expected fla > > trap_ne 0a25 : d0fe > bne * ;failed not equal (non zero) > 0a27 : 28 > plp ;restore status 0a28 : f8 sed tst_stat $ff 0a29 : 08 > php ;save status 0a2a : 68 > pla ;use stack to retrieve status 0a2b : 48 > pha > cmp_flag $ff 0a2c : c9ff > cmp #($ff|fao)&m8 ;expected flags + alw > > trap_ne 0a2e : d0fe > bne * ;failed not equal (non zero) > 0a30 : 28 > plp ;restore status 0a31 : b8 clv tst_stat $ff-overfl 0a32 : 08 > php ;save status 0a33 : 68 > pla ;use stack to retrieve status 0a34 : 48 > pha > cmp_flag $ff-overfl 0a35 : c9bf > cmp #($ff-overfl|fao)&m8 ;expected flag > > trap_ne 0a37 : d0fe > bne * ;failed not equal (non zero) > 0a39 : 28 > plp ;restore status set_stat 0 > load_flag 0 0a3a : a900 > lda #0 ;allow test to change I > 0a3c : 48 > pha ;use stack to load status 0a3d : 28 > plp tst_stat 0 0a3e : 08 > php ;save status 0a3f : 68 > pla ;use stack to retrieve status 0a40 : 48 > pha > cmp_flag 0 0a41 : c930 > cmp #(0|fao)&m8 ;expected flags + alway > > trap_ne 0a43 : d0fe > bne * ;failed not equal (non zero) > 0a45 : 28 > plp ;restore status 0a46 : 38 sec tst_stat carry 0a47 : 08 > php ;save status 0a48 : 68 > pla ;use stack to retrieve status 0a49 : 48 > pha > cmp_flag carry 0a4a : c931 > cmp #(carry|fao)&m8 ;expected flags + a > > trap_ne 0a4c : d0fe > bne * ;failed not equal (non zero) > 0a4e : 28 > plp ;restore status 0a4f : 18 clc tst_stat 0 0a50 : 08 > php ;save status 0a51 : 68 > pla ;use stack to retrieve status 0a52 : 48 > pha > cmp_flag 0 0a53 : c930 > cmp #(0 |fao)&m8 ;expected flags + alw > > trap_ne 0a55 : d0fe > bne * ;failed not equal (non zero) > 0a57 : 28 > plp ;restore status if I_flag = 3 0a58 : 78 sei tst_stat intdis 0a59 : 08 > php ;save status 0a5a : 68 > pla ;use stack to retrieve status 0a5b : 48 > pha > cmp_flag intdis 0a5c : c934 > cmp #(intdis|fao)&m8 ;expected flags + > > trap_ne 0a5e : d0fe > bne * ;failed not equal (non zero) > 0a60 : 28 > plp ;restore status 0a61 : 58 cli tst_stat 0 0a62 : 08 > php ;save status 0a63 : 68 > pla ;use stack to retrieve status 0a64 : 48 > pha > cmp_flag 0 0a65 : c930 > cmp #(0|fao)&m8 ;expected flags + alway > > trap_ne 0a67 : d0fe > bne * ;failed not equal (non zero) > 0a69 : 28 > plp ;restore status endif 0a6a : f8 sed tst_stat decmode 0a6b : 08 > php ;save status 0a6c : 68 > pla ;use stack to retrieve status 0a6d : 48 > pha > cmp_flag decmode 0a6e : c938 > cmp #(decmode|fao)&m8 ;expected flags + > > trap_ne 0a70 : d0fe > bne * ;failed not equal (non zero) > 0a72 : 28 > plp ;restore status 0a73 : d8 cld tst_stat 0 0a74 : 08 > php ;save status 0a75 : 68 > pla ;use stack to retrieve status 0a76 : 48 > pha > cmp_flag 0 0a77 : c930 > cmp #(0 |fao)&m8 ;expected flags + alw > > trap_ne 0a79 : d0fe > bne * ;failed not equal (non zero) > 0a7b : 28 > plp ;restore status set_stat overfl > load_flag overfl 0a7c : a940 > lda #overfl ;allow test to cha > 0a7e : 48 > pha ;use stack to load status 0a7f : 28 > plp tst_stat overfl 0a80 : 08 > php ;save status 0a81 : 68 > pla ;use stack to retrieve status 0a82 : 48 > pha > cmp_flag overfl 0a83 : c970 > cmp #(overfl|fao)&m8 ;expected flags + > > trap_ne 0a85 : d0fe > bne * ;failed not equal (non zero) > 0a87 : 28 > plp ;restore status 0a88 : b8 clv tst_stat 0 0a89 : 08 > php ;save status 0a8a : 68 > pla ;use stack to retrieve status 0a8b : 48 > pha > cmp_flag 0 0a8c : c930 > cmp #(0|fao)&m8 ;expected flags + alway > > trap_ne 0a8e : d0fe > bne * ;failed not equal (non zero) > 0a90 : 28 > plp ;restore status next_test 0a91 : ad0002 > lda test_case ;previous test 0a94 : c90c > cmp #test_num > trap_ne ;test is out of sequence 0a96 : d0fe > bne * ;failed not equal (non zero) > 000d = >test_num = test_num + 1 0a98 : a90d > lda #test_num ;*** next tests' number 0a9a : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; testing index register increment/decrement and trans ; INX INY DEX DEY TAX TXA TAY TYA 0a9d : a2fe ldx #$fe set_stat $ff > load_flag $ff 0a9f : a9ff > lda #$ff ;allow test to change > 0aa1 : 48 > pha ;use stack to load status 0aa2 : 28 > plp 0aa3 : e8 inx ;ff tst_x $ff,$ff-zero 0aa4 : 08 > php ;save flags 0aa5 : e0ff > cpx #$ff ;test result > trap_ne 0aa7 : d0fe > bne * ;failed not equal (non zero) > 0aa9 : 68 > pla ;load status 0aaa : 48 > pha > cmp_flag $ff-zero 0aab : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags > > trap_ne 0aad : d0fe > bne * ;failed not equal (non zero) > 0aaf : 28 > plp ;restore status 0ab0 : e8 inx ;00 tst_x 0,$ff-minus 0ab1 : 08 > php ;save flags 0ab2 : e000 > cpx #0 ;test result > trap_ne 0ab4 : d0fe > bne * ;failed not equal (non zero) > 0ab6 : 68 > pla ;load status 0ab7 : 48 > pha > cmp_flag $ff-minus 0ab8 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags > > trap_ne 0aba : d0fe > bne * ;failed not equal (non zero) > 0abc : 28 > plp ;restore status 0abd : e8 inx ;01 tst_x 1,$ff-minus-zero 0abe : 08 > php ;save flags 0abf : e001 > cpx #1 ;test result > trap_ne 0ac1 : d0fe > bne * ;failed not equal (non zero) > 0ac3 : 68 > pla ;load status 0ac4 : 48 > pha > cmp_flag $ff-minus-zero 0ac5 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected > > trap_ne 0ac7 : d0fe > bne * ;failed not equal (non zero) > 0ac9 : 28 > plp ;restore status 0aca : ca dex ;00 tst_x 0,$ff-minus 0acb : 08 > php ;save flags 0acc : e000 > cpx #0 ;test result > trap_ne 0ace : d0fe > bne * ;failed not equal (non zero) > 0ad0 : 68 > pla ;load status 0ad1 : 48 > pha > cmp_flag $ff-minus 0ad2 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags > > trap_ne 0ad4 : d0fe > bne * ;failed not equal (non zero) > 0ad6 : 28 > plp ;restore status 0ad7 : ca dex ;ff tst_x $ff,$ff-zero 0ad8 : 08 > php ;save flags 0ad9 : e0ff > cpx #$ff ;test result > trap_ne 0adb : d0fe > bne * ;failed not equal (non zero) > 0add : 68 > pla ;load status 0ade : 48 > pha > cmp_flag $ff-zero 0adf : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags > > trap_ne 0ae1 : d0fe > bne * ;failed not equal (non zero) > 0ae3 : 28 > plp ;restore status 0ae4 : ca dex ;fe set_stat 0 > load_flag 0 0ae5 : a900 > lda #0 ;allow test to change I > 0ae7 : 48 > pha ;use stack to load status 0ae8 : 28 > plp 0ae9 : e8 inx ;ff tst_x $ff,minus 0aea : 08 > php ;save flags 0aeb : e0ff > cpx #$ff ;test result > trap_ne 0aed : d0fe > bne * ;failed not equal (non zero) > 0aef : 68 > pla ;load status 0af0 : 48 > pha > cmp_flag minus 0af1 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + a > > trap_ne 0af3 : d0fe > bne * ;failed not equal (non zero) > 0af5 : 28 > plp ;restore status 0af6 : e8 inx ;00 tst_x 0,zero 0af7 : 08 > php ;save flags 0af8 : e000 > cpx #0 ;test result > trap_ne 0afa : d0fe > bne * ;failed not equal (non zero) > 0afc : 68 > pla ;load status 0afd : 48 > pha > cmp_flag zero 0afe : c932 > cmp #(zero|fao)&m8 ;expected flags + al > > trap_ne 0b00 : d0fe > bne * ;failed not equal (non zero) > 0b02 : 28 > plp ;restore status 0b03 : e8 inx ;01 tst_x 1,0 0b04 : 08 > php ;save flags 0b05 : e001 > cpx #1 ;test result > trap_ne 0b07 : d0fe > bne * ;failed not equal (non zero) > 0b09 : 68 > pla ;load status 0b0a : 48 > pha > cmp_flag 0 0b0b : c930 > cmp #(0|fao)&m8 ;expected flags + alway > > trap_ne 0b0d : d0fe > bne * ;failed not equal (non zero) > 0b0f : 28 > plp ;restore status 0b10 : ca dex ;00 tst_x 0,zero 0b11 : 08 > php ;save flags 0b12 : e000 > cpx #0 ;test result > trap_ne 0b14 : d0fe > bne * ;failed not equal (non zero) > 0b16 : 68 > pla ;load status 0b17 : 48 > pha > cmp_flag zero 0b18 : c932 > cmp #(zero|fao)&m8 ;expected flags + al > > trap_ne 0b1a : d0fe > bne * ;failed not equal (non zero) > 0b1c : 28 > plp ;restore status 0b1d : ca dex ;ff tst_x $ff,minus 0b1e : 08 > php ;save flags 0b1f : e0ff > cpx #$ff ;test result > trap_ne 0b21 : d0fe > bne * ;failed not equal (non zero) > 0b23 : 68 > pla ;load status 0b24 : 48 > pha > cmp_flag minus 0b25 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + a > > trap_ne 0b27 : d0fe > bne * ;failed not equal (non zero) > 0b29 : 28 > plp ;restore status 0b2a : a0fe ldy #$fe set_stat $ff > load_flag $ff 0b2c : a9ff > lda #$ff ;allow test to change > 0b2e : 48 > pha ;use stack to load status 0b2f : 28 > plp 0b30 : c8 iny ;ff tst_y $ff,$ff-zero 0b31 : 08 > php ;save flags 0b32 : c0ff > cpy #$ff ;test result > trap_ne 0b34 : d0fe > bne * ;failed not equal (non zero) > 0b36 : 68 > pla ;load status 0b37 : 48 > pha > cmp_flag $ff-zero 0b38 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags > > trap_ne 0b3a : d0fe > bne * ;failed not equal (non zero) > 0b3c : 28 > plp ;restore status 0b3d : c8 iny ;00 tst_y 0,$ff-minus 0b3e : 08 > php ;save flags 0b3f : c000 > cpy #0 ;test result > trap_ne 0b41 : d0fe > bne * ;failed not equal (non zero) > 0b43 : 68 > pla ;load status 0b44 : 48 > pha > cmp_flag $ff-minus 0b45 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags > > trap_ne 0b47 : d0fe > bne * ;failed not equal (non zero) > 0b49 : 28 > plp ;restore status 0b4a : c8 iny ;01 tst_y 1,$ff-minus-zero 0b4b : 08 > php ;save flags 0b4c : c001 > cpy #1 ;test result > trap_ne 0b4e : d0fe > bne * ;failed not equal (non zero) > 0b50 : 68 > pla ;load status 0b51 : 48 > pha > cmp_flag $ff-minus-zero 0b52 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected > > trap_ne 0b54 : d0fe > bne * ;failed not equal (non zero) > 0b56 : 28 > plp ;restore status 0b57 : 88 dey ;00 tst_y 0,$ff-minus 0b58 : 08 > php ;save flags 0b59 : c000 > cpy #0 ;test result > trap_ne 0b5b : d0fe > bne * ;failed not equal (non zero) > 0b5d : 68 > pla ;load status 0b5e : 48 > pha > cmp_flag $ff-minus 0b5f : c97f > cmp #($ff-minus|fao)&m8 ;expected flags > > trap_ne 0b61 : d0fe > bne * ;failed not equal (non zero) > 0b63 : 28 > plp ;restore status 0b64 : 88 dey ;ff tst_y $ff,$ff-zero 0b65 : 08 > php ;save flags 0b66 : c0ff > cpy #$ff ;test result > trap_ne 0b68 : d0fe > bne * ;failed not equal (non zero) > 0b6a : 68 > pla ;load status 0b6b : 48 > pha > cmp_flag $ff-zero 0b6c : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags > > trap_ne 0b6e : d0fe > bne * ;failed not equal (non zero) > 0b70 : 28 > plp ;restore status 0b71 : 88 dey ;fe set_stat 0 > load_flag 0 0b72 : a900 > lda #0 ;allow test to change I > 0b74 : 48 > pha ;use stack to load status 0b75 : 28 > plp 0b76 : c8 iny ;ff tst_y $ff,0+minus 0b77 : 08 > php ;save flags 0b78 : c0ff > cpy #$ff ;test result > trap_ne 0b7a : d0fe > bne * ;failed not equal (non zero) > 0b7c : 68 > pla ;load status 0b7d : 48 > pha > cmp_flag 0+minus 0b7e : c9b0 > cmp #(0+minus|fao)&m8 ;expected flags + > > trap_ne 0b80 : d0fe > bne * ;failed not equal (non zero) > 0b82 : 28 > plp ;restore status 0b83 : c8 iny ;00 tst_y 0,zero 0b84 : 08 > php ;save flags 0b85 : c000 > cpy #0 ;test result > trap_ne 0b87 : d0fe > bne * ;failed not equal (non zero) > 0b89 : 68 > pla ;load status 0b8a : 48 > pha > cmp_flag zero 0b8b : c932 > cmp #(zero|fao)&m8 ;expected flags + al > > trap_ne 0b8d : d0fe > bne * ;failed not equal (non zero) > 0b8f : 28 > plp ;restore status 0b90 : c8 iny ;01 tst_y 1,0 0b91 : 08 > php ;save flags 0b92 : c001 > cpy #1 ;test result > trap_ne 0b94 : d0fe > bne * ;failed not equal (non zero) > 0b96 : 68 > pla ;load status 0b97 : 48 > pha > cmp_flag 0 0b98 : c930 > cmp #(0|fao)&m8 ;expected flags + alway > > trap_ne 0b9a : d0fe > bne * ;failed not equal (non zero) > 0b9c : 28 > plp ;restore status 0b9d : 88 dey ;00 tst_y 0,zero 0b9e : 08 > php ;save flags 0b9f : c000 > cpy #0 ;test result > trap_ne 0ba1 : d0fe > bne * ;failed not equal (non zero) > 0ba3 : 68 > pla ;load status 0ba4 : 48 > pha > cmp_flag zero 0ba5 : c932 > cmp #(zero|fao)&m8 ;expected flags + al > > trap_ne 0ba7 : d0fe > bne * ;failed not equal (non zero) > 0ba9 : 28 > plp ;restore status 0baa : 88 dey ;ff tst_y $ff,minus 0bab : 08 > php ;save flags 0bac : c0ff > cpy #$ff ;test result > trap_ne 0bae : d0fe > bne * ;failed not equal (non zero) > 0bb0 : 68 > pla ;load status 0bb1 : 48 > pha > cmp_flag minus 0bb2 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + a > > trap_ne 0bb4 : d0fe > bne * ;failed not equal (non zero) > 0bb6 : 28 > plp ;restore status 0bb7 : a2ff ldx #$ff set_stat $ff > load_flag $ff 0bb9 : a9ff > lda #$ff ;allow test to change > 0bbb : 48 > pha ;use stack to load status 0bbc : 28 > plp 0bbd : 8a txa tst_a $ff,$ff-zero 0bbe : 08 > php ;save flags 0bbf : c9ff > cmp #$ff ;test result > trap_ne 0bc1 : d0fe > bne * ;failed not equal (non zero) > 0bc3 : 68 > pla ;load status 0bc4 : 48 > pha > cmp_flag $ff-zero 0bc5 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags > > trap_ne 0bc7 : d0fe > bne * ;failed not equal (non zero) > 0bc9 : 28 > plp ;restore status 0bca : 08 php 0bcb : e8 inx ;00 0bcc : 28 plp 0bcd : 8a txa tst_a 0,$ff-minus 0bce : 08 > php ;save flags 0bcf : c900 > cmp #0 ;test result > trap_ne 0bd1 : d0fe > bne * ;failed not equal (non zero) > 0bd3 : 68 > pla ;load status 0bd4 : 48 > pha > cmp_flag $ff-minus 0bd5 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags > > trap_ne 0bd7 : d0fe > bne * ;failed not equal (non zero) > 0bd9 : 28 > plp ;restore status 0bda : 08 php 0bdb : e8 inx ;01 0bdc : 28 plp 0bdd : 8a txa tst_a 1,$ff-minus-zero 0bde : 08 > php ;save flags 0bdf : c901 > cmp #1 ;test result > trap_ne 0be1 : d0fe > bne * ;failed not equal (non zero) > 0be3 : 68 > pla ;load status 0be4 : 48 > pha > cmp_flag $ff-minus-zero 0be5 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected > > trap_ne 0be7 : d0fe > bne * ;failed not equal (non zero) > 0be9 : 28 > plp ;restore status set_stat 0 > load_flag 0 0bea : a900 > lda #0 ;allow test to change I > 0bec : 48 > pha ;use stack to load status 0bed : 28 > plp 0bee : 8a txa tst_a 1,0 0bef : 08 > php ;save flags 0bf0 : c901 > cmp #1 ;test result > trap_ne 0bf2 : d0fe > bne * ;failed not equal (non zero) > 0bf4 : 68 > pla ;load status 0bf5 : 48 > pha > cmp_flag 0 0bf6 : c930 > cmp #(0|fao)&m8 ;expected flags + alway > > trap_ne 0bf8 : d0fe > bne * ;failed not equal (non zero) > 0bfa : 28 > plp ;restore status 0bfb : 08 php 0bfc : ca dex ;00 0bfd : 28 plp 0bfe : 8a txa tst_a 0,zero 0bff : 08 > php ;save flags 0c00 : c900 > cmp #0 ;test result > trap_ne 0c02 : d0fe > bne * ;failed not equal (non zero) > 0c04 : 68 > pla ;load status 0c05 : 48 > pha > cmp_flag zero 0c06 : c932 > cmp #(zero|fao)&m8 ;expected flags + al > > trap_ne 0c08 : d0fe > bne * ;failed not equal (non zero) > 0c0a : 28 > plp ;restore status 0c0b : 08 php 0c0c : ca dex ;ff 0c0d : 28 plp 0c0e : 8a txa tst_a $ff,minus 0c0f : 08 > php ;save flags 0c10 : c9ff > cmp #$ff ;test result > trap_ne 0c12 : d0fe > bne * ;failed not equal (non zero) > 0c14 : 68 > pla ;load status 0c15 : 48 > pha > cmp_flag minus 0c16 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + a > > trap_ne 0c18 : d0fe > bne * ;failed not equal (non zero) > 0c1a : 28 > plp ;restore status 0c1b : a0ff ldy #$ff set_stat $ff > load_flag $ff 0c1d : a9ff > lda #$ff ;allow test to change > 0c1f : 48 > pha ;use stack to load status 0c20 : 28 > plp 0c21 : 98 tya tst_a $ff,$ff-zero 0c22 : 08 > php ;save flags 0c23 : c9ff > cmp #$ff ;test result > trap_ne 0c25 : d0fe > bne * ;failed not equal (non zero) > 0c27 : 68 > pla ;load status 0c28 : 48 > pha > cmp_flag $ff-zero 0c29 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags > > trap_ne 0c2b : d0fe > bne * ;failed not equal (non zero) > 0c2d : 28 > plp ;restore status 0c2e : 08 php 0c2f : c8 iny ;00 0c30 : 28 plp 0c31 : 98 tya tst_a 0,$ff-minus 0c32 : 08 > php ;save flags 0c33 : c900 > cmp #0 ;test result > trap_ne 0c35 : d0fe > bne * ;failed not equal (non zero) > 0c37 : 68 > pla ;load status 0c38 : 48 > pha > cmp_flag $ff-minus 0c39 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags > > trap_ne 0c3b : d0fe > bne * ;failed not equal (non zero) > 0c3d : 28 > plp ;restore status 0c3e : 08 php 0c3f : c8 iny ;01 0c40 : 28 plp 0c41 : 98 tya tst_a 1,$ff-minus-zero 0c42 : 08 > php ;save flags 0c43 : c901 > cmp #1 ;test result > trap_ne 0c45 : d0fe > bne * ;failed not equal (non zero) > 0c47 : 68 > pla ;load status 0c48 : 48 > pha > cmp_flag $ff-minus-zero 0c49 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected > > trap_ne 0c4b : d0fe > bne * ;failed not equal (non zero) > 0c4d : 28 > plp ;restore status set_stat 0 > load_flag 0 0c4e : a900 > lda #0 ;allow test to change I > 0c50 : 48 > pha ;use stack to load status 0c51 : 28 > plp 0c52 : 98 tya tst_a 1,0 0c53 : 08 > php ;save flags 0c54 : c901 > cmp #1 ;test result > trap_ne 0c56 : d0fe > bne * ;failed not equal (non zero) > 0c58 : 68 > pla ;load status 0c59 : 48 > pha > cmp_flag 0 0c5a : c930 > cmp #(0|fao)&m8 ;expected flags + alway > > trap_ne 0c5c : d0fe > bne * ;failed not equal (non zero) > 0c5e : 28 > plp ;restore status 0c5f : 08 php 0c60 : 88 dey ;00 0c61 : 28 plp 0c62 : 98 tya tst_a 0,zero 0c63 : 08 > php ;save flags 0c64 : c900 > cmp #0 ;test result > trap_ne 0c66 : d0fe > bne * ;failed not equal (non zero) > 0c68 : 68 > pla ;load status 0c69 : 48 > pha > cmp_flag zero 0c6a : c932 > cmp #(zero|fao)&m8 ;expected flags + al > > trap_ne 0c6c : d0fe > bne * ;failed not equal (non zero) > 0c6e : 28 > plp ;restore status 0c6f : 08 php 0c70 : 88 dey ;ff 0c71 : 28 plp 0c72 : 98 tya tst_a $ff,minus 0c73 : 08 > php ;save flags 0c74 : c9ff > cmp #$ff ;test result > trap_ne 0c76 : d0fe > bne * ;failed not equal (non zero) > 0c78 : 68 > pla ;load status 0c79 : 48 > pha > cmp_flag minus 0c7a : c9b0 > cmp #(minus|fao)&m8 ;expected flags + a > > trap_ne 0c7c : d0fe > bne * ;failed not equal (non zero) > 0c7e : 28 > plp ;restore status load_flag $ff 0c7f : a9ff > lda #$ff ;allow test to change 0c81 : 48 pha 0c82 : a2ff ldx #$ff ;ff 0c84 : 8a txa 0c85 : 28 plp 0c86 : a8 tay tst_y $ff,$ff-zero 0c87 : 08 > php ;save flags 0c88 : c0ff > cpy #$ff ;test result > trap_ne 0c8a : d0fe > bne * ;failed not equal (non zero) > 0c8c : 68 > pla ;load status 0c8d : 48 > pha > cmp_flag $ff-zero 0c8e : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags > > trap_ne 0c90 : d0fe > bne * ;failed not equal (non zero) > 0c92 : 28 > plp ;restore status 0c93 : 08 php 0c94 : e8 inx ;00 0c95 : 8a txa 0c96 : 28 plp 0c97 : a8 tay tst_y 0,$ff-minus 0c98 : 08 > php ;save flags 0c99 : c000 > cpy #0 ;test result > trap_ne 0c9b : d0fe > bne * ;failed not equal (non zero) > 0c9d : 68 > pla ;load status 0c9e : 48 > pha > cmp_flag $ff-minus 0c9f : c97f > cmp #($ff-minus|fao)&m8 ;expected flags > > trap_ne 0ca1 : d0fe > bne * ;failed not equal (non zero) > 0ca3 : 28 > plp ;restore status 0ca4 : 08 php 0ca5 : e8 inx ;01 0ca6 : 8a txa 0ca7 : 28 plp 0ca8 : a8 tay tst_y 1,$ff-minus-zero 0ca9 : 08 > php ;save flags 0caa : c001 > cpy #1 ;test result > trap_ne 0cac : d0fe > bne * ;failed not equal (non zero) > 0cae : 68 > pla ;load status 0caf : 48 > pha > cmp_flag $ff-minus-zero 0cb0 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected > > trap_ne 0cb2 : d0fe > bne * ;failed not equal (non zero) > 0cb4 : 28 > plp ;restore status load_flag 0 0cb5 : a900 > lda #0 ;allow test to change I 0cb7 : 48 pha 0cb8 : a900 lda #0 0cba : 8a txa 0cbb : 28 plp 0cbc : a8 tay tst_y 1,0 0cbd : 08 > php ;save flags 0cbe : c001 > cpy #1 ;test result > trap_ne 0cc0 : d0fe > bne * ;failed not equal (non zero) > 0cc2 : 68 > pla ;load status 0cc3 : 48 > pha > cmp_flag 0 0cc4 : c930 > cmp #(0|fao)&m8 ;expected flags + alway > > trap_ne 0cc6 : d0fe > bne * ;failed not equal (non zero) > 0cc8 : 28 > plp ;restore status 0cc9 : 08 php 0cca : ca dex ;00 0ccb : 8a txa 0ccc : 28 plp 0ccd : a8 tay tst_y 0,zero 0cce : 08 > php ;save flags 0ccf : c000 > cpy #0 ;test result > trap_ne 0cd1 : d0fe > bne * ;failed not equal (non zero) > 0cd3 : 68 > pla ;load status 0cd4 : 48 > pha > cmp_flag zero 0cd5 : c932 > cmp #(zero|fao)&m8 ;expected flags + al > > trap_ne 0cd7 : d0fe > bne * ;failed not equal (non zero) > 0cd9 : 28 > plp ;restore status 0cda : 08 php 0cdb : ca dex ;ff 0cdc : 8a txa 0cdd : 28 plp 0cde : a8 tay tst_y $ff,minus 0cdf : 08 > php ;save flags 0ce0 : c0ff > cpy #$ff ;test result > trap_ne 0ce2 : d0fe > bne * ;failed not equal (non zero) > 0ce4 : 68 > pla ;load status 0ce5 : 48 > pha > cmp_flag minus 0ce6 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + a > > trap_ne 0ce8 : d0fe > bne * ;failed not equal (non zero) > 0cea : 28 > plp ;restore status load_flag $ff 0ceb : a9ff > lda #$ff ;allow test to change 0ced : 48 pha 0cee : a0ff ldy #$ff ;ff 0cf0 : 98 tya 0cf1 : 28 plp 0cf2 : aa tax tst_x $ff,$ff-zero 0cf3 : 08 > php ;save flags 0cf4 : e0ff > cpx #$ff ;test result > trap_ne 0cf6 : d0fe > bne * ;failed not equal (non zero) > 0cf8 : 68 > pla ;load status 0cf9 : 48 > pha > cmp_flag $ff-zero 0cfa : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags > > trap_ne 0cfc : d0fe > bne * ;failed not equal (non zero) > 0cfe : 28 > plp ;restore status 0cff : 08 php 0d00 : c8 iny ;00 0d01 : 98 tya 0d02 : 28 plp 0d03 : aa tax tst_x 0,$ff-minus 0d04 : 08 > php ;save flags 0d05 : e000 > cpx #0 ;test result > trap_ne 0d07 : d0fe > bne * ;failed not equal (non zero) > 0d09 : 68 > pla ;load status 0d0a : 48 > pha > cmp_flag $ff-minus 0d0b : c97f > cmp #($ff-minus|fao)&m8 ;expected flags > > trap_ne 0d0d : d0fe > bne * ;failed not equal (non zero) > 0d0f : 28 > plp ;restore status 0d10 : 08 php 0d11 : c8 iny ;01 0d12 : 98 tya 0d13 : 28 plp 0d14 : aa tax tst_x 1,$ff-minus-zero 0d15 : 08 > php ;save flags 0d16 : e001 > cpx #1 ;test result > trap_ne 0d18 : d0fe > bne * ;failed not equal (non zero) > 0d1a : 68 > pla ;load status 0d1b : 48 > pha > cmp_flag $ff-minus-zero 0d1c : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected > > trap_ne 0d1e : d0fe > bne * ;failed not equal (non zero) > 0d20 : 28 > plp ;restore status load_flag 0 0d21 : a900 > lda #0 ;allow test to change I 0d23 : 48 pha 0d24 : a900 lda #0 ;preset status 0d26 : 98 tya 0d27 : 28 plp 0d28 : aa tax tst_x 1,0 0d29 : 08 > php ;save flags 0d2a : e001 > cpx #1 ;test result > trap_ne 0d2c : d0fe > bne * ;failed not equal (non zero) > 0d2e : 68 > pla ;load status 0d2f : 48 > pha > cmp_flag 0 0d30 : c930 > cmp #(0|fao)&m8 ;expected flags + alway > > trap_ne 0d32 : d0fe > bne * ;failed not equal (non zero) > 0d34 : 28 > plp ;restore status 0d35 : 08 php 0d36 : 88 dey ;00 0d37 : 98 tya 0d38 : 28 plp 0d39 : aa tax tst_x 0,zero 0d3a : 08 > php ;save flags 0d3b : e000 > cpx #0 ;test result > trap_ne 0d3d : d0fe > bne * ;failed not equal (non zero) > 0d3f : 68 > pla ;load status 0d40 : 48 > pha > cmp_flag zero 0d41 : c932 > cmp #(zero|fao)&m8 ;expected flags + al > > trap_ne 0d43 : d0fe > bne * ;failed not equal (non zero) > 0d45 : 28 > plp ;restore status 0d46 : 08 php 0d47 : 88 dey ;ff 0d48 : 98 tya 0d49 : 28 plp 0d4a : aa tax tst_x $ff,minus 0d4b : 08 > php ;save flags 0d4c : e0ff > cpx #$ff ;test result > trap_ne 0d4e : d0fe > bne * ;failed not equal (non zero) > 0d50 : 68 > pla ;load status 0d51 : 48 > pha > cmp_flag minus 0d52 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + a > > trap_ne 0d54 : d0fe > bne * ;failed not equal (non zero) > 0d56 : 28 > plp ;restore status next_test 0d57 : ad0002 > lda test_case ;previous test 0d5a : c90d > cmp #test_num > trap_ne ;test is out of sequence 0d5c : d0fe > bne * ;failed not equal (non zero) > 000e = >test_num = test_num + 1 0d5e : a90e > lda #test_num ;*** next tests' number 0d60 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ;TSX sets NZ - TXS does not ; This section also tests for proper stack wrap aroun 0d63 : a201 ldx #1 ;01 set_stat $ff > load_flag $ff 0d65 : a9ff > lda #$ff ;allow test to change > 0d67 : 48 > pha ;use stack to load status 0d68 : 28 > plp 0d69 : 9a txs 0d6a : 08 php 0d6b : ad0101 lda $101 cmp_flag $ff 0d6e : c9ff > cmp #($ff|fao)&m8 ;expected flags + alw trap_ne 0d70 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 0d72 : a900 > lda #0 ;allow test to change I > 0d74 : 48 > pha ;use stack to load status 0d75 : 28 > plp 0d76 : 9a txs 0d77 : 08 php 0d78 : ad0101 lda $101 cmp_flag 0 0d7b : c930 > cmp #(0|fao)&m8 ;expected flags + alway trap_ne 0d7d : d0fe > bne * ;failed not equal (non zero) 0d7f : ca dex ;00 set_stat $ff > load_flag $ff 0d80 : a9ff > lda #$ff ;allow test to change > 0d82 : 48 > pha ;use stack to load status 0d83 : 28 > plp 0d84 : 9a txs 0d85 : 08 php 0d86 : ad0001 lda $100 cmp_flag $ff 0d89 : c9ff > cmp #($ff|fao)&m8 ;expected flags + alw trap_ne 0d8b : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 0d8d : a900 > lda #0 ;allow test to change I > 0d8f : 48 > pha ;use stack to load status 0d90 : 28 > plp 0d91 : 9a txs 0d92 : 08 php 0d93 : ad0001 lda $100 cmp_flag 0 0d96 : c930 > cmp #(0|fao)&m8 ;expected flags + alway trap_ne 0d98 : d0fe > bne * ;failed not equal (non zero) 0d9a : ca dex ;ff set_stat $ff > load_flag $ff 0d9b : a9ff > lda #$ff ;allow test to change > 0d9d : 48 > pha ;use stack to load status 0d9e : 28 > plp 0d9f : 9a txs 0da0 : 08 php 0da1 : adff01 lda $1ff cmp_flag $ff 0da4 : c9ff > cmp #($ff|fao)&m8 ;expected flags + alw trap_ne 0da6 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 0da8 : a900 > lda #0 ;allow test to change I > 0daa : 48 > pha ;use stack to load status 0dab : 28 > plp 0dac : 9a txs 0dad : 08 php 0dae : adff01 lda $1ff cmp_flag 0 0db1 : c930 > cmp #(0|fao)&m8 ;expected flags + alway 0db3 : a201 ldx #1 0db5 : 9a txs ;sp=01 set_stat $ff > load_flag $ff 0db6 : a9ff > lda #$ff ;allow test to change > 0db8 : 48 > pha ;use stack to load status 0db9 : 28 > plp 0dba : ba tsx ;clears Z, N 0dbb : 08 php ;sp=00 0dbc : e001 cpx #1 trap_ne 0dbe : d0fe > bne * ;failed not equal (non zero) 0dc0 : ad0101 lda $101 cmp_flag $ff-minus-zero 0dc3 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected trap_ne 0dc5 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 0dc7 : a9ff > lda #$ff ;allow test to change > 0dc9 : 48 > pha ;use stack to load status 0dca : 28 > plp 0dcb : ba tsx ;clears N, sets Z 0dcc : 08 php ;sp=ff 0dcd : e000 cpx #0 trap_ne 0dcf : d0fe > bne * ;failed not equal (non zero) 0dd1 : ad0001 lda $100 cmp_flag $ff-minus 0dd4 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags trap_ne 0dd6 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 0dd8 : a9ff > lda #$ff ;allow test to change > 0dda : 48 > pha ;use stack to load status 0ddb : 28 > plp 0ddc : ba tsx ;clears N, sets Z 0ddd : 08 php ;sp=fe 0dde : e0ff cpx #$ff trap_ne 0de0 : d0fe > bne * ;failed not equal (non zero) 0de2 : adff01 lda $1ff cmp_flag $ff-zero 0de5 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags trap_ne 0de7 : d0fe > bne * ;failed not equal (non zero) 0de9 : a201 ldx #1 0deb : 9a txs ;sp=01 set_stat 0 > load_flag 0 0dec : a900 > lda #0 ;allow test to change I > 0dee : 48 > pha ;use stack to load status 0def : 28 > plp 0df0 : ba tsx ;clears Z, N 0df1 : 08 php ;sp=00 0df2 : e001 cpx #1 trap_ne 0df4 : d0fe > bne * ;failed not equal (non zero) 0df6 : ad0101 lda $101 cmp_flag 0 0df9 : c930 > cmp #(0|fao)&m8 ;expected flags + alway trap_ne 0dfb : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 0dfd : a900 > lda #0 ;allow test to change I > 0dff : 48 > pha ;use stack to load status 0e00 : 28 > plp 0e01 : ba tsx ;clears N, sets Z 0e02 : 08 php ;sp=ff 0e03 : e000 cpx #0 trap_ne 0e05 : d0fe > bne * ;failed not equal (non zero) 0e07 : ad0001 lda $100 cmp_flag zero 0e0a : c932 > cmp #(zero|fao)&m8 ;expected flags + al trap_ne 0e0c : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 0e0e : a900 > lda #0 ;allow test to change I > 0e10 : 48 > pha ;use stack to load status 0e11 : 28 > plp 0e12 : ba tsx ;clears N, sets Z 0e13 : 08 php ;sp=fe 0e14 : e0ff cpx #$ff trap_ne 0e16 : d0fe > bne * ;failed not equal (non zero) 0e18 : adff01 lda $1ff cmp_flag minus 0e1b : c9b0 > cmp #(minus|fao)&m8 ;expected flags + a trap_ne 0e1d : d0fe > bne * ;failed not equal (non zero) 0e1f : 68 pla ;sp=ff next_test 0e20 : ad0002 > lda test_case ;previous test 0e23 : c90e > cmp #test_num > trap_ne ;test is out of sequence 0e25 : d0fe > bne * ;failed not equal (non zero) > 000f = >test_num = test_num + 1 0e27 : a90f > lda #test_num ;*** next tests' number 0e29 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; testing index register load & store LDY LDX STY STX ; LDX / STX - zp,y / abs,y 0e2c : a003 ldy #3 0e2e : tldx set_stat 0 > load_flag 0 0e2e : a900 > lda #0 ;allow test to change I > 0e30 : 48 > pha ;use stack to load status 0e31 : 28 > plp 0e32 : b613 ldx zp1,y 0e34 : 08 php ;test stores do not alter flags 0e35 : 8a txa 0e36 : 49c3 eor #$c3 0e38 : 28 plp 0e39 : 990302 sta abst,y 0e3c : 08 php ;flags after load/store sequence 0e3d : 49c3 eor #$c3 0e3f : d91702 cmp abs1,y ;test result trap_ne 0e42 : d0fe > bne * ;failed not equal (non zero) 0e44 : 68 pla ;load status eor_flag 0 0e45 : 4930 > eor #0|fao ;invert expected flags 0e47 : d91c02 cmp fLDx,y ;test flags trap_ne 0e4a : d0fe > bne * ;failed not equal (non zero) 0e4c : 88 dey 0e4d : 10df bpl tldx 0e4f : a003 ldy #3 0e51 : tldx1 set_stat $ff > load_flag $ff 0e51 : a9ff > lda #$ff ;allow test to change > 0e53 : 48 > pha ;use stack to load status 0e54 : 28 > plp 0e55 : b613 ldx zp1,y 0e57 : 08 php ;test stores do not alter flags 0e58 : 8a txa 0e59 : 49c3 eor #$c3 0e5b : 28 plp 0e5c : 990302 sta abst,y 0e5f : 08 php ;flags after load/store sequence 0e60 : 49c3 eor #$c3 0e62 : d91702 cmp abs1,y ;test result trap_ne 0e65 : d0fe > bne * ;failed not equal (non zero) 0e67 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 0e68 : 497d > eor #lo~fnz |fao ;invert expected 0e6a : d91c02 cmp fLDx,y ;test flags trap_ne 0e6d : d0fe > bne * ;failed not equal (non zero) 0e6f : 88 dey 0e70 : 10df bpl tldx1 0e72 : a003 ldy #3 0e74 : tldx2 set_stat 0 > load_flag 0 0e74 : a900 > lda #0 ;allow test to change I > 0e76 : 48 > pha ;use stack to load status 0e77 : 28 > plp 0e78 : be1702 ldx abs1,y 0e7b : 08 php ;test stores do not alter flags 0e7c : 8a txa 0e7d : 49c3 eor #$c3 0e7f : aa tax 0e80 : 28 plp 0e81 : 960c stx zpt,y 0e83 : 08 php ;flags after load/store sequence 0e84 : 49c3 eor #$c3 0e86 : d91300 cmp zp1,y ;test result trap_ne 0e89 : d0fe > bne * ;failed not equal (non zero) 0e8b : 68 pla ;load status eor_flag 0 0e8c : 4930 > eor #0|fao ;invert expected flags 0e8e : d91c02 cmp fLDx,y ;test flags trap_ne 0e91 : d0fe > bne * ;failed not equal (non zero) 0e93 : 88 dey 0e94 : 10de bpl tldx2 0e96 : a003 ldy #3 0e98 : tldx3 set_stat $ff > load_flag $ff 0e98 : a9ff > lda #$ff ;allow test to change > 0e9a : 48 > pha ;use stack to load status 0e9b : 28 > plp 0e9c : be1702 ldx abs1,y 0e9f : 08 php ;test stores do not alter flags 0ea0 : 8a txa 0ea1 : 49c3 eor #$c3 0ea3 : aa tax 0ea4 : 28 plp 0ea5 : 960c stx zpt,y 0ea7 : 08 php ;flags after load/store sequence 0ea8 : 49c3 eor #$c3 0eaa : d91300 cmp zp1,y ;test result trap_ne 0ead : d0fe > bne * ;failed not equal (non zero) 0eaf : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 0eb0 : 497d > eor #lo~fnz |fao ;invert expected 0eb2 : d91c02 cmp fLDx,y ;test flags trap_ne 0eb5 : d0fe > bne * ;failed not equal (non zero) 0eb7 : 88 dey 0eb8 : 10de bpl tldx3 0eba : a003 ldy #3 ;testing store result 0ebc : a200 ldx #0 0ebe : b90c00 tstx lda zpt,y 0ec1 : 49c3 eor #$c3 0ec3 : d91300 cmp zp1,y trap_ne ;store to zp data 0ec6 : d0fe > bne * ;failed not equal (non zero) 0ec8 : 960c stx zpt,y ;clear 0eca : b90302 lda abst,y 0ecd : 49c3 eor #$c3 0ecf : d91702 cmp abs1,y trap_ne ;store to abs data 0ed2 : d0fe > bne * ;failed not equal (non zero) 0ed4 : 8a txa 0ed5 : 990302 sta abst,y ;clear 0ed8 : 88 dey 0ed9 : 10e3 bpl tstx next_test 0edb : ad0002 > lda test_case ;previous test 0ede : c90f > cmp #test_num > trap_ne ;test is out of sequence 0ee0 : d0fe > bne * ;failed not equal (non zero) > 0010 = >test_num = test_num + 1 0ee2 : a910 > lda #test_num ;*** next tests' number 0ee4 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; indexed wraparound test (only zp should wrap) 0ee7 : a0fd ldy #3+$fa 0ee9 : b619 tldx4 ldx zp1-$fa&$ff,y ;wrap on indexed zp 0eeb : 8a txa 0eec : 990901 sta abst-$fa,y ;no STX abs,y! 0eef : 88 dey 0ef0 : c0fa cpy #$fa 0ef2 : b0f5 bcs tldx4 0ef4 : a0fd ldy #3+$fa 0ef6 : be1d01 tldx5 ldx abs1-$fa,y ;no wrap on indexed abs 0ef9 : 9612 stx zpt-$fa&$ff,y 0efb : 88 dey 0efc : c0fa cpy #$fa 0efe : b0f6 bcs tldx5 0f00 : a003 ldy #3 ;testing wraparound result 0f02 : a200 ldx #0 0f04 : b90c00 tstx1 lda zpt,y 0f07 : d91300 cmp zp1,y trap_ne ;store to zp data 0f0a : d0fe > bne * ;failed not equal (non zero) 0f0c : 960c stx zpt,y ;clear 0f0e : b90302 lda abst,y 0f11 : d91702 cmp abs1,y trap_ne ;store to abs data 0f14 : d0fe > bne * ;failed not equal (non zero) 0f16 : 8a txa 0f17 : 990302 sta abst,y ;clear 0f1a : 88 dey 0f1b : 10e7 bpl tstx1 next_test 0f1d : ad0002 > lda test_case ;previous test 0f20 : c910 > cmp #test_num > trap_ne ;test is out of sequence 0f22 : d0fe > bne * ;failed not equal (non zero) > 0011 = >test_num = test_num + 1 0f24 : a911 > lda #test_num ;*** next tests' number 0f26 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; LDY / STY - zp,x / abs,x 0f29 : a203 ldx #3 0f2b : tldy set_stat 0 > load_flag 0 0f2b : a900 > lda #0 ;allow test to change I > 0f2d : 48 > pha ;use stack to load status 0f2e : 28 > plp 0f2f : b413 ldy zp1,x 0f31 : 08 php ;test stores do not alter flags 0f32 : 98 tya 0f33 : 49c3 eor #$c3 0f35 : 28 plp 0f36 : 9d0302 sta abst,x 0f39 : 08 php ;flags after load/store sequence 0f3a : 49c3 eor #$c3 0f3c : dd1702 cmp abs1,x ;test result trap_ne 0f3f : d0fe > bne * ;failed not equal (non zero) 0f41 : 68 pla ;load status eor_flag 0 0f42 : 4930 > eor #0|fao ;invert expected flags 0f44 : dd1c02 cmp fLDx,x ;test flags trap_ne 0f47 : d0fe > bne * ;failed not equal (non zero) 0f49 : ca dex 0f4a : 10df bpl tldy 0f4c : a203 ldx #3 0f4e : tldy1 set_stat $ff > load_flag $ff 0f4e : a9ff > lda #$ff ;allow test to change > 0f50 : 48 > pha ;use stack to load status 0f51 : 28 > plp 0f52 : b413 ldy zp1,x 0f54 : 08 php ;test stores do not alter flags 0f55 : 98 tya 0f56 : 49c3 eor #$c3 0f58 : 28 plp 0f59 : 9d0302 sta abst,x 0f5c : 08 php ;flags after load/store sequence 0f5d : 49c3 eor #$c3 0f5f : dd1702 cmp abs1,x ;test result trap_ne 0f62 : d0fe > bne * ;failed not equal (non zero) 0f64 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 0f65 : 497d > eor #lo~fnz |fao ;invert expected 0f67 : dd1c02 cmp fLDx,x ;test flags trap_ne 0f6a : d0fe > bne * ;failed not equal (non zero) 0f6c : ca dex 0f6d : 10df bpl tldy1 0f6f : a203 ldx #3 0f71 : tldy2 set_stat 0 > load_flag 0 0f71 : a900 > lda #0 ;allow test to change I > 0f73 : 48 > pha ;use stack to load status 0f74 : 28 > plp 0f75 : bc1702 ldy abs1,x 0f78 : 08 php ;test stores do not alter flags 0f79 : 98 tya 0f7a : 49c3 eor #$c3 0f7c : a8 tay 0f7d : 28 plp 0f7e : 940c sty zpt,x 0f80 : 08 php ;flags after load/store sequence 0f81 : 49c3 eor #$c3 0f83 : d513 cmp zp1,x ;test result trap_ne 0f85 : d0fe > bne * ;failed not equal (non zero) 0f87 : 68 pla ;load status eor_flag 0 0f88 : 4930 > eor #0|fao ;invert expected flags 0f8a : dd1c02 cmp fLDx,x ;test flags trap_ne 0f8d : d0fe > bne * ;failed not equal (non zero) 0f8f : ca dex 0f90 : 10df bpl tldy2 0f92 : a203 ldx #3 0f94 : tldy3 set_stat $ff > load_flag $ff 0f94 : a9ff > lda #$ff ;allow test to change > 0f96 : 48 > pha ;use stack to load status 0f97 : 28 > plp 0f98 : bc1702 ldy abs1,x 0f9b : 08 php ;test stores do not alter flags 0f9c : 98 tya 0f9d : 49c3 eor #$c3 0f9f : a8 tay 0fa0 : 28 plp 0fa1 : 940c sty zpt,x 0fa3 : 08 php ;flags after load/store sequence 0fa4 : 49c3 eor #$c3 0fa6 : d513 cmp zp1,x ;test result trap_ne 0fa8 : d0fe > bne * ;failed not equal (non zero) 0faa : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 0fab : 497d > eor #lo~fnz |fao ;invert expected 0fad : dd1c02 cmp fLDx,x ;test flags trap_ne 0fb0 : d0fe > bne * ;failed not equal (non zero) 0fb2 : ca dex 0fb3 : 10df bpl tldy3 0fb5 : a203 ldx #3 ;testing store result 0fb7 : a000 ldy #0 0fb9 : b50c tsty lda zpt,x 0fbb : 49c3 eor #$c3 0fbd : d513 cmp zp1,x trap_ne ;store to zp,x data 0fbf : d0fe > bne * ;failed not equal (non zero) 0fc1 : 940c sty zpt,x ;clear 0fc3 : bd0302 lda abst,x 0fc6 : 49c3 eor #$c3 0fc8 : dd1702 cmp abs1,x trap_ne ;store to abs,x data 0fcb : d0fe > bne * ;failed not equal (non zero) 0fcd : 8a txa 0fce : 9d0302 sta abst,x ;clear 0fd1 : ca dex 0fd2 : 10e5 bpl tsty next_test 0fd4 : ad0002 > lda test_case ;previous test 0fd7 : c911 > cmp #test_num > trap_ne ;test is out of sequence 0fd9 : d0fe > bne * ;failed not equal (non zero) > 0012 = >test_num = test_num + 1 0fdb : a912 > lda #test_num ;*** next tests' number 0fdd : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; indexed wraparound test (only zp should wrap) 0fe0 : a2fd ldx #3+$fa 0fe2 : b419 tldy4 ldy zp1-$fa&$ff,x ;wrap on indexed zp 0fe4 : 98 tya 0fe5 : 9d0901 sta abst-$fa,x ;no STX abs,x! 0fe8 : ca dex 0fe9 : e0fa cpx #$fa 0feb : b0f5 bcs tldy4 0fed : a2fd ldx #3+$fa 0fef : bc1d01 tldy5 ldy abs1-$fa,x ;no wrap on indexed abs 0ff2 : 9412 sty zpt-$fa&$ff,x 0ff4 : ca dex 0ff5 : e0fa cpx #$fa 0ff7 : b0f6 bcs tldy5 0ff9 : a203 ldx #3 ;testing wraparound result 0ffb : a000 ldy #0 0ffd : b50c tsty1 lda zpt,x 0fff : d513 cmp zp1,x trap_ne ;store to zp,x data 1001 : d0fe > bne * ;failed not equal (non zero) 1003 : 940c sty zpt,x ;clear 1005 : bd0302 lda abst,x 1008 : dd1702 cmp abs1,x trap_ne ;store to abs,x data 100b : d0fe > bne * ;failed not equal (non zero) 100d : 8a txa 100e : 9d0302 sta abst,x ;clear 1011 : ca dex 1012 : 10e9 bpl tsty1 next_test 1014 : ad0002 > lda test_case ;previous test 1017 : c912 > cmp #test_num > trap_ne ;test is out of sequence 1019 : d0fe > bne * ;failed not equal (non zero) > 0013 = >test_num = test_num + 1 101b : a913 > lda #test_num ;*** next tests' number 101d : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; LDX / STX - zp / abs / # set_stat 0 > load_flag 0 1020 : a900 > lda #0 ;allow test to change > 1022 : 48 > pha ;use stack to load status 1023 : 28 > plp 1024 : a613 ldx zp1 1026 : 08 php ;test stores do not alter flags 1027 : 8a txa 1028 : 49c3 eor #$c3 102a : aa tax 102b : 28 plp 102c : 8e0302 stx abst 102f : 08 php ;flags after load/store sequence 1030 : 49c3 eor #$c3 1032 : aa tax 1033 : e0c3 cpx #$c3 ;test result trap_ne 1035 : d0fe > bne * ;failed not equal (non zero) 1037 : 68 pla ;load status eor_flag 0 1038 : 4930 > eor #0|fao ;invert expected flags 103a : cd1c02 cmp fLDx ;test flags trap_ne 103d : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 103f : a900 > lda #0 ;allow test to change I > 1041 : 48 > pha ;use stack to load status 1042 : 28 > plp 1043 : a614 ldx zp1+1 1045 : 08 php ;test stores do not alter flags 1046 : 8a txa 1047 : 49c3 eor #$c3 1049 : aa tax 104a : 28 plp 104b : 8e0402 stx abst+1 104e : 08 php ;flags after load/store sequence 104f : 49c3 eor #$c3 1051 : aa tax 1052 : e082 cpx #$82 ;test result trap_ne 1054 : d0fe > bne * ;failed not equal (non zero) 1056 : 68 pla ;load status eor_flag 0 1057 : 4930 > eor #0|fao ;invert expected flags 1059 : cd1d02 cmp fLDx+1 ;test flags trap_ne 105c : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 105e : a900 > lda #0 ;allow test to change I > 1060 : 48 > pha ;use stack to load status 1061 : 28 > plp 1062 : a615 ldx zp1+2 1064 : 08 php ;test stores do not alter flags 1065 : 8a txa 1066 : 49c3 eor #$c3 1068 : aa tax 1069 : 28 plp 106a : 8e0502 stx abst+2 106d : 08 php ;flags after load/store sequence 106e : 49c3 eor #$c3 1070 : aa tax 1071 : e041 cpx #$41 ;test result trap_ne 1073 : d0fe > bne * ;failed not equal (non zero) 1075 : 68 pla ;load status eor_flag 0 1076 : 4930 > eor #0|fao ;invert expected flags 1078 : cd1e02 cmp fLDx+2 ;test flags trap_ne 107b : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 107d : a900 > lda #0 ;allow test to change I > 107f : 48 > pha ;use stack to load status 1080 : 28 > plp 1081 : a616 ldx zp1+3 1083 : 08 php ;test stores do not alter flags 1084 : 8a txa 1085 : 49c3 eor #$c3 1087 : aa tax 1088 : 28 plp 1089 : 8e0602 stx abst+3 108c : 08 php ;flags after load/store sequence 108d : 49c3 eor #$c3 108f : aa tax 1090 : e000 cpx #0 ;test result trap_ne 1092 : d0fe > bne * ;failed not equal (non zero) 1094 : 68 pla ;load status eor_flag 0 1095 : 4930 > eor #0|fao ;invert expected flags 1097 : cd1f02 cmp fLDx+3 ;test flags trap_ne 109a : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 109c : a9ff > lda #$ff ;allow test to change > 109e : 48 > pha ;use stack to load status 109f : 28 > plp 10a0 : a613 ldx zp1 10a2 : 08 php ;test stores do not alter flags 10a3 : 8a txa 10a4 : 49c3 eor #$c3 10a6 : aa tax 10a7 : 28 plp 10a8 : 8e0302 stx abst 10ab : 08 php ;flags after load/store sequence 10ac : 49c3 eor #$c3 10ae : aa tax 10af : e0c3 cpx #$c3 ;test result trap_ne ; 10b1 : d0fe > bne * ;failed not equal (non zero) 10b3 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 10b4 : 497d > eor #lo~fnz |fao ;invert expected 10b6 : cd1c02 cmp fLDx ;test flags trap_ne 10b9 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 10bb : a9ff > lda #$ff ;allow test to change > 10bd : 48 > pha ;use stack to load status 10be : 28 > plp 10bf : a614 ldx zp1+1 10c1 : 08 php ;test stores do not alter flags 10c2 : 8a txa 10c3 : 49c3 eor #$c3 10c5 : aa tax 10c6 : 28 plp 10c7 : 8e0402 stx abst+1 10ca : 08 php ;flags after load/store sequence 10cb : 49c3 eor #$c3 10cd : aa tax 10ce : e082 cpx #$82 ;test result trap_ne 10d0 : d0fe > bne * ;failed not equal (non zero) 10d2 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 10d3 : 497d > eor #lo~fnz |fao ;invert expected 10d5 : cd1d02 cmp fLDx+1 ;test flags trap_ne 10d8 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 10da : a9ff > lda #$ff ;allow test to change > 10dc : 48 > pha ;use stack to load status 10dd : 28 > plp 10de : a615 ldx zp1+2 10e0 : 08 php ;test stores do not alter flags 10e1 : 8a txa 10e2 : 49c3 eor #$c3 10e4 : aa tax 10e5 : 28 plp 10e6 : 8e0502 stx abst+2 10e9 : 08 php ;flags after load/store sequence 10ea : 49c3 eor #$c3 10ec : aa tax 10ed : e041 cpx #$41 ;test result trap_ne ; 10ef : d0fe > bne * ;failed not equal (non zero) 10f1 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 10f2 : 497d > eor #lo~fnz |fao ;invert expected 10f4 : cd1e02 cmp fLDx+2 ;test flags trap_ne 10f7 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 10f9 : a9ff > lda #$ff ;allow test to change > 10fb : 48 > pha ;use stack to load status 10fc : 28 > plp 10fd : a616 ldx zp1+3 10ff : 08 php ;test stores do not alter flags 1100 : 8a txa 1101 : 49c3 eor #$c3 1103 : aa tax 1104 : 28 plp 1105 : 8e0602 stx abst+3 1108 : 08 php ;flags after load/store sequence 1109 : 49c3 eor #$c3 110b : aa tax 110c : e000 cpx #0 ;test result trap_ne 110e : d0fe > bne * ;failed not equal (non zero) 1110 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1111 : 497d > eor #lo~fnz |fao ;invert expected 1113 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1116 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1118 : a900 > lda #0 ;allow test to change I > 111a : 48 > pha ;use stack to load status 111b : 28 > plp 111c : ae1702 ldx abs1 111f : 08 php ;test stores do not alter flags 1120 : 8a txa 1121 : 49c3 eor #$c3 1123 : aa tax 1124 : 28 plp 1125 : 860c stx zpt 1127 : 08 php ;flags after load/store sequence 1128 : 49c3 eor #$c3 112a : c513 cmp zp1 ;test result trap_ne 112c : d0fe > bne * ;failed not equal (non zero) 112e : 68 pla ;load status eor_flag 0 112f : 4930 > eor #0|fao ;invert expected flags 1131 : cd1c02 cmp fLDx ;test flags trap_ne 1134 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1136 : a900 > lda #0 ;allow test to change I > 1138 : 48 > pha ;use stack to load status 1139 : 28 > plp 113a : ae1802 ldx abs1+1 113d : 08 php ;test stores do not alter flags 113e : 8a txa 113f : 49c3 eor #$c3 1141 : aa tax 1142 : 28 plp 1143 : 860d stx zpt+1 1145 : 08 php ;flags after load/store sequence 1146 : 49c3 eor #$c3 1148 : c514 cmp zp1+1 ;test result trap_ne 114a : d0fe > bne * ;failed not equal (non zero) 114c : 68 pla ;load status eor_flag 0 114d : 4930 > eor #0|fao ;invert expected flags 114f : cd1d02 cmp fLDx+1 ;test flags trap_ne 1152 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1154 : a900 > lda #0 ;allow test to change I > 1156 : 48 > pha ;use stack to load status 1157 : 28 > plp 1158 : ae1902 ldx abs1+2 115b : 08 php ;test stores do not alter flags 115c : 8a txa 115d : 49c3 eor #$c3 115f : aa tax 1160 : 28 plp 1161 : 860e stx zpt+2 1163 : 08 php ;flags after load/store sequence 1164 : 49c3 eor #$c3 1166 : c515 cmp zp1+2 ;test result trap_ne 1168 : d0fe > bne * ;failed not equal (non zero) 116a : 68 pla ;load status eor_flag 0 116b : 4930 > eor #0|fao ;invert expected flags 116d : cd1e02 cmp fLDx+2 ;test flags trap_ne 1170 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1172 : a900 > lda #0 ;allow test to change I > 1174 : 48 > pha ;use stack to load status 1175 : 28 > plp 1176 : ae1a02 ldx abs1+3 1179 : 08 php ;test stores do not alter flags 117a : 8a txa 117b : 49c3 eor #$c3 117d : aa tax 117e : 28 plp 117f : 860f stx zpt+3 1181 : 08 php ;flags after load/store sequence 1182 : 49c3 eor #$c3 1184 : c516 cmp zp1+3 ;test result trap_ne 1186 : d0fe > bne * ;failed not equal (non zero) 1188 : 68 pla ;load status eor_flag 0 1189 : 4930 > eor #0|fao ;invert expected flags 118b : cd1f02 cmp fLDx+3 ;test flags trap_ne 118e : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1190 : a9ff > lda #$ff ;allow test to change > 1192 : 48 > pha ;use stack to load status 1193 : 28 > plp 1194 : ae1702 ldx abs1 1197 : 08 php ;test stores do not alter flags 1198 : 8a txa 1199 : 49c3 eor #$c3 119b : aa tax 119c : 28 plp 119d : 860c stx zpt 119f : 08 php ;flags after load/store sequence 11a0 : 49c3 eor #$c3 11a2 : aa tax 11a3 : e413 cpx zp1 ;test result trap_ne 11a5 : d0fe > bne * ;failed not equal (non zero) 11a7 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 11a8 : 497d > eor #lo~fnz |fao ;invert expected 11aa : cd1c02 cmp fLDx ;test flags trap_ne 11ad : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 11af : a9ff > lda #$ff ;allow test to change > 11b1 : 48 > pha ;use stack to load status 11b2 : 28 > plp 11b3 : ae1802 ldx abs1+1 11b6 : 08 php ;test stores do not alter flags 11b7 : 8a txa 11b8 : 49c3 eor #$c3 11ba : aa tax 11bb : 28 plp 11bc : 860d stx zpt+1 11be : 08 php ;flags after load/store sequence 11bf : 49c3 eor #$c3 11c1 : aa tax 11c2 : e414 cpx zp1+1 ;test result trap_ne 11c4 : d0fe > bne * ;failed not equal (non zero) 11c6 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 11c7 : 497d > eor #lo~fnz |fao ;invert expected 11c9 : cd1d02 cmp fLDx+1 ;test flags trap_ne 11cc : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 11ce : a9ff > lda #$ff ;allow test to change > 11d0 : 48 > pha ;use stack to load status 11d1 : 28 > plp 11d2 : ae1902 ldx abs1+2 11d5 : 08 php ;test stores do not alter flags 11d6 : 8a txa 11d7 : 49c3 eor #$c3 11d9 : aa tax 11da : 28 plp 11db : 860e stx zpt+2 11dd : 08 php ;flags after load/store sequence 11de : 49c3 eor #$c3 11e0 : aa tax 11e1 : e415 cpx zp1+2 ;test result trap_ne 11e3 : d0fe > bne * ;failed not equal (non zero) 11e5 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 11e6 : 497d > eor #lo~fnz |fao ;invert expected 11e8 : cd1e02 cmp fLDx+2 ;test flags trap_ne 11eb : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 11ed : a9ff > lda #$ff ;allow test to change > 11ef : 48 > pha ;use stack to load status 11f0 : 28 > plp 11f1 : ae1a02 ldx abs1+3 11f4 : 08 php ;test stores do not alter flags 11f5 : 8a txa 11f6 : 49c3 eor #$c3 11f8 : aa tax 11f9 : 28 plp 11fa : 860f stx zpt+3 11fc : 08 php ;flags after load/store sequence 11fd : 49c3 eor #$c3 11ff : aa tax 1200 : e416 cpx zp1+3 ;test result trap_ne 1202 : d0fe > bne * ;failed not equal (non zero) 1204 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1205 : 497d > eor #lo~fnz |fao ;invert expected 1207 : cd1f02 cmp fLDx+3 ;test flags trap_ne 120a : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 120c : a900 > lda #0 ;allow test to change > 120e : 48 > pha ;use stack to load status 120f : 28 > plp 1210 : a2c3 ldx #$c3 1212 : 08 php 1213 : ec1702 cpx abs1 ;test result trap_ne 1216 : d0fe > bne * ;failed not equal (non zero) 1218 : 68 pla ;load status eor_flag 0 1219 : 4930 > eor #0|fao ;invert expected flags 121b : cd1c02 cmp fLDx ;test flags trap_ne 121e : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1220 : a900 > lda #0 ;allow test to change I > 1222 : 48 > pha ;use stack to load status 1223 : 28 > plp 1224 : a282 ldx #$82 1226 : 08 php 1227 : ec1802 cpx abs1+1 ;test result trap_ne 122a : d0fe > bne * ;failed not equal (non zero) 122c : 68 pla ;load status eor_flag 0 122d : 4930 > eor #0|fao ;invert expected flags 122f : cd1d02 cmp fLDx+1 ;test flags trap_ne 1232 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1234 : a900 > lda #0 ;allow test to change I > 1236 : 48 > pha ;use stack to load status 1237 : 28 > plp 1238 : a241 ldx #$41 123a : 08 php 123b : ec1902 cpx abs1+2 ;test result trap_ne 123e : d0fe > bne * ;failed not equal (non zero) 1240 : 68 pla ;load status eor_flag 0 1241 : 4930 > eor #0|fao ;invert expected flags 1243 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1246 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1248 : a900 > lda #0 ;allow test to change I > 124a : 48 > pha ;use stack to load status 124b : 28 > plp 124c : a200 ldx #0 124e : 08 php 124f : ec1a02 cpx abs1+3 ;test result trap_ne 1252 : d0fe > bne * ;failed not equal (non zero) 1254 : 68 pla ;load status eor_flag 0 1255 : 4930 > eor #0|fao ;invert expected flags 1257 : cd1f02 cmp fLDx+3 ;test flags trap_ne 125a : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 125c : a9ff > lda #$ff ;allow test to change > 125e : 48 > pha ;use stack to load status 125f : 28 > plp 1260 : a2c3 ldx #$c3 1262 : 08 php 1263 : ec1702 cpx abs1 ;test result trap_ne 1266 : d0fe > bne * ;failed not equal (non zero) 1268 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1269 : 497d > eor #lo~fnz |fao ;invert expected 126b : cd1c02 cmp fLDx ;test flags trap_ne 126e : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1270 : a9ff > lda #$ff ;allow test to change > 1272 : 48 > pha ;use stack to load status 1273 : 28 > plp 1274 : a282 ldx #$82 1276 : 08 php 1277 : ec1802 cpx abs1+1 ;test result trap_ne 127a : d0fe > bne * ;failed not equal (non zero) 127c : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 127d : 497d > eor #lo~fnz |fao ;invert expected 127f : cd1d02 cmp fLDx+1 ;test flags trap_ne 1282 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1284 : a9ff > lda #$ff ;allow test to change > 1286 : 48 > pha ;use stack to load status 1287 : 28 > plp 1288 : a241 ldx #$41 128a : 08 php 128b : ec1902 cpx abs1+2 ;test result trap_ne 128e : d0fe > bne * ;failed not equal (non zero) 1290 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1291 : 497d > eor #lo~fnz |fao ;invert expected 1293 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1296 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1298 : a9ff > lda #$ff ;allow test to change > 129a : 48 > pha ;use stack to load status 129b : 28 > plp 129c : a200 ldx #0 129e : 08 php 129f : ec1a02 cpx abs1+3 ;test result trap_ne 12a2 : d0fe > bne * ;failed not equal (non zero) 12a4 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 12a5 : 497d > eor #lo~fnz |fao ;invert expected 12a7 : cd1f02 cmp fLDx+3 ;test flags trap_ne 12aa : d0fe > bne * ;failed not equal (non zero) 12ac : a200 ldx #0 12ae : a50c lda zpt 12b0 : 49c3 eor #$c3 12b2 : c513 cmp zp1 trap_ne ;store to zp data 12b4 : d0fe > bne * ;failed not equal (non zero) 12b6 : 860c stx zpt ;clear 12b8 : ad0302 lda abst 12bb : 49c3 eor #$c3 12bd : cd1702 cmp abs1 trap_ne ;store to abs data 12c0 : d0fe > bne * ;failed not equal (non zero) 12c2 : 8e0302 stx abst ;clear 12c5 : a50d lda zpt+1 12c7 : 49c3 eor #$c3 12c9 : c514 cmp zp1+1 trap_ne ;store to zp data 12cb : d0fe > bne * ;failed not equal (non zero) 12cd : 860d stx zpt+1 ;clear 12cf : ad0402 lda abst+1 12d2 : 49c3 eor #$c3 12d4 : cd1802 cmp abs1+1 trap_ne ;store to abs data 12d7 : d0fe > bne * ;failed not equal (non zero) 12d9 : 8e0402 stx abst+1 ;clear 12dc : a50e lda zpt+2 12de : 49c3 eor #$c3 12e0 : c515 cmp zp1+2 trap_ne ;store to zp data 12e2 : d0fe > bne * ;failed not equal (non zero) 12e4 : 860e stx zpt+2 ;clear 12e6 : ad0502 lda abst+2 12e9 : 49c3 eor #$c3 12eb : cd1902 cmp abs1+2 trap_ne ;store to abs data 12ee : d0fe > bne * ;failed not equal (non zero) 12f0 : 8e0502 stx abst+2 ;clear 12f3 : a50f lda zpt+3 12f5 : 49c3 eor #$c3 12f7 : c516 cmp zp1+3 trap_ne ;store to zp data 12f9 : d0fe > bne * ;failed not equal (non zero) 12fb : 860f stx zpt+3 ;clear 12fd : ad0602 lda abst+3 1300 : 49c3 eor #$c3 1302 : cd1a02 cmp abs1+3 trap_ne ;store to abs data 1305 : d0fe > bne * ;failed not equal (non zero) 1307 : 8e0602 stx abst+3 ;clear next_test 130a : ad0002 > lda test_case ;previous test 130d : c913 > cmp #test_num > trap_ne ;test is out of sequence 130f : d0fe > bne * ;failed not equal (non zero) > 0014 = >test_num = test_num + 1 1311 : a914 > lda #test_num ;*** next tests' number 1313 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; LDY / STY - zp / abs / # set_stat 0 > load_flag 0 1316 : a900 > lda #0 ;allow test to change I > 1318 : 48 > pha ;use stack to load status 1319 : 28 > plp 131a : a413 ldy zp1 131c : 08 php ;test stores do not alter flags 131d : 98 tya 131e : 49c3 eor #$c3 1320 : a8 tay 1321 : 28 plp 1322 : 8c0302 sty abst 1325 : 08 php ;flags after load/store sequence 1326 : 49c3 eor #$c3 1328 : a8 tay 1329 : c0c3 cpy #$c3 ;test result trap_ne 132b : d0fe > bne * ;failed not equal (non zero) 132d : 68 pla ;load status eor_flag 0 132e : 4930 > eor #0|fao ;invert expected flags 1330 : cd1c02 cmp fLDx ;test flags trap_ne 1333 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1335 : a900 > lda #0 ;allow test to change I > 1337 : 48 > pha ;use stack to load status 1338 : 28 > plp 1339 : a414 ldy zp1+1 133b : 08 php ;test stores do not alter flags 133c : 98 tya 133d : 49c3 eor #$c3 133f : a8 tay 1340 : 28 plp 1341 : 8c0402 sty abst+1 1344 : 08 php ;flags after load/store sequence 1345 : 49c3 eor #$c3 1347 : a8 tay 1348 : c082 cpy #$82 ;test result trap_ne 134a : d0fe > bne * ;failed not equal (non zero) 134c : 68 pla ;load status eor_flag 0 134d : 4930 > eor #0|fao ;invert expected flags 134f : cd1d02 cmp fLDx+1 ;test flags trap_ne 1352 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1354 : a900 > lda #0 ;allow test to change I > 1356 : 48 > pha ;use stack to load status 1357 : 28 > plp 1358 : a415 ldy zp1+2 135a : 08 php ;test stores do not alter flags 135b : 98 tya 135c : 49c3 eor #$c3 135e : a8 tay 135f : 28 plp 1360 : 8c0502 sty abst+2 1363 : 08 php ;flags after load/store sequence 1364 : 49c3 eor #$c3 1366 : a8 tay 1367 : c041 cpy #$41 ;test result trap_ne 1369 : d0fe > bne * ;failed not equal (non zero) 136b : 68 pla ;load status eor_flag 0 136c : 4930 > eor #0|fao ;invert expected flags 136e : cd1e02 cmp fLDx+2 ;test flags trap_ne 1371 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1373 : a900 > lda #0 ;allow test to change I > 1375 : 48 > pha ;use stack to load status 1376 : 28 > plp 1377 : a416 ldy zp1+3 1379 : 08 php ;test stores do not alter flags 137a : 98 tya 137b : 49c3 eor #$c3 137d : a8 tay 137e : 28 plp 137f : 8c0602 sty abst+3 1382 : 08 php ;flags after load/store sequence 1383 : 49c3 eor #$c3 1385 : a8 tay 1386 : c000 cpy #0 ;test result trap_ne 1388 : d0fe > bne * ;failed not equal (non zero) 138a : 68 pla ;load status eor_flag 0 138b : 4930 > eor #0|fao ;invert expected flags 138d : cd1f02 cmp fLDx+3 ;test flags trap_ne 1390 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1392 : a9ff > lda #$ff ;allow test to change > 1394 : 48 > pha ;use stack to load status 1395 : 28 > plp 1396 : a413 ldy zp1 1398 : 08 php ;test stores do not alter flags 1399 : 98 tya 139a : 49c3 eor #$c3 139c : a8 tay 139d : 28 plp 139e : 8c0302 sty abst 13a1 : 08 php ;flags after load/store sequence 13a2 : 49c3 eor #$c3 13a4 : a8 tay 13a5 : c0c3 cpy #$c3 ;test result trap_ne 13a7 : d0fe > bne * ;failed not equal (non zero) 13a9 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 13aa : 497d > eor #lo~fnz |fao ;invert expected 13ac : cd1c02 cmp fLDx ;test flags trap_ne 13af : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 13b1 : a9ff > lda #$ff ;allow test to change > 13b3 : 48 > pha ;use stack to load status 13b4 : 28 > plp 13b5 : a414 ldy zp1+1 13b7 : 08 php ;test stores do not alter flags 13b8 : 98 tya 13b9 : 49c3 eor #$c3 13bb : a8 tay 13bc : 28 plp 13bd : 8c0402 sty abst+1 13c0 : 08 php ;flags after load/store sequence 13c1 : 49c3 eor #$c3 13c3 : a8 tay 13c4 : c082 cpy #$82 ;test result trap_ne 13c6 : d0fe > bne * ;failed not equal (non zero) 13c8 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 13c9 : 497d > eor #lo~fnz |fao ;invert expected 13cb : cd1d02 cmp fLDx+1 ;test flags trap_ne 13ce : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 13d0 : a9ff > lda #$ff ;allow test to change > 13d2 : 48 > pha ;use stack to load status 13d3 : 28 > plp 13d4 : a415 ldy zp1+2 13d6 : 08 php ;test stores do not alter flags 13d7 : 98 tya 13d8 : 49c3 eor #$c3 13da : a8 tay 13db : 28 plp 13dc : 8c0502 sty abst+2 13df : 08 php ;flags after load/store sequence 13e0 : 49c3 eor #$c3 13e2 : a8 tay 13e3 : c041 cpy #$41 ;test result trap_ne 13e5 : d0fe > bne * ;failed not equal (non zero) 13e7 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 13e8 : 497d > eor #lo~fnz |fao ;invert expected 13ea : cd1e02 cmp fLDx+2 ;test flags trap_ne 13ed : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 13ef : a9ff > lda #$ff ;allow test to change > 13f1 : 48 > pha ;use stack to load status 13f2 : 28 > plp 13f3 : a416 ldy zp1+3 13f5 : 08 php ;test stores do not alter flags 13f6 : 98 tya 13f7 : 49c3 eor #$c3 13f9 : a8 tay 13fa : 28 plp 13fb : 8c0602 sty abst+3 13fe : 08 php ;flags after load/store sequence 13ff : 49c3 eor #$c3 1401 : a8 tay 1402 : c000 cpy #0 ;test result trap_ne 1404 : d0fe > bne * ;failed not equal (non zero) 1406 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1407 : 497d > eor #lo~fnz |fao ;invert expected 1409 : cd1f02 cmp fLDx+3 ;test flags trap_ne 140c : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 140e : a900 > lda #0 ;allow test to change I > 1410 : 48 > pha ;use stack to load status 1411 : 28 > plp 1412 : ac1702 ldy abs1 1415 : 08 php ;test stores do not alter flags 1416 : 98 tya 1417 : 49c3 eor #$c3 1419 : a8 tay 141a : 28 plp 141b : 840c sty zpt 141d : 08 php ;flags after load/store sequence 141e : 49c3 eor #$c3 1420 : a8 tay 1421 : c413 cpy zp1 ;test result trap_ne 1423 : d0fe > bne * ;failed not equal (non zero) 1425 : 68 pla ;load status eor_flag 0 1426 : 4930 > eor #0|fao ;invert expected flags 1428 : cd1c02 cmp fLDx ;test flags trap_ne 142b : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 142d : a900 > lda #0 ;allow test to change I > 142f : 48 > pha ;use stack to load status 1430 : 28 > plp 1431 : ac1802 ldy abs1+1 1434 : 08 php ;test stores do not alter flags 1435 : 98 tya 1436 : 49c3 eor #$c3 1438 : a8 tay 1439 : 28 plp 143a : 840d sty zpt+1 143c : 08 php ;flags after load/store sequence 143d : 49c3 eor #$c3 143f : a8 tay 1440 : c414 cpy zp1+1 ;test result trap_ne 1442 : d0fe > bne * ;failed not equal (non zero) 1444 : 68 pla ;load status eor_flag 0 1445 : 4930 > eor #0|fao ;invert expected flags 1447 : cd1d02 cmp fLDx+1 ;test flags trap_ne 144a : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 144c : a900 > lda #0 ;allow test to change I > 144e : 48 > pha ;use stack to load status 144f : 28 > plp 1450 : ac1902 ldy abs1+2 1453 : 08 php ;test stores do not alter flags 1454 : 98 tya 1455 : 49c3 eor #$c3 1457 : a8 tay 1458 : 28 plp 1459 : 840e sty zpt+2 145b : 08 php ;flags after load/store sequence 145c : 49c3 eor #$c3 145e : a8 tay 145f : c415 cpy zp1+2 ;test result trap_ne 1461 : d0fe > bne * ;failed not equal (non zero) 1463 : 68 pla ;load status eor_flag 0 1464 : 4930 > eor #0|fao ;invert expected flags 1466 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1469 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 146b : a900 > lda #0 ;allow test to change I > 146d : 48 > pha ;use stack to load status 146e : 28 > plp 146f : ac1a02 ldy abs1+3 1472 : 08 php ;test stores do not alter flags 1473 : 98 tya 1474 : 49c3 eor #$c3 1476 : a8 tay 1477 : 28 plp 1478 : 840f sty zpt+3 147a : 08 php ;flags after load/store sequence 147b : 49c3 eor #$c3 147d : a8 tay 147e : c416 cpy zp1+3 ;test result trap_ne 1480 : d0fe > bne * ;failed not equal (non zero) 1482 : 68 pla ;load status eor_flag 0 1483 : 4930 > eor #0|fao ;invert expected flags 1485 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1488 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 148a : a9ff > lda #$ff ;allow test to change > 148c : 48 > pha ;use stack to load status 148d : 28 > plp 148e : ac1702 ldy abs1 1491 : 08 php ;test stores do not alter flags 1492 : 98 tya 1493 : 49c3 eor #$c3 1495 : a8 tay 1496 : 28 plp 1497 : 840c sty zpt 1499 : 08 php ;flags after load/store sequence 149a : 49c3 eor #$c3 149c : a8 tay 149d : c513 cmp zp1 ;test result trap_ne 149f : d0fe > bne * ;failed not equal (non zero) 14a1 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 14a2 : 497d > eor #lo~fnz |fao ;invert expected 14a4 : cd1c02 cmp fLDx ;test flags trap_ne 14a7 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 14a9 : a9ff > lda #$ff ;allow test to change > 14ab : 48 > pha ;use stack to load status 14ac : 28 > plp 14ad : ac1802 ldy abs1+1 14b0 : 08 php ;test stores do not alter flags 14b1 : 98 tya 14b2 : 49c3 eor #$c3 14b4 : a8 tay 14b5 : 28 plp 14b6 : 840d sty zpt+1 14b8 : 08 php ;flags after load/store sequence 14b9 : 49c3 eor #$c3 14bb : a8 tay 14bc : c514 cmp zp1+1 ;test result trap_ne 14be : d0fe > bne * ;failed not equal (non zero) 14c0 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 14c1 : 497d > eor #lo~fnz |fao ;invert expected 14c3 : cd1d02 cmp fLDx+1 ;test flags trap_ne 14c6 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 14c8 : a9ff > lda #$ff ;allow test to change > 14ca : 48 > pha ;use stack to load status 14cb : 28 > plp 14cc : ac1902 ldy abs1+2 14cf : 08 php ;test stores do not alter flags 14d0 : 98 tya 14d1 : 49c3 eor #$c3 14d3 : a8 tay 14d4 : 28 plp 14d5 : 840e sty zpt+2 14d7 : 08 php ;flags after load/store sequence 14d8 : 49c3 eor #$c3 14da : a8 tay 14db : c515 cmp zp1+2 ;test result trap_ne 14dd : d0fe > bne * ;failed not equal (non zero) 14df : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 14e0 : 497d > eor #lo~fnz |fao ;invert expected 14e2 : cd1e02 cmp fLDx+2 ;test flags trap_ne 14e5 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 14e7 : a9ff > lda #$ff ;allow test to change > 14e9 : 48 > pha ;use stack to load status 14ea : 28 > plp 14eb : ac1a02 ldy abs1+3 14ee : 08 php ;test stores do not alter flags 14ef : 98 tya 14f0 : 49c3 eor #$c3 14f2 : a8 tay 14f3 : 28 plp 14f4 : 840f sty zpt+3 14f6 : 08 php ;flags after load/store sequence 14f7 : 49c3 eor #$c3 14f9 : a8 tay 14fa : c516 cmp zp1+3 ;test result trap_ne 14fc : d0fe > bne * ;failed not equal (non zero) 14fe : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 14ff : 497d > eor #lo~fnz |fao ;invert expected 1501 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1504 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1506 : a900 > lda #0 ;allow test to change I > 1508 : 48 > pha ;use stack to load status 1509 : 28 > plp 150a : a0c3 ldy #$c3 150c : 08 php 150d : cc1702 cpy abs1 ;test result trap_ne 1510 : d0fe > bne * ;failed not equal (non zero) 1512 : 68 pla ;load status eor_flag 0 1513 : 4930 > eor #0|fao ;invert expected flags 1515 : cd1c02 cmp fLDx ;test flags trap_ne 1518 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 151a : a900 > lda #0 ;allow test to change I > 151c : 48 > pha ;use stack to load status 151d : 28 > plp 151e : a082 ldy #$82 1520 : 08 php 1521 : cc1802 cpy abs1+1 ;test result trap_ne 1524 : d0fe > bne * ;failed not equal (non zero) 1526 : 68 pla ;load status eor_flag 0 1527 : 4930 > eor #0|fao ;invert expected flags 1529 : cd1d02 cmp fLDx+1 ;test flags trap_ne 152c : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 152e : a900 > lda #0 ;allow test to change I > 1530 : 48 > pha ;use stack to load status 1531 : 28 > plp 1532 : a041 ldy #$41 1534 : 08 php 1535 : cc1902 cpy abs1+2 ;test result trap_ne 1538 : d0fe > bne * ;failed not equal (non zero) 153a : 68 pla ;load status eor_flag 0 153b : 4930 > eor #0|fao ;invert expected flags 153d : cd1e02 cmp fLDx+2 ;test flags trap_ne 1540 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1542 : a900 > lda #0 ;allow test to change I > 1544 : 48 > pha ;use stack to load status 1545 : 28 > plp 1546 : a000 ldy #0 1548 : 08 php 1549 : cc1a02 cpy abs1+3 ;test result trap_ne 154c : d0fe > bne * ;failed not equal (non zero) 154e : 68 pla ;load status eor_flag 0 154f : 4930 > eor #0|fao ;invert expected flags 1551 : cd1f02 cmp fLDx+3 ;test flags trap_ne 1554 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1556 : a9ff > lda #$ff ;allow test to change > 1558 : 48 > pha ;use stack to load status 1559 : 28 > plp 155a : a0c3 ldy #$c3 155c : 08 php 155d : cc1702 cpy abs1 ;test result trap_ne 1560 : d0fe > bne * ;failed not equal (non zero) 1562 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1563 : 497d > eor #lo~fnz |fao ;invert expected 1565 : cd1c02 cmp fLDx ;test flags trap_ne 1568 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 156a : a9ff > lda #$ff ;allow test to change > 156c : 48 > pha ;use stack to load status 156d : 28 > plp 156e : a082 ldy #$82 1570 : 08 php 1571 : cc1802 cpy abs1+1 ;test result trap_ne 1574 : d0fe > bne * ;failed not equal (non zero) 1576 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1577 : 497d > eor #lo~fnz |fao ;invert expected 1579 : cd1d02 cmp fLDx+1 ;test flags trap_ne 157c : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 157e : a9ff > lda #$ff ;allow test to change > 1580 : 48 > pha ;use stack to load status 1581 : 28 > plp 1582 : a041 ldy #$41 1584 : 08 php 1585 : cc1902 cpy abs1+2 ;test result trap_ne 1588 : d0fe > bne * ;failed not equal (non zero) 158a : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 158b : 497d > eor #lo~fnz |fao ;invert expected 158d : cd1e02 cmp fLDx+2 ;test flags trap_ne 1590 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1592 : a9ff > lda #$ff ;allow test to change > 1594 : 48 > pha ;use stack to load status 1595 : 28 > plp 1596 : a000 ldy #0 1598 : 08 php 1599 : cc1a02 cpy abs1+3 ;test result trap_ne 159c : d0fe > bne * ;failed not equal (non zero) 159e : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 159f : 497d > eor #lo~fnz |fao ;invert expected 15a1 : cd1f02 cmp fLDx+3 ;test flags trap_ne 15a4 : d0fe > bne * ;failed not equal (non zero) 15a6 : a000 ldy #0 15a8 : a50c lda zpt 15aa : 49c3 eor #$c3 15ac : c513 cmp zp1 trap_ne ;store to zp data 15ae : d0fe > bne * ;failed not equal (non zero) 15b0 : 840c sty zpt ;clear 15b2 : ad0302 lda abst 15b5 : 49c3 eor #$c3 15b7 : cd1702 cmp abs1 trap_ne ;store to abs data 15ba : d0fe > bne * ;failed not equal (non zero) 15bc : 8c0302 sty abst ;clear 15bf : a50d lda zpt+1 15c1 : 49c3 eor #$c3 15c3 : c514 cmp zp1+1 trap_ne ;store to zp+1 data 15c5 : d0fe > bne * ;failed not equal (non zero) 15c7 : 840d sty zpt+1 ;clear 15c9 : ad0402 lda abst+1 15cc : 49c3 eor #$c3 15ce : cd1802 cmp abs1+1 trap_ne ;store to abs+1 data 15d1 : d0fe > bne * ;failed not equal (non zero) 15d3 : 8c0402 sty abst+1 ;clear 15d6 : a50e lda zpt+2 15d8 : 49c3 eor #$c3 15da : c515 cmp zp1+2 trap_ne ;store to zp+2 data 15dc : d0fe > bne * ;failed not equal (non zero) 15de : 840e sty zpt+2 ;clear 15e0 : ad0502 lda abst+2 15e3 : 49c3 eor #$c3 15e5 : cd1902 cmp abs1+2 trap_ne ;store to abs+2 data 15e8 : d0fe > bne * ;failed not equal (non zero) 15ea : 8c0502 sty abst+2 ;clear 15ed : a50f lda zpt+3 15ef : 49c3 eor #$c3 15f1 : c516 cmp zp1+3 trap_ne ;store to zp+3 data 15f3 : d0fe > bne * ;failed not equal (non zero) 15f5 : 840f sty zpt+3 ;clear 15f7 : ad0602 lda abst+3 15fa : 49c3 eor #$c3 15fc : cd1a02 cmp abs1+3 trap_ne ;store to abs+3 data 15ff : d0fe > bne * ;failed not equal (non zero) 1601 : 8c0602 sty abst+3 ;clear next_test 1604 : ad0002 > lda test_case ;previous test 1607 : c914 > cmp #test_num > trap_ne ;test is out of sequence 1609 : d0fe > bne * ;failed not equal (non zero) > 0015 = >test_num = test_num + 1 160b : a915 > lda #test_num ;*** next tests' number 160d : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; testing load / store accumulator LDA / STA all addre ; LDA / STA - zp,x / abs,x 1610 : a203 ldx #3 1612 : tldax set_stat 0 > load_flag 0 1612 : a900 > lda #0 ;allow test to change I > 1614 : 48 > pha ;use stack to load status 1615 : 28 > plp 1616 : b513 lda zp1,x 1618 : 08 php ;test stores do not alter flags 1619 : 49c3 eor #$c3 161b : 28 plp 161c : 9d0302 sta abst,x 161f : 08 php ;flags after load/store sequence 1620 : 49c3 eor #$c3 1622 : dd1702 cmp abs1,x ;test result trap_ne 1625 : d0fe > bne * ;failed not equal (non zero) 1627 : 68 pla ;load status eor_flag 0 1628 : 4930 > eor #0|fao ;invert expected flags 162a : dd1c02 cmp fLDx,x ;test flags trap_ne 162d : d0fe > bne * ;failed not equal (non zero) 162f : ca dex 1630 : 10e0 bpl tldax 1632 : a203 ldx #3 1634 : tldax1 set_stat $ff > load_flag $ff 1634 : a9ff > lda #$ff ;allow test to change > 1636 : 48 > pha ;use stack to load status 1637 : 28 > plp 1638 : b513 lda zp1,x 163a : 08 php ;test stores do not alter flags 163b : 49c3 eor #$c3 163d : 28 plp 163e : 9d0302 sta abst,x 1641 : 08 php ;flags after load/store sequence 1642 : 49c3 eor #$c3 1644 : dd1702 cmp abs1,x ;test result trap_ne 1647 : d0fe > bne * ;failed not equal (non zero) 1649 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 164a : 497d > eor #lo~fnz |fao ;invert expected 164c : dd1c02 cmp fLDx,x ;test flags trap_ne 164f : d0fe > bne * ;failed not equal (non zero) 1651 : ca dex 1652 : 10e0 bpl tldax1 1654 : a203 ldx #3 1656 : tldax2 set_stat 0 > load_flag 0 1656 : a900 > lda #0 ;allow test to change I > 1658 : 48 > pha ;use stack to load status 1659 : 28 > plp 165a : bd1702 lda abs1,x 165d : 08 php ;test stores do not alter flags 165e : 49c3 eor #$c3 1660 : 28 plp 1661 : 950c sta zpt,x 1663 : 08 php ;flags after load/store sequence 1664 : 49c3 eor #$c3 1666 : d513 cmp zp1,x ;test result trap_ne 1668 : d0fe > bne * ;failed not equal (non zero) 166a : 68 pla ;load status eor_flag 0 166b : 4930 > eor #0|fao ;invert expected flags 166d : dd1c02 cmp fLDx,x ;test flags trap_ne 1670 : d0fe > bne * ;failed not equal (non zero) 1672 : ca dex 1673 : 10e1 bpl tldax2 1675 : a203 ldx #3 1677 : tldax3 set_stat $ff > load_flag $ff 1677 : a9ff > lda #$ff ;allow test to change > 1679 : 48 > pha ;use stack to load status 167a : 28 > plp 167b : bd1702 lda abs1,x 167e : 08 php ;test stores do not alter flags 167f : 49c3 eor #$c3 1681 : 28 plp 1682 : 950c sta zpt,x 1684 : 08 php ;flags after load/store sequence 1685 : 49c3 eor #$c3 1687 : d513 cmp zp1,x ;test result trap_ne 1689 : d0fe > bne * ;failed not equal (non zero) 168b : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 168c : 497d > eor #lo~fnz |fao ;invert expected 168e : dd1c02 cmp fLDx,x ;test flags trap_ne 1691 : d0fe > bne * ;failed not equal (non zero) 1693 : ca dex 1694 : 10e1 bpl tldax3 1696 : a203 ldx #3 ;testing store result 1698 : a000 ldy #0 169a : b50c tstax lda zpt,x 169c : 49c3 eor #$c3 169e : d513 cmp zp1,x trap_ne ;store to zp,x data 16a0 : d0fe > bne * ;failed not equal (non zero) 16a2 : 940c sty zpt,x ;clear 16a4 : bd0302 lda abst,x 16a7 : 49c3 eor #$c3 16a9 : dd1702 cmp abs1,x trap_ne ;store to abs,x data 16ac : d0fe > bne * ;failed not equal (non zero) 16ae : 8a txa 16af : 9d0302 sta abst,x ;clear 16b2 : ca dex 16b3 : 10e5 bpl tstax next_test 16b5 : ad0002 > lda test_case ;previous test 16b8 : c915 > cmp #test_num > trap_ne ;test is out of sequence 16ba : d0fe > bne * ;failed not equal (non zero) > 0016 = >test_num = test_num + 1 16bc : a916 > lda #test_num ;*** next tests' number 16be : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; LDA / STA - (zp),y / abs,y / (zp,x) 16c1 : a003 ldy #3 16c3 : tlday set_stat 0 > load_flag 0 16c3 : a900 > lda #0 ;allow test to change I > 16c5 : 48 > pha ;use stack to load status 16c6 : 28 > plp 16c7 : b124 lda (ind1),y 16c9 : 08 php ;test stores do not alter flags 16ca : 49c3 eor #$c3 16cc : 28 plp 16cd : 990302 sta abst,y 16d0 : 08 php ;flags after load/store sequence 16d1 : 49c3 eor #$c3 16d3 : d91702 cmp abs1,y ;test result trap_ne 16d6 : d0fe > bne * ;failed not equal (non zero) 16d8 : 68 pla ;load status eor_flag 0 16d9 : 4930 > eor #0|fao ;invert expected flags 16db : d91c02 cmp fLDx,y ;test flags trap_ne 16de : d0fe > bne * ;failed not equal (non zero) 16e0 : 88 dey 16e1 : 10e0 bpl tlday 16e3 : a003 ldy #3 16e5 : tlday1 set_stat $ff > load_flag $ff 16e5 : a9ff > lda #$ff ;allow test to change > 16e7 : 48 > pha ;use stack to load status 16e8 : 28 > plp 16e9 : b124 lda (ind1),y 16eb : 08 php ;test stores do not alter flags 16ec : 49c3 eor #$c3 16ee : 28 plp 16ef : 990302 sta abst,y 16f2 : 08 php ;flags after load/store sequence 16f3 : 49c3 eor #$c3 16f5 : d91702 cmp abs1,y ;test result trap_ne 16f8 : d0fe > bne * ;failed not equal (non zero) 16fa : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 16fb : 497d > eor #lo~fnz |fao ;invert expected 16fd : d91c02 cmp fLDx,y ;test flags trap_ne 1700 : d0fe > bne * ;failed not equal (non zero) 1702 : 88 dey 1703 : 10e0 bpl tlday1 1705 : a003 ldy #3 ;testing store result 1707 : a200 ldx #0 1709 : b90302 tstay lda abst,y 170c : 49c3 eor #$c3 170e : d91702 cmp abs1,y trap_ne ;store to abs data 1711 : d0fe > bne * ;failed not equal (non zero) 1713 : 8a txa 1714 : 990302 sta abst,y ;clear 1717 : 88 dey 1718 : 10ef bpl tstay 171a : a003 ldy #3 171c : tlday2 set_stat 0 > load_flag 0 171c : a900 > lda #0 ;allow test to change I > 171e : 48 > pha ;use stack to load status 171f : 28 > plp 1720 : b91702 lda abs1,y 1723 : 08 php ;test stores do not alter flags 1724 : 49c3 eor #$c3 1726 : 28 plp 1727 : 9130 sta (indt),y 1729 : 08 php ;flags after load/store sequence 172a : 49c3 eor #$c3 172c : d124 cmp (ind1),y ;test result trap_ne 172e : d0fe > bne * ;failed not equal (non zero) 1730 : 68 pla ;load status eor_flag 0 1731 : 4930 > eor #0|fao ;invert expected flags 1733 : d91c02 cmp fLDx,y ;test flags trap_ne 1736 : d0fe > bne * ;failed not equal (non zero) 1738 : 88 dey 1739 : 10e1 bpl tlday2 173b : a003 ldy #3 173d : tlday3 set_stat $ff > load_flag $ff 173d : a9ff > lda #$ff ;allow test to change > 173f : 48 > pha ;use stack to load status 1740 : 28 > plp 1741 : b91702 lda abs1,y 1744 : 08 php ;test stores do not alter flags 1745 : 49c3 eor #$c3 1747 : 28 plp 1748 : 9130 sta (indt),y 174a : 08 php ;flags after load/store sequence 174b : 49c3 eor #$c3 174d : d124 cmp (ind1),y ;test result trap_ne 174f : d0fe > bne * ;failed not equal (non zero) 1751 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1752 : 497d > eor #lo~fnz |fao ;invert expected 1754 : d91c02 cmp fLDx,y ;test flags trap_ne 1757 : d0fe > bne * ;failed not equal (non zero) 1759 : 88 dey 175a : 10e1 bpl tlday3 175c : a003 ldy #3 ;testing store result 175e : a200 ldx #0 1760 : b90302 tstay1 lda abst,y 1763 : 49c3 eor #$c3 1765 : d91702 cmp abs1,y trap_ne ;store to abs data 1768 : d0fe > bne * ;failed not equal (non zero) 176a : 8a txa 176b : 990302 sta abst,y ;clear 176e : 88 dey 176f : 10ef bpl tstay1 1771 : a206 ldx #6 1773 : a003 ldy #3 1775 : tldax4 set_stat 0 > load_flag 0 1775 : a900 > lda #0 ;allow test to change I > 1777 : 48 > pha ;use stack to load status 1778 : 28 > plp 1779 : a124 lda (ind1,x) 177b : 08 php ;test stores do not alter flags 177c : 49c3 eor #$c3 177e : 28 plp 177f : 8130 sta (indt,x) 1781 : 08 php ;flags after load/store sequence 1782 : 49c3 eor #$c3 1784 : d91702 cmp abs1,y ;test result trap_ne 1787 : d0fe > bne * ;failed not equal (non zero) 1789 : 68 pla ;load status eor_flag 0 178a : 4930 > eor #0|fao ;invert expected flags 178c : d91c02 cmp fLDx,y ;test flags trap_ne 178f : d0fe > bne * ;failed not equal (non zero) 1791 : ca dex 1792 : ca dex 1793 : 88 dey 1794 : 10df bpl tldax4 1796 : a206 ldx #6 1798 : a003 ldy #3 179a : tldax5 set_stat $ff > load_flag $ff 179a : a9ff > lda #$ff ;allow test to change > 179c : 48 > pha ;use stack to load status 179d : 28 > plp 179e : a124 lda (ind1,x) 17a0 : 08 php ;test stores do not alter flags 17a1 : 49c3 eor #$c3 17a3 : 28 plp 17a4 : 8130 sta (indt,x) 17a6 : 08 php ;flags after load/store sequence 17a7 : 49c3 eor #$c3 17a9 : d91702 cmp abs1,y ;test result trap_ne 17ac : d0fe > bne * ;failed not equal (non zero) 17ae : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 17af : 497d > eor #lo~fnz |fao ;invert expected 17b1 : d91c02 cmp fLDx,y ;test flags trap_ne 17b4 : d0fe > bne * ;failed not equal (non zero) 17b6 : ca dex 17b7 : ca dex 17b8 : 88 dey 17b9 : 10df bpl tldax5 17bb : a003 ldy #3 ;testing store result 17bd : a200 ldx #0 17bf : b90302 tstay2 lda abst,y 17c2 : 49c3 eor #$c3 17c4 : d91702 cmp abs1,y trap_ne ;store to abs data 17c7 : d0fe > bne * ;failed not equal (non zero) 17c9 : 8a txa 17ca : 990302 sta abst,y ;clear 17cd : 88 dey 17ce : 10ef bpl tstay2 next_test 17d0 : ad0002 > lda test_case ;previous test 17d3 : c916 > cmp #test_num > trap_ne ;test is out of sequence 17d5 : d0fe > bne * ;failed not equal (non zero) > 0017 = >test_num = test_num + 1 17d7 : a917 > lda #test_num ;*** next tests' number 17d9 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; indexed wraparound test (only zp should wrap) 17dc : a2fd ldx #3+$fa 17de : b519 tldax6 lda zp1-$fa&$ff,x ;wrap on indexed zp 17e0 : 9d0901 sta abst-$fa,x ;no STX abs,x! 17e3 : ca dex 17e4 : e0fa cpx #$fa 17e6 : b0f6 bcs tldax6 17e8 : a2fd ldx #3+$fa 17ea : bd1d01 tldax7 lda abs1-$fa,x ;no wrap on indexed abs 17ed : 9512 sta zpt-$fa&$ff,x 17ef : ca dex 17f0 : e0fa cpx #$fa 17f2 : b0f6 bcs tldax7 17f4 : a203 ldx #3 ;testing wraparound result 17f6 : a000 ldy #0 17f8 : b50c tstax1 lda zpt,x 17fa : d513 cmp zp1,x trap_ne ;store to zp,x data 17fc : d0fe > bne * ;failed not equal (non zero) 17fe : 940c sty zpt,x ;clear 1800 : bd0302 lda abst,x 1803 : dd1702 cmp abs1,x trap_ne ;store to abs,x data 1806 : d0fe > bne * ;failed not equal (non zero) 1808 : 8a txa 1809 : 9d0302 sta abst,x ;clear 180c : ca dex 180d : 10e9 bpl tstax1 180f : a0fb ldy #3+$f8 1811 : a2fe ldx #6+$f8 1813 : a12c tlday4 lda (ind1-$f8&$ff,x) ;wrap on indexed zp indir 1815 : 990b01 sta abst-$f8,y 1818 : ca dex 1819 : ca dex 181a : 88 dey 181b : c0f8 cpy #$f8 181d : b0f4 bcs tlday4 181f : a003 ldy #3 ;testing wraparound result 1821 : a200 ldx #0 1823 : b90302 tstay4 lda abst,y 1826 : d91702 cmp abs1,y trap_ne ;store to abs data 1829 : d0fe > bne * ;failed not equal (non zero) 182b : 8a txa 182c : 990302 sta abst,y ;clear 182f : 88 dey 1830 : 10f1 bpl tstay4 1832 : a0fb ldy #3+$f8 1834 : b91f01 tlday5 lda abs1-$f8,y ;no wrap on indexed abs 1837 : 9138 sta (inwt),y 1839 : 88 dey 183a : c0f8 cpy #$f8 183c : b0f6 bcs tlday5 183e : a003 ldy #3 ;testing wraparound result 1840 : a200 ldx #0 1842 : b90302 tstay5 lda abst,y 1845 : d91702 cmp abs1,y trap_ne ;store to abs data 1848 : d0fe > bne * ;failed not equal (non zero) 184a : 8a txa 184b : 990302 sta abst,y ;clear 184e : 88 dey 184f : 10f1 bpl tstay5 1851 : a0fb ldy #3+$f8 1853 : a2fe ldx #6+$f8 1855 : b12e tlday6 lda (inw1),y ;no wrap on zp indirect indexe 1857 : 8138 sta (indt-$f8&$ff,x) 1859 : ca dex 185a : ca dex 185b : 88 dey 185c : c0f8 cpy #$f8 185e : b0f5 bcs tlday6 1860 : a003 ldy #3 ;testing wraparound result 1862 : a200 ldx #0 1864 : b90302 tstay6 lda abst,y 1867 : d91702 cmp abs1,y trap_ne ;store to abs data 186a : d0fe > bne * ;failed not equal (non zero) 186c : 8a txa 186d : 990302 sta abst,y ;clear 1870 : 88 dey 1871 : 10f1 bpl tstay6 next_test 1873 : ad0002 > lda test_case ;previous test 1876 : c917 > cmp #test_num > trap_ne ;test is out of sequence 1878 : d0fe > bne * ;failed not equal (non zero) > 0018 = >test_num = test_num + 1 187a : a918 > lda #test_num ;*** next tests' number 187c : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; LDA / STA - zp / abs / # set_stat 0 > load_flag 0 187f : a900 > lda #0 ;allow test to change > 1881 : 48 > pha ;use stack to load status 1882 : 28 > plp 1883 : a513 lda zp1 1885 : 08 php ;test stores do not alter flags 1886 : 49c3 eor #$c3 1888 : 28 plp 1889 : 8d0302 sta abst 188c : 08 php ;flags after load/store sequence 188d : 49c3 eor #$c3 188f : c9c3 cmp #$c3 ;test result trap_ne 1891 : d0fe > bne * ;failed not equal (non zero) 1893 : 68 pla ;load status eor_flag 0 1894 : 4930 > eor #0|fao ;invert expected flags 1896 : cd1c02 cmp fLDx ;test flags trap_ne 1899 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 189b : a900 > lda #0 ;allow test to change I > 189d : 48 > pha ;use stack to load status 189e : 28 > plp 189f : a514 lda zp1+1 18a1 : 08 php ;test stores do not alter flags 18a2 : 49c3 eor #$c3 18a4 : 28 plp 18a5 : 8d0402 sta abst+1 18a8 : 08 php ;flags after load/store sequence 18a9 : 49c3 eor #$c3 18ab : c982 cmp #$82 ;test result trap_ne 18ad : d0fe > bne * ;failed not equal (non zero) 18af : 68 pla ;load status eor_flag 0 18b0 : 4930 > eor #0|fao ;invert expected flags 18b2 : cd1d02 cmp fLDx+1 ;test flags trap_ne 18b5 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 18b7 : a900 > lda #0 ;allow test to change I > 18b9 : 48 > pha ;use stack to load status 18ba : 28 > plp 18bb : a515 lda zp1+2 18bd : 08 php ;test stores do not alter flags 18be : 49c3 eor #$c3 18c0 : 28 plp 18c1 : 8d0502 sta abst+2 18c4 : 08 php ;flags after load/store sequence 18c5 : 49c3 eor #$c3 18c7 : c941 cmp #$41 ;test result trap_ne 18c9 : d0fe > bne * ;failed not equal (non zero) 18cb : 68 pla ;load status eor_flag 0 18cc : 4930 > eor #0|fao ;invert expected flags 18ce : cd1e02 cmp fLDx+2 ;test flags trap_ne 18d1 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 18d3 : a900 > lda #0 ;allow test to change I > 18d5 : 48 > pha ;use stack to load status 18d6 : 28 > plp 18d7 : a516 lda zp1+3 18d9 : 08 php ;test stores do not alter flags 18da : 49c3 eor #$c3 18dc : 28 plp 18dd : 8d0602 sta abst+3 18e0 : 08 php ;flags after load/store sequence 18e1 : 49c3 eor #$c3 18e3 : c900 cmp #0 ;test result trap_ne 18e5 : d0fe > bne * ;failed not equal (non zero) 18e7 : 68 pla ;load status eor_flag 0 18e8 : 4930 > eor #0|fao ;invert expected flags 18ea : cd1f02 cmp fLDx+3 ;test flags trap_ne 18ed : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 18ef : a9ff > lda #$ff ;allow test to change > 18f1 : 48 > pha ;use stack to load status 18f2 : 28 > plp 18f3 : a513 lda zp1 18f5 : 08 php ;test stores do not alter flags 18f6 : 49c3 eor #$c3 18f8 : 28 plp 18f9 : 8d0302 sta abst 18fc : 08 php ;flags after load/store sequence 18fd : 49c3 eor #$c3 18ff : c9c3 cmp #$c3 ;test result trap_ne 1901 : d0fe > bne * ;failed not equal (non zero) 1903 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1904 : 497d > eor #lo~fnz |fao ;invert expected 1906 : cd1c02 cmp fLDx ;test flags trap_ne 1909 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 190b : a9ff > lda #$ff ;allow test to change > 190d : 48 > pha ;use stack to load status 190e : 28 > plp 190f : a514 lda zp1+1 1911 : 08 php ;test stores do not alter flags 1912 : 49c3 eor #$c3 1914 : 28 plp 1915 : 8d0402 sta abst+1 1918 : 08 php ;flags after load/store sequence 1919 : 49c3 eor #$c3 191b : c982 cmp #$82 ;test result trap_ne 191d : d0fe > bne * ;failed not equal (non zero) 191f : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1920 : 497d > eor #lo~fnz |fao ;invert expected 1922 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1925 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1927 : a9ff > lda #$ff ;allow test to change > 1929 : 48 > pha ;use stack to load status 192a : 28 > plp 192b : a515 lda zp1+2 192d : 08 php ;test stores do not alter flags 192e : 49c3 eor #$c3 1930 : 28 plp 1931 : 8d0502 sta abst+2 1934 : 08 php ;flags after load/store sequence 1935 : 49c3 eor #$c3 1937 : c941 cmp #$41 ;test result trap_ne 1939 : d0fe > bne * ;failed not equal (non zero) 193b : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 193c : 497d > eor #lo~fnz |fao ;invert expected 193e : cd1e02 cmp fLDx+2 ;test flags trap_ne 1941 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1943 : a9ff > lda #$ff ;allow test to change > 1945 : 48 > pha ;use stack to load status 1946 : 28 > plp 1947 : a516 lda zp1+3 1949 : 08 php ;test stores do not alter flags 194a : 49c3 eor #$c3 194c : 28 plp 194d : 8d0602 sta abst+3 1950 : 08 php ;flags after load/store sequence 1951 : 49c3 eor #$c3 1953 : c900 cmp #0 ;test result trap_ne 1955 : d0fe > bne * ;failed not equal (non zero) 1957 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1958 : 497d > eor #lo~fnz |fao ;invert expected 195a : cd1f02 cmp fLDx+3 ;test flags trap_ne 195d : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 195f : a900 > lda #0 ;allow test to change I > 1961 : 48 > pha ;use stack to load status 1962 : 28 > plp 1963 : ad1702 lda abs1 1966 : 08 php ;test stores do not alter flags 1967 : 49c3 eor #$c3 1969 : 28 plp 196a : 850c sta zpt 196c : 08 php ;flags after load/store sequence 196d : 49c3 eor #$c3 196f : c513 cmp zp1 ;test result trap_ne 1971 : d0fe > bne * ;failed not equal (non zero) 1973 : 68 pla ;load status eor_flag 0 1974 : 4930 > eor #0|fao ;invert expected flags 1976 : cd1c02 cmp fLDx ;test flags trap_ne 1979 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 197b : a900 > lda #0 ;allow test to change I > 197d : 48 > pha ;use stack to load status 197e : 28 > plp 197f : ad1802 lda abs1+1 1982 : 08 php ;test stores do not alter flags 1983 : 49c3 eor #$c3 1985 : 28 plp 1986 : 850d sta zpt+1 1988 : 08 php ;flags after load/store sequence 1989 : 49c3 eor #$c3 198b : c514 cmp zp1+1 ;test result trap_ne 198d : d0fe > bne * ;failed not equal (non zero) 198f : 68 pla ;load status eor_flag 0 1990 : 4930 > eor #0|fao ;invert expected flags 1992 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1995 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1997 : a900 > lda #0 ;allow test to change I > 1999 : 48 > pha ;use stack to load status 199a : 28 > plp 199b : ad1902 lda abs1+2 199e : 08 php ;test stores do not alter flags 199f : 49c3 eor #$c3 19a1 : 28 plp 19a2 : 850e sta zpt+2 19a4 : 08 php ;flags after load/store sequence 19a5 : 49c3 eor #$c3 19a7 : c515 cmp zp1+2 ;test result trap_ne 19a9 : d0fe > bne * ;failed not equal (non zero) 19ab : 68 pla ;load status eor_flag 0 19ac : 4930 > eor #0|fao ;invert expected flags 19ae : cd1e02 cmp fLDx+2 ;test flags trap_ne 19b1 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 19b3 : a900 > lda #0 ;allow test to change I > 19b5 : 48 > pha ;use stack to load status 19b6 : 28 > plp 19b7 : ad1a02 lda abs1+3 19ba : 08 php ;test stores do not alter flags 19bb : 49c3 eor #$c3 19bd : 28 plp 19be : 850f sta zpt+3 19c0 : 08 php ;flags after load/store sequence 19c1 : 49c3 eor #$c3 19c3 : c516 cmp zp1+3 ;test result trap_ne 19c5 : d0fe > bne * ;failed not equal (non zero) 19c7 : 68 pla ;load status eor_flag 0 19c8 : 4930 > eor #0|fao ;invert expected flags 19ca : cd1f02 cmp fLDx+3 ;test flags trap_ne 19cd : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 19cf : a9ff > lda #$ff ;allow test to change > 19d1 : 48 > pha ;use stack to load status 19d2 : 28 > plp 19d3 : ad1702 lda abs1 19d6 : 08 php ;test stores do not alter flags 19d7 : 49c3 eor #$c3 19d9 : 28 plp 19da : 850c sta zpt 19dc : 08 php ;flags after load/store sequence 19dd : 49c3 eor #$c3 19df : c513 cmp zp1 ;test result trap_ne 19e1 : d0fe > bne * ;failed not equal (non zero) 19e3 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 19e4 : 497d > eor #lo~fnz |fao ;invert expected 19e6 : cd1c02 cmp fLDx ;test flags trap_ne 19e9 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 19eb : a9ff > lda #$ff ;allow test to change > 19ed : 48 > pha ;use stack to load status 19ee : 28 > plp 19ef : ad1802 lda abs1+1 19f2 : 08 php ;test stores do not alter flags 19f3 : 49c3 eor #$c3 19f5 : 28 plp 19f6 : 850d sta zpt+1 19f8 : 08 php ;flags after load/store sequence 19f9 : 49c3 eor #$c3 19fb : c514 cmp zp1+1 ;test result trap_ne 19fd : d0fe > bne * ;failed not equal (non zero) 19ff : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1a00 : 497d > eor #lo~fnz |fao ;invert expected 1a02 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1a05 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1a07 : a9ff > lda #$ff ;allow test to change > 1a09 : 48 > pha ;use stack to load status 1a0a : 28 > plp 1a0b : ad1902 lda abs1+2 1a0e : 08 php ;test stores do not alter flags 1a0f : 49c3 eor #$c3 1a11 : 28 plp 1a12 : 850e sta zpt+2 1a14 : 08 php ;flags after load/store sequence 1a15 : 49c3 eor #$c3 1a17 : c515 cmp zp1+2 ;test result trap_ne 1a19 : d0fe > bne * ;failed not equal (non zero) 1a1b : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1a1c : 497d > eor #lo~fnz |fao ;invert expected 1a1e : cd1e02 cmp fLDx+2 ;test flags trap_ne 1a21 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1a23 : a9ff > lda #$ff ;allow test to change > 1a25 : 48 > pha ;use stack to load status 1a26 : 28 > plp 1a27 : ad1a02 lda abs1+3 1a2a : 08 php ;test stores do not alter flags 1a2b : 49c3 eor #$c3 1a2d : 28 plp 1a2e : 850f sta zpt+3 1a30 : 08 php ;flags after load/store sequence 1a31 : 49c3 eor #$c3 1a33 : c516 cmp zp1+3 ;test result trap_ne 1a35 : d0fe > bne * ;failed not equal (non zero) 1a37 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1a38 : 497d > eor #lo~fnz |fao ;invert expected 1a3a : cd1f02 cmp fLDx+3 ;test flags trap_ne 1a3d : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1a3f : a900 > lda #0 ;allow test to change > 1a41 : 48 > pha ;use stack to load status 1a42 : 28 > plp 1a43 : a9c3 lda #$c3 1a45 : 08 php 1a46 : cd1702 cmp abs1 ;test result trap_ne 1a49 : d0fe > bne * ;failed not equal (non zero) 1a4b : 68 pla ;load status eor_flag 0 1a4c : 4930 > eor #0|fao ;invert expected flags 1a4e : cd1c02 cmp fLDx ;test flags trap_ne 1a51 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1a53 : a900 > lda #0 ;allow test to change I > 1a55 : 48 > pha ;use stack to load status 1a56 : 28 > plp 1a57 : a982 lda #$82 1a59 : 08 php 1a5a : cd1802 cmp abs1+1 ;test result trap_ne 1a5d : d0fe > bne * ;failed not equal (non zero) 1a5f : 68 pla ;load status eor_flag 0 1a60 : 4930 > eor #0|fao ;invert expected flags 1a62 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1a65 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1a67 : a900 > lda #0 ;allow test to change I > 1a69 : 48 > pha ;use stack to load status 1a6a : 28 > plp 1a6b : a941 lda #$41 1a6d : 08 php 1a6e : cd1902 cmp abs1+2 ;test result trap_ne 1a71 : d0fe > bne * ;failed not equal (non zero) 1a73 : 68 pla ;load status eor_flag 0 1a74 : 4930 > eor #0|fao ;invert expected flags 1a76 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1a79 : d0fe > bne * ;failed not equal (non zero) set_stat 0 > load_flag 0 1a7b : a900 > lda #0 ;allow test to change I > 1a7d : 48 > pha ;use stack to load status 1a7e : 28 > plp 1a7f : a900 lda #0 1a81 : 08 php 1a82 : cd1a02 cmp abs1+3 ;test result trap_ne 1a85 : d0fe > bne * ;failed not equal (non zero) 1a87 : 68 pla ;load status eor_flag 0 1a88 : 4930 > eor #0|fao ;invert expected flags 1a8a : cd1f02 cmp fLDx+3 ;test flags trap_ne 1a8d : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1a8f : a9ff > lda #$ff ;allow test to change > 1a91 : 48 > pha ;use stack to load status 1a92 : 28 > plp 1a93 : a9c3 lda #$c3 1a95 : 08 php 1a96 : cd1702 cmp abs1 ;test result trap_ne 1a99 : d0fe > bne * ;failed not equal (non zero) 1a9b : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1a9c : 497d > eor #lo~fnz |fao ;invert expected 1a9e : cd1c02 cmp fLDx ;test flags trap_ne 1aa1 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1aa3 : a9ff > lda #$ff ;allow test to change > 1aa5 : 48 > pha ;use stack to load status 1aa6 : 28 > plp 1aa7 : a982 lda #$82 1aa9 : 08 php 1aaa : cd1802 cmp abs1+1 ;test result trap_ne 1aad : d0fe > bne * ;failed not equal (non zero) 1aaf : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1ab0 : 497d > eor #lo~fnz |fao ;invert expected 1ab2 : cd1d02 cmp fLDx+1 ;test flags trap_ne 1ab5 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1ab7 : a9ff > lda #$ff ;allow test to change > 1ab9 : 48 > pha ;use stack to load status 1aba : 28 > plp 1abb : a941 lda #$41 1abd : 08 php 1abe : cd1902 cmp abs1+2 ;test result trap_ne 1ac1 : d0fe > bne * ;failed not equal (non zero) 1ac3 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1ac4 : 497d > eor #lo~fnz |fao ;invert expected 1ac6 : cd1e02 cmp fLDx+2 ;test flags trap_ne 1ac9 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 1acb : a9ff > lda #$ff ;allow test to change > 1acd : 48 > pha ;use stack to load status 1ace : 28 > plp 1acf : a900 lda #0 1ad1 : 08 php 1ad2 : cd1a02 cmp abs1+3 ;test result trap_ne 1ad5 : d0fe > bne * ;failed not equal (non zero) 1ad7 : 68 pla ;load status eor_flag lo~fnz ;mask bits not altered 1ad8 : 497d > eor #lo~fnz |fao ;invert expected 1ada : cd1f02 cmp fLDx+3 ;test flags trap_ne 1add : d0fe > bne * ;failed not equal (non zero) 1adf : a200 ldx #0 1ae1 : a50c lda zpt 1ae3 : 49c3 eor #$c3 1ae5 : c513 cmp zp1 trap_ne ;store to zp data 1ae7 : d0fe > bne * ;failed not equal (non zero) 1ae9 : 860c stx zpt ;clear 1aeb : ad0302 lda abst 1aee : 49c3 eor #$c3 1af0 : cd1702 cmp abs1 trap_ne ;store to abs data 1af3 : d0fe > bne * ;failed not equal (non zero) 1af5 : 8e0302 stx abst ;clear 1af8 : a50d lda zpt+1 1afa : 49c3 eor #$c3 1afc : c514 cmp zp1+1 trap_ne ;store to zp data 1afe : d0fe > bne * ;failed not equal (non zero) 1b00 : 860d stx zpt+1 ;clear 1b02 : ad0402 lda abst+1 1b05 : 49c3 eor #$c3 1b07 : cd1802 cmp abs1+1 trap_ne ;store to abs data 1b0a : d0fe > bne * ;failed not equal (non zero) 1b0c : 8e0402 stx abst+1 ;clear 1b0f : a50e lda zpt+2 1b11 : 49c3 eor #$c3 1b13 : c515 cmp zp1+2 trap_ne ;store to zp data 1b15 : d0fe > bne * ;failed not equal (non zero) 1b17 : 860e stx zpt+2 ;clear 1b19 : ad0502 lda abst+2 1b1c : 49c3 eor #$c3 1b1e : cd1902 cmp abs1+2 trap_ne ;store to abs data 1b21 : d0fe > bne * ;failed not equal (non zero) 1b23 : 8e0502 stx abst+2 ;clear 1b26 : a50f lda zpt+3 1b28 : 49c3 eor #$c3 1b2a : c516 cmp zp1+3 trap_ne ;store to zp data 1b2c : d0fe > bne * ;failed not equal (non zero) 1b2e : 860f stx zpt+3 ;clear 1b30 : ad0602 lda abst+3 1b33 : 49c3 eor #$c3 1b35 : cd1a02 cmp abs1+3 trap_ne ;store to abs data 1b38 : d0fe > bne * ;failed not equal (non zero) 1b3a : 8e0602 stx abst+3 ;clear next_test 1b3d : ad0002 > lda test_case ;previous test 1b40 : c918 > cmp #test_num > trap_ne ;test is out of sequence 1b42 : d0fe > bne * ;failed not equal (non zero) > 0019 = >test_num = test_num + 1 1b44 : a919 > lda #test_num ;*** next tests' number 1b46 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; testing bit test & compares BIT CPX CPY CMP all addr ; BIT - zp / abs set_a $ff,0 > load_flag 0 1b49 : a900 > lda #0 ;allow test to change I > 1b4b : 48 > pha ;use stack to load status 1b4c : a9ff > lda #$ff ;precharge accu 1b4e : 28 > plp 1b4f : 2416 bit zp1+3 ;00 - should set Z / clear NV tst_a $ff,fz 1b51 : 08 > php ;save flags 1b52 : c9ff > cmp #$ff ;test result > trap_ne 1b54 : d0fe > bne * ;failed not equal (non zero) > 1b56 : 68 > pla ;load status 1b57 : 48 > pha > cmp_flag fz 1b58 : c932 > cmp #(fz |fao)&m8 ;expected flags + alw > > trap_ne 1b5a : d0fe > bne * ;failed not equal (non zero) > 1b5c : 28 > plp ;restore status set_a 1,0 > load_flag 0 1b5d : a900 > lda #0 ;allow test to change I > 1b5f : 48 > pha ;use stack to load status 1b60 : a901 > lda #1 ;precharge accu 1b62 : 28 > plp 1b63 : 2415 bit zp1+2 ;41 - should set V (M6) / clear NZ tst_a 1,fv 1b65 : 08 > php ;save flags 1b66 : c901 > cmp #1 ;test result > trap_ne 1b68 : d0fe > bne * ;failed not equal (non zero) > 1b6a : 68 > pla ;load status 1b6b : 48 > pha > cmp_flag fv 1b6c : c970 > cmp #(fv|fao)&m8 ;expected flags + alwa > > trap_ne 1b6e : d0fe > bne * ;failed not equal (non zero) > 1b70 : 28 > plp ;restore status set_a 1,0 > load_flag 0 1b71 : a900 > lda #0 ;allow test to change I > 1b73 : 48 > pha ;use stack to load status 1b74 : a901 > lda #1 ;precharge accu 1b76 : 28 > plp 1b77 : 2414 bit zp1+1 ;82 - should set N (M7) & Z / clea tst_a 1,fnz 1b79 : 08 > php ;save flags 1b7a : c901 > cmp #1 ;test result > trap_ne 1b7c : d0fe > bne * ;failed not equal (non zero) > 1b7e : 68 > pla ;load status 1b7f : 48 > pha > cmp_flag fnz 1b80 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + alw > > trap_ne 1b82 : d0fe > bne * ;failed not equal (non zero) > 1b84 : 28 > plp ;restore status set_a 1,0 > load_flag 0 1b85 : a900 > lda #0 ;allow test to change I > 1b87 : 48 > pha ;use stack to load status 1b88 : a901 > lda #1 ;precharge accu 1b8a : 28 > plp 1b8b : 2413 bit zp1 ;c3 - should set N (M7) & V (M6) / tst_a 1,fnv 1b8d : 08 > php ;save flags 1b8e : c901 > cmp #1 ;test result > trap_ne 1b90 : d0fe > bne * ;failed not equal (non zero) > 1b92 : 68 > pla ;load status 1b93 : 48 > pha > cmp_flag fnv 1b94 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + alw > > trap_ne 1b96 : d0fe > bne * ;failed not equal (non zero) > 1b98 : 28 > plp ;restore status set_a $ff,$ff > load_flag $ff 1b99 : a9ff > lda #$ff ;allow test to change > 1b9b : 48 > pha ;use stack to load status 1b9c : a9ff > lda #$ff ;precharge accu 1b9e : 28 > plp 1b9f : 2416 bit zp1+3 ;00 - should set Z / clear NV tst_a $ff,~fnv 1ba1 : 08 > php ;save flags 1ba2 : c9ff > cmp #$ff ;test result > trap_ne 1ba4 : d0fe > bne * ;failed not equal (non zero) > 1ba6 : 68 > pla ;load status 1ba7 : 48 > pha > cmp_flag ~fnv 1ba8 : c93f > cmp #(~fnv |fao)&m8 ;expected flags + a > > trap_ne 1baa : d0fe > bne * ;failed not equal (non zero) > 1bac : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1bad : a9ff > lda #$ff ;allow test to change > 1baf : 48 > pha ;use stack to load status 1bb0 : a901 > lda #1 ;precharge accu 1bb2 : 28 > plp 1bb3 : 2415 bit zp1+2 ;41 - should set V (M6) / clear NZ tst_a 1,~fnz 1bb5 : 08 > php ;save flags 1bb6 : c901 > cmp #1 ;test result > trap_ne 1bb8 : d0fe > bne * ;failed not equal (non zero) > 1bba : 68 > pla ;load status 1bbb : 48 > pha > cmp_flag ~fnz 1bbc : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 1bbe : d0fe > bne * ;failed not equal (non zero) > 1bc0 : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1bc1 : a9ff > lda #$ff ;allow test to change > 1bc3 : 48 > pha ;use stack to load status 1bc4 : a901 > lda #1 ;precharge accu 1bc6 : 28 > plp 1bc7 : 2414 bit zp1+1 ;82 - should set N (M7) & Z / clea tst_a 1,~fv 1bc9 : 08 > php ;save flags 1bca : c901 > cmp #1 ;test result > trap_ne 1bcc : d0fe > bne * ;failed not equal (non zero) > 1bce : 68 > pla ;load status 1bcf : 48 > pha > cmp_flag ~fv 1bd0 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + alw > > trap_ne 1bd2 : d0fe > bne * ;failed not equal (non zero) > 1bd4 : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1bd5 : a9ff > lda #$ff ;allow test to change > 1bd7 : 48 > pha ;use stack to load status 1bd8 : a901 > lda #1 ;precharge accu 1bda : 28 > plp 1bdb : 2413 bit zp1 ;c3 - should set N (M7) & V (M6) / tst_a 1,~fz 1bdd : 08 > php ;save flags 1bde : c901 > cmp #1 ;test result > trap_ne 1be0 : d0fe > bne * ;failed not equal (non zero) > 1be2 : 68 > pla ;load status 1be3 : 48 > pha > cmp_flag ~fz 1be4 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + alw > > trap_ne 1be6 : d0fe > bne * ;failed not equal (non zero) > 1be8 : 28 > plp ;restore status set_a $ff,0 > load_flag 0 1be9 : a900 > lda #0 ;allow test to change I > 1beb : 48 > pha ;use stack to load status 1bec : a9ff > lda #$ff ;precharge accu 1bee : 28 > plp 1bef : 2c1a02 bit abs1+3 ;00 - should set Z / clear NV tst_a $ff,fz 1bf2 : 08 > php ;save flags 1bf3 : c9ff > cmp #$ff ;test result > trap_ne 1bf5 : d0fe > bne * ;failed not equal (non zero) > 1bf7 : 68 > pla ;load status 1bf8 : 48 > pha > cmp_flag fz 1bf9 : c932 > cmp #(fz |fao)&m8 ;expected flags + alw > > trap_ne 1bfb : d0fe > bne * ;failed not equal (non zero) > 1bfd : 28 > plp ;restore status set_a 1,0 > load_flag 0 1bfe : a900 > lda #0 ;allow test to change I > 1c00 : 48 > pha ;use stack to load status 1c01 : a901 > lda #1 ;precharge accu 1c03 : 28 > plp 1c04 : 2c1902 bit abs1+2 ;41 - should set V (M6) / clear NZ tst_a 1,fv 1c07 : 08 > php ;save flags 1c08 : c901 > cmp #1 ;test result > trap_ne 1c0a : d0fe > bne * ;failed not equal (non zero) > 1c0c : 68 > pla ;load status 1c0d : 48 > pha > cmp_flag fv 1c0e : c970 > cmp #(fv|fao)&m8 ;expected flags + alwa > > trap_ne 1c10 : d0fe > bne * ;failed not equal (non zero) > 1c12 : 28 > plp ;restore status set_a 1,0 > load_flag 0 1c13 : a900 > lda #0 ;allow test to change I > 1c15 : 48 > pha ;use stack to load status 1c16 : a901 > lda #1 ;precharge accu 1c18 : 28 > plp 1c19 : 2c1802 bit abs1+1 ;82 - should set N (M7) & Z / clea tst_a 1,fnz 1c1c : 08 > php ;save flags 1c1d : c901 > cmp #1 ;test result > trap_ne 1c1f : d0fe > bne * ;failed not equal (non zero) > 1c21 : 68 > pla ;load status 1c22 : 48 > pha > cmp_flag fnz 1c23 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + alw > > trap_ne 1c25 : d0fe > bne * ;failed not equal (non zero) > 1c27 : 28 > plp ;restore status set_a 1,0 > load_flag 0 1c28 : a900 > lda #0 ;allow test to change I > 1c2a : 48 > pha ;use stack to load status 1c2b : a901 > lda #1 ;precharge accu 1c2d : 28 > plp 1c2e : 2c1702 bit abs1 ;c3 - should set N (M7) & V (M6) / tst_a 1,fnv 1c31 : 08 > php ;save flags 1c32 : c901 > cmp #1 ;test result > trap_ne 1c34 : d0fe > bne * ;failed not equal (non zero) > 1c36 : 68 > pla ;load status 1c37 : 48 > pha > cmp_flag fnv 1c38 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + alw > > trap_ne 1c3a : d0fe > bne * ;failed not equal (non zero) > 1c3c : 28 > plp ;restore status set_a $ff,$ff > load_flag $ff 1c3d : a9ff > lda #$ff ;allow test to change > 1c3f : 48 > pha ;use stack to load status 1c40 : a9ff > lda #$ff ;precharge accu 1c42 : 28 > plp 1c43 : 2c1a02 bit abs1+3 ;00 - should set Z / clear NV tst_a $ff,~fnv 1c46 : 08 > php ;save flags 1c47 : c9ff > cmp #$ff ;test result > trap_ne 1c49 : d0fe > bne * ;failed not equal (non zero) > 1c4b : 68 > pla ;load status 1c4c : 48 > pha > cmp_flag ~fnv 1c4d : c93f > cmp #(~fnv |fao)&m8 ;expected flags + a > > trap_ne 1c4f : d0fe > bne * ;failed not equal (non zero) > 1c51 : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1c52 : a9ff > lda #$ff ;allow test to change > 1c54 : 48 > pha ;use stack to load status 1c55 : a901 > lda #1 ;precharge accu 1c57 : 28 > plp 1c58 : 2c1902 bit abs1+2 ;41 - should set V (M6) / clear NZ tst_a 1,~fnz 1c5b : 08 > php ;save flags 1c5c : c901 > cmp #1 ;test result > trap_ne 1c5e : d0fe > bne * ;failed not equal (non zero) > 1c60 : 68 > pla ;load status 1c61 : 48 > pha > cmp_flag ~fnz 1c62 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 1c64 : d0fe > bne * ;failed not equal (non zero) > 1c66 : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1c67 : a9ff > lda #$ff ;allow test to change > 1c69 : 48 > pha ;use stack to load status 1c6a : a901 > lda #1 ;precharge accu 1c6c : 28 > plp 1c6d : 2c1802 bit abs1+1 ;82 - should set N (M7) & Z / clea tst_a 1,~fv 1c70 : 08 > php ;save flags 1c71 : c901 > cmp #1 ;test result > trap_ne 1c73 : d0fe > bne * ;failed not equal (non zero) > 1c75 : 68 > pla ;load status 1c76 : 48 > pha > cmp_flag ~fv 1c77 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + alw > > trap_ne 1c79 : d0fe > bne * ;failed not equal (non zero) > 1c7b : 28 > plp ;restore status set_a 1,$ff > load_flag $ff 1c7c : a9ff > lda #$ff ;allow test to change > 1c7e : 48 > pha ;use stack to load status 1c7f : a901 > lda #1 ;precharge accu 1c81 : 28 > plp 1c82 : 2c1702 bit abs1 ;c3 - should set N (M7) & V (M6) / tst_a 1,~fz 1c85 : 08 > php ;save flags 1c86 : c901 > cmp #1 ;test result > trap_ne 1c88 : d0fe > bne * ;failed not equal (non zero) > 1c8a : 68 > pla ;load status 1c8b : 48 > pha > cmp_flag ~fz 1c8c : c9fd > cmp #(~fz|fao)&m8 ;expected flags + alw > > trap_ne 1c8e : d0fe > bne * ;failed not equal (non zero) > 1c90 : 28 > plp ;restore status next_test 1c91 : ad0002 > lda test_case ;previous test 1c94 : c919 > cmp #test_num > trap_ne ;test is out of sequence 1c96 : d0fe > bne * ;failed not equal (non zero) > 001a = >test_num = test_num + 1 1c98 : a91a > lda #test_num ;*** next tests' number 1c9a : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; CPX - zp / abs / # set_x $80,0 > load_flag 0 1c9d : a900 > lda #0 ;allow test to change I > 1c9f : 48 > pha ;use stack to load status 1ca0 : a280 > ldx #$80 ;precharge index x 1ca2 : 28 > plp 1ca3 : e417 cpx zp7f tst_stat fc 1ca5 : 08 > php ;save status 1ca6 : 68 > pla ;use stack to retrieve status 1ca7 : 48 > pha > cmp_flag fc 1ca8 : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 1caa : d0fe > bne * ;failed not equal (non zero) > 1cac : 28 > plp ;restore status 1cad : ca dex 1cae : e417 cpx zp7f tst_stat fzc 1cb0 : 08 > php ;save status 1cb1 : 68 > pla ;use stack to retrieve status 1cb2 : 48 > pha > cmp_flag fzc 1cb3 : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 1cb5 : d0fe > bne * ;failed not equal (non zero) > 1cb7 : 28 > plp ;restore status 1cb8 : ca dex 1cb9 : e417 cpx zp7f tst_x $7e,fn 1cbb : 08 > php ;save flags 1cbc : e07e > cpx #$7e ;test result > trap_ne 1cbe : d0fe > bne * ;failed not equal (non zero) > 1cc0 : 68 > pla ;load status 1cc1 : 48 > pha > cmp_flag fn 1cc2 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 1cc4 : d0fe > bne * ;failed not equal (non zero) > 1cc6 : 28 > plp ;restore status set_x $80,$ff > load_flag $ff 1cc7 : a9ff > lda #$ff ;allow test to change > 1cc9 : 48 > pha ;use stack to load status 1cca : a280 > ldx #$80 ;precharge index x 1ccc : 28 > plp 1ccd : e417 cpx zp7f tst_stat ~fnz 1ccf : 08 > php ;save status 1cd0 : 68 > pla ;use stack to retrieve status 1cd1 : 48 > pha > cmp_flag ~fnz 1cd2 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 1cd4 : d0fe > bne * ;failed not equal (non zero) > 1cd6 : 28 > plp ;restore status 1cd7 : ca dex 1cd8 : e417 cpx zp7f tst_stat ~fn 1cda : 08 > php ;save status 1cdb : 68 > pla ;use stack to retrieve status 1cdc : 48 > pha > cmp_flag ~fn 1cdd : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 1cdf : d0fe > bne * ;failed not equal (non zero) > 1ce1 : 28 > plp ;restore status 1ce2 : ca dex 1ce3 : e417 cpx zp7f tst_x $7e,~fzc 1ce5 : 08 > php ;save flags 1ce6 : e07e > cpx #$7e ;test result > trap_ne 1ce8 : d0fe > bne * ;failed not equal (non zero) > 1cea : 68 > pla ;load status 1ceb : 48 > pha > cmp_flag ~fzc 1cec : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 1cee : d0fe > bne * ;failed not equal (non zero) > 1cf0 : 28 > plp ;restore status set_x $80,0 > load_flag 0 1cf1 : a900 > lda #0 ;allow test to change I > 1cf3 : 48 > pha ;use stack to load status 1cf4 : a280 > ldx #$80 ;precharge index x 1cf6 : 28 > plp 1cf7 : ec1b02 cpx abs7f tst_stat fc 1cfa : 08 > php ;save status 1cfb : 68 > pla ;use stack to retrieve status 1cfc : 48 > pha > cmp_flag fc 1cfd : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 1cff : d0fe > bne * ;failed not equal (non zero) > 1d01 : 28 > plp ;restore status 1d02 : ca dex 1d03 : ec1b02 cpx abs7f tst_stat fzc 1d06 : 08 > php ;save status 1d07 : 68 > pla ;use stack to retrieve status 1d08 : 48 > pha > cmp_flag fzc 1d09 : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 1d0b : d0fe > bne * ;failed not equal (non zero) > 1d0d : 28 > plp ;restore status 1d0e : ca dex 1d0f : ec1b02 cpx abs7f tst_x $7e,fn 1d12 : 08 > php ;save flags 1d13 : e07e > cpx #$7e ;test result > trap_ne 1d15 : d0fe > bne * ;failed not equal (non zero) > 1d17 : 68 > pla ;load status 1d18 : 48 > pha > cmp_flag fn 1d19 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 1d1b : d0fe > bne * ;failed not equal (non zero) > 1d1d : 28 > plp ;restore status set_x $80,$ff > load_flag $ff 1d1e : a9ff > lda #$ff ;allow test to change > 1d20 : 48 > pha ;use stack to load status 1d21 : a280 > ldx #$80 ;precharge index x 1d23 : 28 > plp 1d24 : ec1b02 cpx abs7f tst_stat ~fnz 1d27 : 08 > php ;save status 1d28 : 68 > pla ;use stack to retrieve status 1d29 : 48 > pha > cmp_flag ~fnz 1d2a : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 1d2c : d0fe > bne * ;failed not equal (non zero) > 1d2e : 28 > plp ;restore status 1d2f : ca dex 1d30 : ec1b02 cpx abs7f tst_stat ~fn 1d33 : 08 > php ;save status 1d34 : 68 > pla ;use stack to retrieve status 1d35 : 48 > pha > cmp_flag ~fn 1d36 : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 1d38 : d0fe > bne * ;failed not equal (non zero) > 1d3a : 28 > plp ;restore status 1d3b : ca dex 1d3c : ec1b02 cpx abs7f tst_x $7e,~fzc 1d3f : 08 > php ;save flags 1d40 : e07e > cpx #$7e ;test result > trap_ne 1d42 : d0fe > bne * ;failed not equal (non zero) > 1d44 : 68 > pla ;load status 1d45 : 48 > pha > cmp_flag ~fzc 1d46 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 1d48 : d0fe > bne * ;failed not equal (non zero) > 1d4a : 28 > plp ;restore status set_x $80,0 > load_flag 0 1d4b : a900 > lda #0 ;allow test to change I > 1d4d : 48 > pha ;use stack to load status 1d4e : a280 > ldx #$80 ;precharge index x 1d50 : 28 > plp 1d51 : e07f cpx #$7f tst_stat fc 1d53 : 08 > php ;save status 1d54 : 68 > pla ;use stack to retrieve status 1d55 : 48 > pha > cmp_flag fc 1d56 : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 1d58 : d0fe > bne * ;failed not equal (non zero) > 1d5a : 28 > plp ;restore status 1d5b : ca dex 1d5c : e07f cpx #$7f tst_stat fzc 1d5e : 08 > php ;save status 1d5f : 68 > pla ;use stack to retrieve status 1d60 : 48 > pha > cmp_flag fzc 1d61 : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 1d63 : d0fe > bne * ;failed not equal (non zero) > 1d65 : 28 > plp ;restore status 1d66 : ca dex 1d67 : e07f cpx #$7f tst_x $7e,fn 1d69 : 08 > php ;save flags 1d6a : e07e > cpx #$7e ;test result > trap_ne 1d6c : d0fe > bne * ;failed not equal (non zero) > 1d6e : 68 > pla ;load status 1d6f : 48 > pha > cmp_flag fn 1d70 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 1d72 : d0fe > bne * ;failed not equal (non zero) > 1d74 : 28 > plp ;restore status set_x $80,$ff > load_flag $ff 1d75 : a9ff > lda #$ff ;allow test to change > 1d77 : 48 > pha ;use stack to load status 1d78 : a280 > ldx #$80 ;precharge index x 1d7a : 28 > plp 1d7b : e07f cpx #$7f tst_stat ~fnz 1d7d : 08 > php ;save status 1d7e : 68 > pla ;use stack to retrieve status 1d7f : 48 > pha > cmp_flag ~fnz 1d80 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 1d82 : d0fe > bne * ;failed not equal (non zero) > 1d84 : 28 > plp ;restore status 1d85 : ca dex 1d86 : e07f cpx #$7f tst_stat ~fn 1d88 : 08 > php ;save status 1d89 : 68 > pla ;use stack to retrieve status 1d8a : 48 > pha > cmp_flag ~fn 1d8b : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 1d8d : d0fe > bne * ;failed not equal (non zero) > 1d8f : 28 > plp ;restore status 1d90 : ca dex 1d91 : e07f cpx #$7f tst_x $7e,~fzc 1d93 : 08 > php ;save flags 1d94 : e07e > cpx #$7e ;test result > trap_ne 1d96 : d0fe > bne * ;failed not equal (non zero) > 1d98 : 68 > pla ;load status 1d99 : 48 > pha > cmp_flag ~fzc 1d9a : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 1d9c : d0fe > bne * ;failed not equal (non zero) > 1d9e : 28 > plp ;restore status next_test 1d9f : ad0002 > lda test_case ;previous test 1da2 : c91a > cmp #test_num > trap_ne ;test is out of sequence 1da4 : d0fe > bne * ;failed not equal (non zero) > 001b = >test_num = test_num + 1 1da6 : a91b > lda #test_num ;*** next tests' number 1da8 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; CPY - zp / abs / # set_y $80,0 > load_flag 0 1dab : a900 > lda #0 ;allow test to change I > 1dad : 48 > pha ;use stack to load status 1dae : a080 > ldy #$80 ;precharge index y 1db0 : 28 > plp 1db1 : c417 cpy zp7f tst_stat fc 1db3 : 08 > php ;save status 1db4 : 68 > pla ;use stack to retrieve status 1db5 : 48 > pha > cmp_flag fc 1db6 : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 1db8 : d0fe > bne * ;failed not equal (non zero) > 1dba : 28 > plp ;restore status 1dbb : 88 dey 1dbc : c417 cpy zp7f tst_stat fzc 1dbe : 08 > php ;save status 1dbf : 68 > pla ;use stack to retrieve status 1dc0 : 48 > pha > cmp_flag fzc 1dc1 : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 1dc3 : d0fe > bne * ;failed not equal (non zero) > 1dc5 : 28 > plp ;restore status 1dc6 : 88 dey 1dc7 : c417 cpy zp7f tst_y $7e,fn 1dc9 : 08 > php ;save flags 1dca : c07e > cpy #$7e ;test result > trap_ne 1dcc : d0fe > bne * ;failed not equal (non zero) > 1dce : 68 > pla ;load status 1dcf : 48 > pha > cmp_flag fn 1dd0 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 1dd2 : d0fe > bne * ;failed not equal (non zero) > 1dd4 : 28 > plp ;restore status set_y $80,$ff > load_flag $ff 1dd5 : a9ff > lda #$ff ;allow test to change > 1dd7 : 48 > pha ;use stack to load status 1dd8 : a080 > ldy #$80 ;precharge index y 1dda : 28 > plp 1ddb : c417 cpy zp7f tst_stat ~fnz 1ddd : 08 > php ;save status 1dde : 68 > pla ;use stack to retrieve status 1ddf : 48 > pha > cmp_flag ~fnz 1de0 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 1de2 : d0fe > bne * ;failed not equal (non zero) > 1de4 : 28 > plp ;restore status 1de5 : 88 dey 1de6 : c417 cpy zp7f tst_stat ~fn 1de8 : 08 > php ;save status 1de9 : 68 > pla ;use stack to retrieve status 1dea : 48 > pha > cmp_flag ~fn 1deb : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 1ded : d0fe > bne * ;failed not equal (non zero) > 1def : 28 > plp ;restore status 1df0 : 88 dey 1df1 : c417 cpy zp7f tst_y $7e,~fzc 1df3 : 08 > php ;save flags 1df4 : c07e > cpy #$7e ;test result > trap_ne 1df6 : d0fe > bne * ;failed not equal (non zero) > 1df8 : 68 > pla ;load status 1df9 : 48 > pha > cmp_flag ~fzc 1dfa : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 1dfc : d0fe > bne * ;failed not equal (non zero) > 1dfe : 28 > plp ;restore status set_y $80,0 > load_flag 0 1dff : a900 > lda #0 ;allow test to change I > 1e01 : 48 > pha ;use stack to load status 1e02 : a080 > ldy #$80 ;precharge index y 1e04 : 28 > plp 1e05 : cc1b02 cpy abs7f tst_stat fc 1e08 : 08 > php ;save status 1e09 : 68 > pla ;use stack to retrieve status 1e0a : 48 > pha > cmp_flag fc 1e0b : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 1e0d : d0fe > bne * ;failed not equal (non zero) > 1e0f : 28 > plp ;restore status 1e10 : 88 dey 1e11 : cc1b02 cpy abs7f tst_stat fzc 1e14 : 08 > php ;save status 1e15 : 68 > pla ;use stack to retrieve status 1e16 : 48 > pha > cmp_flag fzc 1e17 : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 1e19 : d0fe > bne * ;failed not equal (non zero) > 1e1b : 28 > plp ;restore status 1e1c : 88 dey 1e1d : cc1b02 cpy abs7f tst_y $7e,fn 1e20 : 08 > php ;save flags 1e21 : c07e > cpy #$7e ;test result > trap_ne 1e23 : d0fe > bne * ;failed not equal (non zero) > 1e25 : 68 > pla ;load status 1e26 : 48 > pha > cmp_flag fn 1e27 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 1e29 : d0fe > bne * ;failed not equal (non zero) > 1e2b : 28 > plp ;restore status set_y $80,$ff > load_flag $ff 1e2c : a9ff > lda #$ff ;allow test to change > 1e2e : 48 > pha ;use stack to load status 1e2f : a080 > ldy #$80 ;precharge index y 1e31 : 28 > plp 1e32 : cc1b02 cpy abs7f tst_stat ~fnz 1e35 : 08 > php ;save status 1e36 : 68 > pla ;use stack to retrieve status 1e37 : 48 > pha > cmp_flag ~fnz 1e38 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 1e3a : d0fe > bne * ;failed not equal (non zero) > 1e3c : 28 > plp ;restore status 1e3d : 88 dey 1e3e : cc1b02 cpy abs7f tst_stat ~fn 1e41 : 08 > php ;save status 1e42 : 68 > pla ;use stack to retrieve status 1e43 : 48 > pha > cmp_flag ~fn 1e44 : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 1e46 : d0fe > bne * ;failed not equal (non zero) > 1e48 : 28 > plp ;restore status 1e49 : 88 dey 1e4a : cc1b02 cpy abs7f tst_y $7e,~fzc 1e4d : 08 > php ;save flags 1e4e : c07e > cpy #$7e ;test result > trap_ne 1e50 : d0fe > bne * ;failed not equal (non zero) > 1e52 : 68 > pla ;load status 1e53 : 48 > pha > cmp_flag ~fzc 1e54 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 1e56 : d0fe > bne * ;failed not equal (non zero) > 1e58 : 28 > plp ;restore status set_y $80,0 > load_flag 0 1e59 : a900 > lda #0 ;allow test to change I > 1e5b : 48 > pha ;use stack to load status 1e5c : a080 > ldy #$80 ;precharge index y 1e5e : 28 > plp 1e5f : c07f cpy #$7f tst_stat fc 1e61 : 08 > php ;save status 1e62 : 68 > pla ;use stack to retrieve status 1e63 : 48 > pha > cmp_flag fc 1e64 : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 1e66 : d0fe > bne * ;failed not equal (non zero) > 1e68 : 28 > plp ;restore status 1e69 : 88 dey 1e6a : c07f cpy #$7f tst_stat fzc 1e6c : 08 > php ;save status 1e6d : 68 > pla ;use stack to retrieve status 1e6e : 48 > pha > cmp_flag fzc 1e6f : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 1e71 : d0fe > bne * ;failed not equal (non zero) > 1e73 : 28 > plp ;restore status 1e74 : 88 dey 1e75 : c07f cpy #$7f tst_y $7e,fn 1e77 : 08 > php ;save flags 1e78 : c07e > cpy #$7e ;test result > trap_ne 1e7a : d0fe > bne * ;failed not equal (non zero) > 1e7c : 68 > pla ;load status 1e7d : 48 > pha > cmp_flag fn 1e7e : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 1e80 : d0fe > bne * ;failed not equal (non zero) > 1e82 : 28 > plp ;restore status set_y $80,$ff > load_flag $ff 1e83 : a9ff > lda #$ff ;allow test to change > 1e85 : 48 > pha ;use stack to load status 1e86 : a080 > ldy #$80 ;precharge index y 1e88 : 28 > plp 1e89 : c07f cpy #$7f tst_stat ~fnz 1e8b : 08 > php ;save status 1e8c : 68 > pla ;use stack to retrieve status 1e8d : 48 > pha > cmp_flag ~fnz 1e8e : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 1e90 : d0fe > bne * ;failed not equal (non zero) > 1e92 : 28 > plp ;restore status 1e93 : 88 dey 1e94 : c07f cpy #$7f tst_stat ~fn 1e96 : 08 > php ;save status 1e97 : 68 > pla ;use stack to retrieve status 1e98 : 48 > pha > cmp_flag ~fn 1e99 : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 1e9b : d0fe > bne * ;failed not equal (non zero) > 1e9d : 28 > plp ;restore status 1e9e : 88 dey 1e9f : c07f cpy #$7f tst_y $7e,~fzc 1ea1 : 08 > php ;save flags 1ea2 : c07e > cpy #$7e ;test result > trap_ne 1ea4 : d0fe > bne * ;failed not equal (non zero) > 1ea6 : 68 > pla ;load status 1ea7 : 48 > pha > cmp_flag ~fzc 1ea8 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 1eaa : d0fe > bne * ;failed not equal (non zero) > 1eac : 28 > plp ;restore status next_test 1ead : ad0002 > lda test_case ;previous test 1eb0 : c91b > cmp #test_num > trap_ne ;test is out of sequence 1eb2 : d0fe > bne * ;failed not equal (non zero) > 001c = >test_num = test_num + 1 1eb4 : a91c > lda #test_num ;*** next tests' number 1eb6 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; CMP - zp / abs / # set_a $80,0 > load_flag 0 1eb9 : a900 > lda #0 ;allow test to change I > 1ebb : 48 > pha ;use stack to load status 1ebc : a980 > lda #$80 ;precharge accu 1ebe : 28 > plp 1ebf : c517 cmp zp7f tst_a $80,fc 1ec1 : 08 > php ;save flags 1ec2 : c980 > cmp #$80 ;test result > trap_ne 1ec4 : d0fe > bne * ;failed not equal (non zero) > 1ec6 : 68 > pla ;load status 1ec7 : 48 > pha > cmp_flag fc 1ec8 : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 1eca : d0fe > bne * ;failed not equal (non zero) > 1ecc : 28 > plp ;restore status set_a $7f,0 > load_flag 0 1ecd : a900 > lda #0 ;allow test to change I > 1ecf : 48 > pha ;use stack to load status 1ed0 : a97f > lda #$7f ;precharge accu 1ed2 : 28 > plp 1ed3 : c517 cmp zp7f tst_a $7f,fzc 1ed5 : 08 > php ;save flags 1ed6 : c97f > cmp #$7f ;test result > trap_ne 1ed8 : d0fe > bne * ;failed not equal (non zero) > 1eda : 68 > pla ;load status 1edb : 48 > pha > cmp_flag fzc 1edc : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 1ede : d0fe > bne * ;failed not equal (non zero) > 1ee0 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 1ee1 : a900 > lda #0 ;allow test to change I > 1ee3 : 48 > pha ;use stack to load status 1ee4 : a97e > lda #$7e ;precharge accu 1ee6 : 28 > plp 1ee7 : c517 cmp zp7f tst_a $7e,fn 1ee9 : 08 > php ;save flags 1eea : c97e > cmp #$7e ;test result > trap_ne 1eec : d0fe > bne * ;failed not equal (non zero) > 1eee : 68 > pla ;load status 1eef : 48 > pha > cmp_flag fn 1ef0 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 1ef2 : d0fe > bne * ;failed not equal (non zero) > 1ef4 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 1ef5 : a9ff > lda #$ff ;allow test to change > 1ef7 : 48 > pha ;use stack to load status 1ef8 : a980 > lda #$80 ;precharge accu 1efa : 28 > plp 1efb : c517 cmp zp7f tst_a $80,~fnz 1efd : 08 > php ;save flags 1efe : c980 > cmp #$80 ;test result > trap_ne 1f00 : d0fe > bne * ;failed not equal (non zero) > 1f02 : 68 > pla ;load status 1f03 : 48 > pha > cmp_flag ~fnz 1f04 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 1f06 : d0fe > bne * ;failed not equal (non zero) > 1f08 : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 1f09 : a9ff > lda #$ff ;allow test to change > 1f0b : 48 > pha ;use stack to load status 1f0c : a97f > lda #$7f ;precharge accu 1f0e : 28 > plp 1f0f : c517 cmp zp7f tst_a $7f,~fn 1f11 : 08 > php ;save flags 1f12 : c97f > cmp #$7f ;test result > trap_ne 1f14 : d0fe > bne * ;failed not equal (non zero) > 1f16 : 68 > pla ;load status 1f17 : 48 > pha > cmp_flag ~fn 1f18 : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 1f1a : d0fe > bne * ;failed not equal (non zero) > 1f1c : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 1f1d : a9ff > lda #$ff ;allow test to change > 1f1f : 48 > pha ;use stack to load status 1f20 : a97e > lda #$7e ;precharge accu 1f22 : 28 > plp 1f23 : c517 cmp zp7f tst_a $7e,~fzc 1f25 : 08 > php ;save flags 1f26 : c97e > cmp #$7e ;test result > trap_ne 1f28 : d0fe > bne * ;failed not equal (non zero) > 1f2a : 68 > pla ;load status 1f2b : 48 > pha > cmp_flag ~fzc 1f2c : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 1f2e : d0fe > bne * ;failed not equal (non zero) > 1f30 : 28 > plp ;restore status set_a $80,0 > load_flag 0 1f31 : a900 > lda #0 ;allow test to change I > 1f33 : 48 > pha ;use stack to load status 1f34 : a980 > lda #$80 ;precharge accu 1f36 : 28 > plp 1f37 : cd1b02 cmp abs7f tst_a $80,fc 1f3a : 08 > php ;save flags 1f3b : c980 > cmp #$80 ;test result > trap_ne 1f3d : d0fe > bne * ;failed not equal (non zero) > 1f3f : 68 > pla ;load status 1f40 : 48 > pha > cmp_flag fc 1f41 : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 1f43 : d0fe > bne * ;failed not equal (non zero) > 1f45 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 1f46 : a900 > lda #0 ;allow test to change I > 1f48 : 48 > pha ;use stack to load status 1f49 : a97f > lda #$7f ;precharge accu 1f4b : 28 > plp 1f4c : cd1b02 cmp abs7f tst_a $7f,fzc 1f4f : 08 > php ;save flags 1f50 : c97f > cmp #$7f ;test result > trap_ne 1f52 : d0fe > bne * ;failed not equal (non zero) > 1f54 : 68 > pla ;load status 1f55 : 48 > pha > cmp_flag fzc 1f56 : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 1f58 : d0fe > bne * ;failed not equal (non zero) > 1f5a : 28 > plp ;restore status set_a $7e,0 > load_flag 0 1f5b : a900 > lda #0 ;allow test to change I > 1f5d : 48 > pha ;use stack to load status 1f5e : a97e > lda #$7e ;precharge accu 1f60 : 28 > plp 1f61 : cd1b02 cmp abs7f tst_a $7e,fn 1f64 : 08 > php ;save flags 1f65 : c97e > cmp #$7e ;test result > trap_ne 1f67 : d0fe > bne * ;failed not equal (non zero) > 1f69 : 68 > pla ;load status 1f6a : 48 > pha > cmp_flag fn 1f6b : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 1f6d : d0fe > bne * ;failed not equal (non zero) > 1f6f : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 1f70 : a9ff > lda #$ff ;allow test to change > 1f72 : 48 > pha ;use stack to load status 1f73 : a980 > lda #$80 ;precharge accu 1f75 : 28 > plp 1f76 : cd1b02 cmp abs7f tst_a $80,~fnz 1f79 : 08 > php ;save flags 1f7a : c980 > cmp #$80 ;test result > trap_ne 1f7c : d0fe > bne * ;failed not equal (non zero) > 1f7e : 68 > pla ;load status 1f7f : 48 > pha > cmp_flag ~fnz 1f80 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 1f82 : d0fe > bne * ;failed not equal (non zero) > 1f84 : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 1f85 : a9ff > lda #$ff ;allow test to change > 1f87 : 48 > pha ;use stack to load status 1f88 : a97f > lda #$7f ;precharge accu 1f8a : 28 > plp 1f8b : cd1b02 cmp abs7f tst_a $7f,~fn 1f8e : 08 > php ;save flags 1f8f : c97f > cmp #$7f ;test result > trap_ne 1f91 : d0fe > bne * ;failed not equal (non zero) > 1f93 : 68 > pla ;load status 1f94 : 48 > pha > cmp_flag ~fn 1f95 : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 1f97 : d0fe > bne * ;failed not equal (non zero) > 1f99 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 1f9a : a9ff > lda #$ff ;allow test to change > 1f9c : 48 > pha ;use stack to load status 1f9d : a97e > lda #$7e ;precharge accu 1f9f : 28 > plp 1fa0 : cd1b02 cmp abs7f tst_a $7e,~fzc 1fa3 : 08 > php ;save flags 1fa4 : c97e > cmp #$7e ;test result > trap_ne 1fa6 : d0fe > bne * ;failed not equal (non zero) > 1fa8 : 68 > pla ;load status 1fa9 : 48 > pha > cmp_flag ~fzc 1faa : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 1fac : d0fe > bne * ;failed not equal (non zero) > 1fae : 28 > plp ;restore status set_a $80,0 > load_flag 0 1faf : a900 > lda #0 ;allow test to change I > 1fb1 : 48 > pha ;use stack to load status 1fb2 : a980 > lda #$80 ;precharge accu 1fb4 : 28 > plp 1fb5 : c97f cmp #$7f tst_a $80,fc 1fb7 : 08 > php ;save flags 1fb8 : c980 > cmp #$80 ;test result > trap_ne 1fba : d0fe > bne * ;failed not equal (non zero) > 1fbc : 68 > pla ;load status 1fbd : 48 > pha > cmp_flag fc 1fbe : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 1fc0 : d0fe > bne * ;failed not equal (non zero) > 1fc2 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 1fc3 : a900 > lda #0 ;allow test to change I > 1fc5 : 48 > pha ;use stack to load status 1fc6 : a97f > lda #$7f ;precharge accu 1fc8 : 28 > plp 1fc9 : c97f cmp #$7f tst_a $7f,fzc 1fcb : 08 > php ;save flags 1fcc : c97f > cmp #$7f ;test result > trap_ne 1fce : d0fe > bne * ;failed not equal (non zero) > 1fd0 : 68 > pla ;load status 1fd1 : 48 > pha > cmp_flag fzc 1fd2 : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 1fd4 : d0fe > bne * ;failed not equal (non zero) > 1fd6 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 1fd7 : a900 > lda #0 ;allow test to change I > 1fd9 : 48 > pha ;use stack to load status 1fda : a97e > lda #$7e ;precharge accu 1fdc : 28 > plp 1fdd : c97f cmp #$7f tst_a $7e,fn 1fdf : 08 > php ;save flags 1fe0 : c97e > cmp #$7e ;test result > trap_ne 1fe2 : d0fe > bne * ;failed not equal (non zero) > 1fe4 : 68 > pla ;load status 1fe5 : 48 > pha > cmp_flag fn 1fe6 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 1fe8 : d0fe > bne * ;failed not equal (non zero) > 1fea : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 1feb : a9ff > lda #$ff ;allow test to change > 1fed : 48 > pha ;use stack to load status 1fee : a980 > lda #$80 ;precharge accu 1ff0 : 28 > plp 1ff1 : c97f cmp #$7f tst_a $80,~fnz 1ff3 : 08 > php ;save flags 1ff4 : c980 > cmp #$80 ;test result > trap_ne 1ff6 : d0fe > bne * ;failed not equal (non zero) > 1ff8 : 68 > pla ;load status 1ff9 : 48 > pha > cmp_flag ~fnz 1ffa : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 1ffc : d0fe > bne * ;failed not equal (non zero) > 1ffe : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 1fff : a9ff > lda #$ff ;allow test to change > 2001 : 48 > pha ;use stack to load status 2002 : a97f > lda #$7f ;precharge accu 2004 : 28 > plp 2005 : c97f cmp #$7f tst_a $7f,~fn 2007 : 08 > php ;save flags 2008 : c97f > cmp #$7f ;test result > trap_ne 200a : d0fe > bne * ;failed not equal (non zero) > 200c : 68 > pla ;load status 200d : 48 > pha > cmp_flag ~fn 200e : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 2010 : d0fe > bne * ;failed not equal (non zero) > 2012 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 2013 : a9ff > lda #$ff ;allow test to change > 2015 : 48 > pha ;use stack to load status 2016 : a97e > lda #$7e ;precharge accu 2018 : 28 > plp 2019 : c97f cmp #$7f tst_a $7e,~fzc 201b : 08 > php ;save flags 201c : c97e > cmp #$7e ;test result > trap_ne 201e : d0fe > bne * ;failed not equal (non zero) > 2020 : 68 > pla ;load status 2021 : 48 > pha > cmp_flag ~fzc 2022 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 2024 : d0fe > bne * ;failed not equal (non zero) > 2026 : 28 > plp ;restore status 2027 : a204 ldx #4 ;with indexing by X set_a $80,0 > load_flag 0 2029 : a900 > lda #0 ;allow test to change I > 202b : 48 > pha ;use stack to load status 202c : a980 > lda #$80 ;precharge accu 202e : 28 > plp 202f : d513 cmp zp1,x tst_a $80,fc 2031 : 08 > php ;save flags 2032 : c980 > cmp #$80 ;test result > trap_ne 2034 : d0fe > bne * ;failed not equal (non zero) > 2036 : 68 > pla ;load status 2037 : 48 > pha > cmp_flag fc 2038 : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 203a : d0fe > bne * ;failed not equal (non zero) > 203c : 28 > plp ;restore status set_a $7f,0 > load_flag 0 203d : a900 > lda #0 ;allow test to change I > 203f : 48 > pha ;use stack to load status 2040 : a97f > lda #$7f ;precharge accu 2042 : 28 > plp 2043 : d513 cmp zp1,x tst_a $7f,fzc 2045 : 08 > php ;save flags 2046 : c97f > cmp #$7f ;test result > trap_ne 2048 : d0fe > bne * ;failed not equal (non zero) > 204a : 68 > pla ;load status 204b : 48 > pha > cmp_flag fzc 204c : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 204e : d0fe > bne * ;failed not equal (non zero) > 2050 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 2051 : a900 > lda #0 ;allow test to change I > 2053 : 48 > pha ;use stack to load status 2054 : a97e > lda #$7e ;precharge accu 2056 : 28 > plp 2057 : d513 cmp zp1,x tst_a $7e,fn 2059 : 08 > php ;save flags 205a : c97e > cmp #$7e ;test result > trap_ne 205c : d0fe > bne * ;failed not equal (non zero) > 205e : 68 > pla ;load status 205f : 48 > pha > cmp_flag fn 2060 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 2062 : d0fe > bne * ;failed not equal (non zero) > 2064 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 2065 : a9ff > lda #$ff ;allow test to change > 2067 : 48 > pha ;use stack to load status 2068 : a980 > lda #$80 ;precharge accu 206a : 28 > plp 206b : d513 cmp zp1,x tst_a $80,~fnz 206d : 08 > php ;save flags 206e : c980 > cmp #$80 ;test result > trap_ne 2070 : d0fe > bne * ;failed not equal (non zero) > 2072 : 68 > pla ;load status 2073 : 48 > pha > cmp_flag ~fnz 2074 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 2076 : d0fe > bne * ;failed not equal (non zero) > 2078 : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 2079 : a9ff > lda #$ff ;allow test to change > 207b : 48 > pha ;use stack to load status 207c : a97f > lda #$7f ;precharge accu 207e : 28 > plp 207f : d513 cmp zp1,x tst_a $7f,~fn 2081 : 08 > php ;save flags 2082 : c97f > cmp #$7f ;test result > trap_ne 2084 : d0fe > bne * ;failed not equal (non zero) > 2086 : 68 > pla ;load status 2087 : 48 > pha > cmp_flag ~fn 2088 : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 208a : d0fe > bne * ;failed not equal (non zero) > 208c : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 208d : a9ff > lda #$ff ;allow test to change > 208f : 48 > pha ;use stack to load status 2090 : a97e > lda #$7e ;precharge accu 2092 : 28 > plp 2093 : d513 cmp zp1,x tst_a $7e,~fzc 2095 : 08 > php ;save flags 2096 : c97e > cmp #$7e ;test result > trap_ne 2098 : d0fe > bne * ;failed not equal (non zero) > 209a : 68 > pla ;load status 209b : 48 > pha > cmp_flag ~fzc 209c : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 209e : d0fe > bne * ;failed not equal (non zero) > 20a0 : 28 > plp ;restore status set_a $80,0 > load_flag 0 20a1 : a900 > lda #0 ;allow test to change I > 20a3 : 48 > pha ;use stack to load status 20a4 : a980 > lda #$80 ;precharge accu 20a6 : 28 > plp 20a7 : dd1702 cmp abs1,x tst_a $80,fc 20aa : 08 > php ;save flags 20ab : c980 > cmp #$80 ;test result > trap_ne 20ad : d0fe > bne * ;failed not equal (non zero) > 20af : 68 > pla ;load status 20b0 : 48 > pha > cmp_flag fc 20b1 : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 20b3 : d0fe > bne * ;failed not equal (non zero) > 20b5 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 20b6 : a900 > lda #0 ;allow test to change I > 20b8 : 48 > pha ;use stack to load status 20b9 : a97f > lda #$7f ;precharge accu 20bb : 28 > plp 20bc : dd1702 cmp abs1,x tst_a $7f,fzc 20bf : 08 > php ;save flags 20c0 : c97f > cmp #$7f ;test result > trap_ne 20c2 : d0fe > bne * ;failed not equal (non zero) > 20c4 : 68 > pla ;load status 20c5 : 48 > pha > cmp_flag fzc 20c6 : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 20c8 : d0fe > bne * ;failed not equal (non zero) > 20ca : 28 > plp ;restore status set_a $7e,0 > load_flag 0 20cb : a900 > lda #0 ;allow test to change I > 20cd : 48 > pha ;use stack to load status 20ce : a97e > lda #$7e ;precharge accu 20d0 : 28 > plp 20d1 : dd1702 cmp abs1,x tst_a $7e,fn 20d4 : 08 > php ;save flags 20d5 : c97e > cmp #$7e ;test result > trap_ne 20d7 : d0fe > bne * ;failed not equal (non zero) > 20d9 : 68 > pla ;load status 20da : 48 > pha > cmp_flag fn 20db : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 20dd : d0fe > bne * ;failed not equal (non zero) > 20df : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 20e0 : a9ff > lda #$ff ;allow test to change > 20e2 : 48 > pha ;use stack to load status 20e3 : a980 > lda #$80 ;precharge accu 20e5 : 28 > plp 20e6 : dd1702 cmp abs1,x tst_a $80,~fnz 20e9 : 08 > php ;save flags 20ea : c980 > cmp #$80 ;test result > trap_ne 20ec : d0fe > bne * ;failed not equal (non zero) > 20ee : 68 > pla ;load status 20ef : 48 > pha > cmp_flag ~fnz 20f0 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 20f2 : d0fe > bne * ;failed not equal (non zero) > 20f4 : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 20f5 : a9ff > lda #$ff ;allow test to change > 20f7 : 48 > pha ;use stack to load status 20f8 : a97f > lda #$7f ;precharge accu 20fa : 28 > plp 20fb : dd1702 cmp abs1,x tst_a $7f,~fn 20fe : 08 > php ;save flags 20ff : c97f > cmp #$7f ;test result > trap_ne 2101 : d0fe > bne * ;failed not equal (non zero) > 2103 : 68 > pla ;load status 2104 : 48 > pha > cmp_flag ~fn 2105 : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 2107 : d0fe > bne * ;failed not equal (non zero) > 2109 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 210a : a9ff > lda #$ff ;allow test to change > 210c : 48 > pha ;use stack to load status 210d : a97e > lda #$7e ;precharge accu 210f : 28 > plp 2110 : dd1702 cmp abs1,x tst_a $7e,~fzc 2113 : 08 > php ;save flags 2114 : c97e > cmp #$7e ;test result > trap_ne 2116 : d0fe > bne * ;failed not equal (non zero) > 2118 : 68 > pla ;load status 2119 : 48 > pha > cmp_flag ~fzc 211a : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 211c : d0fe > bne * ;failed not equal (non zero) > 211e : 28 > plp ;restore status 211f : a004 ldy #4 ;with indexing by Y 2121 : a208 ldx #8 ;with indexed indirect set_a $80,0 > load_flag 0 2123 : a900 > lda #0 ;allow test to change I > 2125 : 48 > pha ;use stack to load status 2126 : a980 > lda #$80 ;precharge accu 2128 : 28 > plp 2129 : d91702 cmp abs1,y tst_a $80,fc 212c : 08 > php ;save flags 212d : c980 > cmp #$80 ;test result > trap_ne 212f : d0fe > bne * ;failed not equal (non zero) > 2131 : 68 > pla ;load status 2132 : 48 > pha > cmp_flag fc 2133 : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 2135 : d0fe > bne * ;failed not equal (non zero) > 2137 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 2138 : a900 > lda #0 ;allow test to change I > 213a : 48 > pha ;use stack to load status 213b : a97f > lda #$7f ;precharge accu 213d : 28 > plp 213e : d91702 cmp abs1,y tst_a $7f,fzc 2141 : 08 > php ;save flags 2142 : c97f > cmp #$7f ;test result > trap_ne 2144 : d0fe > bne * ;failed not equal (non zero) > 2146 : 68 > pla ;load status 2147 : 48 > pha > cmp_flag fzc 2148 : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 214a : d0fe > bne * ;failed not equal (non zero) > 214c : 28 > plp ;restore status set_a $7e,0 > load_flag 0 214d : a900 > lda #0 ;allow test to change I > 214f : 48 > pha ;use stack to load status 2150 : a97e > lda #$7e ;precharge accu 2152 : 28 > plp 2153 : d91702 cmp abs1,y tst_a $7e,fn 2156 : 08 > php ;save flags 2157 : c97e > cmp #$7e ;test result > trap_ne 2159 : d0fe > bne * ;failed not equal (non zero) > 215b : 68 > pla ;load status 215c : 48 > pha > cmp_flag fn 215d : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 215f : d0fe > bne * ;failed not equal (non zero) > 2161 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 2162 : a9ff > lda #$ff ;allow test to change > 2164 : 48 > pha ;use stack to load status 2165 : a980 > lda #$80 ;precharge accu 2167 : 28 > plp 2168 : d91702 cmp abs1,y tst_a $80,~fnz 216b : 08 > php ;save flags 216c : c980 > cmp #$80 ;test result > trap_ne 216e : d0fe > bne * ;failed not equal (non zero) > 2170 : 68 > pla ;load status 2171 : 48 > pha > cmp_flag ~fnz 2172 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 2174 : d0fe > bne * ;failed not equal (non zero) > 2176 : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 2177 : a9ff > lda #$ff ;allow test to change > 2179 : 48 > pha ;use stack to load status 217a : a97f > lda #$7f ;precharge accu 217c : 28 > plp 217d : d91702 cmp abs1,y tst_a $7f,~fn 2180 : 08 > php ;save flags 2181 : c97f > cmp #$7f ;test result > trap_ne 2183 : d0fe > bne * ;failed not equal (non zero) > 2185 : 68 > pla ;load status 2186 : 48 > pha > cmp_flag ~fn 2187 : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 2189 : d0fe > bne * ;failed not equal (non zero) > 218b : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 218c : a9ff > lda #$ff ;allow test to change > 218e : 48 > pha ;use stack to load status 218f : a97e > lda #$7e ;precharge accu 2191 : 28 > plp 2192 : d91702 cmp abs1,y tst_a $7e,~fzc 2195 : 08 > php ;save flags 2196 : c97e > cmp #$7e ;test result > trap_ne 2198 : d0fe > bne * ;failed not equal (non zero) > 219a : 68 > pla ;load status 219b : 48 > pha > cmp_flag ~fzc 219c : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 219e : d0fe > bne * ;failed not equal (non zero) > 21a0 : 28 > plp ;restore status set_a $80,0 > load_flag 0 21a1 : a900 > lda #0 ;allow test to change I > 21a3 : 48 > pha ;use stack to load status 21a4 : a980 > lda #$80 ;precharge accu 21a6 : 28 > plp 21a7 : c124 cmp (ind1,x) tst_a $80,fc 21a9 : 08 > php ;save flags 21aa : c980 > cmp #$80 ;test result > trap_ne 21ac : d0fe > bne * ;failed not equal (non zero) > 21ae : 68 > pla ;load status 21af : 48 > pha > cmp_flag fc 21b0 : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 21b2 : d0fe > bne * ;failed not equal (non zero) > 21b4 : 28 > plp ;restore status set_a $7f,0 > load_flag 0 21b5 : a900 > lda #0 ;allow test to change I > 21b7 : 48 > pha ;use stack to load status 21b8 : a97f > lda #$7f ;precharge accu 21ba : 28 > plp 21bb : c124 cmp (ind1,x) tst_a $7f,fzc 21bd : 08 > php ;save flags 21be : c97f > cmp #$7f ;test result > trap_ne 21c0 : d0fe > bne * ;failed not equal (non zero) > 21c2 : 68 > pla ;load status 21c3 : 48 > pha > cmp_flag fzc 21c4 : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 21c6 : d0fe > bne * ;failed not equal (non zero) > 21c8 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 21c9 : a900 > lda #0 ;allow test to change I > 21cb : 48 > pha ;use stack to load status 21cc : a97e > lda #$7e ;precharge accu 21ce : 28 > plp 21cf : c124 cmp (ind1,x) tst_a $7e,fn 21d1 : 08 > php ;save flags 21d2 : c97e > cmp #$7e ;test result > trap_ne 21d4 : d0fe > bne * ;failed not equal (non zero) > 21d6 : 68 > pla ;load status 21d7 : 48 > pha > cmp_flag fn 21d8 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 21da : d0fe > bne * ;failed not equal (non zero) > 21dc : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 21dd : a9ff > lda #$ff ;allow test to change > 21df : 48 > pha ;use stack to load status 21e0 : a980 > lda #$80 ;precharge accu 21e2 : 28 > plp 21e3 : c124 cmp (ind1,x) tst_a $80,~fnz 21e5 : 08 > php ;save flags 21e6 : c980 > cmp #$80 ;test result > trap_ne 21e8 : d0fe > bne * ;failed not equal (non zero) > 21ea : 68 > pla ;load status 21eb : 48 > pha > cmp_flag ~fnz 21ec : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 21ee : d0fe > bne * ;failed not equal (non zero) > 21f0 : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 21f1 : a9ff > lda #$ff ;allow test to change > 21f3 : 48 > pha ;use stack to load status 21f4 : a97f > lda #$7f ;precharge accu 21f6 : 28 > plp 21f7 : c124 cmp (ind1,x) tst_a $7f,~fn 21f9 : 08 > php ;save flags 21fa : c97f > cmp #$7f ;test result > trap_ne 21fc : d0fe > bne * ;failed not equal (non zero) > 21fe : 68 > pla ;load status 21ff : 48 > pha > cmp_flag ~fn 2200 : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 2202 : d0fe > bne * ;failed not equal (non zero) > 2204 : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 2205 : a9ff > lda #$ff ;allow test to change > 2207 : 48 > pha ;use stack to load status 2208 : a97e > lda #$7e ;precharge accu 220a : 28 > plp 220b : c124 cmp (ind1,x) tst_a $7e,~fzc 220d : 08 > php ;save flags 220e : c97e > cmp #$7e ;test result > trap_ne 2210 : d0fe > bne * ;failed not equal (non zero) > 2212 : 68 > pla ;load status 2213 : 48 > pha > cmp_flag ~fzc 2214 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 2216 : d0fe > bne * ;failed not equal (non zero) > 2218 : 28 > plp ;restore status set_a $80,0 > load_flag 0 2219 : a900 > lda #0 ;allow test to change I > 221b : 48 > pha ;use stack to load status 221c : a980 > lda #$80 ;precharge accu 221e : 28 > plp 221f : d124 cmp (ind1),y tst_a $80,fc 2221 : 08 > php ;save flags 2222 : c980 > cmp #$80 ;test result > trap_ne 2224 : d0fe > bne * ;failed not equal (non zero) > 2226 : 68 > pla ;load status 2227 : 48 > pha > cmp_flag fc 2228 : c931 > cmp #(fc|fao)&m8 ;expected flags + alwa > > trap_ne 222a : d0fe > bne * ;failed not equal (non zero) > 222c : 28 > plp ;restore status set_a $7f,0 > load_flag 0 222d : a900 > lda #0 ;allow test to change I > 222f : 48 > pha ;use stack to load status 2230 : a97f > lda #$7f ;precharge accu 2232 : 28 > plp 2233 : d124 cmp (ind1),y tst_a $7f,fzc 2235 : 08 > php ;save flags 2236 : c97f > cmp #$7f ;test result > trap_ne 2238 : d0fe > bne * ;failed not equal (non zero) > 223a : 68 > pla ;load status 223b : 48 > pha > cmp_flag fzc 223c : c933 > cmp #(fzc|fao)&m8 ;expected flags + alw > > trap_ne 223e : d0fe > bne * ;failed not equal (non zero) > 2240 : 28 > plp ;restore status set_a $7e,0 > load_flag 0 2241 : a900 > lda #0 ;allow test to change I > 2243 : 48 > pha ;use stack to load status 2244 : a97e > lda #$7e ;precharge accu 2246 : 28 > plp 2247 : d124 cmp (ind1),y tst_a $7e,fn 2249 : 08 > php ;save flags 224a : c97e > cmp #$7e ;test result > trap_ne 224c : d0fe > bne * ;failed not equal (non zero) > 224e : 68 > pla ;load status 224f : 48 > pha > cmp_flag fn 2250 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + alwa > > trap_ne 2252 : d0fe > bne * ;failed not equal (non zero) > 2254 : 28 > plp ;restore status set_a $80,$ff > load_flag $ff 2255 : a9ff > lda #$ff ;allow test to change > 2257 : 48 > pha ;use stack to load status 2258 : a980 > lda #$80 ;precharge accu 225a : 28 > plp 225b : d124 cmp (ind1),y tst_a $80,~fnz 225d : 08 > php ;save flags 225e : c980 > cmp #$80 ;test result > trap_ne 2260 : d0fe > bne * ;failed not equal (non zero) > 2262 : 68 > pla ;load status 2263 : 48 > pha > cmp_flag ~fnz 2264 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + al > > trap_ne 2266 : d0fe > bne * ;failed not equal (non zero) > 2268 : 28 > plp ;restore status set_a $7f,$ff > load_flag $ff 2269 : a9ff > lda #$ff ;allow test to change > 226b : 48 > pha ;use stack to load status 226c : a97f > lda #$7f ;precharge accu 226e : 28 > plp 226f : d124 cmp (ind1),y tst_a $7f,~fn 2271 : 08 > php ;save flags 2272 : c97f > cmp #$7f ;test result > trap_ne 2274 : d0fe > bne * ;failed not equal (non zero) > 2276 : 68 > pla ;load status 2277 : 48 > pha > cmp_flag ~fn 2278 : c97f > cmp #(~fn|fao)&m8 ;expected flags + alw > > trap_ne 227a : d0fe > bne * ;failed not equal (non zero) > 227c : 28 > plp ;restore status set_a $7e,$ff > load_flag $ff 227d : a9ff > lda #$ff ;allow test to change > 227f : 48 > pha ;use stack to load status 2280 : a97e > lda #$7e ;precharge accu 2282 : 28 > plp 2283 : d124 cmp (ind1),y tst_a $7e,~fzc 2285 : 08 > php ;save flags 2286 : c97e > cmp #$7e ;test result > trap_ne 2288 : d0fe > bne * ;failed not equal (non zero) > 228a : 68 > pla ;load status 228b : 48 > pha > cmp_flag ~fzc 228c : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + al > > trap_ne 228e : d0fe > bne * ;failed not equal (non zero) > 2290 : 28 > plp ;restore status next_test 2291 : ad0002 > lda test_case ;previous test 2294 : c91c > cmp #test_num > trap_ne ;test is out of sequence 2296 : d0fe > bne * ;failed not equal (non zero) > 001d = >test_num = test_num + 1 2298 : a91d > lda #test_num ;*** next tests' number 229a : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; testing shifts - ASL LSR ROL ROR all addressing mode ; shifts - accumulator 229d : a203 ldx #3 229f : tasl set_ax zp1,0 > load_flag 0 229f : a900 > lda #0 ;allow test to change I > 22a1 : 48 > pha ;use stack to load status 22a2 : b513 > lda zp1,x ;precharge accu 22a4 : 28 > plp 22a5 : 0a asl a tst_ax rASL,fASL,0 22a6 : 08 > php ;save flags 22a7 : dd2002 > cmp rASL,x ;test result > trap_ne 22aa : d0fe > bne * ;failed not equal (non zero) > 22ac : 68 > pla ;load status > eor_flag 0 22ad : 4930 > eor #0|fao ;invert expected flags > 22af : dd3002 > cmp fASL,x ;test flags > trap_ne ; 22b2 : d0fe > bne * ;failed not equal (non zero) > 22b4 : ca dex 22b5 : 10e8 bpl tasl 22b7 : a203 ldx #3 22b9 : tasl1 set_ax zp1,$ff > load_flag $ff 22b9 : a9ff > lda #$ff ;allow test to change > 22bb : 48 > pha ;use stack to load status 22bc : b513 > lda zp1,x ;precharge accu 22be : 28 > plp 22bf : 0a asl a tst_ax rASL,fASL,$ff-fnzc 22c0 : 08 > php ;save flags 22c1 : dd2002 > cmp rASL,x ;test result > trap_ne 22c4 : d0fe > bne * ;failed not equal (non zero) > 22c6 : 68 > pla ;load status > eor_flag $ff-fnzc 22c7 : 497c > eor #$ff-fnzc|fao ;invert expected > 22c9 : dd3002 > cmp fASL,x ;test flags > trap_ne ; 22cc : d0fe > bne * ;failed not equal (non zero) > 22ce : ca dex 22cf : 10e8 bpl tasl1 22d1 : a203 ldx #3 22d3 : tlsr set_ax zp1,0 > load_flag 0 22d3 : a900 > lda #0 ;allow test to change I > 22d5 : 48 > pha ;use stack to load status 22d6 : b513 > lda zp1,x ;precharge accu 22d8 : 28 > plp 22d9 : 4a lsr a tst_ax rLSR,fLSR,0 22da : 08 > php ;save flags 22db : dd2802 > cmp rLSR,x ;test result > trap_ne 22de : d0fe > bne * ;failed not equal (non zero) > 22e0 : 68 > pla ;load status > eor_flag 0 22e1 : 4930 > eor #0|fao ;invert expected flags > 22e3 : dd3802 > cmp fLSR,x ;test flags > trap_ne ; 22e6 : d0fe > bne * ;failed not equal (non zero) > 22e8 : ca dex 22e9 : 10e8 bpl tlsr 22eb : a203 ldx #3 22ed : tlsr1 set_ax zp1,$ff > load_flag $ff 22ed : a9ff > lda #$ff ;allow test to change > 22ef : 48 > pha ;use stack to load status 22f0 : b513 > lda zp1,x ;precharge accu 22f2 : 28 > plp 22f3 : 4a lsr a tst_ax rLSR,fLSR,$ff-fnzc 22f4 : 08 > php ;save flags 22f5 : dd2802 > cmp rLSR,x ;test result > trap_ne 22f8 : d0fe > bne * ;failed not equal (non zero) > 22fa : 68 > pla ;load status > eor_flag $ff-fnzc 22fb : 497c > eor #$ff-fnzc|fao ;invert expected > 22fd : dd3802 > cmp fLSR,x ;test flags > trap_ne ; 2300 : d0fe > bne * ;failed not equal (non zero) > 2302 : ca dex 2303 : 10e8 bpl tlsr1 2305 : a203 ldx #3 2307 : trol set_ax zp1,0 > load_flag 0 2307 : a900 > lda #0 ;allow test to change I > 2309 : 48 > pha ;use stack to load status 230a : b513 > lda zp1,x ;precharge accu 230c : 28 > plp 230d : 2a rol a tst_ax rROL,fROL,0 230e : 08 > php ;save flags 230f : dd2002 > cmp rROL,x ;test result > trap_ne 2312 : d0fe > bne * ;failed not equal (non zero) > 2314 : 68 > pla ;load status > eor_flag 0 2315 : 4930 > eor #0|fao ;invert expected flags > 2317 : dd3002 > cmp fROL,x ;test flags > trap_ne ; 231a : d0fe > bne * ;failed not equal (non zero) > 231c : ca dex 231d : 10e8 bpl trol 231f : a203 ldx #3 2321 : trol1 set_ax zp1,$ff-fc > load_flag $ff-fc 2321 : a9fe > lda #$ff-fc ;allow test to cha > 2323 : 48 > pha ;use stack to load status 2324 : b513 > lda zp1,x ;precharge accu 2326 : 28 > plp 2327 : 2a rol a tst_ax rROL,fROL,$ff-fnzc 2328 : 08 > php ;save flags 2329 : dd2002 > cmp rROL,x ;test result > trap_ne 232c : d0fe > bne * ;failed not equal (non zero) > 232e : 68 > pla ;load status > eor_flag $ff-fnzc 232f : 497c > eor #$ff-fnzc|fao ;invert expected > 2331 : dd3002 > cmp fROL,x ;test flags > trap_ne ; 2334 : d0fe > bne * ;failed not equal (non zero) > 2336 : ca dex 2337 : 10e8 bpl trol1 2339 : a203 ldx #3 233b : trolc set_ax zp1,fc > load_flag fc 233b : a901 > lda #fc ;allow test to change > 233d : 48 > pha ;use stack to load status 233e : b513 > lda zp1,x ;precharge accu 2340 : 28 > plp 2341 : 2a rol a tst_ax rROLc,fROLc,0 2342 : 08 > php ;save flags 2343 : dd2402 > cmp rROLc,x ;test result > trap_ne 2346 : d0fe > bne * ;failed not equal (non zero) > 2348 : 68 > pla ;load status > eor_flag 0 2349 : 4930 > eor #0|fao ;invert expected flags > 234b : dd3402 > cmp fROLc,x ;test flags > trap_ne ; 234e : d0fe > bne * ;failed not equal (non zero) > 2350 : ca dex 2351 : 10e8 bpl trolc 2353 : a203 ldx #3 2355 : trolc1 set_ax zp1,$ff > load_flag $ff 2355 : a9ff > lda #$ff ;allow test to change > 2357 : 48 > pha ;use stack to load status 2358 : b513 > lda zp1,x ;precharge accu 235a : 28 > plp 235b : 2a rol a tst_ax rROLc,fROLc,$ff-fnzc 235c : 08 > php ;save flags 235d : dd2402 > cmp rROLc,x ;test result > trap_ne 2360 : d0fe > bne * ;failed not equal (non zero) > 2362 : 68 > pla ;load status > eor_flag $ff-fnzc 2363 : 497c > eor #$ff-fnzc|fao ;invert expected > 2365 : dd3402 > cmp fROLc,x ;test flags > trap_ne ; 2368 : d0fe > bne * ;failed not equal (non zero) > 236a : ca dex 236b : 10e8 bpl trolc1 236d : a203 ldx #3 236f : tror set_ax zp1,0 > load_flag 0 236f : a900 > lda #0 ;allow test to change I > 2371 : 48 > pha ;use stack to load status 2372 : b513 > lda zp1,x ;precharge accu 2374 : 28 > plp 2375 : 6a ror a tst_ax rROR,fROR,0 2376 : 08 > php ;save flags 2377 : dd2802 > cmp rROR,x ;test result > trap_ne 237a : d0fe > bne * ;failed not equal (non zero) > 237c : 68 > pla ;load status > eor_flag 0 237d : 4930 > eor #0|fao ;invert expected flags > 237f : dd3802 > cmp fROR,x ;test flags > trap_ne ; 2382 : d0fe > bne * ;failed not equal (non zero) > 2384 : ca dex 2385 : 10e8 bpl tror 2387 : a203 ldx #3 2389 : tror1 set_ax zp1,$ff-fc > load_flag $ff-fc 2389 : a9fe > lda #$ff-fc ;allow test to cha > 238b : 48 > pha ;use stack to load status 238c : b513 > lda zp1,x ;precharge accu 238e : 28 > plp 238f : 6a ror a tst_ax rROR,fROR,$ff-fnzc 2390 : 08 > php ;save flags 2391 : dd2802 > cmp rROR,x ;test result > trap_ne 2394 : d0fe > bne * ;failed not equal (non zero) > 2396 : 68 > pla ;load status > eor_flag $ff-fnzc 2397 : 497c > eor #$ff-fnzc|fao ;invert expected > 2399 : dd3802 > cmp fROR,x ;test flags > trap_ne ; 239c : d0fe > bne * ;failed not equal (non zero) > 239e : ca dex 239f : 10e8 bpl tror1 23a1 : a203 ldx #3 23a3 : trorc set_ax zp1,fc > load_flag fc 23a3 : a901 > lda #fc ;allow test to change > 23a5 : 48 > pha ;use stack to load status 23a6 : b513 > lda zp1,x ;precharge accu 23a8 : 28 > plp 23a9 : 6a ror a tst_ax rRORc,fRORc,0 23aa : 08 > php ;save flags 23ab : dd2c02 > cmp rRORc,x ;test result > trap_ne 23ae : d0fe > bne * ;failed not equal (non zero) > 23b0 : 68 > pla ;load status > eor_flag 0 23b1 : 4930 > eor #0|fao ;invert expected flags > 23b3 : dd3c02 > cmp fRORc,x ;test flags > trap_ne ; 23b6 : d0fe > bne * ;failed not equal (non zero) > 23b8 : ca dex 23b9 : 10e8 bpl trorc 23bb : a203 ldx #3 23bd : trorc1 set_ax zp1,$ff > load_flag $ff 23bd : a9ff > lda #$ff ;allow test to change > 23bf : 48 > pha ;use stack to load status 23c0 : b513 > lda zp1,x ;precharge accu 23c2 : 28 > plp 23c3 : 6a ror a tst_ax rRORc,fRORc,$ff-fnzc 23c4 : 08 > php ;save flags 23c5 : dd2c02 > cmp rRORc,x ;test result > trap_ne 23c8 : d0fe > bne * ;failed not equal (non zero) > 23ca : 68 > pla ;load status > eor_flag $ff-fnzc 23cb : 497c > eor #$ff-fnzc|fao ;invert expected > 23cd : dd3c02 > cmp fRORc,x ;test flags > trap_ne ; 23d0 : d0fe > bne * ;failed not equal (non zero) > 23d2 : ca dex 23d3 : 10e8 bpl trorc1 next_test 23d5 : ad0002 > lda test_case ;previous test 23d8 : c91d > cmp #test_num > trap_ne ;test is out of sequence 23da : d0fe > bne * ;failed not equal (non zero) > 001e = >test_num = test_num + 1 23dc : a91e > lda #test_num ;*** next tests' number 23de : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; shifts - zeropage 23e1 : a203 ldx #3 23e3 : tasl2 set_z zp1,0 > load_flag 0 23e3 : a900 > lda #0 ;allow test to change I > 23e5 : 48 > pha ;use stack to load status 23e6 : b513 > lda zp1,x ;load to zeropage 23e8 : 850c > sta zpt 23ea : 28 > plp 23eb : 060c asl zpt tst_z rASL,fASL,0 23ed : 08 > php ;save flags 23ee : a50c > lda zpt 23f0 : dd2002 > cmp rASL,x ;test result > trap_ne 23f3 : d0fe > bne * ;failed not equal (non zero) > 23f5 : 68 > pla ;load status > eor_flag 0 23f6 : 4930 > eor #0|fao ;invert expected flags > 23f8 : dd3002 > cmp fASL,x ;test flags > trap_ne 23fb : d0fe > bne * ;failed not equal (non zero) > 23fd : ca dex 23fe : 10e3 bpl tasl2 2400 : a203 ldx #3 2402 : tasl3 set_z zp1,$ff > load_flag $ff 2402 : a9ff > lda #$ff ;allow test to change > 2404 : 48 > pha ;use stack to load status 2405 : b513 > lda zp1,x ;load to zeropage 2407 : 850c > sta zpt 2409 : 28 > plp 240a : 060c asl zpt tst_z rASL,fASL,$ff-fnzc 240c : 08 > php ;save flags 240d : a50c > lda zpt 240f : dd2002 > cmp rASL,x ;test result > trap_ne 2412 : d0fe > bne * ;failed not equal (non zero) > 2414 : 68 > pla ;load status > eor_flag $ff-fnzc 2415 : 497c > eor #$ff-fnzc|fao ;invert expected > 2417 : dd3002 > cmp fASL,x ;test flags > trap_ne 241a : d0fe > bne * ;failed not equal (non zero) > 241c : ca dex 241d : 10e3 bpl tasl3 241f : a203 ldx #3 2421 : tlsr2 set_z zp1,0 > load_flag 0 2421 : a900 > lda #0 ;allow test to change I > 2423 : 48 > pha ;use stack to load status 2424 : b513 > lda zp1,x ;load to zeropage 2426 : 850c > sta zpt 2428 : 28 > plp 2429 : 460c lsr zpt tst_z rLSR,fLSR,0 242b : 08 > php ;save flags 242c : a50c > lda zpt 242e : dd2802 > cmp rLSR,x ;test result > trap_ne 2431 : d0fe > bne * ;failed not equal (non zero) > 2433 : 68 > pla ;load status > eor_flag 0 2434 : 4930 > eor #0|fao ;invert expected flags > 2436 : dd3802 > cmp fLSR,x ;test flags > trap_ne 2439 : d0fe > bne * ;failed not equal (non zero) > 243b : ca dex 243c : 10e3 bpl tlsr2 243e : a203 ldx #3 2440 : tlsr3 set_z zp1,$ff > load_flag $ff 2440 : a9ff > lda #$ff ;allow test to change > 2442 : 48 > pha ;use stack to load status 2443 : b513 > lda zp1,x ;load to zeropage 2445 : 850c > sta zpt 2447 : 28 > plp 2448 : 460c lsr zpt tst_z rLSR,fLSR,$ff-fnzc 244a : 08 > php ;save flags 244b : a50c > lda zpt 244d : dd2802 > cmp rLSR,x ;test result > trap_ne 2450 : d0fe > bne * ;failed not equal (non zero) > 2452 : 68 > pla ;load status > eor_flag $ff-fnzc 2453 : 497c > eor #$ff-fnzc|fao ;invert expected > 2455 : dd3802 > cmp fLSR,x ;test flags > trap_ne 2458 : d0fe > bne * ;failed not equal (non zero) > 245a : ca dex 245b : 10e3 bpl tlsr3 245d : a203 ldx #3 245f : trol2 set_z zp1,0 > load_flag 0 245f : a900 > lda #0 ;allow test to change I > 2461 : 48 > pha ;use stack to load status 2462 : b513 > lda zp1,x ;load to zeropage 2464 : 850c > sta zpt 2466 : 28 > plp 2467 : 260c rol zpt tst_z rROL,fROL,0 2469 : 08 > php ;save flags 246a : a50c > lda zpt 246c : dd2002 > cmp rROL,x ;test result > trap_ne 246f : d0fe > bne * ;failed not equal (non zero) > 2471 : 68 > pla ;load status > eor_flag 0 2472 : 4930 > eor #0|fao ;invert expected flags > 2474 : dd3002 > cmp fROL,x ;test flags > trap_ne 2477 : d0fe > bne * ;failed not equal (non zero) > 2479 : ca dex 247a : 10e3 bpl trol2 247c : a203 ldx #3 247e : trol3 set_z zp1,$ff-fc > load_flag $ff-fc 247e : a9fe > lda #$ff-fc ;allow test to cha > 2480 : 48 > pha ;use stack to load status 2481 : b513 > lda zp1,x ;load to zeropage 2483 : 850c > sta zpt 2485 : 28 > plp 2486 : 260c rol zpt tst_z rROL,fROL,$ff-fnzc 2488 : 08 > php ;save flags 2489 : a50c > lda zpt 248b : dd2002 > cmp rROL,x ;test result > trap_ne 248e : d0fe > bne * ;failed not equal (non zero) > 2490 : 68 > pla ;load status > eor_flag $ff-fnzc 2491 : 497c > eor #$ff-fnzc|fao ;invert expected > 2493 : dd3002 > cmp fROL,x ;test flags > trap_ne 2496 : d0fe > bne * ;failed not equal (non zero) > 2498 : ca dex 2499 : 10e3 bpl trol3 249b : a203 ldx #3 249d : trolc2 set_z zp1,fc > load_flag fc 249d : a901 > lda #fc ;allow test to change > 249f : 48 > pha ;use stack to load status 24a0 : b513 > lda zp1,x ;load to zeropage 24a2 : 850c > sta zpt 24a4 : 28 > plp 24a5 : 260c rol zpt tst_z rROLc,fROLc,0 24a7 : 08 > php ;save flags 24a8 : a50c > lda zpt 24aa : dd2402 > cmp rROLc,x ;test result > trap_ne 24ad : d0fe > bne * ;failed not equal (non zero) > 24af : 68 > pla ;load status > eor_flag 0 24b0 : 4930 > eor #0|fao ;invert expected flags > 24b2 : dd3402 > cmp fROLc,x ;test flags > trap_ne 24b5 : d0fe > bne * ;failed not equal (non zero) > 24b7 : ca dex 24b8 : 10e3 bpl trolc2 24ba : a203 ldx #3 24bc : trolc3 set_z zp1,$ff > load_flag $ff 24bc : a9ff > lda #$ff ;allow test to change > 24be : 48 > pha ;use stack to load status 24bf : b513 > lda zp1,x ;load to zeropage 24c1 : 850c > sta zpt 24c3 : 28 > plp 24c4 : 260c rol zpt tst_z rROLc,fROLc,$ff-fnzc 24c6 : 08 > php ;save flags 24c7 : a50c > lda zpt 24c9 : dd2402 > cmp rROLc,x ;test result > trap_ne 24cc : d0fe > bne * ;failed not equal (non zero) > 24ce : 68 > pla ;load status > eor_flag $ff-fnzc 24cf : 497c > eor #$ff-fnzc|fao ;invert expected > 24d1 : dd3402 > cmp fROLc,x ;test flags > trap_ne 24d4 : d0fe > bne * ;failed not equal (non zero) > 24d6 : ca dex 24d7 : 10e3 bpl trolc3 24d9 : a203 ldx #3 24db : tror2 set_z zp1,0 > load_flag 0 24db : a900 > lda #0 ;allow test to change I > 24dd : 48 > pha ;use stack to load status 24de : b513 > lda zp1,x ;load to zeropage 24e0 : 850c > sta zpt 24e2 : 28 > plp 24e3 : 660c ror zpt tst_z rROR,fROR,0 24e5 : 08 > php ;save flags 24e6 : a50c > lda zpt 24e8 : dd2802 > cmp rROR,x ;test result > trap_ne 24eb : d0fe > bne * ;failed not equal (non zero) > 24ed : 68 > pla ;load status > eor_flag 0 24ee : 4930 > eor #0|fao ;invert expected flags > 24f0 : dd3802 > cmp fROR,x ;test flags > trap_ne 24f3 : d0fe > bne * ;failed not equal (non zero) > 24f5 : ca dex 24f6 : 10e3 bpl tror2 24f8 : a203 ldx #3 24fa : tror3 set_z zp1,$ff-fc > load_flag $ff-fc 24fa : a9fe > lda #$ff-fc ;allow test to cha > 24fc : 48 > pha ;use stack to load status 24fd : b513 > lda zp1,x ;load to zeropage 24ff : 850c > sta zpt 2501 : 28 > plp 2502 : 660c ror zpt tst_z rROR,fROR,$ff-fnzc 2504 : 08 > php ;save flags 2505 : a50c > lda zpt 2507 : dd2802 > cmp rROR,x ;test result > trap_ne 250a : d0fe > bne * ;failed not equal (non zero) > 250c : 68 > pla ;load status > eor_flag $ff-fnzc 250d : 497c > eor #$ff-fnzc|fao ;invert expected > 250f : dd3802 > cmp fROR,x ;test flags > trap_ne 2512 : d0fe > bne * ;failed not equal (non zero) > 2514 : ca dex 2515 : 10e3 bpl tror3 2517 : a203 ldx #3 2519 : trorc2 set_z zp1,fc > load_flag fc 2519 : a901 > lda #fc ;allow test to change > 251b : 48 > pha ;use stack to load status 251c : b513 > lda zp1,x ;load to zeropage 251e : 850c > sta zpt 2520 : 28 > plp 2521 : 660c ror zpt tst_z rRORc,fRORc,0 2523 : 08 > php ;save flags 2524 : a50c > lda zpt 2526 : dd2c02 > cmp rRORc,x ;test result > trap_ne 2529 : d0fe > bne * ;failed not equal (non zero) > 252b : 68 > pla ;load status > eor_flag 0 252c : 4930 > eor #0|fao ;invert expected flags > 252e : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2531 : d0fe > bne * ;failed not equal (non zero) > 2533 : ca dex 2534 : 10e3 bpl trorc2 2536 : a203 ldx #3 2538 : trorc3 set_z zp1,$ff > load_flag $ff 2538 : a9ff > lda #$ff ;allow test to change > 253a : 48 > pha ;use stack to load status 253b : b513 > lda zp1,x ;load to zeropage 253d : 850c > sta zpt 253f : 28 > plp 2540 : 660c ror zpt tst_z rRORc,fRORc,$ff-fnzc 2542 : 08 > php ;save flags 2543 : a50c > lda zpt 2545 : dd2c02 > cmp rRORc,x ;test result > trap_ne 2548 : d0fe > bne * ;failed not equal (non zero) > 254a : 68 > pla ;load status > eor_flag $ff-fnzc 254b : 497c > eor #$ff-fnzc|fao ;invert expected > 254d : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2550 : d0fe > bne * ;failed not equal (non zero) > 2552 : ca dex 2553 : 10e3 bpl trorc3 next_test 2555 : ad0002 > lda test_case ;previous test 2558 : c91e > cmp #test_num > trap_ne ;test is out of sequence 255a : d0fe > bne * ;failed not equal (non zero) > 001f = >test_num = test_num + 1 255c : a91f > lda #test_num ;*** next tests' number 255e : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; shifts - absolute 2561 : a203 ldx #3 2563 : tasl4 set_abs zp1,0 > load_flag 0 2563 : a900 > lda #0 ;allow test to change I > 2565 : 48 > pha ;use stack to load status 2566 : b513 > lda zp1,x ;load to memory 2568 : 8d0302 > sta abst 256b : 28 > plp 256c : 0e0302 asl abst tst_abs rASL,fASL,0 256f : 08 > php ;save flags 2570 : ad0302 > lda abst 2573 : dd2002 > cmp rASL,x ;test result > trap_ne 2576 : d0fe > bne * ;failed not equal (non zero) > 2578 : 68 > pla ;load status > eor_flag 0 2579 : 4930 > eor #0|fao ;invert expected flags > 257b : dd3002 > cmp fASL,x ;test flags > trap_ne 257e : d0fe > bne * ;failed not equal (non zero) > 2580 : ca dex 2581 : 10e0 bpl tasl4 2583 : a203 ldx #3 2585 : tasl5 set_abs zp1,$ff > load_flag $ff 2585 : a9ff > lda #$ff ;allow test to change > 2587 : 48 > pha ;use stack to load status 2588 : b513 > lda zp1,x ;load to memory 258a : 8d0302 > sta abst 258d : 28 > plp 258e : 0e0302 asl abst tst_abs rASL,fASL,$ff-fnzc 2591 : 08 > php ;save flags 2592 : ad0302 > lda abst 2595 : dd2002 > cmp rASL,x ;test result > trap_ne 2598 : d0fe > bne * ;failed not equal (non zero) > 259a : 68 > pla ;load status > eor_flag $ff-fnzc 259b : 497c > eor #$ff-fnzc|fao ;invert expected > 259d : dd3002 > cmp fASL,x ;test flags > trap_ne 25a0 : d0fe > bne * ;failed not equal (non zero) > 25a2 : ca dex 25a3 : 10e0 bpl tasl5 25a5 : a203 ldx #3 25a7 : tlsr4 set_abs zp1,0 > load_flag 0 25a7 : a900 > lda #0 ;allow test to change I > 25a9 : 48 > pha ;use stack to load status 25aa : b513 > lda zp1,x ;load to memory 25ac : 8d0302 > sta abst 25af : 28 > plp 25b0 : 4e0302 lsr abst tst_abs rLSR,fLSR,0 25b3 : 08 > php ;save flags 25b4 : ad0302 > lda abst 25b7 : dd2802 > cmp rLSR,x ;test result > trap_ne 25ba : d0fe > bne * ;failed not equal (non zero) > 25bc : 68 > pla ;load status > eor_flag 0 25bd : 4930 > eor #0|fao ;invert expected flags > 25bf : dd3802 > cmp fLSR,x ;test flags > trap_ne 25c2 : d0fe > bne * ;failed not equal (non zero) > 25c4 : ca dex 25c5 : 10e0 bpl tlsr4 25c7 : a203 ldx #3 25c9 : tlsr5 set_abs zp1,$ff > load_flag $ff 25c9 : a9ff > lda #$ff ;allow test to change > 25cb : 48 > pha ;use stack to load status 25cc : b513 > lda zp1,x ;load to memory 25ce : 8d0302 > sta abst 25d1 : 28 > plp 25d2 : 4e0302 lsr abst tst_abs rLSR,fLSR,$ff-fnzc 25d5 : 08 > php ;save flags 25d6 : ad0302 > lda abst 25d9 : dd2802 > cmp rLSR,x ;test result > trap_ne 25dc : d0fe > bne * ;failed not equal (non zero) > 25de : 68 > pla ;load status > eor_flag $ff-fnzc 25df : 497c > eor #$ff-fnzc|fao ;invert expected > 25e1 : dd3802 > cmp fLSR,x ;test flags > trap_ne 25e4 : d0fe > bne * ;failed not equal (non zero) > 25e6 : ca dex 25e7 : 10e0 bpl tlsr5 25e9 : a203 ldx #3 25eb : trol4 set_abs zp1,0 > load_flag 0 25eb : a900 > lda #0 ;allow test to change I > 25ed : 48 > pha ;use stack to load status 25ee : b513 > lda zp1,x ;load to memory 25f0 : 8d0302 > sta abst 25f3 : 28 > plp 25f4 : 2e0302 rol abst tst_abs rROL,fROL,0 25f7 : 08 > php ;save flags 25f8 : ad0302 > lda abst 25fb : dd2002 > cmp rROL,x ;test result > trap_ne 25fe : d0fe > bne * ;failed not equal (non zero) > 2600 : 68 > pla ;load status > eor_flag 0 2601 : 4930 > eor #0|fao ;invert expected flags > 2603 : dd3002 > cmp fROL,x ;test flags > trap_ne 2606 : d0fe > bne * ;failed not equal (non zero) > 2608 : ca dex 2609 : 10e0 bpl trol4 260b : a203 ldx #3 260d : trol5 set_abs zp1,$ff-fc > load_flag $ff-fc 260d : a9fe > lda #$ff-fc ;allow test to cha > 260f : 48 > pha ;use stack to load status 2610 : b513 > lda zp1,x ;load to memory 2612 : 8d0302 > sta abst 2615 : 28 > plp 2616 : 2e0302 rol abst tst_abs rROL,fROL,$ff-fnzc 2619 : 08 > php ;save flags 261a : ad0302 > lda abst 261d : dd2002 > cmp rROL,x ;test result > trap_ne 2620 : d0fe > bne * ;failed not equal (non zero) > 2622 : 68 > pla ;load status > eor_flag $ff-fnzc 2623 : 497c > eor #$ff-fnzc|fao ;invert expected > 2625 : dd3002 > cmp fROL,x ;test flags > trap_ne 2628 : d0fe > bne * ;failed not equal (non zero) > 262a : ca dex 262b : 10e0 bpl trol5 262d : a203 ldx #3 262f : trolc4 set_abs zp1,fc > load_flag fc 262f : a901 > lda #fc ;allow test to change > 2631 : 48 > pha ;use stack to load status 2632 : b513 > lda zp1,x ;load to memory 2634 : 8d0302 > sta abst 2637 : 28 > plp 2638 : 2e0302 rol abst tst_abs rROLc,fROLc,0 263b : 08 > php ;save flags 263c : ad0302 > lda abst 263f : dd2402 > cmp rROLc,x ;test result > trap_ne 2642 : d0fe > bne * ;failed not equal (non zero) > 2644 : 68 > pla ;load status > eor_flag 0 2645 : 4930 > eor #0|fao ;invert expected flags > 2647 : dd3402 > cmp fROLc,x ;test flags > trap_ne 264a : d0fe > bne * ;failed not equal (non zero) > 264c : ca dex 264d : 10e0 bpl trolc4 264f : a203 ldx #3 2651 : trolc5 set_abs zp1,$ff > load_flag $ff 2651 : a9ff > lda #$ff ;allow test to change > 2653 : 48 > pha ;use stack to load status 2654 : b513 > lda zp1,x ;load to memory 2656 : 8d0302 > sta abst 2659 : 28 > plp 265a : 2e0302 rol abst tst_abs rROLc,fROLc,$ff-fnzc 265d : 08 > php ;save flags 265e : ad0302 > lda abst 2661 : dd2402 > cmp rROLc,x ;test result > trap_ne 2664 : d0fe > bne * ;failed not equal (non zero) > 2666 : 68 > pla ;load status > eor_flag $ff-fnzc 2667 : 497c > eor #$ff-fnzc|fao ;invert expected > 2669 : dd3402 > cmp fROLc,x ;test flags > trap_ne 266c : d0fe > bne * ;failed not equal (non zero) > 266e : ca dex 266f : 10e0 bpl trolc5 2671 : a203 ldx #3 2673 : tror4 set_abs zp1,0 > load_flag 0 2673 : a900 > lda #0 ;allow test to change I > 2675 : 48 > pha ;use stack to load status 2676 : b513 > lda zp1,x ;load to memory 2678 : 8d0302 > sta abst 267b : 28 > plp 267c : 6e0302 ror abst tst_abs rROR,fROR,0 267f : 08 > php ;save flags 2680 : ad0302 > lda abst 2683 : dd2802 > cmp rROR,x ;test result > trap_ne 2686 : d0fe > bne * ;failed not equal (non zero) > 2688 : 68 > pla ;load status > eor_flag 0 2689 : 4930 > eor #0|fao ;invert expected flags > 268b : dd3802 > cmp fROR,x ;test flags > trap_ne 268e : d0fe > bne * ;failed not equal (non zero) > 2690 : ca dex 2691 : 10e0 bpl tror4 2693 : a203 ldx #3 2695 : tror5 set_abs zp1,$ff-fc > load_flag $ff-fc 2695 : a9fe > lda #$ff-fc ;allow test to cha > 2697 : 48 > pha ;use stack to load status 2698 : b513 > lda zp1,x ;load to memory 269a : 8d0302 > sta abst 269d : 28 > plp 269e : 6e0302 ror abst tst_abs rROR,fROR,$ff-fnzc 26a1 : 08 > php ;save flags 26a2 : ad0302 > lda abst 26a5 : dd2802 > cmp rROR,x ;test result > trap_ne 26a8 : d0fe > bne * ;failed not equal (non zero) > 26aa : 68 > pla ;load status > eor_flag $ff-fnzc 26ab : 497c > eor #$ff-fnzc|fao ;invert expected > 26ad : dd3802 > cmp fROR,x ;test flags > trap_ne 26b0 : d0fe > bne * ;failed not equal (non zero) > 26b2 : ca dex 26b3 : 10e0 bpl tror5 26b5 : a203 ldx #3 26b7 : trorc4 set_abs zp1,fc > load_flag fc 26b7 : a901 > lda #fc ;allow test to change > 26b9 : 48 > pha ;use stack to load status 26ba : b513 > lda zp1,x ;load to memory 26bc : 8d0302 > sta abst 26bf : 28 > plp 26c0 : 6e0302 ror abst tst_abs rRORc,fRORc,0 26c3 : 08 > php ;save flags 26c4 : ad0302 > lda abst 26c7 : dd2c02 > cmp rRORc,x ;test result > trap_ne 26ca : d0fe > bne * ;failed not equal (non zero) > 26cc : 68 > pla ;load status > eor_flag 0 26cd : 4930 > eor #0|fao ;invert expected flags > 26cf : dd3c02 > cmp fRORc,x ;test flags > trap_ne 26d2 : d0fe > bne * ;failed not equal (non zero) > 26d4 : ca dex 26d5 : 10e0 bpl trorc4 26d7 : a203 ldx #3 26d9 : trorc5 set_abs zp1,$ff > load_flag $ff 26d9 : a9ff > lda #$ff ;allow test to change > 26db : 48 > pha ;use stack to load status 26dc : b513 > lda zp1,x ;load to memory 26de : 8d0302 > sta abst 26e1 : 28 > plp 26e2 : 6e0302 ror abst tst_abs rRORc,fRORc,$ff-fnzc 26e5 : 08 > php ;save flags 26e6 : ad0302 > lda abst 26e9 : dd2c02 > cmp rRORc,x ;test result > trap_ne 26ec : d0fe > bne * ;failed not equal (non zero) > 26ee : 68 > pla ;load status > eor_flag $ff-fnzc 26ef : 497c > eor #$ff-fnzc|fao ;invert expected > 26f1 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 26f4 : d0fe > bne * ;failed not equal (non zero) > 26f6 : ca dex 26f7 : 10e0 bpl trorc5 next_test 26f9 : ad0002 > lda test_case ;previous test 26fc : c91f > cmp #test_num > trap_ne ;test is out of sequence 26fe : d0fe > bne * ;failed not equal (non zero) > 0020 = >test_num = test_num + 1 2700 : a920 > lda #test_num ;*** next tests' number 2702 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; shifts - zp indexed 2705 : a203 ldx #3 2707 : tasl6 set_zx zp1,0 > load_flag 0 2707 : a900 > lda #0 ;allow test to change I > 2709 : 48 > pha ;use stack to load status 270a : b513 > lda zp1,x ;load to indexed zeropage 270c : 950c > sta zpt,x 270e : 28 > plp 270f : 160c asl zpt,x tst_zx rASL,fASL,0 2711 : 08 > php ;save flags 2712 : b50c > lda zpt,x 2714 : dd2002 > cmp rASL,x ;test result > trap_ne 2717 : d0fe > bne * ;failed not equal (non zero) > 2719 : 68 > pla ;load status > eor_flag 0 271a : 4930 > eor #0|fao ;invert expected flags > 271c : dd3002 > cmp fASL,x ;test flags > trap_ne 271f : d0fe > bne * ;failed not equal (non zero) > 2721 : ca dex 2722 : 10e3 bpl tasl6 2724 : a203 ldx #3 2726 : tasl7 set_zx zp1,$ff > load_flag $ff 2726 : a9ff > lda #$ff ;allow test to change > 2728 : 48 > pha ;use stack to load status 2729 : b513 > lda zp1,x ;load to indexed zeropage 272b : 950c > sta zpt,x 272d : 28 > plp 272e : 160c asl zpt,x tst_zx rASL,fASL,$ff-fnzc 2730 : 08 > php ;save flags 2731 : b50c > lda zpt,x 2733 : dd2002 > cmp rASL,x ;test result > trap_ne 2736 : d0fe > bne * ;failed not equal (non zero) > 2738 : 68 > pla ;load status > eor_flag $ff-fnzc 2739 : 497c > eor #$ff-fnzc|fao ;invert expected > 273b : dd3002 > cmp fASL,x ;test flags > trap_ne 273e : d0fe > bne * ;failed not equal (non zero) > 2740 : ca dex 2741 : 10e3 bpl tasl7 2743 : a203 ldx #3 2745 : tlsr6 set_zx zp1,0 > load_flag 0 2745 : a900 > lda #0 ;allow test to change I > 2747 : 48 > pha ;use stack to load status 2748 : b513 > lda zp1,x ;load to indexed zeropage 274a : 950c > sta zpt,x 274c : 28 > plp 274d : 560c lsr zpt,x tst_zx rLSR,fLSR,0 274f : 08 > php ;save flags 2750 : b50c > lda zpt,x 2752 : dd2802 > cmp rLSR,x ;test result > trap_ne 2755 : d0fe > bne * ;failed not equal (non zero) > 2757 : 68 > pla ;load status > eor_flag 0 2758 : 4930 > eor #0|fao ;invert expected flags > 275a : dd3802 > cmp fLSR,x ;test flags > trap_ne 275d : d0fe > bne * ;failed not equal (non zero) > 275f : ca dex 2760 : 10e3 bpl tlsr6 2762 : a203 ldx #3 2764 : tlsr7 set_zx zp1,$ff > load_flag $ff 2764 : a9ff > lda #$ff ;allow test to change > 2766 : 48 > pha ;use stack to load status 2767 : b513 > lda zp1,x ;load to indexed zeropage 2769 : 950c > sta zpt,x 276b : 28 > plp 276c : 560c lsr zpt,x tst_zx rLSR,fLSR,$ff-fnzc 276e : 08 > php ;save flags 276f : b50c > lda zpt,x 2771 : dd2802 > cmp rLSR,x ;test result > trap_ne 2774 : d0fe > bne * ;failed not equal (non zero) > 2776 : 68 > pla ;load status > eor_flag $ff-fnzc 2777 : 497c > eor #$ff-fnzc|fao ;invert expected > 2779 : dd3802 > cmp fLSR,x ;test flags > trap_ne 277c : d0fe > bne * ;failed not equal (non zero) > 277e : ca dex 277f : 10e3 bpl tlsr7 2781 : a203 ldx #3 2783 : trol6 set_zx zp1,0 > load_flag 0 2783 : a900 > lda #0 ;allow test to change I > 2785 : 48 > pha ;use stack to load status 2786 : b513 > lda zp1,x ;load to indexed zeropage 2788 : 950c > sta zpt,x 278a : 28 > plp 278b : 360c rol zpt,x tst_zx rROL,fROL,0 278d : 08 > php ;save flags 278e : b50c > lda zpt,x 2790 : dd2002 > cmp rROL,x ;test result > trap_ne 2793 : d0fe > bne * ;failed not equal (non zero) > 2795 : 68 > pla ;load status > eor_flag 0 2796 : 4930 > eor #0|fao ;invert expected flags > 2798 : dd3002 > cmp fROL,x ;test flags > trap_ne 279b : d0fe > bne * ;failed not equal (non zero) > 279d : ca dex 279e : 10e3 bpl trol6 27a0 : a203 ldx #3 27a2 : trol7 set_zx zp1,$ff-fc > load_flag $ff-fc 27a2 : a9fe > lda #$ff-fc ;allow test to cha > 27a4 : 48 > pha ;use stack to load status 27a5 : b513 > lda zp1,x ;load to indexed zeropage 27a7 : 950c > sta zpt,x 27a9 : 28 > plp 27aa : 360c rol zpt,x tst_zx rROL,fROL,$ff-fnzc 27ac : 08 > php ;save flags 27ad : b50c > lda zpt,x 27af : dd2002 > cmp rROL,x ;test result > trap_ne 27b2 : d0fe > bne * ;failed not equal (non zero) > 27b4 : 68 > pla ;load status > eor_flag $ff-fnzc 27b5 : 497c > eor #$ff-fnzc|fao ;invert expected > 27b7 : dd3002 > cmp fROL,x ;test flags > trap_ne 27ba : d0fe > bne * ;failed not equal (non zero) > 27bc : ca dex 27bd : 10e3 bpl trol7 27bf : a203 ldx #3 27c1 : trolc6 set_zx zp1,fc > load_flag fc 27c1 : a901 > lda #fc ;allow test to change > 27c3 : 48 > pha ;use stack to load status 27c4 : b513 > lda zp1,x ;load to indexed zeropage 27c6 : 950c > sta zpt,x 27c8 : 28 > plp 27c9 : 360c rol zpt,x tst_zx rROLc,fROLc,0 27cb : 08 > php ;save flags 27cc : b50c > lda zpt,x 27ce : dd2402 > cmp rROLc,x ;test result > trap_ne 27d1 : d0fe > bne * ;failed not equal (non zero) > 27d3 : 68 > pla ;load status > eor_flag 0 27d4 : 4930 > eor #0|fao ;invert expected flags > 27d6 : dd3402 > cmp fROLc,x ;test flags > trap_ne 27d9 : d0fe > bne * ;failed not equal (non zero) > 27db : ca dex 27dc : 10e3 bpl trolc6 27de : a203 ldx #3 27e0 : trolc7 set_zx zp1,$ff > load_flag $ff 27e0 : a9ff > lda #$ff ;allow test to change > 27e2 : 48 > pha ;use stack to load status 27e3 : b513 > lda zp1,x ;load to indexed zeropage 27e5 : 950c > sta zpt,x 27e7 : 28 > plp 27e8 : 360c rol zpt,x tst_zx rROLc,fROLc,$ff-fnzc 27ea : 08 > php ;save flags 27eb : b50c > lda zpt,x 27ed : dd2402 > cmp rROLc,x ;test result > trap_ne 27f0 : d0fe > bne * ;failed not equal (non zero) > 27f2 : 68 > pla ;load status > eor_flag $ff-fnzc 27f3 : 497c > eor #$ff-fnzc|fao ;invert expected > 27f5 : dd3402 > cmp fROLc,x ;test flags > trap_ne 27f8 : d0fe > bne * ;failed not equal (non zero) > 27fa : ca dex 27fb : 10e3 bpl trolc7 27fd : a203 ldx #3 27ff : tror6 set_zx zp1,0 > load_flag 0 27ff : a900 > lda #0 ;allow test to change I > 2801 : 48 > pha ;use stack to load status 2802 : b513 > lda zp1,x ;load to indexed zeropage 2804 : 950c > sta zpt,x 2806 : 28 > plp 2807 : 760c ror zpt,x tst_zx rROR,fROR,0 2809 : 08 > php ;save flags 280a : b50c > lda zpt,x 280c : dd2802 > cmp rROR,x ;test result > trap_ne 280f : d0fe > bne * ;failed not equal (non zero) > 2811 : 68 > pla ;load status > eor_flag 0 2812 : 4930 > eor #0|fao ;invert expected flags > 2814 : dd3802 > cmp fROR,x ;test flags > trap_ne 2817 : d0fe > bne * ;failed not equal (non zero) > 2819 : ca dex 281a : 10e3 bpl tror6 281c : a203 ldx #3 281e : tror7 set_zx zp1,$ff-fc > load_flag $ff-fc 281e : a9fe > lda #$ff-fc ;allow test to cha > 2820 : 48 > pha ;use stack to load status 2821 : b513 > lda zp1,x ;load to indexed zeropage 2823 : 950c > sta zpt,x 2825 : 28 > plp 2826 : 760c ror zpt,x tst_zx rROR,fROR,$ff-fnzc 2828 : 08 > php ;save flags 2829 : b50c > lda zpt,x 282b : dd2802 > cmp rROR,x ;test result > trap_ne 282e : d0fe > bne * ;failed not equal (non zero) > 2830 : 68 > pla ;load status > eor_flag $ff-fnzc 2831 : 497c > eor #$ff-fnzc|fao ;invert expected > 2833 : dd3802 > cmp fROR,x ;test flags > trap_ne 2836 : d0fe > bne * ;failed not equal (non zero) > 2838 : ca dex 2839 : 10e3 bpl tror7 283b : a203 ldx #3 283d : trorc6 set_zx zp1,fc > load_flag fc 283d : a901 > lda #fc ;allow test to change > 283f : 48 > pha ;use stack to load status 2840 : b513 > lda zp1,x ;load to indexed zeropage 2842 : 950c > sta zpt,x 2844 : 28 > plp 2845 : 760c ror zpt,x tst_zx rRORc,fRORc,0 2847 : 08 > php ;save flags 2848 : b50c > lda zpt,x 284a : dd2c02 > cmp rRORc,x ;test result > trap_ne 284d : d0fe > bne * ;failed not equal (non zero) > 284f : 68 > pla ;load status > eor_flag 0 2850 : 4930 > eor #0|fao ;invert expected flags > 2852 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2855 : d0fe > bne * ;failed not equal (non zero) > 2857 : ca dex 2858 : 10e3 bpl trorc6 285a : a203 ldx #3 285c : trorc7 set_zx zp1,$ff > load_flag $ff 285c : a9ff > lda #$ff ;allow test to change > 285e : 48 > pha ;use stack to load status 285f : b513 > lda zp1,x ;load to indexed zeropage 2861 : 950c > sta zpt,x 2863 : 28 > plp 2864 : 760c ror zpt,x tst_zx rRORc,fRORc,$ff-fnzc 2866 : 08 > php ;save flags 2867 : b50c > lda zpt,x 2869 : dd2c02 > cmp rRORc,x ;test result > trap_ne 286c : d0fe > bne * ;failed not equal (non zero) > 286e : 68 > pla ;load status > eor_flag $ff-fnzc 286f : 497c > eor #$ff-fnzc|fao ;invert expected > 2871 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2874 : d0fe > bne * ;failed not equal (non zero) > 2876 : ca dex 2877 : 10e3 bpl trorc7 next_test 2879 : ad0002 > lda test_case ;previous test 287c : c920 > cmp #test_num > trap_ne ;test is out of sequence 287e : d0fe > bne * ;failed not equal (non zero) > 0021 = >test_num = test_num + 1 2880 : a921 > lda #test_num ;*** next tests' number 2882 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; shifts - abs indexed 2885 : a203 ldx #3 2887 : tasl8 set_absx zp1,0 > load_flag 0 2887 : a900 > lda #0 ;allow test to change I > 2889 : 48 > pha ;use stack to load status 288a : b513 > lda zp1,x ;load to indexed memory 288c : 9d0302 > sta abst,x 288f : 28 > plp 2890 : 1e0302 asl abst,x tst_absx rASL,fASL,0 2893 : 08 > php ;save flags 2894 : bd0302 > lda abst,x 2897 : dd2002 > cmp rASL,x ;test result > trap_ne 289a : d0fe > bne * ;failed not equal (non zero) > 289c : 68 > pla ;load status > eor_flag 0 289d : 4930 > eor #0|fao ;invert expected flags > 289f : dd3002 > cmp fASL,x ;test flags > trap_ne 28a2 : d0fe > bne * ;failed not equal (non zero) > 28a4 : ca dex 28a5 : 10e0 bpl tasl8 28a7 : a203 ldx #3 28a9 : tasl9 set_absx zp1,$ff > load_flag $ff 28a9 : a9ff > lda #$ff ;allow test to change > 28ab : 48 > pha ;use stack to load status 28ac : b513 > lda zp1,x ;load to indexed memory 28ae : 9d0302 > sta abst,x 28b1 : 28 > plp 28b2 : 1e0302 asl abst,x tst_absx rASL,fASL,$ff-fnzc 28b5 : 08 > php ;save flags 28b6 : bd0302 > lda abst,x 28b9 : dd2002 > cmp rASL,x ;test result > trap_ne 28bc : d0fe > bne * ;failed not equal (non zero) > 28be : 68 > pla ;load status > eor_flag $ff-fnzc 28bf : 497c > eor #$ff-fnzc|fao ;invert expected > 28c1 : dd3002 > cmp fASL,x ;test flags > trap_ne 28c4 : d0fe > bne * ;failed not equal (non zero) > 28c6 : ca dex 28c7 : 10e0 bpl tasl9 28c9 : a203 ldx #3 28cb : tlsr8 set_absx zp1,0 > load_flag 0 28cb : a900 > lda #0 ;allow test to change I > 28cd : 48 > pha ;use stack to load status 28ce : b513 > lda zp1,x ;load to indexed memory 28d0 : 9d0302 > sta abst,x 28d3 : 28 > plp 28d4 : 5e0302 lsr abst,x tst_absx rLSR,fLSR,0 28d7 : 08 > php ;save flags 28d8 : bd0302 > lda abst,x 28db : dd2802 > cmp rLSR,x ;test result > trap_ne 28de : d0fe > bne * ;failed not equal (non zero) > 28e0 : 68 > pla ;load status > eor_flag 0 28e1 : 4930 > eor #0|fao ;invert expected flags > 28e3 : dd3802 > cmp fLSR,x ;test flags > trap_ne 28e6 : d0fe > bne * ;failed not equal (non zero) > 28e8 : ca dex 28e9 : 10e0 bpl tlsr8 28eb : a203 ldx #3 28ed : tlsr9 set_absx zp1,$ff > load_flag $ff 28ed : a9ff > lda #$ff ;allow test to change > 28ef : 48 > pha ;use stack to load status 28f0 : b513 > lda zp1,x ;load to indexed memory 28f2 : 9d0302 > sta abst,x 28f5 : 28 > plp 28f6 : 5e0302 lsr abst,x tst_absx rLSR,fLSR,$ff-fnzc 28f9 : 08 > php ;save flags 28fa : bd0302 > lda abst,x 28fd : dd2802 > cmp rLSR,x ;test result > trap_ne 2900 : d0fe > bne * ;failed not equal (non zero) > 2902 : 68 > pla ;load status > eor_flag $ff-fnzc 2903 : 497c > eor #$ff-fnzc|fao ;invert expected > 2905 : dd3802 > cmp fLSR,x ;test flags > trap_ne 2908 : d0fe > bne * ;failed not equal (non zero) > 290a : ca dex 290b : 10e0 bpl tlsr9 290d : a203 ldx #3 290f : trol8 set_absx zp1,0 > load_flag 0 290f : a900 > lda #0 ;allow test to change I > 2911 : 48 > pha ;use stack to load status 2912 : b513 > lda zp1,x ;load to indexed memory 2914 : 9d0302 > sta abst,x 2917 : 28 > plp 2918 : 3e0302 rol abst,x tst_absx rROL,fROL,0 291b : 08 > php ;save flags 291c : bd0302 > lda abst,x 291f : dd2002 > cmp rROL,x ;test result > trap_ne 2922 : d0fe > bne * ;failed not equal (non zero) > 2924 : 68 > pla ;load status > eor_flag 0 2925 : 4930 > eor #0|fao ;invert expected flags > 2927 : dd3002 > cmp fROL,x ;test flags > trap_ne 292a : d0fe > bne * ;failed not equal (non zero) > 292c : ca dex 292d : 10e0 bpl trol8 292f : a203 ldx #3 2931 : trol9 set_absx zp1,$ff-fc > load_flag $ff-fc 2931 : a9fe > lda #$ff-fc ;allow test to cha > 2933 : 48 > pha ;use stack to load status 2934 : b513 > lda zp1,x ;load to indexed memory 2936 : 9d0302 > sta abst,x 2939 : 28 > plp 293a : 3e0302 rol abst,x tst_absx rROL,fROL,$ff-fnzc 293d : 08 > php ;save flags 293e : bd0302 > lda abst,x 2941 : dd2002 > cmp rROL,x ;test result > trap_ne 2944 : d0fe > bne * ;failed not equal (non zero) > 2946 : 68 > pla ;load status > eor_flag $ff-fnzc 2947 : 497c > eor #$ff-fnzc|fao ;invert expected > 2949 : dd3002 > cmp fROL,x ;test flags > trap_ne 294c : d0fe > bne * ;failed not equal (non zero) > 294e : ca dex 294f : 10e0 bpl trol9 2951 : a203 ldx #3 2953 : trolc8 set_absx zp1,fc > load_flag fc 2953 : a901 > lda #fc ;allow test to change > 2955 : 48 > pha ;use stack to load status 2956 : b513 > lda zp1,x ;load to indexed memory 2958 : 9d0302 > sta abst,x 295b : 28 > plp 295c : 3e0302 rol abst,x tst_absx rROLc,fROLc,0 295f : 08 > php ;save flags 2960 : bd0302 > lda abst,x 2963 : dd2402 > cmp rROLc,x ;test result > trap_ne 2966 : d0fe > bne * ;failed not equal (non zero) > 2968 : 68 > pla ;load status > eor_flag 0 2969 : 4930 > eor #0|fao ;invert expected flags > 296b : dd3402 > cmp fROLc,x ;test flags > trap_ne 296e : d0fe > bne * ;failed not equal (non zero) > 2970 : ca dex 2971 : 10e0 bpl trolc8 2973 : a203 ldx #3 2975 : trolc9 set_absx zp1,$ff > load_flag $ff 2975 : a9ff > lda #$ff ;allow test to change > 2977 : 48 > pha ;use stack to load status 2978 : b513 > lda zp1,x ;load to indexed memory 297a : 9d0302 > sta abst,x 297d : 28 > plp 297e : 3e0302 rol abst,x tst_absx rROLc,fROLc,$ff-fnzc 2981 : 08 > php ;save flags 2982 : bd0302 > lda abst,x 2985 : dd2402 > cmp rROLc,x ;test result > trap_ne 2988 : d0fe > bne * ;failed not equal (non zero) > 298a : 68 > pla ;load status > eor_flag $ff-fnzc 298b : 497c > eor #$ff-fnzc|fao ;invert expected > 298d : dd3402 > cmp fROLc,x ;test flags > trap_ne 2990 : d0fe > bne * ;failed not equal (non zero) > 2992 : ca dex 2993 : 10e0 bpl trolc9 2995 : a203 ldx #3 2997 : tror8 set_absx zp1,0 > load_flag 0 2997 : a900 > lda #0 ;allow test to change I > 2999 : 48 > pha ;use stack to load status 299a : b513 > lda zp1,x ;load to indexed memory 299c : 9d0302 > sta abst,x 299f : 28 > plp 29a0 : 7e0302 ror abst,x tst_absx rROR,fROR,0 29a3 : 08 > php ;save flags 29a4 : bd0302 > lda abst,x 29a7 : dd2802 > cmp rROR,x ;test result > trap_ne 29aa : d0fe > bne * ;failed not equal (non zero) > 29ac : 68 > pla ;load status > eor_flag 0 29ad : 4930 > eor #0|fao ;invert expected flags > 29af : dd3802 > cmp fROR,x ;test flags > trap_ne 29b2 : d0fe > bne * ;failed not equal (non zero) > 29b4 : ca dex 29b5 : 10e0 bpl tror8 29b7 : a203 ldx #3 29b9 : tror9 set_absx zp1,$ff-fc > load_flag $ff-fc 29b9 : a9fe > lda #$ff-fc ;allow test to cha > 29bb : 48 > pha ;use stack to load status 29bc : b513 > lda zp1,x ;load to indexed memory 29be : 9d0302 > sta abst,x 29c1 : 28 > plp 29c2 : 7e0302 ror abst,x tst_absx rROR,fROR,$ff-fnzc 29c5 : 08 > php ;save flags 29c6 : bd0302 > lda abst,x 29c9 : dd2802 > cmp rROR,x ;test result > trap_ne 29cc : d0fe > bne * ;failed not equal (non zero) > 29ce : 68 > pla ;load status > eor_flag $ff-fnzc 29cf : 497c > eor #$ff-fnzc|fao ;invert expected > 29d1 : dd3802 > cmp fROR,x ;test flags > trap_ne 29d4 : d0fe > bne * ;failed not equal (non zero) > 29d6 : ca dex 29d7 : 10e0 bpl tror9 29d9 : a203 ldx #3 29db : trorc8 set_absx zp1,fc > load_flag fc 29db : a901 > lda #fc ;allow test to change > 29dd : 48 > pha ;use stack to load status 29de : b513 > lda zp1,x ;load to indexed memory 29e0 : 9d0302 > sta abst,x 29e3 : 28 > plp 29e4 : 7e0302 ror abst,x tst_absx rRORc,fRORc,0 29e7 : 08 > php ;save flags 29e8 : bd0302 > lda abst,x 29eb : dd2c02 > cmp rRORc,x ;test result > trap_ne 29ee : d0fe > bne * ;failed not equal (non zero) > 29f0 : 68 > pla ;load status > eor_flag 0 29f1 : 4930 > eor #0|fao ;invert expected flags > 29f3 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 29f6 : d0fe > bne * ;failed not equal (non zero) > 29f8 : ca dex 29f9 : 10e0 bpl trorc8 29fb : a203 ldx #3 29fd : trorc9 set_absx zp1,$ff > load_flag $ff 29fd : a9ff > lda #$ff ;allow test to change > 29ff : 48 > pha ;use stack to load status 2a00 : b513 > lda zp1,x ;load to indexed memory 2a02 : 9d0302 > sta abst,x 2a05 : 28 > plp 2a06 : 7e0302 ror abst,x tst_absx rRORc,fRORc,$ff-fnzc 2a09 : 08 > php ;save flags 2a0a : bd0302 > lda abst,x 2a0d : dd2c02 > cmp rRORc,x ;test result > trap_ne 2a10 : d0fe > bne * ;failed not equal (non zero) > 2a12 : 68 > pla ;load status > eor_flag $ff-fnzc 2a13 : 497c > eor #$ff-fnzc|fao ;invert expected > 2a15 : dd3c02 > cmp fRORc,x ;test flags > trap_ne 2a18 : d0fe > bne * ;failed not equal (non zero) > 2a1a : ca dex 2a1b : 10e0 bpl trorc9 next_test 2a1d : ad0002 > lda test_case ;previous test 2a20 : c921 > cmp #test_num > trap_ne ;test is out of sequence 2a22 : d0fe > bne * ;failed not equal (non zero) > 0022 = >test_num = test_num + 1 2a24 : a922 > lda #test_num ;*** next tests' number 2a26 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; testing memory increment/decrement - INC DEC all add ; zeropage 2a29 : a200 ldx #0 2a2b : a97e lda #$7e 2a2d : 850c sta zpt 2a2f : tinc set_stat 0 > load_flag 0 2a2f : a900 > lda #0 ;allow test to change I > 2a31 : 48 > pha ;use stack to load status 2a32 : 28 > plp 2a33 : e60c inc zpt tst_z rINC,fINC,0 2a35 : 08 > php ;save flags 2a36 : a50c > lda zpt 2a38 : dd4002 > cmp rINC,x ;test result > trap_ne 2a3b : d0fe > bne * ;failed not equal (non zero) > 2a3d : 68 > pla ;load status > eor_flag 0 2a3e : 4930 > eor #0|fao ;invert expected flags > 2a40 : dd4502 > cmp fINC,x ;test flags > trap_ne 2a43 : d0fe > bne * ;failed not equal (non zero) > 2a45 : e8 inx 2a46 : e002 cpx #2 2a48 : d004 bne tinc1 2a4a : a9fe lda #$fe 2a4c : 850c sta zpt 2a4e : e005 tinc1 cpx #5 2a50 : d0dd bne tinc 2a52 : ca dex 2a53 : e60c inc zpt 2a55 : tdec set_stat 0 > load_flag 0 2a55 : a900 > lda #0 ;allow test to change I > 2a57 : 48 > pha ;use stack to load status 2a58 : 28 > plp 2a59 : c60c dec zpt tst_z rINC,fINC,0 2a5b : 08 > php ;save flags 2a5c : a50c > lda zpt 2a5e : dd4002 > 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 > 2a66 : dd4502 > cmp fINC,x ;test flags > trap_ne 2a69 : d0fe > bne * ;failed not equal (non zero) > 2a6b : ca dex 2a6c : 300a bmi tdec1 2a6e : e001 cpx #1 2a70 : d0e3 bne tdec 2a72 : a981 lda #$81 2a74 : 850c sta zpt 2a76 : d0dd bne tdec 2a78 : tdec1 2a78 : a200 ldx #0 2a7a : a97e lda #$7e 2a7c : 850c sta zpt 2a7e : tinc10 set_stat $ff > load_flag $ff 2a7e : a9ff > lda #$ff ;allow test to change > 2a80 : 48 > pha ;use stack to load status 2a81 : 28 > plp 2a82 : e60c inc zpt tst_z rINC,fINC,$ff-fnz 2a84 : 08 > php ;save flags 2a85 : a50c > lda zpt 2a87 : dd4002 > cmp rINC,x ;test result > trap_ne 2a8a : d0fe > bne * ;failed not equal (non zero) > 2a8c : 68 > pla ;load status > eor_flag $ff-fnz 2a8d : 497d > eor #$ff-fnz|fao ;invert expected > 2a8f : dd4502 > cmp fINC,x ;test flags > trap_ne 2a92 : d0fe > bne * ;failed not equal (non zero) > 2a94 : e8 inx 2a95 : e002 cpx #2 2a97 : d004 bne tinc11 2a99 : a9fe lda #$fe 2a9b : 850c sta zpt 2a9d : e005 tinc11 cpx #5 2a9f : d0dd bne tinc10 2aa1 : ca dex 2aa2 : e60c inc zpt 2aa4 : tdec10 set_stat $ff > load_flag $ff 2aa4 : a9ff > lda #$ff ;allow test to change > 2aa6 : 48 > pha ;use stack to load status 2aa7 : 28 > plp 2aa8 : c60c dec zpt tst_z rINC,fINC,$ff-fnz 2aaa : 08 > php ;save flags 2aab : a50c > lda zpt 2aad : dd4002 > 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 > 2ab5 : dd4502 > cmp fINC,x ;test flags > trap_ne 2ab8 : d0fe > bne * ;failed not equal (non zero) > 2aba : ca dex 2abb : 300a bmi tdec11 2abd : e001 cpx #1 2abf : d0e3 bne tdec10 2ac1 : a981 lda #$81 2ac3 : 850c sta zpt 2ac5 : d0dd bne tdec10 2ac7 : tdec11 next_test 2ac7 : ad0002 > lda test_case ;previous test 2aca : c922 > cmp #test_num > trap_ne ;test is out of sequence 2acc : d0fe > bne * ;failed not equal (non zero) > 0023 = >test_num = test_num + 1 2ace : a923 > lda #test_num ;*** next tests' number 2ad0 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; absolute memory 2ad3 : a200 ldx #0 2ad5 : a97e lda #$7e 2ad7 : 8d0302 sta abst 2ada : tinc2 set_stat 0 > load_flag 0 2ada : a900 > lda #0 ;allow test to change I > 2adc : 48 > pha ;use stack to load status 2add : 28 > plp 2ade : ee0302 inc abst tst_abs rINC,fINC,0 2ae1 : 08 > php ;save flags 2ae2 : ad0302 > lda abst 2ae5 : dd4002 > cmp rINC,x ;test result > trap_ne 2ae8 : d0fe > bne * ;failed not equal (non zero) > 2aea : 68 > pla ;load status > eor_flag 0 2aeb : 4930 > eor #0|fao ;invert expected flags > 2aed : dd4502 > cmp fINC,x ;test flags > trap_ne 2af0 : d0fe > bne * ;failed not equal (non zero) > 2af2 : e8 inx 2af3 : e002 cpx #2 2af5 : d005 bne tinc3 2af7 : a9fe lda #$fe 2af9 : 8d0302 sta abst 2afc : e005 tinc3 cpx #5 2afe : d0da bne tinc2 2b00 : ca dex 2b01 : ee0302 inc abst 2b04 : tdec2 set_stat 0 > load_flag 0 2b04 : a900 > lda #0 ;allow test to change I > 2b06 : 48 > pha ;use stack to load status 2b07 : 28 > plp 2b08 : ce0302 dec abst tst_abs rINC,fINC,0 2b0b : 08 > php ;save flags 2b0c : ad0302 > lda abst 2b0f : dd4002 > cmp rINC,x ;test result > trap_ne 2b12 : d0fe > bne * ;failed not equal (non zero) > 2b14 : 68 > pla ;load status > eor_flag 0 2b15 : 4930 > eor #0|fao ;invert expected flags > 2b17 : dd4502 > cmp fINC,x ;test flags > trap_ne 2b1a : d0fe > bne * ;failed not equal (non zero) > 2b1c : ca dex 2b1d : 300b bmi tdec3 2b1f : e001 cpx #1 2b21 : d0e1 bne tdec2 2b23 : a981 lda #$81 2b25 : 8d0302 sta abst 2b28 : d0da bne tdec2 2b2a : tdec3 2b2a : a200 ldx #0 2b2c : a97e lda #$7e 2b2e : 8d0302 sta abst 2b31 : tinc12 set_stat $ff > load_flag $ff 2b31 : a9ff > lda #$ff ;allow test to change > 2b33 : 48 > pha ;use stack to load status 2b34 : 28 > plp 2b35 : ee0302 inc abst tst_abs rINC,fINC,$ff-fnz 2b38 : 08 > php ;save flags 2b39 : ad0302 > lda abst 2b3c : dd4002 > cmp rINC,x ;test result > trap_ne 2b3f : d0fe > bne * ;failed not equal (non zero) > 2b41 : 68 > pla ;load status > eor_flag $ff-fnz 2b42 : 497d > eor #$ff-fnz|fao ;invert expected > 2b44 : dd4502 > cmp fINC,x ;test flags > trap_ne 2b47 : d0fe > bne * ;failed not equal (non zero) > 2b49 : e8 inx 2b4a : e002 cpx #2 2b4c : d005 bne tinc13 2b4e : a9fe lda #$fe 2b50 : 8d0302 sta abst 2b53 : e005 tinc13 cpx #5 2b55 : d0da bne tinc12 2b57 : ca dex 2b58 : ee0302 inc abst 2b5b : tdec12 set_stat $ff > load_flag $ff 2b5b : a9ff > lda #$ff ;allow test to change > 2b5d : 48 > pha ;use stack to load status 2b5e : 28 > plp 2b5f : ce0302 dec abst tst_abs rINC,fINC,$ff-fnz 2b62 : 08 > php ;save flags 2b63 : ad0302 > lda abst 2b66 : dd4002 > cmp rINC,x ;test result > trap_ne 2b69 : d0fe > bne * ;failed not equal (non zero) > 2b6b : 68 > pla ;load status > eor_flag $ff-fnz 2b6c : 497d > eor #$ff-fnz|fao ;invert expected > 2b6e : dd4502 > cmp fINC,x ;test flags > trap_ne 2b71 : d0fe > bne * ;failed not equal (non zero) > 2b73 : ca dex 2b74 : 300b bmi tdec13 2b76 : e001 cpx #1 2b78 : d0e1 bne tdec12 2b7a : a981 lda #$81 2b7c : 8d0302 sta abst 2b7f : d0da bne tdec12 2b81 : tdec13 next_test 2b81 : ad0002 > lda test_case ;previous test 2b84 : c923 > cmp #test_num > trap_ne ;test is out of sequence 2b86 : d0fe > bne * ;failed not equal (non zero) > 0024 = >test_num = test_num + 1 2b88 : a924 > lda #test_num ;*** next tests' number 2b8a : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; zeropage indexed 2b8d : a200 ldx #0 2b8f : a97e lda #$7e 2b91 : 950c tinc4 sta zpt,x set_stat 0 > load_flag 0 2b93 : a900 > lda #0 ;allow test to change I > 2b95 : 48 > pha ;use stack to load status 2b96 : 28 > plp 2b97 : f60c inc zpt,x tst_zx rINC,fINC,0 2b99 : 08 > php ;save flags 2b9a : b50c > lda zpt,x 2b9c : dd4002 > cmp rINC,x ;test result > trap_ne 2b9f : d0fe > bne * ;failed not equal (non zero) > 2ba1 : 68 > pla ;load status > eor_flag 0 2ba2 : 4930 > eor #0|fao ;invert expected flags > 2ba4 : dd4502 > cmp fINC,x ;test flags > trap_ne 2ba7 : d0fe > bne * ;failed not equal (non zero) > 2ba9 : b50c lda zpt,x 2bab : e8 inx 2bac : e002 cpx #2 2bae : d002 bne tinc5 2bb0 : a9fe lda #$fe 2bb2 : e005 tinc5 cpx #5 2bb4 : d0db bne tinc4 2bb6 : ca dex 2bb7 : a902 lda #2 2bb9 : 950c tdec4 sta zpt,x set_stat 0 > load_flag 0 2bbb : a900 > lda #0 ;allow test to change I > 2bbd : 48 > pha ;use stack to load status 2bbe : 28 > plp 2bbf : d60c dec zpt,x tst_zx rINC,fINC,0 2bc1 : 08 > php ;save flags 2bc2 : b50c > lda zpt,x 2bc4 : dd4002 > cmp rINC,x ;test result > trap_ne 2bc7 : d0fe > bne * ;failed not equal (non zero) > 2bc9 : 68 > pla ;load status > eor_flag 0 2bca : 4930 > eor #0|fao ;invert expected flags > 2bcc : dd4502 > cmp fINC,x ;test flags > trap_ne 2bcf : d0fe > bne * ;failed not equal (non zero) > 2bd1 : b50c lda zpt,x 2bd3 : ca dex 2bd4 : 3008 bmi tdec5 2bd6 : e001 cpx #1 2bd8 : d0df bne tdec4 2bda : a981 lda #$81 2bdc : d0db bne tdec4 2bde : tdec5 2bde : a200 ldx #0 2be0 : a97e lda #$7e 2be2 : 950c tinc14 sta zpt,x set_stat $ff > load_flag $ff 2be4 : a9ff > lda #$ff ;allow test to change > 2be6 : 48 > pha ;use stack to load status 2be7 : 28 > plp 2be8 : f60c inc zpt,x tst_zx rINC,fINC,$ff-fnz 2bea : 08 > php ;save flags 2beb : b50c > lda zpt,x 2bed : dd4002 > cmp rINC,x ;test result > trap_ne 2bf0 : d0fe > bne * ;failed not equal (non zero) > 2bf2 : 68 > pla ;load status > eor_flag $ff-fnz 2bf3 : 497d > eor #$ff-fnz|fao ;invert expected > 2bf5 : dd4502 > cmp fINC,x ;test flags > trap_ne 2bf8 : d0fe > bne * ;failed not equal (non zero) > 2bfa : b50c lda zpt,x 2bfc : e8 inx 2bfd : e002 cpx #2 2bff : d002 bne tinc15 2c01 : a9fe lda #$fe 2c03 : e005 tinc15 cpx #5 2c05 : d0db bne tinc14 2c07 : ca dex 2c08 : a902 lda #2 2c0a : 950c tdec14 sta zpt,x set_stat $ff > load_flag $ff 2c0c : a9ff > lda #$ff ;allow test to change > 2c0e : 48 > pha ;use stack to load status 2c0f : 28 > plp 2c10 : d60c dec zpt,x tst_zx rINC,fINC,$ff-fnz 2c12 : 08 > php ;save flags 2c13 : b50c > lda zpt,x 2c15 : dd4002 > cmp rINC,x ;test result > trap_ne 2c18 : d0fe > bne * ;failed not equal (non zero) > 2c1a : 68 > pla ;load status > eor_flag $ff-fnz 2c1b : 497d > eor #$ff-fnz|fao ;invert expected > 2c1d : dd4502 > cmp fINC,x ;test flags > trap_ne 2c20 : d0fe > bne * ;failed not equal (non zero) > 2c22 : b50c lda zpt,x 2c24 : ca dex 2c25 : 3008 bmi tdec15 2c27 : e001 cpx #1 2c29 : d0df bne tdec14 2c2b : a981 lda #$81 2c2d : d0db bne tdec14 2c2f : tdec15 next_test 2c2f : ad0002 > lda test_case ;previous test 2c32 : c924 > cmp #test_num > trap_ne ;test is out of sequence 2c34 : d0fe > bne * ;failed not equal (non zero) > 0025 = >test_num = test_num + 1 2c36 : a925 > lda #test_num ;*** next tests' number 2c38 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; memory indexed 2c3b : a200 ldx #0 2c3d : a97e lda #$7e 2c3f : 9d0302 tinc6 sta abst,x set_stat 0 > load_flag 0 2c42 : a900 > lda #0 ;allow test to change I > 2c44 : 48 > pha ;use stack to load status 2c45 : 28 > plp 2c46 : fe0302 inc abst,x tst_absx rINC,fINC,0 2c49 : 08 > php ;save flags 2c4a : bd0302 > lda abst,x 2c4d : dd4002 > cmp rINC,x ;test result > trap_ne 2c50 : d0fe > bne * ;failed not equal (non zero) > 2c52 : 68 > pla ;load status > eor_flag 0 2c53 : 4930 > eor #0|fao ;invert expected flags > 2c55 : dd4502 > cmp fINC,x ;test flags > trap_ne 2c58 : d0fe > bne * ;failed not equal (non zero) > 2c5a : bd0302 lda abst,x 2c5d : e8 inx 2c5e : e002 cpx #2 2c60 : d002 bne tinc7 2c62 : a9fe lda #$fe 2c64 : e005 tinc7 cpx #5 2c66 : d0d7 bne tinc6 2c68 : ca dex 2c69 : a902 lda #2 2c6b : 9d0302 tdec6 sta abst,x set_stat 0 > load_flag 0 2c6e : a900 > lda #0 ;allow test to change I > 2c70 : 48 > pha ;use stack to load status 2c71 : 28 > plp 2c72 : de0302 dec abst,x tst_absx rINC,fINC,0 2c75 : 08 > php ;save flags 2c76 : bd0302 > lda abst,x 2c79 : dd4002 > cmp rINC,x ;test result > trap_ne 2c7c : d0fe > bne * ;failed not equal (non zero) > 2c7e : 68 > pla ;load status > eor_flag 0 2c7f : 4930 > eor #0|fao ;invert expected flags > 2c81 : dd4502 > cmp fINC,x ;test flags > trap_ne 2c84 : d0fe > bne * ;failed not equal (non zero) > 2c86 : bd0302 lda abst,x 2c89 : ca dex 2c8a : 3008 bmi tdec7 2c8c : e001 cpx #1 2c8e : d0db bne tdec6 2c90 : a981 lda #$81 2c92 : d0d7 bne tdec6 2c94 : tdec7 2c94 : a200 ldx #0 2c96 : a97e lda #$7e 2c98 : 9d0302 tinc16 sta abst,x set_stat $ff > load_flag $ff 2c9b : a9ff > lda #$ff ;allow test to change > 2c9d : 48 > pha ;use stack to load status 2c9e : 28 > plp 2c9f : fe0302 inc abst,x tst_absx rINC,fINC,$ff-fnz 2ca2 : 08 > php ;save flags 2ca3 : bd0302 > lda abst,x 2ca6 : dd4002 > cmp rINC,x ;test result > trap_ne 2ca9 : d0fe > bne * ;failed not equal (non zero) > 2cab : 68 > pla ;load status > eor_flag $ff-fnz 2cac : 497d > eor #$ff-fnz|fao ;invert expected > 2cae : dd4502 > cmp fINC,x ;test flags > trap_ne 2cb1 : d0fe > bne * ;failed not equal (non zero) > 2cb3 : bd0302 lda abst,x 2cb6 : e8 inx 2cb7 : e002 cpx #2 2cb9 : d002 bne tinc17 2cbb : a9fe lda #$fe 2cbd : e005 tinc17 cpx #5 2cbf : d0d7 bne tinc16 2cc1 : ca dex 2cc2 : a902 lda #2 2cc4 : 9d0302 tdec16 sta abst,x set_stat $ff > load_flag $ff 2cc7 : a9ff > lda #$ff ;allow test to change > 2cc9 : 48 > pha ;use stack to load status 2cca : 28 > plp 2ccb : de0302 dec abst,x tst_absx rINC,fINC,$ff-fnz 2cce : 08 > php ;save flags 2ccf : bd0302 > lda abst,x 2cd2 : dd4002 > cmp rINC,x ;test result > trap_ne 2cd5 : d0fe > bne * ;failed not equal (non zero) > 2cd7 : 68 > pla ;load status > eor_flag $ff-fnz 2cd8 : 497d > eor #$ff-fnz|fao ;invert expected > 2cda : dd4502 > cmp fINC,x ;test flags > trap_ne 2cdd : d0fe > bne * ;failed not equal (non zero) > 2cdf : bd0302 lda abst,x 2ce2 : ca dex 2ce3 : 3008 bmi tdec17 2ce5 : e001 cpx #1 2ce7 : d0db bne tdec16 2ce9 : a981 lda #$81 2ceb : d0d7 bne tdec16 2ced : tdec17 next_test 2ced : ad0002 > lda test_case ;previous test 2cf0 : c925 > cmp #test_num > trap_ne ;test is out of sequence 2cf2 : d0fe > bne * ;failed not equal (non zero) > 0026 = >test_num = test_num + 1 2cf4 : a926 > lda #test_num ;*** next tests' number 2cf6 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; testing logical instructions - AND EOR ORA all addre ; AND 2cf9 : a203 ldx #3 ;immediate 2cfb : b51c tand lda zpAN,x 2cfd : 8d0902 sta ex_andi+1 ;set AND # operand set_ax absANa,0 > load_flag 0 2d00 : a900 > lda #0 ;allow test to change I > 2d02 : 48 > pha ;use stack to load status 2d03 : bd5a02 > lda absANa,x ;precharge accu 2d06 : 28 > plp 2d07 : 200802 jsr ex_andi ;execute AND # in RAM tst_ax absrlo,absflo,0 2d0a : 08 > php ;save flags 2d0b : dd6202 > cmp absrlo,x ;test result > trap_ne 2d0e : d0fe > bne * ;failed not equal (non zero) > 2d10 : 68 > pla ;load status > eor_flag 0 2d11 : 4930 > eor #0|fao ;invert expected flags > 2d13 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2d16 : d0fe > bne * ;failed not equal (non zero) > 2d18 : ca dex 2d19 : 10e0 bpl tand 2d1b : a203 ldx #3 2d1d : b51c tand1 lda zpAN,x 2d1f : 8d0902 sta ex_andi+1 ;set AND # operand set_ax absANa,$ff > load_flag $ff 2d22 : a9ff > lda #$ff ;allow test to change > 2d24 : 48 > pha ;use stack to load status 2d25 : bd5a02 > lda absANa,x ;precharge accu 2d28 : 28 > plp 2d29 : 200802 jsr ex_andi ;execute AND # in RAM tst_ax absrlo,absflo,$ff-fnz 2d2c : 08 > php ;save flags 2d2d : dd6202 > cmp absrlo,x ;test result > trap_ne 2d30 : d0fe > bne * ;failed not equal (non zero) > 2d32 : 68 > pla ;load status > eor_flag $ff-fnz 2d33 : 497d > eor #$ff-fnz|fao ;invert expected > 2d35 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2d38 : d0fe > bne * ;failed not equal (non zero) > 2d3a : ca dex 2d3b : 10e0 bpl tand1 2d3d : a203 ldx #3 ;zp 2d3f : b51c tand2 lda zpAN,x 2d41 : 850c sta zpt set_ax absANa,0 > load_flag 0 2d43 : a900 > lda #0 ;allow test to change I > 2d45 : 48 > pha ;use stack to load status 2d46 : bd5a02 > lda absANa,x ;precharge accu 2d49 : 28 > plp 2d4a : 250c and zpt tst_ax absrlo,absflo,0 2d4c : 08 > php ;save flags 2d4d : dd6202 > cmp absrlo,x ;test result > trap_ne 2d50 : d0fe > bne * ;failed not equal (non zero) > 2d52 : 68 > pla ;load status > eor_flag 0 2d53 : 4930 > eor #0|fao ;invert expected flags > 2d55 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2d58 : d0fe > bne * ;failed not equal (non zero) > 2d5a : ca dex 2d5b : 10e2 bpl tand2 2d5d : a203 ldx #3 2d5f : b51c tand3 lda zpAN,x 2d61 : 850c sta zpt set_ax absANa,$ff > load_flag $ff 2d63 : a9ff > lda #$ff ;allow test to change > 2d65 : 48 > pha ;use stack to load status 2d66 : bd5a02 > lda absANa,x ;precharge accu 2d69 : 28 > plp 2d6a : 250c and zpt tst_ax absrlo,absflo,$ff-fnz 2d6c : 08 > php ;save flags 2d6d : dd6202 > cmp absrlo,x ;test result > trap_ne 2d70 : d0fe > bne * ;failed not equal (non zero) > 2d72 : 68 > pla ;load status > eor_flag $ff-fnz 2d73 : 497d > eor #$ff-fnz|fao ;invert expected > 2d75 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2d78 : d0fe > bne * ;failed not equal (non zero) > 2d7a : ca dex 2d7b : 10e2 bpl tand3 2d7d : a203 ldx #3 ;abs 2d7f : b51c tand4 lda zpAN,x 2d81 : 8d0302 sta abst set_ax absANa,0 > load_flag 0 2d84 : a900 > lda #0 ;allow test to change I > 2d86 : 48 > pha ;use stack to load status 2d87 : bd5a02 > lda absANa,x ;precharge accu 2d8a : 28 > plp 2d8b : 2d0302 and abst tst_ax absrlo,absflo,0 2d8e : 08 > php ;save flags 2d8f : dd6202 > cmp absrlo,x ;test result > trap_ne 2d92 : d0fe > bne * ;failed not equal (non zero) > 2d94 : 68 > pla ;load status > eor_flag 0 2d95 : 4930 > eor #0|fao ;invert expected flags > 2d97 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2d9a : d0fe > bne * ;failed not equal (non zero) > 2d9c : ca dex 2d9d : 10e0 bpl tand4 2d9f : a203 ldx #3 2da1 : b51c tand5 lda zpAN,x 2da3 : 8d0302 sta abst set_ax absANa,$ff > load_flag $ff 2da6 : a9ff > lda #$ff ;allow test to change > 2da8 : 48 > pha ;use stack to load status 2da9 : bd5a02 > lda absANa,x ;precharge accu 2dac : 28 > plp 2dad : 2d0302 and abst tst_ax absrlo,absflo,$ff-fnz 2db0 : 08 > php ;save flags 2db1 : dd6202 > cmp absrlo,x ;test result > trap_ne 2db4 : d0fe > bne * ;failed not equal (non zero) > 2db6 : 68 > pla ;load status > eor_flag $ff-fnz 2db7 : 497d > eor #$ff-fnz|fao ;invert expected > 2db9 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2dbc : d0fe > bne * ;failed not equal (non zero) > 2dbe : ca dex 2dbf : 1002 bpl tand6 2dc1 : a203 ldx #3 ;zp,x 2dc3 : tand6 set_ax absANa,0 > load_flag 0 2dc3 : a900 > lda #0 ;allow test to change I > 2dc5 : 48 > pha ;use stack to load status 2dc6 : bd5a02 > lda absANa,x ;precharge accu 2dc9 : 28 > plp 2dca : 351c and zpAN,x tst_ax absrlo,absflo,0 2dcc : 08 > php ;save flags 2dcd : dd6202 > cmp absrlo,x ;test result > trap_ne 2dd0 : d0fe > bne * ;failed not equal (non zero) > 2dd2 : 68 > pla ;load status > eor_flag 0 2dd3 : 4930 > eor #0|fao ;invert expected flags > 2dd5 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2dd8 : d0fe > bne * ;failed not equal (non zero) > 2dda : ca dex 2ddb : 10e6 bpl tand6 2ddd : a203 ldx #3 2ddf : tand7 set_ax absANa,$ff > load_flag $ff 2ddf : a9ff > lda #$ff ;allow test to change > 2de1 : 48 > pha ;use stack to load status 2de2 : bd5a02 > lda absANa,x ;precharge accu 2de5 : 28 > plp 2de6 : 351c and zpAN,x tst_ax absrlo,absflo,$ff-fnz 2de8 : 08 > php ;save flags 2de9 : dd6202 > cmp absrlo,x ;test result > trap_ne 2dec : d0fe > bne * ;failed not equal (non zero) > 2dee : 68 > pla ;load status > eor_flag $ff-fnz 2def : 497d > eor #$ff-fnz|fao ;invert expected > 2df1 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2df4 : d0fe > bne * ;failed not equal (non zero) > 2df6 : ca dex 2df7 : 10e6 bpl tand7 2df9 : a203 ldx #3 ;abs,x 2dfb : tand8 set_ax absANa,0 > load_flag 0 2dfb : a900 > lda #0 ;allow test to change I > 2dfd : 48 > pha ;use stack to load status 2dfe : bd5a02 > lda absANa,x ;precharge accu 2e01 : 28 > plp 2e02 : 3d4e02 and absAN,x tst_ax absrlo,absflo,0 2e05 : 08 > php ;save flags 2e06 : dd6202 > cmp absrlo,x ;test result > trap_ne 2e09 : d0fe > bne * ;failed not equal (non zero) > 2e0b : 68 > pla ;load status > eor_flag 0 2e0c : 4930 > eor #0|fao ;invert expected flags > 2e0e : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2e11 : d0fe > bne * ;failed not equal (non zero) > 2e13 : ca dex 2e14 : 10e5 bpl tand8 2e16 : a203 ldx #3 2e18 : tand9 set_ax absANa,$ff > load_flag $ff 2e18 : a9ff > lda #$ff ;allow test to change > 2e1a : 48 > pha ;use stack to load status 2e1b : bd5a02 > lda absANa,x ;precharge accu 2e1e : 28 > plp 2e1f : 3d4e02 and absAN,x tst_ax absrlo,absflo,$ff-fnz 2e22 : 08 > php ;save flags 2e23 : dd6202 > cmp absrlo,x ;test result > trap_ne 2e26 : d0fe > bne * ;failed not equal (non zero) > 2e28 : 68 > pla ;load status > eor_flag $ff-fnz 2e29 : 497d > eor #$ff-fnz|fao ;invert expected > 2e2b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2e2e : d0fe > bne * ;failed not equal (non zero) > 2e30 : ca dex 2e31 : 10e5 bpl tand9 2e33 : a003 ldy #3 ;abs,y 2e35 : tand10 set_ay absANa,0 > load_flag 0 2e35 : a900 > lda #0 ;allow test to change I > 2e37 : 48 > pha ;use stack to load status 2e38 : b95a02 > lda absANa,y ;precharge accu 2e3b : 28 > plp 2e3c : 394e02 and absAN,y tst_ay absrlo,absflo,0 2e3f : 08 > php ;save flags 2e40 : d96202 > cmp absrlo,y ;test result > trap_ne ; 2e43 : d0fe > bne * ;failed not equal (non zero) > 2e45 : 68 > pla ;load status > eor_flag 0 2e46 : 4930 > eor #0|fao ;invert expected flags > 2e48 : d96602 > cmp absflo,y ;test flags > trap_ne 2e4b : d0fe > bne * ;failed not equal (non zero) > 2e4d : 88 dey 2e4e : 10e5 bpl tand10 2e50 : a003 ldy #3 2e52 : tand11 set_ay absANa,$ff > load_flag $ff 2e52 : a9ff > lda #$ff ;allow test to change > 2e54 : 48 > pha ;use stack to load status 2e55 : b95a02 > lda absANa,y ;precharge accu 2e58 : 28 > plp 2e59 : 394e02 and absAN,y tst_ay absrlo,absflo,$ff-fnz 2e5c : 08 > php ;save flags 2e5d : d96202 > cmp absrlo,y ;test result > trap_ne ; 2e60 : d0fe > bne * ;failed not equal (non zero) > 2e62 : 68 > pla ;load status > eor_flag $ff-fnz 2e63 : 497d > eor #$ff-fnz|fao ;invert expected > 2e65 : d96602 > cmp absflo,y ;test flags > trap_ne 2e68 : d0fe > bne * ;failed not equal (non zero) > 2e6a : 88 dey 2e6b : 10e5 bpl tand11 2e6d : a206 ldx #6 ;(zp,x) 2e6f : a003 ldy #3 2e71 : tand12 set_ay absANa,0 > load_flag 0 2e71 : a900 > lda #0 ;allow test to change I > 2e73 : 48 > pha ;use stack to load status 2e74 : b95a02 > lda absANa,y ;precharge accu 2e77 : 28 > plp 2e78 : 213a and (indAN,x) tst_ay absrlo,absflo,0 2e7a : 08 > php ;save flags 2e7b : d96202 > cmp absrlo,y ;test result > trap_ne ; 2e7e : d0fe > bne * ;failed not equal (non zero) > 2e80 : 68 > pla ;load status > eor_flag 0 2e81 : 4930 > eor #0|fao ;invert expected flags > 2e83 : d96602 > cmp absflo,y ;test flags > trap_ne 2e86 : d0fe > bne * ;failed not equal (non zero) > 2e88 : ca dex 2e89 : ca dex 2e8a : 88 dey 2e8b : 10e4 bpl tand12 2e8d : a206 ldx #6 2e8f : a003 ldy #3 2e91 : tand13 set_ay absANa,$ff > load_flag $ff 2e91 : a9ff > lda #$ff ;allow test to change > 2e93 : 48 > pha ;use stack to load status 2e94 : b95a02 > lda absANa,y ;precharge accu 2e97 : 28 > plp 2e98 : 213a and (indAN,x) tst_ay absrlo,absflo,$ff-fnz 2e9a : 08 > php ;save flags 2e9b : d96202 > cmp absrlo,y ;test result > trap_ne ; 2e9e : d0fe > bne * ;failed not equal (non zero) > 2ea0 : 68 > pla ;load status > eor_flag $ff-fnz 2ea1 : 497d > eor #$ff-fnz|fao ;invert expected > 2ea3 : d96602 > cmp absflo,y ;test flags > trap_ne 2ea6 : d0fe > bne * ;failed not equal (non zero) > 2ea8 : ca dex 2ea9 : ca dex 2eaa : 88 dey 2eab : 10e4 bpl tand13 2ead : a003 ldy #3 ;(zp),y 2eaf : tand14 set_ay absANa,0 > load_flag 0 2eaf : a900 > lda #0 ;allow test to change I > 2eb1 : 48 > pha ;use stack to load status 2eb2 : b95a02 > lda absANa,y ;precharge accu 2eb5 : 28 > plp 2eb6 : 313a and (indAN),y tst_ay absrlo,absflo,0 2eb8 : 08 > php ;save flags 2eb9 : d96202 > cmp absrlo,y ;test result > trap_ne ; 2ebc : d0fe > bne * ;failed not equal (non zero) > 2ebe : 68 > pla ;load status > eor_flag 0 2ebf : 4930 > eor #0|fao ;invert expected flags > 2ec1 : d96602 > cmp absflo,y ;test flags > trap_ne 2ec4 : d0fe > bne * ;failed not equal (non zero) > 2ec6 : 88 dey 2ec7 : 10e6 bpl tand14 2ec9 : a003 ldy #3 2ecb : tand15 set_ay absANa,$ff > load_flag $ff 2ecb : a9ff > lda #$ff ;allow test to change > 2ecd : 48 > pha ;use stack to load status 2ece : b95a02 > lda absANa,y ;precharge accu 2ed1 : 28 > plp 2ed2 : 313a and (indAN),y tst_ay absrlo,absflo,$ff-fnz 2ed4 : 08 > php ;save flags 2ed5 : d96202 > cmp absrlo,y ;test result > trap_ne ; 2ed8 : d0fe > bne * ;failed not equal (non zero) > 2eda : 68 > pla ;load status > eor_flag $ff-fnz 2edb : 497d > eor #$ff-fnz|fao ;invert expected > 2edd : d96602 > cmp absflo,y ;test flags > trap_ne 2ee0 : d0fe > bne * ;failed not equal (non zero) > 2ee2 : 88 dey 2ee3 : 10e6 bpl tand15 next_test 2ee5 : ad0002 > lda test_case ;previous test 2ee8 : c926 > cmp #test_num > trap_ne ;test is out of sequence 2eea : d0fe > bne * ;failed not equal (non zero) > 0027 = >test_num = test_num + 1 2eec : a927 > lda #test_num ;*** next tests' number 2eee : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; EOR 2ef1 : a203 ldx #3 ;immediate - self modifying co 2ef3 : b520 teor lda zpEO,x 2ef5 : 8d0c02 sta ex_eori+1 ;set EOR # operand set_ax absEOa,0 > load_flag 0 2ef8 : a900 > lda #0 ;allow test to change I > 2efa : 48 > pha ;use stack to load status 2efb : bd5e02 > lda absEOa,x ;precharge accu 2efe : 28 > plp 2eff : 200b02 jsr ex_eori ;execute EOR # in RAM tst_ax absrlo,absflo,0 2f02 : 08 > php ;save flags 2f03 : dd6202 > cmp absrlo,x ;test result > trap_ne 2f06 : d0fe > bne * ;failed not equal (non zero) > 2f08 : 68 > pla ;load status > eor_flag 0 2f09 : 4930 > eor #0|fao ;invert expected flags > 2f0b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2f0e : d0fe > bne * ;failed not equal (non zero) > 2f10 : ca dex 2f11 : 10e0 bpl teor 2f13 : a203 ldx #3 2f15 : b520 teor1 lda zpEO,x 2f17 : 8d0c02 sta ex_eori+1 ;set EOR # operand set_ax absEOa,$ff > load_flag $ff 2f1a : a9ff > lda #$ff ;allow test to change > 2f1c : 48 > pha ;use stack to load status 2f1d : bd5e02 > lda absEOa,x ;precharge accu 2f20 : 28 > plp 2f21 : 200b02 jsr ex_eori ;execute EOR # in RAM tst_ax absrlo,absflo,$ff-fnz 2f24 : 08 > php ;save flags 2f25 : dd6202 > cmp absrlo,x ;test result > trap_ne 2f28 : d0fe > bne * ;failed not equal (non zero) > 2f2a : 68 > pla ;load status > eor_flag $ff-fnz 2f2b : 497d > eor #$ff-fnz|fao ;invert expected > 2f2d : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2f30 : d0fe > bne * ;failed not equal (non zero) > 2f32 : ca dex 2f33 : 10e0 bpl teor1 2f35 : a203 ldx #3 ;zp 2f37 : b520 teor2 lda zpEO,x 2f39 : 850c sta zpt set_ax absEOa,0 > load_flag 0 2f3b : a900 > lda #0 ;allow test to change I > 2f3d : 48 > pha ;use stack to load status 2f3e : bd5e02 > lda absEOa,x ;precharge accu 2f41 : 28 > plp 2f42 : 450c eor zpt tst_ax absrlo,absflo,0 2f44 : 08 > php ;save flags 2f45 : dd6202 > cmp absrlo,x ;test result > trap_ne 2f48 : d0fe > bne * ;failed not equal (non zero) > 2f4a : 68 > pla ;load status > eor_flag 0 2f4b : 4930 > eor #0|fao ;invert expected flags > 2f4d : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2f50 : d0fe > bne * ;failed not equal (non zero) > 2f52 : ca dex 2f53 : 10e2 bpl teor2 2f55 : a203 ldx #3 2f57 : b520 teor3 lda zpEO,x 2f59 : 850c sta zpt set_ax absEOa,$ff > load_flag $ff 2f5b : a9ff > lda #$ff ;allow test to change > 2f5d : 48 > pha ;use stack to load status 2f5e : bd5e02 > lda absEOa,x ;precharge accu 2f61 : 28 > plp 2f62 : 450c eor zpt tst_ax absrlo,absflo,$ff-fnz 2f64 : 08 > php ;save flags 2f65 : dd6202 > cmp absrlo,x ;test result > trap_ne 2f68 : d0fe > bne * ;failed not equal (non zero) > 2f6a : 68 > pla ;load status > eor_flag $ff-fnz 2f6b : 497d > eor #$ff-fnz|fao ;invert expected > 2f6d : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2f70 : d0fe > bne * ;failed not equal (non zero) > 2f72 : ca dex 2f73 : 10e2 bpl teor3 2f75 : a203 ldx #3 ;abs 2f77 : b520 teor4 lda zpEO,x 2f79 : 8d0302 sta abst set_ax absEOa,0 > load_flag 0 2f7c : a900 > lda #0 ;allow test to change I > 2f7e : 48 > pha ;use stack to load status 2f7f : bd5e02 > lda absEOa,x ;precharge accu 2f82 : 28 > plp 2f83 : 4d0302 eor abst tst_ax absrlo,absflo,0 2f86 : 08 > php ;save flags 2f87 : dd6202 > cmp absrlo,x ;test result > trap_ne 2f8a : d0fe > bne * ;failed not equal (non zero) > 2f8c : 68 > pla ;load status > eor_flag 0 2f8d : 4930 > eor #0|fao ;invert expected flags > 2f8f : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2f92 : d0fe > bne * ;failed not equal (non zero) > 2f94 : ca dex 2f95 : 10e0 bpl teor4 2f97 : a203 ldx #3 2f99 : b520 teor5 lda zpEO,x 2f9b : 8d0302 sta abst set_ax absEOa,$ff > load_flag $ff 2f9e : a9ff > lda #$ff ;allow test to change > 2fa0 : 48 > pha ;use stack to load status 2fa1 : bd5e02 > lda absEOa,x ;precharge accu 2fa4 : 28 > plp 2fa5 : 4d0302 eor abst tst_ax absrlo,absflo,$ff-fnz 2fa8 : 08 > php ;save flags 2fa9 : dd6202 > cmp absrlo,x ;test result > trap_ne 2fac : d0fe > bne * ;failed not equal (non zero) > 2fae : 68 > pla ;load status > eor_flag $ff-fnz 2faf : 497d > eor #$ff-fnz|fao ;invert expected > 2fb1 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2fb4 : d0fe > bne * ;failed not equal (non zero) > 2fb6 : ca dex 2fb7 : 1002 bpl teor6 2fb9 : a203 ldx #3 ;zp,x 2fbb : teor6 set_ax absEOa,0 > load_flag 0 2fbb : a900 > lda #0 ;allow test to change I > 2fbd : 48 > pha ;use stack to load status 2fbe : bd5e02 > lda absEOa,x ;precharge accu 2fc1 : 28 > plp 2fc2 : 5520 eor zpEO,x tst_ax absrlo,absflo,0 2fc4 : 08 > php ;save flags 2fc5 : dd6202 > cmp absrlo,x ;test result > trap_ne 2fc8 : d0fe > bne * ;failed not equal (non zero) > 2fca : 68 > pla ;load status > eor_flag 0 2fcb : 4930 > eor #0|fao ;invert expected flags > 2fcd : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2fd0 : d0fe > bne * ;failed not equal (non zero) > 2fd2 : ca dex 2fd3 : 10e6 bpl teor6 2fd5 : a203 ldx #3 2fd7 : teor7 set_ax absEOa,$ff > load_flag $ff 2fd7 : a9ff > lda #$ff ;allow test to change > 2fd9 : 48 > pha ;use stack to load status 2fda : bd5e02 > lda absEOa,x ;precharge accu 2fdd : 28 > plp 2fde : 5520 eor zpEO,x tst_ax absrlo,absflo,$ff-fnz 2fe0 : 08 > php ;save flags 2fe1 : dd6202 > cmp absrlo,x ;test result > trap_ne 2fe4 : d0fe > bne * ;failed not equal (non zero) > 2fe6 : 68 > pla ;load status > eor_flag $ff-fnz 2fe7 : 497d > eor #$ff-fnz|fao ;invert expected > 2fe9 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 2fec : d0fe > bne * ;failed not equal (non zero) > 2fee : ca dex 2fef : 10e6 bpl teor7 2ff1 : a203 ldx #3 ;abs,x 2ff3 : teor8 set_ax absEOa,0 > load_flag 0 2ff3 : a900 > lda #0 ;allow test to change I > 2ff5 : 48 > pha ;use stack to load status 2ff6 : bd5e02 > lda absEOa,x ;precharge accu 2ff9 : 28 > plp 2ffa : 5d5202 eor absEO,x tst_ax absrlo,absflo,0 2ffd : 08 > php ;save flags 2ffe : dd6202 > cmp absrlo,x ;test result > trap_ne 3001 : d0fe > bne * ;failed not equal (non zero) > 3003 : 68 > pla ;load status > eor_flag 0 3004 : 4930 > eor #0|fao ;invert expected flags > 3006 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3009 : d0fe > bne * ;failed not equal (non zero) > 300b : ca dex 300c : 10e5 bpl teor8 300e : a203 ldx #3 3010 : teor9 set_ax absEOa,$ff > load_flag $ff 3010 : a9ff > lda #$ff ;allow test to change > 3012 : 48 > pha ;use stack to load status 3013 : bd5e02 > lda absEOa,x ;precharge accu 3016 : 28 > plp 3017 : 5d5202 eor absEO,x tst_ax absrlo,absflo,$ff-fnz 301a : 08 > php ;save flags 301b : dd6202 > cmp absrlo,x ;test result > trap_ne 301e : d0fe > bne * ;failed not equal (non zero) > 3020 : 68 > pla ;load status > eor_flag $ff-fnz 3021 : 497d > eor #$ff-fnz|fao ;invert expected > 3023 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3026 : d0fe > bne * ;failed not equal (non zero) > 3028 : ca dex 3029 : 10e5 bpl teor9 302b : a003 ldy #3 ;abs,y 302d : teor10 set_ay absEOa,0 > load_flag 0 302d : a900 > lda #0 ;allow test to change I > 302f : 48 > pha ;use stack to load status 3030 : b95e02 > lda absEOa,y ;precharge accu 3033 : 28 > plp 3034 : 595202 eor absEO,y tst_ay absrlo,absflo,0 3037 : 08 > php ;save flags 3038 : d96202 > cmp absrlo,y ;test result > trap_ne ; 303b : d0fe > bne * ;failed not equal (non zero) > 303d : 68 > pla ;load status > eor_flag 0 303e : 4930 > eor #0|fao ;invert expected flags > 3040 : d96602 > cmp absflo,y ;test flags > trap_ne 3043 : d0fe > bne * ;failed not equal (non zero) > 3045 : 88 dey 3046 : 10e5 bpl teor10 3048 : a003 ldy #3 304a : teor11 set_ay absEOa,$ff > load_flag $ff 304a : a9ff > lda #$ff ;allow test to change > 304c : 48 > pha ;use stack to load status 304d : b95e02 > lda absEOa,y ;precharge accu 3050 : 28 > plp 3051 : 595202 eor absEO,y tst_ay absrlo,absflo,$ff-fnz 3054 : 08 > php ;save flags 3055 : d96202 > cmp absrlo,y ;test result > trap_ne ; 3058 : d0fe > bne * ;failed not equal (non zero) > 305a : 68 > pla ;load status > eor_flag $ff-fnz 305b : 497d > eor #$ff-fnz|fao ;invert expected > 305d : d96602 > cmp absflo,y ;test flags > trap_ne 3060 : d0fe > bne * ;failed not equal (non zero) > 3062 : 88 dey 3063 : 10e5 bpl teor11 3065 : a206 ldx #6 ;(zp,x) 3067 : a003 ldy #3 3069 : teor12 set_ay absEOa,0 > load_flag 0 3069 : a900 > lda #0 ;allow test to change I > 306b : 48 > pha ;use stack to load status 306c : b95e02 > lda absEOa,y ;precharge accu 306f : 28 > plp 3070 : 4142 eor (indEO,x) tst_ay absrlo,absflo,0 3072 : 08 > php ;save flags 3073 : d96202 > cmp absrlo,y ;test result > trap_ne ; 3076 : d0fe > bne * ;failed not equal (non zero) > 3078 : 68 > pla ;load status > eor_flag 0 3079 : 4930 > eor #0|fao ;invert expected flags > 307b : d96602 > cmp absflo,y ;test flags > trap_ne 307e : d0fe > bne * ;failed not equal (non zero) > 3080 : ca dex 3081 : ca dex 3082 : 88 dey 3083 : 10e4 bpl teor12 3085 : a206 ldx #6 3087 : a003 ldy #3 3089 : teor13 set_ay absEOa,$ff > load_flag $ff 3089 : a9ff > lda #$ff ;allow test to change > 308b : 48 > pha ;use stack to load status 308c : b95e02 > lda absEOa,y ;precharge accu 308f : 28 > plp 3090 : 4142 eor (indEO,x) tst_ay absrlo,absflo,$ff-fnz 3092 : 08 > php ;save flags 3093 : d96202 > cmp absrlo,y ;test result > trap_ne ; 3096 : d0fe > bne * ;failed not equal (non zero) > 3098 : 68 > pla ;load status > eor_flag $ff-fnz 3099 : 497d > eor #$ff-fnz|fao ;invert expected > 309b : d96602 > cmp absflo,y ;test flags > trap_ne 309e : d0fe > bne * ;failed not equal (non zero) > 30a0 : ca dex 30a1 : ca dex 30a2 : 88 dey 30a3 : 10e4 bpl teor13 30a5 : a003 ldy #3 ;(zp),y 30a7 : teor14 set_ay absEOa,0 > load_flag 0 30a7 : a900 > lda #0 ;allow test to change I > 30a9 : 48 > pha ;use stack to load status 30aa : b95e02 > lda absEOa,y ;precharge accu 30ad : 28 > plp 30ae : 5142 eor (indEO),y tst_ay absrlo,absflo,0 30b0 : 08 > php ;save flags 30b1 : d96202 > cmp absrlo,y ;test result > trap_ne ; 30b4 : d0fe > bne * ;failed not equal (non zero) > 30b6 : 68 > pla ;load status > eor_flag 0 30b7 : 4930 > eor #0|fao ;invert expected flags > 30b9 : d96602 > cmp absflo,y ;test flags > trap_ne 30bc : d0fe > bne * ;failed not equal (non zero) > 30be : 88 dey 30bf : 10e6 bpl teor14 30c1 : a003 ldy #3 30c3 : teor15 set_ay absEOa,$ff > load_flag $ff 30c3 : a9ff > lda #$ff ;allow test to change > 30c5 : 48 > pha ;use stack to load status 30c6 : b95e02 > lda absEOa,y ;precharge accu 30c9 : 28 > plp 30ca : 5142 eor (indEO),y tst_ay absrlo,absflo,$ff-fnz 30cc : 08 > php ;save flags 30cd : d96202 > cmp absrlo,y ;test result > trap_ne ; 30d0 : d0fe > bne * ;failed not equal (non zero) > 30d2 : 68 > pla ;load status > eor_flag $ff-fnz 30d3 : 497d > eor #$ff-fnz|fao ;invert expected > 30d5 : d96602 > cmp absflo,y ;test flags > trap_ne 30d8 : d0fe > bne * ;failed not equal (non zero) > 30da : 88 dey 30db : 10e6 bpl teor15 next_test 30dd : ad0002 > lda test_case ;previous test 30e0 : c927 > cmp #test_num > trap_ne ;test is out of sequence 30e2 : d0fe > bne * ;failed not equal (non zero) > 0028 = >test_num = test_num + 1 30e4 : a928 > lda #test_num ;*** next tests' number 30e6 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; OR 30e9 : a203 ldx #3 ;immediate - self modifying co 30eb : b518 tora lda zpOR,x 30ed : 8d0f02 sta ex_orai+1 ;set ORA # operand set_ax absORa,0 > load_flag 0 30f0 : a900 > lda #0 ;allow test to change I > 30f2 : 48 > pha ;use stack to load status 30f3 : bd5602 > lda absORa,x ;precharge accu 30f6 : 28 > plp 30f7 : 200e02 jsr ex_orai ;execute ORA # in RAM tst_ax absrlo,absflo,0 30fa : 08 > php ;save flags 30fb : dd6202 > cmp absrlo,x ;test result > trap_ne 30fe : d0fe > bne * ;failed not equal (non zero) > 3100 : 68 > pla ;load status > eor_flag 0 3101 : 4930 > eor #0|fao ;invert expected flags > 3103 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3106 : d0fe > bne * ;failed not equal (non zero) > 3108 : ca dex 3109 : 10e0 bpl tora 310b : a203 ldx #3 310d : b518 tora1 lda zpOR,x 310f : 8d0f02 sta ex_orai+1 ;set ORA # operand set_ax absORa,$ff > load_flag $ff 3112 : a9ff > lda #$ff ;allow test to change > 3114 : 48 > pha ;use stack to load status 3115 : bd5602 > lda absORa,x ;precharge accu 3118 : 28 > plp 3119 : 200e02 jsr ex_orai ;execute ORA # in RAM tst_ax absrlo,absflo,$ff-fnz 311c : 08 > php ;save flags 311d : dd6202 > cmp absrlo,x ;test result > trap_ne 3120 : d0fe > bne * ;failed not equal (non zero) > 3122 : 68 > pla ;load status > eor_flag $ff-fnz 3123 : 497d > eor #$ff-fnz|fao ;invert expected > 3125 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3128 : d0fe > bne * ;failed not equal (non zero) > 312a : ca dex 312b : 10e0 bpl tora1 312d : a203 ldx #3 ;zp 312f : b518 tora2 lda zpOR,x 3131 : 850c sta zpt set_ax absORa,0 > load_flag 0 3133 : a900 > lda #0 ;allow test to change I > 3135 : 48 > pha ;use stack to load status 3136 : bd5602 > lda absORa,x ;precharge accu 3139 : 28 > plp 313a : 050c ora zpt tst_ax absrlo,absflo,0 313c : 08 > php ;save flags 313d : dd6202 > cmp absrlo,x ;test result > trap_ne 3140 : d0fe > bne * ;failed not equal (non zero) > 3142 : 68 > pla ;load status > eor_flag 0 3143 : 4930 > eor #0|fao ;invert expected flags > 3145 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3148 : d0fe > bne * ;failed not equal (non zero) > 314a : ca dex 314b : 10e2 bpl tora2 314d : a203 ldx #3 314f : b518 tora3 lda zpOR,x 3151 : 850c sta zpt set_ax absORa,$ff > load_flag $ff 3153 : a9ff > lda #$ff ;allow test to change > 3155 : 48 > pha ;use stack to load status 3156 : bd5602 > lda absORa,x ;precharge accu 3159 : 28 > plp 315a : 050c ora zpt tst_ax absrlo,absflo,$ff-fnz 315c : 08 > php ;save flags 315d : dd6202 > cmp absrlo,x ;test result > trap_ne 3160 : d0fe > bne * ;failed not equal (non zero) > 3162 : 68 > pla ;load status > eor_flag $ff-fnz 3163 : 497d > eor #$ff-fnz|fao ;invert expected > 3165 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3168 : d0fe > bne * ;failed not equal (non zero) > 316a : ca dex 316b : 10e2 bpl tora3 316d : a203 ldx #3 ;abs 316f : b518 tora4 lda zpOR,x 3171 : 8d0302 sta abst set_ax absORa,0 > load_flag 0 3174 : a900 > lda #0 ;allow test to change I > 3176 : 48 > pha ;use stack to load status 3177 : bd5602 > lda absORa,x ;precharge accu 317a : 28 > plp 317b : 0d0302 ora abst tst_ax absrlo,absflo,0 317e : 08 > php ;save flags 317f : dd6202 > cmp absrlo,x ;test result > trap_ne 3182 : d0fe > bne * ;failed not equal (non zero) > 3184 : 68 > pla ;load status > eor_flag 0 3185 : 4930 > eor #0|fao ;invert expected flags > 3187 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 318a : d0fe > bne * ;failed not equal (non zero) > 318c : ca dex 318d : 10e0 bpl tora4 318f : a203 ldx #3 3191 : b518 tora5 lda zpOR,x 3193 : 8d0302 sta abst set_ax absORa,$ff > load_flag $ff 3196 : a9ff > lda #$ff ;allow test to change > 3198 : 48 > pha ;use stack to load status 3199 : bd5602 > lda absORa,x ;precharge accu 319c : 28 > plp 319d : 0d0302 ora abst tst_ax absrlo,absflo,$ff-fnz 31a0 : 08 > php ;save flags 31a1 : dd6202 > cmp absrlo,x ;test result > trap_ne 31a4 : d0fe > bne * ;failed not equal (non zero) > 31a6 : 68 > pla ;load status > eor_flag $ff-fnz 31a7 : 497d > eor #$ff-fnz|fao ;invert expected > 31a9 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 31ac : d0fe > bne * ;failed not equal (non zero) > 31ae : ca dex 31af : 1002 bpl tora6 31b1 : a203 ldx #3 ;zp,x 31b3 : tora6 set_ax absORa,0 > load_flag 0 31b3 : a900 > lda #0 ;allow test to change I > 31b5 : 48 > pha ;use stack to load status 31b6 : bd5602 > lda absORa,x ;precharge accu 31b9 : 28 > plp 31ba : 1518 ora zpOR,x tst_ax absrlo,absflo,0 31bc : 08 > php ;save flags 31bd : dd6202 > cmp absrlo,x ;test result > trap_ne 31c0 : d0fe > bne * ;failed not equal (non zero) > 31c2 : 68 > pla ;load status > eor_flag 0 31c3 : 4930 > eor #0|fao ;invert expected flags > 31c5 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 31c8 : d0fe > bne * ;failed not equal (non zero) > 31ca : ca dex 31cb : 10e6 bpl tora6 31cd : a203 ldx #3 31cf : tora7 set_ax absORa,$ff > load_flag $ff 31cf : a9ff > lda #$ff ;allow test to change > 31d1 : 48 > pha ;use stack to load status 31d2 : bd5602 > lda absORa,x ;precharge accu 31d5 : 28 > plp 31d6 : 1518 ora zpOR,x tst_ax absrlo,absflo,$ff-fnz 31d8 : 08 > php ;save flags 31d9 : dd6202 > cmp absrlo,x ;test result > trap_ne 31dc : d0fe > bne * ;failed not equal (non zero) > 31de : 68 > pla ;load status > eor_flag $ff-fnz 31df : 497d > eor #$ff-fnz|fao ;invert expected > 31e1 : dd6602 > cmp absflo,x ;test flags > trap_ne ; 31e4 : d0fe > bne * ;failed not equal (non zero) > 31e6 : ca dex 31e7 : 10e6 bpl tora7 31e9 : a203 ldx #3 ;abs,x 31eb : tora8 set_ax absORa,0 > load_flag 0 31eb : a900 > lda #0 ;allow test to change I > 31ed : 48 > pha ;use stack to load status 31ee : bd5602 > lda absORa,x ;precharge accu 31f1 : 28 > plp 31f2 : 1d4a02 ora absOR,x tst_ax absrlo,absflo,0 31f5 : 08 > php ;save flags 31f6 : dd6202 > cmp absrlo,x ;test result > trap_ne 31f9 : d0fe > bne * ;failed not equal (non zero) > 31fb : 68 > pla ;load status > eor_flag 0 31fc : 4930 > eor #0|fao ;invert expected flags > 31fe : dd6602 > cmp absflo,x ;test flags > trap_ne ; 3201 : d0fe > bne * ;failed not equal (non zero) > 3203 : ca dex 3204 : 10e5 bpl tora8 3206 : a203 ldx #3 3208 : tora9 set_ax absORa,$ff > load_flag $ff 3208 : a9ff > lda #$ff ;allow test to change > 320a : 48 > pha ;use stack to load status 320b : bd5602 > lda absORa,x ;precharge accu 320e : 28 > plp 320f : 1d4a02 ora absOR,x tst_ax absrlo,absflo,$ff-fnz 3212 : 08 > php ;save flags 3213 : dd6202 > cmp absrlo,x ;test result > trap_ne 3216 : d0fe > bne * ;failed not equal (non zero) > 3218 : 68 > pla ;load status > eor_flag $ff-fnz 3219 : 497d > eor #$ff-fnz|fao ;invert expected > 321b : dd6602 > cmp absflo,x ;test flags > trap_ne ; 321e : d0fe > bne * ;failed not equal (non zero) > 3220 : ca dex 3221 : 10e5 bpl tora9 3223 : a003 ldy #3 ;abs,y 3225 : tora10 set_ay absORa,0 > load_flag 0 3225 : a900 > lda #0 ;allow test to change I > 3227 : 48 > pha ;use stack to load status 3228 : b95602 > lda absORa,y ;precharge accu 322b : 28 > plp 322c : 194a02 ora absOR,y tst_ay absrlo,absflo,0 322f : 08 > php ;save flags 3230 : d96202 > cmp absrlo,y ;test result > trap_ne ; 3233 : d0fe > bne * ;failed not equal (non zero) > 3235 : 68 > pla ;load status > eor_flag 0 3236 : 4930 > eor #0|fao ;invert expected flags > 3238 : d96602 > cmp absflo,y ;test flags > trap_ne 323b : d0fe > bne * ;failed not equal (non zero) > 323d : 88 dey 323e : 10e5 bpl tora10 3240 : a003 ldy #3 3242 : tora11 set_ay absORa,$ff > load_flag $ff 3242 : a9ff > lda #$ff ;allow test to change > 3244 : 48 > pha ;use stack to load status 3245 : b95602 > lda absORa,y ;precharge accu 3248 : 28 > plp 3249 : 194a02 ora absOR,y tst_ay absrlo,absflo,$ff-fnz 324c : 08 > php ;save flags 324d : d96202 > cmp absrlo,y ;test result > trap_ne ; 3250 : d0fe > bne * ;failed not equal (non zero) > 3252 : 68 > pla ;load status > eor_flag $ff-fnz 3253 : 497d > eor #$ff-fnz|fao ;invert expected > 3255 : d96602 > cmp absflo,y ;test flags > trap_ne 3258 : d0fe > bne * ;failed not equal (non zero) > 325a : 88 dey 325b : 10e5 bpl tora11 325d : a206 ldx #6 ;(zp,x) 325f : a003 ldy #3 3261 : tora12 set_ay absORa,0 > load_flag 0 3261 : a900 > lda #0 ;allow test to change I > 3263 : 48 > pha ;use stack to load status 3264 : b95602 > lda absORa,y ;precharge accu 3267 : 28 > plp 3268 : 014a ora (indOR,x) tst_ay absrlo,absflo,0 326a : 08 > php ;save flags 326b : d96202 > cmp absrlo,y ;test result > trap_ne ; 326e : d0fe > bne * ;failed not equal (non zero) > 3270 : 68 > pla ;load status > eor_flag 0 3271 : 4930 > eor #0|fao ;invert expected flags > 3273 : d96602 > cmp absflo,y ;test flags > trap_ne 3276 : d0fe > bne * ;failed not equal (non zero) > 3278 : ca dex 3279 : ca dex 327a : 88 dey 327b : 10e4 bpl tora12 327d : a206 ldx #6 327f : a003 ldy #3 3281 : tora13 set_ay absORa,$ff > load_flag $ff 3281 : a9ff > lda #$ff ;allow test to change > 3283 : 48 > pha ;use stack to load status 3284 : b95602 > lda absORa,y ;precharge accu 3287 : 28 > plp 3288 : 014a ora (indOR,x) tst_ay absrlo,absflo,$ff-fnz 328a : 08 > php ;save flags 328b : d96202 > cmp absrlo,y ;test result > trap_ne ; 328e : d0fe > bne * ;failed not equal (non zero) > 3290 : 68 > pla ;load status > eor_flag $ff-fnz 3291 : 497d > eor #$ff-fnz|fao ;invert expected > 3293 : d96602 > cmp absflo,y ;test flags > trap_ne 3296 : d0fe > bne * ;failed not equal (non zero) > 3298 : ca dex 3299 : ca dex 329a : 88 dey 329b : 10e4 bpl tora13 329d : a003 ldy #3 ;(zp),y 329f : tora14 set_ay absORa,0 > load_flag 0 329f : a900 > lda #0 ;allow test to change I > 32a1 : 48 > pha ;use stack to load status 32a2 : b95602 > lda absORa,y ;precharge accu 32a5 : 28 > plp 32a6 : 114a ora (indOR),y tst_ay absrlo,absflo,0 32a8 : 08 > php ;save flags 32a9 : d96202 > cmp absrlo,y ;test result > trap_ne ; 32ac : d0fe > bne * ;failed not equal (non zero) > 32ae : 68 > pla ;load status > eor_flag 0 32af : 4930 > eor #0|fao ;invert expected flags > 32b1 : d96602 > cmp absflo,y ;test flags > trap_ne 32b4 : d0fe > bne * ;failed not equal (non zero) > 32b6 : 88 dey 32b7 : 10e6 bpl tora14 32b9 : a003 ldy #3 32bb : tora15 set_ay absORa,$ff > load_flag $ff 32bb : a9ff > lda #$ff ;allow test to change > 32bd : 48 > pha ;use stack to load status 32be : b95602 > lda absORa,y ;precharge accu 32c1 : 28 > plp 32c2 : 114a ora (indOR),y tst_ay absrlo,absflo,$ff-fnz 32c4 : 08 > php ;save flags 32c5 : d96202 > cmp absrlo,y ;test result > trap_ne ; 32c8 : d0fe > bne * ;failed not equal (non zero) > 32ca : 68 > pla ;load status > eor_flag $ff-fnz 32cb : 497d > eor #$ff-fnz|fao ;invert expected > 32cd : d96602 > cmp absflo,y ;test flags > trap_ne 32d0 : d0fe > bne * ;failed not equal (non zero) > 32d2 : 88 dey 32d3 : 10e6 bpl tora15 if I_flag = 3 32d5 : 58 cli endif next_test 32d6 : ad0002 > lda test_case ;previous test 32d9 : c928 > cmp #test_num > trap_ne ;test is out of sequence 32db : d0fe > bne * ;failed not equal (non zero) > 0029 = >test_num = test_num + 1 32dd : a929 > lda #test_num ;*** next tests' number 32df : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; full binary add/subtract test ; iterates through all combinations of operands and ca ; uses increments/decrements to predict result & resul 32e2 : d8 cld 32e3 : a20e ldx #ad2 ;for indexed test 32e5 : a0ff ldy #$ff ;max range 32e7 : a900 lda #0 ;start with adding zeroes & no 32e9 : 850c sta adfc ;carry in - for diag 32eb : 850d sta ad1 ;operand 1 - accumulator 32ed : 850e sta ad2 ;operand 2 - memory or immedia 32ef : 8d0302 sta ada2 ;non zp 32f2 : 850f sta adrl ;expected result bits 0-7 32f4 : 8510 sta adrh ;expected result bit 8 (carry 32f6 : a9ff lda #$ff ;complemented operand 2 for su 32f8 : 8512 sta sb2 32fa : 8d0402 sta sba2 ;non zp 32fd : a902 lda #2 ;expected Z-flag 32ff : 8511 sta adrf 3301 : 18 tadd clc ;test with carry clear 3302 : 207c35 jsr chkadd 3305 : e60c inc adfc ;now with carry 3307 : e60f inc adrl ;result +1 3309 : 08 php ;save N & Z from low result 330a : 08 php 330b : 68 pla ;accu holds expected flags 330c : 2982 and #$82 ;mask N & Z 330e : 28 plp 330f : d002 bne tadd1 3311 : e610 inc adrh ;result bit 8 - carry 3313 : 0510 tadd1 ora adrh ;merge C to expected flags 3315 : 8511 sta adrf ;save expected flags except ov 3317 : 38 sec ;test with carry set 3318 : 207c35 jsr chkadd 331b : c60c dec adfc ;same for operand +1 but no ca 331d : e60d inc ad1 331f : d0e0 bne tadd ;iterate op1 3321 : a900 lda #0 ;preset result to op2 when op1 3323 : 8510 sta adrh 3325 : ee0302 inc ada2 3328 : e60e inc ad2 332a : 08 php ;save NZ as operand 2 becomes 332b : 68 pla 332c : 2982 and #$82 ;mask N00000Z0 332e : 8511 sta adrf ;no need to check carry as we 3330 : c612 dec sb2 ;complement subtract operand 2 3332 : ce0402 dec sba2 3335 : a50e lda ad2 3337 : 850f sta adrl 3339 : d0c6 bne tadd ;iterate op2 if disable_decimal < 1 next_test 333b : ad0002 > lda test_case ;previous test 333e : c929 > cmp #test_num > trap_ne ;test is out of sequence 3340 : d0fe > bne * ;failed not equal (non zero) > 002a = >test_num = test_num + 1 3342 : a92a > lda #test_num ;*** next tests' number 3344 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; decimal add/subtract test ; *** WARNING - tests documented behavior only! *** ; only valid BCD operands are tested, N V Z flags ar ; iterates through all valid combinations of operands ; uses increments/decrements to predict result & carry 3347 : f8 sed 3348 : a20e ldx #ad2 ;for indexed test 334a : a0ff ldy #$ff ;max range 334c : a999 lda #$99 ;start with adding 99 to 99 wi 334e : 850d sta ad1 ;operand 1 - accumulator 3350 : 850e sta ad2 ;operand 2 - memory or immedia 3352 : 8d0302 sta ada2 ;non zp 3355 : 850f sta adrl ;expected result bits 0-7 3357 : a901 lda #1 ;set carry in & out 3359 : 850c sta adfc ;carry in - for diag 335b : 8510 sta adrh ;expected result bit 8 (carry 335d : a900 lda #0 ;complemented operand 2 for su 335f : 8512 sta sb2 3361 : 8d0402 sta sba2 ;non zp 3364 : 38 tdad sec ;test with carry set 3365 : 204934 jsr chkdad 3368 : c60c dec adfc ;now with carry clear 336a : a50f lda adrl ;decimal adjust result 336c : d008 bne tdad1 ;skip clear carry & preset res 336e : c610 dec adrh 3370 : a999 lda #$99 3372 : 850f sta adrl 3374 : d012 bne tdad3 3376 : 290f tdad1 and #$f ;lower nibble mask 3378 : d00c bne tdad2 ;no decimal adjust needed 337a : c60f dec adrl ;decimal adjust (?0-6) 337c : c60f dec adrl 337e : c60f dec adrl 3380 : c60f dec adrl 3382 : c60f dec adrl 3384 : c60f dec adrl 3386 : c60f tdad2 dec adrl ;result -1 3388 : 18 tdad3 clc ;test with carry clear 3389 : 204934 jsr chkdad 338c : e60c inc adfc ;same for operand -1 but with 338e : a50d lda ad1 ;decimal adjust operand 1 3390 : f015 beq tdad5 ;iterate operand 2 3392 : 290f and #$f ;lower nibble mask 3394 : d00c bne tdad4 ;skip decimal adjust 3396 : c60d dec ad1 ;decimal adjust (?0-6) 3398 : c60d dec ad1 339a : c60d dec ad1 339c : c60d dec ad1 339e : c60d dec ad1 33a0 : c60d dec ad1 33a2 : c60d tdad4 dec ad1 ;operand 1 -1 33a4 : 4c6433 jmp tdad ;iterate op1 33a7 : a999 tdad5 lda #$99 ;precharge op1 max 33a9 : 850d sta ad1 33ab : a50e lda ad2 ;decimal adjust operand 2 33ad : f030 beq tdad7 ;end of iteration 33af : 290f and #$f ;lower nibble mask 33b1 : d018 bne tdad6 ;skip decimal adjust 33b3 : c60e dec ad2 ;decimal adjust (?0-6) 33b5 : c60e dec ad2 33b7 : c60e dec ad2 33b9 : c60e dec ad2 33bb : c60e dec ad2 33bd : c60e dec ad2 33bf : e612 inc sb2 ;complemented decimal adjust f 33c1 : e612 inc sb2 33c3 : e612 inc sb2 33c5 : e612 inc sb2 33c7 : e612 inc sb2 33c9 : e612 inc sb2 33cb : c60e tdad6 dec ad2 ;operand 2 -1 33cd : e612 inc sb2 ;complemented operand for subt 33cf : a512 lda sb2 33d1 : 8d0402 sta sba2 ;copy as non zp operand 33d4 : a50e lda ad2 33d6 : 8d0302 sta ada2 ;copy as non zp operand 33d9 : 850f sta adrl ;new result since op1+carry=00 33db : e610 inc adrh ;result carry 33dd : d085 bne tdad ;iterate op2 33df : tdad7 next_test 33df : ad0002 > lda test_case ;previous test 33e2 : c92a > cmp #test_num > trap_ne ;test is out of sequence 33e4 : d0fe > bne * ;failed not equal (non zero) > 002b = >test_num = test_num + 1 33e6 : a92b > lda #test_num ;*** next tests' number 33e8 : 8d0002 > sta test_case > ;check_ram ;uncomment to find altere ; decimal/binary switch test ; tests CLD, SED, PLP, RTI to properly switch between ; tables 33eb : 18 clc 33ec : d8 cld 33ed : 08 php 33ee : a955 lda #$55 33f0 : 6955 adc #$55 33f2 : c9aa cmp #$aa trap_ne ;expected binary result after 33f4 : d0fe > bne * ;failed not equal (non zero) 33f6 : 18 clc 33f7 : f8 sed 33f8 : 08 php 33f9 : a955 lda #$55 33fb : 6955 adc #$55 33fd : c910 cmp #$10 trap_ne ;expected decimal result after 33ff : d0fe > bne * ;failed not equal (non zero) 3401 : d8 cld 3402 : 28 plp 3403 : a955 lda #$55 3405 : 6955 adc #$55 3407 : c910 cmp #$10 trap_ne ;expected decimal result after 3409 : d0fe > bne * ;failed not equal (non zero) 340b : 28 plp 340c : a955 lda #$55 340e : 6955 adc #$55 3410 : c9aa cmp #$aa trap_ne ;expected binary result after 3412 : d0fe > bne * ;failed not equal (non zero) 3414 : 18 clc 3415 : a934 lda #hi bin_rti_ret ;emulated interrupt for rt 3417 : 48 pha 3418 : a92f lda #lo bin_rti_ret 341a : 48 pha 341b : 08 php 341c : f8 sed 341d : a934 lda #hi dec_rti_ret ;emulated interrupt for rt 341f : 48 pha 3420 : a926 lda #lo dec_rti_ret 3422 : 48 pha 3423 : 08 php 3424 : d8 cld 3425 : 40 rti 3426 : dec_rti_ret 3426 : a955 lda #$55 3428 : 6955 adc #$55 342a : c910 cmp #$10 trap_ne ;expected decimal result after 342c : d0fe > bne * ;failed not equal (non zero) 342e : 40 rti 342f : bin_rti_ret 342f : a955 lda #$55 3431 : 6955 adc #$55 3433 : c9aa cmp #$aa trap_ne ;expected binary result after 3435 : d0fe > bne * ;failed not equal (non zero) endif 3437 : ad0002 lda test_case 343a : c92b cmp #test_num trap_ne ;previous test is out of seque 343c : d0fe > bne * ;failed not equal (non zero) 343e : a9f0 lda #$f0 ;mark opcode testing complete 3440 : 8d0002 sta test_case ; final RAM integrity test ; verifies that none of the previous tests has alter ; designated write areas. check_ram > ;RAM check disabled - RAM size not set ; *** DEBUG INFO *** ; to debug checksum errors uncomment check_ram in the ; narrow down the responsible opcode. ; may give false errors when monitor, OS or other back ; allowed during previous tests. ; S U C C E S S ************************************** ; ------------- success ;if you get here everything we 3443 : 4c4334 > jmp * ;test passed, no errors ; ------------- ; S U C C E S S ************************************** 3446 : 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 ar ; iterates through all valid combinations of operands ; uses increments/decrements to predict result & carry 3449 : chkdad ; decimal ADC / SBC zp 3449 : 08 php ;save carry for subtract 344a : a50d lda ad1 344c : 650e adc ad2 ;perform add 344e : 08 php 344f : c50f cmp adrl ;check result trap_ne ;bad result 3451 : d0fe > bne * ;failed not equal (non zero) 3453 : 68 pla ;check flags 3454 : 2901 and #1 ;mask carry 3456 : c510 cmp adrh trap_ne ;bad carry 3458 : d0fe > bne * ;failed not equal (non zero) 345a : 28 plp 345b : 08 php ;save carry for next add 345c : a50d lda ad1 345e : e512 sbc sb2 ;perform subtract 3460 : 08 php 3461 : c50f cmp adrl ;check result trap_ne ;bad result 3463 : d0fe > bne * ;failed not equal (non zero) 3465 : 68 pla ;check flags 3466 : 2901 and #1 ;mask carry 3468 : c510 cmp adrh trap_ne ;bad flags 346a : d0fe > bne * ;failed not equal (non zero) 346c : 28 plp ; decimal ADC / SBC abs 346d : 08 php ;save carry for subtract 346e : a50d lda ad1 3470 : 6d0302 adc ada2 ;perform add 3473 : 08 php 3474 : c50f cmp adrl ;check result trap_ne ;bad result 3476 : d0fe > bne * ;failed not equal (non zero) 3478 : 68 pla ;check flags 3479 : 2901 and #1 ;mask carry 347b : c510 cmp adrh trap_ne ;bad carry 347d : d0fe > bne * ;failed not equal (non zero) 347f : 28 plp 3480 : 08 php ;save carry for next add 3481 : a50d lda ad1 3483 : ed0402 sbc sba2 ;perform subtract 3486 : 08 php 3487 : c50f 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 : c510 cmp adrh trap_ne ;bad carry 3490 : d0fe > bne * ;failed not equal (non zero) 3492 : 28 plp ; decimal ADC / SBC # 3493 : 08 php ;save carry for subtract 3494 : a50e lda ad2 3496 : 8d1202 sta ex_adci+1 ;set ADC # operand 3499 : a50d lda ad1 349b : 201102 jsr ex_adci ;execute ADC # in RAM 349e : 08 php 349f : c50f cmp adrl ;check result trap_ne ;bad result 34a1 : d0fe > bne * ;failed not equal (non zero) 34a3 : 68 pla ;check flags 34a4 : 2901 and #1 ;mask carry 34a6 : c510 cmp adrh trap_ne ;bad carry 34a8 : d0fe > bne * ;failed not equal (non zero) 34aa : 28 plp 34ab : 08 php ;save carry for next add 34ac : a512 lda sb2 34ae : 8d1502 sta ex_sbci+1 ;set SBC # operand 34b1 : a50d lda ad1 34b3 : 201402 jsr ex_sbci ;execute SBC # in RAM 34b6 : 08 php 34b7 : c50f cmp adrl ;check result trap_ne ;bad result 34b9 : d0fe > bne * ;failed not equal (non zero) 34bb : 68 pla ;check flags 34bc : 2901 and #1 ;mask carry 34be : c510 cmp adrh trap_ne ;bad carry 34c0 : d0fe > bne * ;failed not equal (non zero) 34c2 : 28 plp ; decimal ADC / SBC zp,x 34c3 : 08 php ;save carry for subtract 34c4 : a50d lda ad1 34c6 : 7500 adc 0,x ;perform add 34c8 : 08 php 34c9 : c50f cmp adrl ;check result trap_ne ;bad result 34cb : d0fe > bne * ;failed not equal (non zero) 34cd : 68 pla ;check flags 34ce : 2901 and #1 ;mask carry 34d0 : c510 cmp adrh trap_ne ;bad carry 34d2 : d0fe > bne * ;failed not equal (non zero) 34d4 : 28 plp 34d5 : 08 php ;save carry for next add 34d6 : a50d lda ad1 34d8 : f504 sbc sb2-ad2,x ;perform subtract 34da : 08 php 34db : c50f cmp adrl ;check result trap_ne ;bad result 34dd : d0fe > bne * ;failed not equal (non zero) 34df : 68 pla ;check flags 34e0 : 2901 and #1 ;mask carry 34e2 : c510 cmp adrh trap_ne ;bad carry 34e4 : d0fe > bne * ;failed not equal (non zero) 34e6 : 28 plp ; decimal ADC / SBC abs,x 34e7 : 08 php ;save carry for subtract 34e8 : a50d lda ad1 34ea : 7df501 adc ada2-ad2,x ;perform add 34ed : 08 php 34ee : c50f cmp adrl ;check result trap_ne ;bad result 34f0 : d0fe > bne * ;failed not equal (non zero) 34f2 : 68 pla ;check flags 34f3 : 2901 and #1 ;mask carry 34f5 : c510 cmp adrh trap_ne ;bad carry 34f7 : d0fe > bne * ;failed not equal (non zero) 34f9 : 28 plp 34fa : 08 php ;save carry for next add 34fb : a50d lda ad1 34fd : fdf601 sbc sba2-ad2,x ;perform subtract 3500 : 08 php 3501 : c50f 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 : c510 cmp adrh trap_ne ;bad carry 350a : d0fe > bne * ;failed not equal (non zero) 350c : 28 plp ; decimal ADC / SBC abs,y 350d : 08 php ;save carry for subtract 350e : a50d lda ad1 3510 : 790401 adc ada2-$ff,y ;perform add 3513 : 08 php 3514 : c50f 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 : c510 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 : a50d lda ad1 3523 : f90501 sbc sba2-$ff,y ;perform subtract 3526 : 08 php 3527 : c50f 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 : c510 cmp adrh trap_ne ;bad carry 3530 : d0fe > bne * ;failed not equal (non zero) 3532 : 28 plp ; decimal ADC / SBC (zp,x) 3533 : 08 php ;save carry for subtract 3534 : a50d lda ad1 3536 : 6144 adc (lo adi2-ad2,x) ;perform add 3538 : 08 php 3539 : c50f cmp adrl ;check result trap_ne ;bad result 353b : d0fe > bne * ;failed not equal (non zero) 353d : 68 pla ;check flags 353e : 2901 and #1 ;mask carry 3540 : c510 cmp adrh trap_ne ;bad carry 3542 : d0fe > bne * ;failed not equal (non zero) 3544 : 28 plp 3545 : 08 php ;save carry for next add 3546 : a50d lda ad1 3548 : e146 sbc (lo sbi2-ad2,x) ;perform subtract 354a : 08 php 354b : c50f cmp adrl ;check result trap_ne ;bad result 354d : d0fe > bne * ;failed not equal (non zero) 354f : 68 pla ;check flags 3550 : 2901 and #1 ;mask carry 3552 : c510 cmp adrh trap_ne ;bad carry 3554 : d0fe > bne * ;failed not equal (non zero) 3556 : 28 plp ; decimal ADC / SBC (abs),y 3557 : 08 php ;save carry for subtract 3558 : a50d lda ad1 355a : 7156 adc (adiy2),y ;perform add 355c : 08 php 355d : c50f cmp adrl ;check result trap_ne ;bad result 355f : d0fe > bne * ;failed not equal (non zero) 3561 : 68 pla ;check flags 3562 : 2901 and #1 ;mask carry 3564 : c510 cmp adrh trap_ne ;bad carry 3566 : d0fe > bne * ;failed not equal (non zero) 3568 : 28 plp 3569 : 08 php ;save carry for next add 356a : a50d lda ad1 356c : f158 sbc (sbiy2),y ;perform subtract 356e : 08 php 356f : c50f cmp adrl ;check result trap_ne ;bad result 3571 : d0fe > bne * ;failed not equal (non zero) 3573 : 68 pla ;check flags 3574 : 2901 and #1 ;mask carry 3576 : c510 cmp adrh trap_ne ;bad carry 3578 : d0fe > bne * ;failed not equal (non zero) 357a : 28 plp 357b : 60 rts endif ; core subroutine of the full binary add/subtract test ; iterates through all combinations of operands and ca ; uses increments/decrements to predict result & resul 357c : a511 chkadd lda adrf ;add V-flag if overflow 357e : 2983 and #$83 ;keep N-----ZC / clear V 3580 : 48 pha 3581 : a50d lda ad1 ;test sign unequal between ope 3583 : 450e eor ad2 3585 : 300a bmi ckad1 ;no overflow possible - operan 3587 : a50d lda ad1 ;test sign equal between opera 3589 : 450f eor adrl 358b : 1004 bpl ckad1 ;no overflow occured - operand 358d : 68 pla 358e : 0940 ora #$40 ;set V 3590 : 48 pha 3591 : 68 ckad1 pla 3592 : 8511 sta adrf ;save expected flags ; binary ADC / SBC zp 3594 : 08 php ;save carry for subtract 3595 : a50d lda ad1 3597 : 650e adc ad2 ;perform add 3599 : 08 php 359a : c50f cmp adrl ;check result trap_ne ;bad result 359c : d0fe > bne * ;failed not equal (non zero) 359e : 68 pla ;check flags 359f : 29c3 and #$c3 ;mask NV----ZC 35a1 : c511 cmp adrf trap_ne ;bad flags 35a3 : d0fe > bne * ;failed not equal (non zero) 35a5 : 28 plp 35a6 : 08 php ;save carry for next add 35a7 : a50d lda ad1 35a9 : e512 sbc sb2 ;perform subtract 35ab : 08 php 35ac : c50f cmp adrl ;check result trap_ne ;bad result 35ae : d0fe > bne * ;failed not equal (non zero) 35b0 : 68 pla ;check flags 35b1 : 29c3 and #$c3 ;mask NV----ZC 35b3 : c511 cmp adrf trap_ne ;bad flags 35b5 : d0fe > bne * ;failed not equal (non zero) 35b7 : 28 plp ; binary ADC / SBC abs 35b8 : 08 php ;save carry for subtract 35b9 : a50d lda ad1 35bb : 6d0302 adc ada2 ;perform add 35be : 08 php 35bf : c50f cmp adrl ;check result trap_ne ;bad result 35c1 : d0fe > bne * ;failed not equal (non zero) 35c3 : 68 pla ;check flags 35c4 : 29c3 and #$c3 ;mask NV----ZC 35c6 : c511 cmp adrf trap_ne ;bad flags 35c8 : d0fe > bne * ;failed not equal (non zero) 35ca : 28 plp 35cb : 08 php ;save carry for next add 35cc : a50d lda ad1 35ce : ed0402 sbc sba2 ;perform subtract 35d1 : 08 php 35d2 : c50f 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 : c511 cmp adrf trap_ne ;bad flags 35db : d0fe > bne * ;failed not equal (non zero) 35dd : 28 plp ; binary ADC / SBC # 35de : 08 php ;save carry for subtract 35df : a50e lda ad2 35e1 : 8d1202 sta ex_adci+1 ;set ADC # operand 35e4 : a50d lda ad1 35e6 : 201102 jsr ex_adci ;execute ADC # in RAM 35e9 : 08 php 35ea : c50f cmp adrl ;check result trap_ne ;bad result 35ec : d0fe > bne * ;failed not equal (non zero) 35ee : 68 pla ;check flags 35ef : 29c3 and #$c3 ;mask NV----ZC 35f1 : c511 cmp adrf trap_ne ;bad flags 35f3 : d0fe > bne * ;failed not equal (non zero) 35f5 : 28 plp 35f6 : 08 php ;save carry for next add 35f7 : a512 lda sb2 35f9 : 8d1502 sta ex_sbci+1 ;set SBC # operand 35fc : a50d lda ad1 35fe : 201402 jsr ex_sbci ;execute SBC # in RAM 3601 : 08 php 3602 : c50f cmp adrl ;check result trap_ne ;bad result 3604 : d0fe > bne * ;failed not equal (non zero) 3606 : 68 pla ;check flags 3607 : 29c3 and #$c3 ;mask NV----ZC 3609 : c511 cmp adrf trap_ne ;bad flags 360b : d0fe > bne * ;failed not equal (non zero) 360d : 28 plp ; binary ADC / SBC zp,x 360e : 08 php ;save carry for subtract 360f : a50d lda ad1 3611 : 7500 adc 0,x ;perform add 3613 : 08 php 3614 : c50f cmp adrl ;check result trap_ne ;bad result 3616 : d0fe > bne * ;failed not equal (non zero) 3618 : 68 pla ;check flags 3619 : 29c3 and #$c3 ;mask NV----ZC 361b : c511 cmp adrf trap_ne ;bad flags 361d : d0fe > bne * ;failed not equal (non zero) 361f : 28 plp 3620 : 08 php ;save carry for next add 3621 : a50d lda ad1 3623 : f504 sbc sb2-ad2,x ;perform subtract 3625 : 08 php 3626 : c50f cmp adrl ;check result trap_ne ;bad result 3628 : d0fe > bne * ;failed not equal (non zero) 362a : 68 pla ;check flags 362b : 29c3 and #$c3 ;mask NV----ZC 362d : c511 cmp adrf trap_ne ;bad flags 362f : d0fe > bne * ;failed not equal (non zero) 3631 : 28 plp ; binary ADC / SBC abs,x 3632 : 08 php ;save carry for subtract 3633 : a50d lda ad1 3635 : 7df501 adc ada2-ad2,x ;perform add 3638 : 08 php 3639 : c50f cmp adrl ;check result trap_ne ;bad result 363b : d0fe > bne * ;failed not equal (non zero) 363d : 68 pla ;check flags 363e : 29c3 and #$c3 ;mask NV----ZC 3640 : c511 cmp adrf trap_ne ;bad flags 3642 : d0fe > bne * ;failed not equal (non zero) 3644 : 28 plp 3645 : 08 php ;save carry for next add 3646 : a50d lda ad1 3648 : fdf601 sbc sba2-ad2,x ;perform subtract 364b : 08 php 364c : c50f 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 : c511 cmp adrf trap_ne ;bad flags 3655 : d0fe > bne * ;failed not equal (non zero) 3657 : 28 plp ; binary ADC / SBC abs,y 3658 : 08 php ;save carry for subtract 3659 : a50d lda ad1 365b : 790401 adc ada2-$ff,y ;perform add 365e : 08 php 365f : c50f 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 : c511 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 : a50d lda ad1 366e : f90501 sbc sba2-$ff,y ;perform subtract 3671 : 08 php 3672 : c50f 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 : c511 cmp adrf trap_ne ;bad flags 367b : d0fe > bne * ;failed not equal (non zero) 367d : 28 plp ; binary ADC / SBC (zp,x) 367e : 08 php ;save carry for subtract 367f : a50d lda ad1 3681 : 6144 adc (lo adi2-ad2,x) ;perform add 3683 : 08 php 3684 : c50f cmp adrl ;check result trap_ne ;bad result 3686 : d0fe > bne * ;failed not equal (non zero) 3688 : 68 pla ;check flags 3689 : 29c3 and #$c3 ;mask NV----ZC 368b : c511 cmp adrf trap_ne ;bad flags 368d : d0fe > bne * ;failed not equal (non zero) 368f : 28 plp 3690 : 08 php ;save carry for next add 3691 : a50d lda ad1 3693 : e146 sbc (lo sbi2-ad2,x) ;perform subtract 3695 : 08 php 3696 : c50f cmp adrl ;check result trap_ne ;bad result 3698 : d0fe > bne * ;failed not equal (non zero) 369a : 68 pla ;check flags 369b : 29c3 and #$c3 ;mask NV----ZC 369d : c511 cmp adrf trap_ne ;bad flags 369f : d0fe > bne * ;failed not equal (non zero) 36a1 : 28 plp ; binary ADC / SBC (abs),y 36a2 : 08 php ;save carry for subtract 36a3 : a50d lda ad1 36a5 : 7156 adc (adiy2),y ;perform add 36a7 : 08 php 36a8 : c50f cmp adrl ;check result trap_ne ;bad result 36aa : d0fe > bne * ;failed not equal (non zero) 36ac : 68 pla ;check flags 36ad : 29c3 and #$c3 ;mask NV----ZC 36af : c511 cmp adrf trap_ne ;bad flags 36b1 : d0fe > bne * ;failed not equal (non zero) 36b3 : 28 plp 36b4 : 08 php ;save carry for next add 36b5 : a50d lda ad1 36b7 : f158 sbc (sbiy2),y ;perform subtract 36b9 : 08 php 36ba : c50f cmp adrl ;check result trap_ne ;bad result 36bc : d0fe > bne * ;failed not equal (non zero) 36be : 68 pla ;check flags 36bf : 29c3 and #$c3 ;mask NV----ZC 36c1 : c511 cmp adrf trap_ne ;bad flags 36c3 : d0fe > bne * ;failed not equal (non zero) 36c5 : 28 plp 36c6 : 60 rts ; target for the jump absolute test 36c7 : 88 dey 36c8 : 88 dey 36c9 : test_far 36c9 : 08 php ;either SP or Y count will fai 36ca : 88 dey 36cb : 88 dey 36cc : 88 dey 36cd : 28 plp trap_cs ;flags loaded? 36ce : b0fe > bcs * ;failed carry set trap_vs 36d0 : 70fe > bvs * ;failed overflow set trap_mi 36d2 : 30fe > bmi * ;failed minus (bit 7 set) trap_eq 36d4 : f0fe > beq * ;failed equal (zero) 36d6 : c946 cmp #'F' ;registers loaded? trap_ne 36d8 : d0fe > bne * ;failed not equal (non zero) 36da : e041 cpx #'A' trap_ne 36dc : d0fe > bne * ;failed not equal (non zero) 36de : c04f cpy #('R'-3) trap_ne 36e0 : d0fe > bne * ;failed not equal (non zero) 36e2 : 48 pha ;save a,x 36e3 : 8a txa 36e4 : 48 pha 36e5 : ba tsx 36e6 : e0fd cpx #$fd ;check SP trap_ne 36e8 : d0fe > bne * ;failed not equal (non zero) 36ea : 68 pla ;restore x 36eb : aa tax set_stat $ff > load_flag $ff 36ec : a9ff > lda #$ff ;allow test to change > 36ee : 48 > pha ;use stack to load status 36ef : 28 > plp 36f0 : 68 pla ;restore a 36f1 : e8 inx ;return registers with modific 36f2 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 36f4 : 4c0f09 jmp far_ret ; target for the jump indirect test 36f7 : 00 align 36f8 : 0137 ptr_tst_ind dw test_ind 36fa : 6409 ptr_ind_ret dw ind_ret trap ;runover protection 36fc : 4cfc36 > jmp * ;failed anyway 36ff : 88 dey 3700 : 88 dey 3701 : test_ind 3701 : 08 php ;either SP or Y count will fai 3702 : 88 dey 3703 : 88 dey 3704 : 88 dey 3705 : 28 plp trap_cs ;flags loaded? 3706 : b0fe > bcs * ;failed carry set trap_vs 3708 : 70fe > bvs * ;failed overflow set trap_mi 370a : 30fe > bmi * ;failed minus (bit 7 set) trap_eq 370c : f0fe > beq * ;failed equal (zero) 370e : c949 cmp #'I' ;registers loaded? trap_ne 3710 : d0fe > bne * ;failed not equal (non zero) 3712 : e04e cpx #'N' trap_ne 3714 : d0fe > bne * ;failed not equal (non zero) 3716 : c041 cpy #('D'-3) trap_ne 3718 : d0fe > bne * ;failed not equal (non zero) 371a : 48 pha ;save a,x 371b : 8a txa 371c : 48 pha 371d : ba tsx 371e : e0fd cpx #$fd ;check SP trap_ne 3720 : d0fe > bne * ;failed not equal (non zero) 3722 : 68 pla ;restore x 3723 : aa tax set_stat $ff > load_flag $ff 3724 : a9ff > lda #$ff ;allow test to change > 3726 : 48 > pha ;use stack to load status 3727 : 28 > plp 3728 : 68 pla ;restore a 3729 : e8 inx ;return registers with modific 372a : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 372c : 6cfa36 jmp (ptr_ind_ret) trap ;runover protection 372f : 4c2f37 > jmp * ;failed anyway ; target for the jump subroutine test 3732 : 88 dey 3733 : 88 dey 3734 : test_jsr 3734 : 08 php ;either SP or Y count will fai 3735 : 88 dey 3736 : 88 dey 3737 : 88 dey 3738 : 28 plp trap_cs ;flags loaded? 3739 : b0fe > bcs * ;failed carry set trap_vs 373b : 70fe > bvs * ;failed overflow set trap_mi 373d : 30fe > bmi * ;failed minus (bit 7 set) trap_eq 373f : f0fe > beq * ;failed equal (zero) 3741 : c94a cmp #'J' ;registers loaded? trap_ne 3743 : d0fe > bne * ;failed not equal (non zero) 3745 : e053 cpx #'S' trap_ne 3747 : d0fe > bne * ;failed not equal (non zero) 3749 : c04f cpy #('R'-3) trap_ne 374b : d0fe > bne * ;failed not equal (non zero) 374d : 48 pha ;save a,x 374e : 8a txa 374f : 48 pha 3750 : ba tsx ;sp -4? (return addr,a,x) 3751 : e0fb cpx #$fb trap_ne 3753 : d0fe > bne * ;failed not equal (non zero) 3755 : adff01 lda $1ff ;propper return on stack 3758 : c909 cmp #hi(jsr_ret) trap_ne 375a : d0fe > bne * ;failed not equal (non zero) 375c : adfe01 lda $1fe 375f : c99a cmp #lo(jsr_ret) trap_ne 3761 : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 3763 : a9ff > lda #$ff ;allow test to change > 3765 : 48 > pha ;use stack to load status 3766 : 28 > plp 3767 : 68 pla ;pull x,a 3768 : aa tax 3769 : 68 pla 376a : e8 inx ;return registers with modific 376b : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 376d : 60 rts trap ;runover protection 376e : 4c6e37 > jmp * ;failed anyway ;trap in case of unexpected IRQ, NMI, BRK, RESET - BRK 3771 : nmi_trap trap ;check stack for conditions at 3771 : 4c7137 > jmp * ;failed anyway 3774 : res_trap trap ;unexpected RESET 3774 : 4c7437 > jmp * ;failed anyway 3777 : 88 dey 3778 : 88 dey 3779 : irq_trap ;BRK test or unextpected BRK o 3779 : 08 php ;either SP or Y count will fai 377a : 88 dey 377b : 88 dey 377c : 88 dey ;next 4 traps could be caused by unexpected BR ;check stack for BREAK and originating locatio ;possible jump/branch into weeds (uninitialize 377d : c942 cmp #'B' ;registers loaded? trap_ne 377f : d0fe > bne * ;failed not equal (non zero) 3781 : e052 cpx #'R' trap_ne 3783 : d0fe > bne * ;failed not equal (non zero) 3785 : c048 cpy #('K'-3) trap_ne 3787 : d0fe > bne * ;failed not equal (non zero) 3789 : 850a sta irq_a ;save registers during break t 378b : 860b stx irq_x 378d : ba tsx ;test break on stack 378e : bd0201 lda $102,x cmp_flag 0 ;break test should have B=1 3791 : c930 > cmp #(0 |fao)&m8 ;expected flags + trap_ne ; - no break flag on stack 3793 : d0fe > bne * ;failed not equal (non zero) 3795 : 68 pla 3796 : c934 cmp #fai ;should have added interrupt d trap_ne 3798 : d0fe > bne * ;failed not equal (non zero) 379a : ba tsx 379b : e0fc cpx #$fc ;sp -3? (return addr, flags) trap_ne 379d : d0fe > bne * ;failed not equal (non zero) 379f : adff01 lda $1ff ;propper return on stack 37a2 : c909 cmp #hi(brk_ret) trap_ne 37a4 : d0fe > bne * ;failed not equal (non zero) 37a6 : adfe01 lda $1fe 37a9 : c9d1 cmp #lo(brk_ret) trap_ne 37ab : d0fe > bne * ;failed not equal (non zero) set_stat $ff > load_flag $ff 37ad : a9ff > lda #$ff ;allow test to change > 37af : 48 > pha ;use stack to load status 37b0 : 28 > plp 37b1 : a60b ldx irq_x 37b3 : e8 inx ;return registers with modific 37b4 : a50a lda irq_a 37b6 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 but origin 37b8 : 40 rti trap ;runover protection 37b9 : 4cb937 > jmp * ;failed anyway if report = 1 include "report.i65" endif ;copy of data to initialize BSS segment if load_data_direct != 1 zp_init zp1_ db $c3,$82,$41,0 ;test patterns for LDx BIT 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 patte dw abs1+1 dw abs1+2 dw abs1+3 dw abs7f inw1_ dw abs1-$f8 ;indirect pointer for wrap indt_ dw abst ;indirect pointer to store dw abst+1 dw abst+2 dw abst+3 inwt_ dw abst-$f8 ;indirect pointer for wrap indAN_ dw absAN ;indirect pointer to AND p dw absAN+1 dw absAN+2 dw absAN+3 indEO_ dw absEO ;indirect pointer to EOR p dw absEO+1 dw absEO+2 dw absEO+3 indOR_ dw absOR ;indirect pointer to OR pa dw absOR+1 dw absOR+2 dw absOR+3 ;add/subtract indirect pointers adi2_ dw ada2 ;indirect pointer to opera sbi2_ dw sba2 ;indirect pointer to compl adiy2_ dw ada2-$ff ;with offset for indirect 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 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 abs1_ db $c3,$82,$41,0 ;test patterns for LDx BIT abs7f_ db $7f ;test pattern for compare ;loads fLDx_ db fn,fn,0,fz ;expected flags for load ;shifts rASL_ ;expected result ASL & ROL rROL_ db $86,$04,$82,0 ; " rROLc_ db $87,$05,$83,1 ;expected result ROL +carr rLSR_ ;expected result LSR & ROR rROR_ db $61,$41,$20,0 ; " rRORc_ db $e1,$c1,$a0,$80 ;expected result ROR +carr fASL_ ;expected flags for shifts fROL_ db fnc,fc,fn,fz ;no carry in fROLc_ db fnc,fc,fn,0 ;carry in fLSR_ fROR_ db fc,0,fc,fz ;no carry in fRORc_ db fnc,fn,fnc,fn ;carry in ;increments (decrements) rINC_ db $7f,$80,$ff,0,1 ;expected result for INC/D fINC_ db 0,fn,fn,fz,0 ;expected flags for INC/DE ;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_ ;force assembler error if size is different ERROR ERROR ERROR ;mismatch between bss and 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 : 7137 dw nmi_trap fffc : 7437 dw res_trap fffe : 7937 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).