URL https://opencores.org/ocsvn/m65c02/m65c02/trunk

Subversion Repositories m65c02

[/] [m65c02/] [trunk/] [Src/] [M65C02-Test-Programs/] [Klaus2m5_Functional_Tests/] [65c02_ft.lst] - Diff between revs 2 and 3

Show entire file | Details | Blame | View Log

Rev 2	Rev 3
Line 5...	Line 5...

`Symbol Value Decimal`	`Symbol Value Decimal`

`absAN : $023f 575`	`absAN : $023f 575`
`absANa : $024b 587`	`absANa : $024b 587`
	`absANa_ : $3ed6 16086`
	`absAN_ : $3eca 16074`
`absEO : $0243 579`	`absEO : $0243 579`
`absEOa : $024f 591`	`absEOa : $024f 591`
	`absEOa_ : $3eda 16090`
	`absEO_ : $3ece 16078`
`absflo : $0257 599`	`absflo : $0257 599`
	`absflo_ : $3ee2 16098`
`absOR : $023b 571`	`absOR : $023b 571`
`absORa : $0247 583`	`absORa : $0247 583`
	`absORa_ : $3ed2 16082`
	`absOR_ : $3ec6 16070`
`absrlo : $0253 595`	`absrlo : $0253 595`
	`absrlo_ : $3ede 16094`
`abst : $0203 515`	`abst : $0203 515`
`abs1 : $0208 520`	`abs1 : $0208 520`
	`abs1_ : $3e93 16019`
`abs7f : $020c 524`	`abs7f : $020c 524`
	`abs7f_ : $3e97 16023`
`ada2 : $0203 515`	`ada2 : $0203 515`
`adfc : $000c 12`	`adfc : $00b2 178`
`adiy2 : $0056 86`	`adiy2 : $00fc 252`
`adi2 : $0052 82`	`adiy2_ : $3e8f 16015`
`adrf : $0011 17`	`adi2 : $00f8 248`
`adrh : $0010 16`	`adi2_ : $3e8b 16011`
`adrl : $000f 15`	`adrf : $00b7 183`
`ad1 : $000d 13`	`adrh : $00b6 182`
`ad2 : $000e 14`	`adrl : $00b5 181`
`bin_test : $31b8 12728`	`ad1 : $00b3 179`
	`ad2 : $00b4 180`
	`bin_test : $38fc 14588`
`break : $0010 16`	`break : $0010 16`
`brk_ret : $08b9 2233`	`brk_ret : $09bb 2491`
`br1 : $05c9 1481`	`br1 : $0613 1555`
`br11 : $060d 1549`	`br11 : $065d 1629`
`br12 : $0612 1554`	`br12 : $0661 1633`
`br13 : $0617 1559`	`br13 : $0665 1637`
`br14 : $0628 1576`	`br14 : $0671 1649`
`br2 : $05ce 1486`	`br2 : $0617 1559`
`br3 : $05d3 1491`	`br3 : $061b 1563`
`br4 : $05e4 1508`	`br4 : $0627 1575`
`carry : $0001 1`	`carry : $0001 1`
`check_ram :`	`check_ram :`
`chkadd : $3403 13315`	`chkadd : $3b90 15248`
`chkadi : $346e 13422 *`	`chkadi : $3c0b 15371 *`
`chkdad : $32d2 13010`	`chkdad : $3a1f 14879`
`chkdadi : $3325 13093 *`	`chkdadi : $3a82 14978 *`
`chkdsbi : $333c 13116 *`	`chkdsbi : $3a9d 15005 *`
`chksbi : $3485 13445 *`	`chksbi : $3c26 15398 *`
`ckad1 : $3418 13336`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 2`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`ckad1 : $3ba5 15269`
`cmp_flag :`	`cmp_flag :`
`code_segment : $0400 1024 *`	`code_segment : $0400 1024 *`
`data_bss : $0208 520`	`data_bss : $0208 520`
`data_bss_end : $025b 603`	`data_bss_end : $025b 603`
	`data_end : $3ee6 16102`
	`data_init : $3e93 16019`
`data_segment : $0200 512 *`	`data_segment : $0200 512 *`
`decmode : $0008 8`	`decmode : $0008 8`
`dec_test : $3220 12832`	`dec_test : $3968 14696`
`eor_flag :`	`eor_flag :`
`fASL : $0221 545`	`fASL : $0221 545`
	`fASL_ : $3eac 16044`
`fai : $0034 52`	`fai : $0034 52`
`fao : $0030 48`	`fao : $0030 48`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 2`	`far_ret : $08a8 2216`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`far_ret : $07f7 2039`
`fc : $0001 1`	`fc : $0001 1`
`fINC : $0236 566`	`fINC : $0236 566`
	`fINC_ : $3ec1 16065`
`fLDx : $020d 525`	`fLDx : $020d 525`
	`fLDx_ : $3e98 16024`
`fLSR : $0229 553`	`fLSR : $0229 553`
	`fLSR_ : $3eb4 16052`
`fn : $0080 128`	`fn : $0080 128`
`fnc : $0081 129`	`fnc : $0081 129`
`fnv : $00c0 192`	`fnv : $00c0 192`
`fnz : $0082 130`	`fnz : $0082 130`
`fnzc : $0083 131`	`fnzc : $0083 131`
`fROL : $0221 545`	`fROL : $0221 545`
`fROLc : $0225 549`	`fROLc : $0225 549`
	`fROLc_ : $3eb0 16048`
	`fROL_ : $3eac 16044`
`fROR : $0229 553`	`fROR : $0229 553`
`fRORc : $022d 557`	`fRORc : $022d 557`
	`fRORc_ : $3eb8 16056`
	`fROR_ : $3eb4 16052`
`fv : $0040 64`	`fv : $0040 64`
`fvz : $0042 66`	`fvz : $0042 66`
`fz : $0002 2`	`fz : $0002 2`
`fzc : $0003 3`	`fzc : $0003 3`
`I_flag : $0003 3 *`	`I_flag : $0003 3 *`
`indAN : $003a 58`	`indAN : $00e0 224`
`indEO : $0042 66`	`indAN_ : $3e73 15987`
`indOR : $004a 74`	`indEO : $00e8 232`
`indt : $0030 48`	`indEO_ : $3e7b 15995`
`ind1 : $0024 36`	`indOR : $00f0 240`
`ind_ret : $084c 2124`	`indOR_ : $3e83 16003`
	`indt : $00d6 214`
	`indt_ : $3e69 15977`
	`ind1 : $00ca 202`
	`ind1_ : $3e5d 15965`
	`ind_ret : $091f 2335`
`intdis : $0004 4`	`intdis : $0004 4`
`inwt : $0038 56`	`inwt : $00de 222`
`inw1 : $002e 46`	`inwt_ : $3e71 15985`
`irq_a : $000a 10`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 3`
`irq_trap : $35fd 13821`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`irq_x : $000b 11`
`jsr_ret : $0882 2178 *`	`inw1 : $00d4 212`
`load_data_direct : $0001 1 *`	`inw1_ : $3e67 15975`
	`irq_a : $00b0 176`
	`irq_trap : $3dfa 15866`
	`irq_x : $00b1 177`
	`jsr_ret : $0967 2407 *`
	`ld_data : $0412 1042`
	`ld_zp : $0408 1032`
	`load_data_direct : $0000 0 *`
`load_flag :`	`load_flag :`
`minus : $0080 128`	`minus : $0080 128`
`m8 : $00ff 255`	`m8 : $00ff 255`
`m8i : $00fb 251`	`m8i : $00fb 251`
`nbr1 : $05d8 1496`	`nbr1 : $061f 1567`
`nbr11 : $061c 1564`	`nbr11 : $0669 1641`
`nbr12 : $061f 1567`	`nbr12 : $066b 1643`
`nbr13 : $0622 1570`	`nbr13 : $066d 1645`
`nbr14 : $0625 1573`	`nbr14 : $066f 1647`
`nbr2 : $05db 1499`	`nbr2 : $0621 1569`
`nbr3 : $05de 1502`	`nbr3 : $0623 1571`
`nbr4 : $05e1 1505`	`nbr4 : $0625 1573`
`next_test :`	`next_test :`
`nmi_trap : $35f5 13813`	`nmi_trap : $3df4 15860`
`overfl : $0040 64`	`overfl : $0040 64`
`ptr_ind_ret : $357e 13694`	`ptr_ind_ret : $3d5c 15708`
`ptr_tst_ind : $357c 13692`	`ptr_tst_ind : $3d5a 15706`
`ROM_vectors : $0001 1 *`	`ROM_vectors : $0000 0 *`
`rASL : $0211 529`	`rASL : $0211 529`
	`rASL_ : $3e9c 16028`
`ram_chksm : $0201 513`	`ram_chksm : $0201 513`
`ram_top : $ffff -1 *`	`ram_top : $ffff -1 *`
`range_adr : $04a5 1189 *`	`range_adr : $04bc 1212 *`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 3`	`range_end : $0547 1351`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`range_fw : $0433 1075`
	`range_loop : $042b 1067`
`range_end : $0531 1329`	`range_ok : $0540 1344`
`range_fw : $041c 1052`	`range_op : $04bb 1211`
`range_loop : $0414 1044`
`range_ok : $052a 1322`
`range_op : $04a4 1188`
`reserv : $0020 32`	`reserv : $0020 32`
`res_trap : $35f8 13816`	`res_trap : $3df6 15862`
`rINC : $0231 561`	`rINC : $0231 561`
	`rINC_ : $3ebc 16060`
`rLSR : $0219 537`	`rLSR : $0219 537`
	`rLSR_ : $3ea4 16036`
`rROL : $0211 529`	`rROL : $0211 529`
`rROLc : $0215 533`	`rROLc : $0215 533`
	`rROLc_ : $3ea0 16032`
	`rROL_ : $3e9c 16028`
`rROR : $0219 537`	`rROR : $0219 537`
`rRORc : $021d 541`	`rRORc : $021d 541`
	`rRORc_ : $3ea8 16040`
	`rROR_ : $3ea4 16036`
`sba2 : $0204 516`	`sba2 : $0204 516`
`sbiy2 : $0058 88`	`sbiy2 : $00fe 254`
`sbi2 : $0054 84`	`sbiy2_ : $3e91 16017`
`sb2 : $0012 18`	`sbi2 : $00fa 250`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 4`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`sbi2_ : $3e8d 16013`
	`sb2 : $00b8 184`
`set_a :`	`set_a :`
`set_abs :`	`set_abs :`
`set_absx :`	`set_absx :`
`set_ax :`	`set_ax :`
`set_ay :`	`set_ay :`
`set_stat :`	`set_stat :`
`set_x :`	`set_x :`
`set_y :`	`set_y :`
`set_z :`	`set_z :`
`set_zx :`	`set_zx :`
`skip_bin_test : $0001 1 *`	`skip0002 : $0424 1060`
`skip_dec_test : $0001 1 *`	`skip0006 : $0550 1360`
	`skip0009 : $0563 1379`
	`skip0011 : $0567 1383`
	`skip0013 : $056b 1387`
	`skip0015 : $0571 1393`
	`skip0017 : $0575 1397`
	`skip0019 : $0579 1401`
	`skip0021 : $0580 1408`
	`skip0023 : $0584 1412`
	`skip0025 : $0588 1416`
	`skip0027 : $058e 1422`
	`skip0029 : $0592 1426`
	`skip0031 : $0596 1430`
	`skip0033 : $059d 1437`
	`skip0035 : $05a1 1441`
	`skip0037 : $05a5 1445`
	`skip0039 : $05ab 1451`
	`skip0041 : $05af 1455`
	`skip0043 : $05b3 1459`
	`skip0046 : $05bc 1468`
	`skip0048 : $05d1 1489`
	`skip0050 : $05d9 1497`
	`skip0052 : $05e0 1504`
	`skip0054 : $05e7 1511`
	`skip0056 : $05ee 1518`
	`skip0058 : $05f5 1525`
	`skip0061 : $05fe 1534`
	`skip0073 : $062f 1583`
	`skip0076 : $0636 1590`
	`skip0078 : $063d 1597`
	`skip0082 : $064d 1613`
	`skip0084 : $0651 1617`
	`skip0086 : $0655 1621`
	`skip0088 : $0659 1625`
	`skip0099 : $0679 1657`
	`skip0103 : $0681 1665`
	`skip0107 : $0689 1673`
	`skip0111 : $0691 1681`
	`skip0115 : $0699 1689`
	`skip0119 : $06a1 1697`
	`skip0123 : $06a9 1705`
	`skip0127 : $06b1 1713`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 5`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip0131 : $06b9 1721`
	`skip0134 : $06c2 1730`
	`skip0139 : $06da 1754`
	`skip0142 : $06e1 1761`
	`skip0147 : $06f1 1777`
	`skip0150 : $06f8 1784`
	`skip0155 : $0708 1800`
	`skip0158 : $070f 1807`
	`skip0163 : $071f 1823`
	`skip0166 : $0726 1830`
	`skip0171 : $0736 1846`
	`skip0174 : $073d 1853`
	`skip0179 : $074d 1869`
	`skip0182 : $0754 1876`
	`skip0187 : $0764 1892`
	`skip0190 : $076b 1899`
	`skip0195 : $077b 1915`
	`skip0198 : $0782 1922`
	`skip0203 : $0792 1938`
	`skip0206 : $0799 1945`
	`skip0211 : $07a9 1961`
	`skip0214 : $07b0 1968`
	`skip0219 : $07c0 1984`
	`skip0222 : $07c7 1991`
	`skip0227 : $07d7 2007`
	`skip0230 : $07de 2014`
	`skip0232 : $07e5 2021`
	`skip0234 : $07eb 2027`
	`skip0237 : $07f4 2036`
	`skip0242 : $0809 2057`
	`skip0245 : $0810 2064`
	`skip0250 : $0821 2081`
	`skip0253 : $0828 2088`
	`skip0256 : $0832 2098`
	`skip0261 : $084a 2122`
	`skip0264 : $0851 2129`
	`skip0266 : $0858 2136`
	`skip0268 : $085e 2142`
	`skip0273 : $0871 2161`
	`skip0276 : $0878 2168`
	`skip0278 : $087f 2175`
	`skip0280 : $0885 2181`
	`skip0283 : $088e 2190`
	`skip0287 : $08a6 2214`
	`skip0289 : $08ac 2220`
	`skip0291 : $08b0 2224`
	`skip0293 : $08b4 2228`
	`skip0295 : $08b8 2232`
	`skip0297 : $08be 2238`
	`skip0299 : $08c4 2244`
	`skip0301 : $08ca 2250`
	`skip0303 : $08d9 2265`
	`skip0305 : $08df 2271`
	`skip0307 : $08e3 2275`
	`skip0309 : $08e7 2279`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 6`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip0311 : $08eb 2283`
	`skip0313 : $08f1 2289`
	`skip0315 : $08f7 2295`
	`skip0317 : $08fd 2301`
	`skip0320 : $0906 2310`
	`skip0324 : $091d 2333`
	`skip0326 : $0928 2344`
	`skip0328 : $092c 2348`
	`skip0330 : $0930 2352`
	`skip0332 : $0934 2356`
	`skip0334 : $093a 2362`
	`skip0336 : $0940 2368`
	`skip0338 : $0946 2374`
	`skip0340 : $094d 2381`
	`skip0343 : $0956 2390`
	`skip0347 : $0971 2417`
	`skip0349 : $0975 2421`
	`skip0351 : $0979 2425`
	`skip0353 : $097d 2429`
	`skip0355 : $0983 2435`
	`skip0357 : $0989 2441`
	`skip0359 : $098f 2447`
	`skip0361 : $0996 2454`
	`skip0364 : $099f 2463`
	`skip0368 : $09c5 2501`
	`skip0370 : $09cb 2507`
	`skip0372 : $09d1 2513`
	`skip0375 : $09d8 2520`
	`skip0377 : $09df 2527`
	`skip0380 : $09e8 2536`
	`skip0386 : $09fb 2555`
	`skip0390 : $0a06 2566`
	`skip0394 : $0a11 2577`
	`skip0398 : $0a1c 2588`
	`skip0402 : $0a27 2599`
	`skip0406 : $0a32 2610`
	`skip0410 : $0a3d 2621`
	`skip0416 : $0a4b 2635`
	`skip0420 : $0a56 2646`
	`skip0424 : $0a61 2657`
	`skip0428 : $0a6c 2668`
	`skip0432 : $0a77 2679`
	`skip0436 : $0a82 2690`
	`skip0440 : $0a8d 2701`
	`skip0446 : $0a9b 2715`
	`skip0450 : $0aa6 2726`
	`skip0453 : $0ab0 2736`
	`skip0458 : $0ac4 2756`
	`skip0461 : $0acb 2763`
	`skip0464 : $0ad5 2773`
	`skip0467 : $0adc 2780`
	`skip0470 : $0ae6 2790`
	`skip0473 : $0aed 2797`
	`skip0476 : $0af7 2807`
	`skip0479 : $0afe 2814`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 7`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip0482 : $0b08 2824`
	`skip0485 : $0b0f 2831`
	`skip0490 : $0b1e 2846`
	`skip0493 : $0b25 2853`
	`skip0496 : $0b2f 2863`
	`skip0499 : $0b36 2870`
	`skip0502 : $0b40 2880`
	`skip0505 : $0b47 2887`
	`skip0508 : $0b51 2897`
	`skip0511 : $0b58 2904`
	`skip0514 : $0b62 2914`
	`skip0517 : $0b69 2921`
	`skip0522 : $0b79 2937`
	`skip0525 : $0b80 2944`
	`skip0528 : $0b8a 2954`
	`skip0531 : $0b91 2961`
	`skip0534 : $0b9b 2971`
	`skip0537 : $0ba2 2978`
	`skip0540 : $0bac 2988`
	`skip0543 : $0bb3 2995`
	`skip0546 : $0bbd 3005`
	`skip0549 : $0bc4 3012`
	`skip0554 : $0bd3 3027`
	`skip0557 : $0bda 3034`
	`skip0560 : $0be4 3044`
	`skip0563 : $0beb 3051`
	`skip0566 : $0bf5 3061`
	`skip0569 : $0bfc 3068`
	`skip0572 : $0c06 3078`
	`skip0575 : $0c0d 3085`
	`skip0578 : $0c17 3095`
	`skip0581 : $0c1e 3102`
	`skip0586 : $0c2e 3118`
	`skip0589 : $0c35 3125`
	`skip0592 : $0c42 3138`
	`skip0595 : $0c49 3145`
	`skip0598 : $0c56 3158`
	`skip0601 : $0c5d 3165`
	`skip0606 : $0c6b 3179`
	`skip0609 : $0c72 3186`
	`skip0612 : $0c7f 3199`
	`skip0615 : $0c86 3206`
	`skip0618 : $0c93 3219`
	`skip0621 : $0c9a 3226`
	`skip0626 : $0caa 3242`
	`skip0629 : $0cb1 3249`
	`skip0632 : $0cbe 3262`
	`skip0635 : $0cc5 3269`
	`skip0638 : $0cd2 3282`
	`skip0641 : $0cd9 3289`
	`skip0646 : $0ce7 3303`
	`skip0649 : $0cee 3310`
	`skip0652 : $0cfb 3323`
	`skip0655 : $0d02 3330`
	`skip0658 : $0d0f 3343`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 8`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip0661 : $0d16 3350`
	`skip0665 : $0d27 3367`
	`skip0668 : $0d2e 3374`
	`skip0671 : $0d3c 3388`
	`skip0674 : $0d43 3395`
	`skip0677 : $0d51 3409`
	`skip0680 : $0d58 3416`
	`skip0684 : $0d69 3433`
	`skip0687 : $0d70 3440`
	`skip0690 : $0d7e 3454`
	`skip0693 : $0d85 3461`
	`skip0696 : $0d93 3475`
	`skip0699 : $0d9a 3482`
	`skip0703 : $0dab 3499`
	`skip0706 : $0db2 3506`
	`skip0709 : $0dc0 3520`
	`skip0712 : $0dc7 3527`
	`skip0715 : $0dd5 3541`
	`skip0718 : $0ddc 3548`
	`skip0722 : $0ded 3565`
	`skip0725 : $0df4 3572`
	`skip0728 : $0e02 3586`
	`skip0731 : $0e09 3593`
	`skip0734 : $0e17 3607`
	`skip0737 : $0e1e 3614`
	`skip0740 : $0e28 3624`
	`skip0745 : $0e3e 3646`
	`skip0750 : $0e4d 3661`
	`skip0755 : $0e5d 3677`
	`skip0760 : $0e6c 3692`
	`skip0765 : $0e7c 3708`
	`skip0772 : $0e96 3734`
	`skip0775 : $0e9f 3743`
	`skip0779 : $0eab 3755`
	`skip0782 : $0eb4 3764`
	`skip0786 : $0ec0 3776`
	`skip0789 : $0ec9 3785`
	`skip0793 : $0ed8 3800`
	`skip0796 : $0ee1 3809`
	`skip0800 : $0eed 3821`
	`skip0803 : $0ef6 3830`
	`skip0807 : $0f02 3842`
	`skip0810 : $0f0b 3851`
	`skip0813 : $0f15 3861`
	`skip0817 : $0f34 3892`
	`skip0820 : $0f3e 3902`
	`skip0824 : $0f5b 3931`
	`skip0827 : $0f65 3941`
	`skip0831 : $0f83 3971`
	`skip0834 : $0f8d 3981`
	`skip0838 : $0fab 4011`
	`skip0841 : $0fb5 4021`
	`skip0843 : $0fc8 4040`
	`skip0845 : $0fd6 4054`
	`skip0848 : $0fe6 4070`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 9`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip0850 : $1012 4114`
	`skip0852 : $101e 4126`
	`skip0855 : $102e 4142`
	`skip0859 : $104d 4173`
	`skip0862 : $1057 4183`
	`skip0866 : $1074 4212`
	`skip0869 : $107e 4222`
	`skip0873 : $109b 4251`
	`skip0876 : $10a5 4261`
	`skip0880 : $10c2 4290`
	`skip0883 : $10cc 4300`
	`skip0885 : $10dd 4317`
	`skip0887 : $10eb 4331`
	`skip0890 : $10fb 4347`
	`skip0892 : $1125 4389`
	`skip0894 : $1131 4401`
	`skip0897 : $1141 4417`
	`skip0901 : $115f 4447`
	`skip0904 : $1169 4457`
	`skip0908 : $1182 4482`
	`skip0911 : $118c 4492`
	`skip0915 : $11a5 4517`
	`skip0918 : $11af 4527`
	`skip0922 : $11c8 4552`
	`skip0925 : $11d2 4562`
	`skip0929 : $11eb 4587`
	`skip0932 : $11f5 4597`
	`skip0936 : $120e 4622`
	`skip0939 : $1218 4632`
	`skip0943 : $1231 4657`
	`skip0946 : $123b 4667`
	`skip0950 : $1254 4692`
	`skip0953 : $125e 4702`
	`skip0957 : $1276 4726`
	`skip0960 : $1280 4736`
	`skip0964 : $1298 4760`
	`skip0967 : $12a2 4770`
	`skip0971 : $12ba 4794`
	`skip0974 : $12c4 4804`
	`skip0978 : $12dc 4828`
	`skip0981 : $12e6 4838`
	`skip0985 : $12ff 4863`
	`skip0988 : $1309 4873`
	`skip0992 : $1322 4898`
	`skip0995 : $132c 4908`
	`skip0999 : $1345 4933`
	`skip1002 : $134f 4943`
	`skip1006 : $1368 4968`
	`skip1009 : $1372 4978`
	`skip1013 : $1380 4992`
	`skip1016 : $138a 5002`
	`skip1020 : $1398 5016`
	`skip1023 : $13a2 5026`
	`skip1027 : $13b0 5040`
	`skip1030 : $13ba 5050`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 10`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip1034 : $13c8 5064`
	`skip1037 : $13d2 5074`
	`skip1041 : $13e0 5088`
	`skip1044 : $13ea 5098`
	`skip1048 : $13f8 5112`
	`skip1051 : $1402 5122`
	`skip1055 : $1410 5136`
	`skip1058 : $141a 5146`
	`skip1062 : $1428 5160`
	`skip1065 : $1432 5170`
	`skip1067 : $143e 5182`
	`skip1069 : $144c 5196`
	`skip1071 : $1459 5209`
	`skip1073 : $1467 5223`
	`skip1075 : $1474 5236`
	`skip1077 : $1482 5250`
	`skip1079 : $148f 5263`
	`skip1081 : $149d 5277`
	`skip1084 : $14a9 5289`
	`skip1088 : $14c7 5319`
	`skip1091 : $14d1 5329`
	`skip1095 : $14ea 5354`
	`skip1098 : $14f4 5364`
	`skip1102 : $150d 5389`
	`skip1105 : $1517 5399`
	`skip1109 : $1530 5424`
	`skip1112 : $153a 5434`
	`skip1116 : $1553 5459`
	`skip1119 : $155d 5469`
	`skip1123 : $1576 5494`
	`skip1126 : $1580 5504`
	`skip1130 : $1599 5529`
	`skip1133 : $15a3 5539`
	`skip1137 : $15bc 5564`
	`skip1140 : $15c6 5574`
	`skip1144 : $15df 5599`
	`skip1147 : $15e9 5609`
	`skip1151 : $1602 5634`
	`skip1154 : $160c 5644`
	`skip1158 : $1625 5669`
	`skip1161 : $162f 5679`
	`skip1165 : $1648 5704`
	`skip1168 : $1652 5714`
	`skip1172 : $166b 5739`
	`skip1175 : $1675 5749`
	`skip1179 : $168e 5774`
	`skip1182 : $1698 5784`
	`skip1186 : $16b1 5809`
	`skip1189 : $16bb 5819`
	`skip1193 : $16d4 5844`
	`skip1196 : $16de 5854`
	`skip1200 : $16ec 5868`
	`skip1203 : $16f6 5878`
	`skip1207 : $1704 5892`
	`skip1210 : $170e 5902`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 11`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip1214 : $171c 5916`
	`skip1217 : $1726 5926`
	`skip1221 : $1734 5940`
	`skip1224 : $173e 5950`
	`skip1228 : $174c 5964`
	`skip1231 : $1756 5974`
	`skip1235 : $1764 5988`
	`skip1238 : $176e 5998`
	`skip1242 : $177c 6012`
	`skip1245 : $1786 6022`
	`skip1249 : $1794 6036`
	`skip1252 : $179e 6046`
	`skip1254 : $17aa 6058`
	`skip1256 : $17b8 6072`
	`skip1258 : $17c5 6085`
	`skip1260 : $17d3 6099`
	`skip1262 : $17e0 6112`
	`skip1264 : $17ee 6126`
	`skip1266 : $17fb 6139`
	`skip1268 : $1809 6153`
	`skip1271 : $1815 6165`
	`skip1275 : $1833 6195`
	`skip1278 : $183d 6205`
	`skip1282 : $1859 6233`
	`skip1285 : $1863 6243`
	`skip1289 : $187e 6270`
	`skip1292 : $1888 6280`
	`skip1296 : $18a3 6307`
	`skip1299 : $18ad 6317`
	`skip1301 : $18be 6334`
	`skip1303 : $18cc 6348`
	`skip1306 : $18dc 6364`
	`skip1310 : $18fa 6394`
	`skip1313 : $1904 6404`
	`skip1317 : $1920 6432`
	`skip1320 : $192a 6442`
	`skip1322 : $193d 6461`
	`skip1326 : $195c 6492`
	`skip1329 : $1966 6502`
	`skip1333 : $1981 6529`
	`skip1336 : $198b 6539`
	`skip1338 : $199e 6558`
	`skip1342 : $19bf 6591`
	`skip1345 : $19c9 6601`
	`skip1349 : $19e8 6632`
	`skip1352 : $19f2 6642`
	`skip1354 : $1a07 6663`
	`skip1357 : $1a17 6679`
	`skip1359 : $1a40 6720`
	`skip1361 : $1a4c 6732`
	`skip1363 : $1a71 6769`
	`skip1365 : $1a92 6802`
	`skip1367 : $1ab6 6838`
	`skip1370 : $1ac6 6854`
	`skip1374 : $1ae1 6881`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 12`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip1377 : $1aeb 6891`
	`skip1381 : $1b01 6913`
	`skip1384 : $1b0b 6923`
	`skip1388 : $1b21 6945`
	`skip1391 : $1b2b 6955`
	`skip1395 : $1b41 6977`
	`skip1398 : $1b4b 6987`
	`skip1402 : $1b61 7009`
	`skip1405 : $1b6b 7019`
	`skip1409 : $1b81 7041`
	`skip1412 : $1b8b 7051`
	`skip1416 : $1ba1 7073`
	`skip1419 : $1bab 7083`
	`skip1423 : $1bc1 7105`
	`skip1426 : $1bcb 7115`
	`skip1430 : $1be1 7137`
	`skip1433 : $1beb 7147`
	`skip1437 : $1c01 7169`
	`skip1440 : $1c0b 7179`
	`skip1444 : $1c21 7201`
	`skip1447 : $1c2b 7211`
	`skip1451 : $1c41 7233`
	`skip1454 : $1c4b 7243`
	`skip1458 : $1c61 7265`
	`skip1461 : $1c6b 7275`
	`skip1465 : $1c81 7297`
	`skip1468 : $1c8b 7307`
	`skip1472 : $1ca1 7329`
	`skip1475 : $1cab 7339`
	`skip1479 : $1cc1 7361`
	`skip1482 : $1ccb 7371`
	`skip1486 : $1cd9 7385`
	`skip1489 : $1ce3 7395`
	`skip1493 : $1cf1 7409`
	`skip1496 : $1cfb 7419`
	`skip1500 : $1d09 7433`
	`skip1503 : $1d13 7443`
	`skip1507 : $1d21 7457`
	`skip1510 : $1d2b 7467`
	`skip1514 : $1d39 7481`
	`skip1517 : $1d43 7491`
	`skip1521 : $1d51 7505`
	`skip1524 : $1d5b 7515`
	`skip1528 : $1d69 7529`
	`skip1531 : $1d73 7539`
	`skip1535 : $1d81 7553`
	`skip1538 : $1d8b 7563`
	`skip1540 : $1d97 7575`
	`skip1542 : $1da5 7589`
	`skip1544 : $1db2 7602`
	`skip1546 : $1dc0 7616`
	`skip1548 : $1dcd 7629`
	`skip1550 : $1ddb 7643`
	`skip1552 : $1de8 7656`
	`skip1554 : $1df6 7670`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 13`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip1557 : $1e02 7682`
	`skip1562 : $1e17 7703`
	`skip1565 : $1e1e 7710`
	`skip1570 : $1e2f 7727`
	`skip1573 : $1e36 7734`
	`skip1578 : $1e47 7751`
	`skip1581 : $1e4e 7758`
	`skip1586 : $1e5f 7775`
	`skip1589 : $1e66 7782`
	`skip1594 : $1e77 7799`
	`skip1597 : $1e7e 7806`
	`skip1602 : $1e8f 7823`
	`skip1605 : $1e96 7830`
	`skip1610 : $1ea7 7847`
	`skip1613 : $1eae 7854`
	`skip1618 : $1ebf 7871`
	`skip1621 : $1ec6 7878`
	`skip1626 : $1ed8 7896`
	`skip1629 : $1edf 7903`
	`skip1634 : $1ef1 7921`
	`skip1637 : $1ef8 7928`
	`skip1642 : $1f0a 7946`
	`skip1645 : $1f11 7953`
	`skip1650 : $1f23 7971`
	`skip1653 : $1f2a 7978`
	`skip1658 : $1f3c 7996`
	`skip1661 : $1f43 8003`
	`skip1666 : $1f55 8021`
	`skip1669 : $1f5c 8028`
	`skip1674 : $1f6e 8046`
	`skip1677 : $1f75 8053`
	`skip1682 : $1f87 8071`
	`skip1685 : $1f8e 8078`
	`skip1688 : $1f98 8088`
	`skip1694 : $1fae 8110`
	`skip1698 : $1fbb 8123`
	`skip1701 : $1fc7 8135`
	`skip1704 : $1fce 8142`
	`skip1710 : $1fe0 8160`
	`skip1714 : $1fed 8173`
	`skip1717 : $1ff9 8185`
	`skip1720 : $2000 8192`
	`skip1726 : $2013 8211`
	`skip1730 : $2021 8225`
	`skip1733 : $202e 8238`
	`skip1736 : $2035 8245`
	`skip1742 : $2048 8264`
	`skip1746 : $2056 8278`
	`skip1749 : $2063 8291`
	`skip1752 : $206a 8298`
	`skip1758 : $207c 8316`
	`skip1762 : $2089 8329`
	`skip1765 : $2095 8341`
	`skip1768 : $209c 8348`
	`skip1774 : $20ae 8366`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 14`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip1778 : $20bb 8379`
	`skip1781 : $20c7 8391`
	`skip1784 : $20ce 8398`
	`skip1787 : $20d8 8408`
	`skip1793 : $20ee 8430`
	`skip1797 : $20fb 8443`
	`skip1800 : $2107 8455`
	`skip1803 : $210e 8462`
	`skip1809 : $2120 8480`
	`skip1813 : $212d 8493`
	`skip1816 : $2139 8505`
	`skip1819 : $2140 8512`
	`skip1825 : $2153 8531`
	`skip1829 : $2161 8545`
	`skip1832 : $216e 8558`
	`skip1835 : $2175 8565`
	`skip1841 : $2188 8584`
	`skip1845 : $2196 8598`
	`skip1848 : $21a3 8611`
	`skip1851 : $21aa 8618`
	`skip1857 : $21bc 8636`
	`skip1861 : $21c9 8649`
	`skip1864 : $21d5 8661`
	`skip1867 : $21dc 8668`
	`skip1873 : $21ee 8686`
	`skip1877 : $21fb 8699`
	`skip1880 : $2207 8711`
	`skip1883 : $220e 8718`
	`skip1886 : $2218 8728`
	`skip1891 : $222d 8749`
	`skip1894 : $2234 8756`
	`skip1899 : $2245 8773`
	`skip1902 : $224c 8780`
	`skip1907 : $225d 8797`
	`skip1910 : $2264 8804`
	`skip1915 : $2275 8821`
	`skip1918 : $227c 8828`
	`skip1923 : $228d 8845`
	`skip1926 : $2294 8852`
	`skip1931 : $22a5 8869`
	`skip1934 : $22ac 8876`
	`skip1939 : $22be 8894`
	`skip1942 : $22c5 8901`
	`skip1947 : $22d7 8919`
	`skip1950 : $22de 8926`
	`skip1955 : $22f0 8944`
	`skip1958 : $22f7 8951`
	`skip1963 : $2309 8969`
	`skip1966 : $2310 8976`
	`skip1971 : $2322 8994`
	`skip1974 : $2329 9001`
	`skip1979 : $233b 9019`
	`skip1982 : $2342 9026`
	`skip1987 : $2353 9043`
	`skip1990 : $235a 9050`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 15`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip1995 : $236b 9067`
	`skip1998 : $2372 9074`
	`skip2003 : $2383 9091`
	`skip2006 : $238a 9098`
	`skip2011 : $239b 9115`
	`skip2014 : $23a2 9122`
	`skip2019 : $23b3 9139`
	`skip2022 : $23ba 9146`
	`skip2027 : $23cb 9163`
	`skip2030 : $23d2 9170`
	`skip2035 : $23e5 9189`
	`skip2038 : $23ec 9196`
	`skip2043 : $23fd 9213`
	`skip2046 : $2404 9220`
	`skip2051 : $2415 9237`
	`skip2054 : $241c 9244`
	`skip2059 : $242d 9261`
	`skip2062 : $2434 9268`
	`skip2067 : $2445 9285`
	`skip2070 : $244c 9292`
	`skip2075 : $245d 9309`
	`skip2078 : $2464 9316`
	`skip2083 : $2476 9334`
	`skip2086 : $247d 9341`
	`skip2091 : $248f 9359`
	`skip2094 : $2496 9366`
	`skip2099 : $24a8 9384`
	`skip2102 : $24af 9391`
	`skip2107 : $24c1 9409`
	`skip2110 : $24c8 9416`
	`skip2115 : $24da 9434`
	`skip2118 : $24e1 9441`
	`skip2123 : $24f3 9459`
	`skip2126 : $24fa 9466`
	`skip2131 : $2510 9488`
	`skip2134 : $2517 9495`
	`skip2139 : $2529 9513`
	`skip2142 : $2530 9520`
	`skip2147 : $2542 9538`
	`skip2150 : $2549 9545`
	`skip2155 : $255b 9563`
	`skip2158 : $2562 9570`
	`skip2163 : $2574 9588`
	`skip2166 : $257b 9595`
	`skip2171 : $258d 9613`
	`skip2174 : $2594 9620`
	`skip2179 : $25a5 9637`
	`skip2182 : $25ac 9644`
	`skip2187 : $25bd 9661`
	`skip2190 : $25c4 9668`
	`skip2195 : $25d5 9685`
	`skip2198 : $25dc 9692`
	`skip2203 : $25ed 9709`
	`skip2206 : $25f4 9716`
	`skip2211 : $2605 9733`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 16`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip2214 : $260c 9740`
	`skip2219 : $261d 9757`
	`skip2222 : $2624 9764`
	`skip2227 : $2635 9781`
	`skip2230 : $263c 9788`
	`skip2235 : $264d 9805`
	`skip2238 : $2654 9812`
	`skip2243 : $2665 9829`
	`skip2246 : $266c 9836`
	`skip2251 : $267d 9853`
	`skip2254 : $2684 9860`
	`skip2259 : $2695 9877`
	`skip2262 : $269c 9884`
	`skip2267 : $26ad 9901`
	`skip2270 : $26b4 9908`
	`skip2273 : $26be 9918`
	`skip2278 : $26d4 9940`
	`skip2281 : $26de 9950`
	`skip2286 : $26f2 9970`
	`skip2289 : $26fc 9980`
	`skip2294 : $2710 10000`
	`skip2297 : $271a 10010`
	`skip2302 : $272e 10030`
	`skip2305 : $2738 10040`
	`skip2310 : $274c 10060`
	`skip2313 : $2756 10070`
	`skip2318 : $276a 10090`
	`skip2321 : $2774 10100`
	`skip2326 : $2788 10120`
	`skip2329 : $2792 10130`
	`skip2334 : $27a6 10150`
	`skip2337 : $27b0 10160`
	`skip2342 : $27c4 10180`
	`skip2345 : $27ce 10190`
	`skip2350 : $27e2 10210`
	`skip2353 : $27ec 10220`
	`skip2358 : $2800 10240`
	`skip2361 : $280a 10250`
	`skip2366 : $281e 10270`
	`skip2369 : $2828 10280`
	`skip2372 : $2834 10292`
	`skip2377 : $284f 10319`
	`skip2380 : $2859 10329`
	`skip2385 : $2872 10354`
	`skip2388 : $287c 10364`
	`skip2393 : $2895 10389`
	`skip2396 : $289f 10399`
	`skip2401 : $28b8 10424`
	`skip2404 : $28c2 10434`
	`skip2409 : $28db 10459`
	`skip2412 : $28e5 10469`
	`skip2417 : $28fe 10494`
	`skip2420 : $2908 10504`
	`skip2425 : $2921 10529`
	`skip2428 : $292b 10539`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 17`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip2433 : $2944 10564`
	`skip2436 : $294e 10574`
	`skip2441 : $2967 10599`
	`skip2444 : $2971 10609`
	`skip2449 : $298a 10634`
	`skip2452 : $2994 10644`
	`skip2457 : $29ad 10669`
	`skip2460 : $29b7 10679`
	`skip2465 : $29d0 10704`
	`skip2468 : $29da 10714`
	`skip2471 : $29e6 10726`
	`skip2476 : $2a04 10756`
	`skip2479 : $2a0e 10766`
	`skip2484 : $2a2a 10794`
	`skip2487 : $2a34 10804`
	`skip2492 : $2a50 10832`
	`skip2495 : $2a5a 10842`
	`skip2500 : $2a76 10870`
	`skip2503 : $2a80 10880`
	`skip2508 : $2a9c 10908`
	`skip2511 : $2aa6 10918`
	`skip2516 : $2ac2 10946`
	`skip2519 : $2acc 10956`
	`skip2524 : $2ae8 10984`
	`skip2527 : $2af2 10994`
	`skip2532 : $2b0e 11022`
	`skip2535 : $2b18 11032`
	`skip2540 : $2b34 11060`
	`skip2543 : $2b3e 11070`
	`skip2548 : $2b5a 11098`
	`skip2551 : $2b64 11108`
	`skip2556 : $2b80 11136`
	`skip2559 : $2b8a 11146`
	`skip2564 : $2ba6 11174`
	`skip2567 : $2bb0 11184`
	`skip2570 : $2bbc 11196`
	`skip2575 : $2bd7 11223`
	`skip2578 : $2be1 11233`
	`skip2583 : $2bfa 11258`
	`skip2586 : $2c04 11268`
	`skip2591 : $2c1d 11293`
	`skip2594 : $2c27 11303`
	`skip2599 : $2c40 11328`
	`skip2602 : $2c4a 11338`
	`skip2607 : $2c63 11363`
	`skip2610 : $2c6d 11373`
	`skip2615 : $2c86 11398`
	`skip2618 : $2c90 11408`
	`skip2623 : $2ca9 11433`
	`skip2626 : $2cb3 11443`
	`skip2631 : $2ccc 11468`
	`skip2634 : $2cd6 11478`
	`skip2639 : $2cef 11503`
	`skip2642 : $2cf9 11513`
	`skip2647 : $2d12 11538`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 18`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip2650 : $2d1c 11548`
	`skip2655 : $2d35 11573`
	`skip2658 : $2d3f 11583`
	`skip2663 : $2d58 11608`
	`skip2666 : $2d62 11618`
	`skip2669 : $2d6e 11630`
	`skip2674 : $2d8c 11660`
	`skip2677 : $2d96 11670`
	`skip2682 : $2db2 11698`
	`skip2685 : $2dbc 11708`
	`skip2690 : $2dd8 11736`
	`skip2693 : $2de2 11746`
	`skip2698 : $2dfe 11774`
	`skip2701 : $2e08 11784`
	`skip2706 : $2e24 11812`
	`skip2709 : $2e2e 11822`
	`skip2714 : $2e4a 11850`
	`skip2717 : $2e54 11860`
	`skip2722 : $2e70 11888`
	`skip2725 : $2e7a 11898`
	`skip2730 : $2e96 11926`
	`skip2733 : $2ea0 11936`
	`skip2738 : $2ebc 11964`
	`skip2741 : $2ec6 11974`
	`skip2746 : $2ee2 12002`
	`skip2749 : $2eec 12012`
	`skip2754 : $2f08 12040`
	`skip2757 : $2f12 12050`
	`skip2762 : $2f2e 12078`
	`skip2765 : $2f38 12088`
	`skip2768 : $2f44 12100`
	`skip2773 : $2f5f 12127`
	`skip2776 : $2f69 12137`
	`skip2781 : $2f89 12169`
	`skip2784 : $2f93 12179`
	`skip2789 : $2fb6 12214`
	`skip2792 : $2fc0 12224`
	`skip2797 : $2fe0 12256`
	`skip2800 : $2fea 12266`
	`skip2803 : $3000 12288`
	`skip2808 : $301e 12318`
	`skip2811 : $3028 12328`
	`skip2816 : $304c 12364`
	`skip2819 : $3056 12374`
	`skip2824 : $307d 12413`
	`skip2827 : $3087 12423`
	`skip2832 : $30ab 12459`
	`skip2835 : $30b5 12469`
	`skip2838 : $30cc 12492`
	`skip2843 : $30e7 12519`
	`skip2846 : $30f1 12529`
	`skip2851 : $3113 12563`
	`skip2854 : $311d 12573`
	`skip2859 : $3140 12608`
	`skip2862 : $314a 12618`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 19`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip2867 : $316c 12652`
	`skip2870 : $3176 12662`
	`skip2873 : $318c 12684`
	`skip2878 : $31aa 12714`
	`skip2881 : $31b4 12724`
	`skip2886 : $31da 12762`
	`skip2889 : $31e4 12772`
	`skip2894 : $320b 12811`
	`skip2897 : $3215 12821`
	`skip2902 : $323b 12859`
	`skip2905 : $3245 12869`
	`skip2908 : $325c 12892`
	`skip2913 : $3279 12921`
	`skip2916 : $3283 12931`
	`skip2921 : $329e 12958`
	`skip2924 : $32a8 12968`
	`skip2929 : $32c2 12994`
	`skip2932 : $32cc 13004`
	`skip2937 : $32e6 13030`
	`skip2940 : $32f0 13040`
	`skip2945 : $330c 13068`
	`skip2948 : $3316 13078`
	`skip2953 : $3332 13106`
	`skip2956 : $333c 13116`
	`skip2961 : $3352 13138`
	`skip2964 : $335c 13148`
	`skip2969 : $3372 13170`
	`skip2972 : $337c 13180`
	`skip2977 : $3393 13203`
	`skip2980 : $339d 13213`
	`skip2985 : $33b4 13236`
	`skip2988 : $33be 13246`
	`skip2993 : $33d5 13269`
	`skip2996 : $33df 13279`
	`skip3001 : $33f6 13302`
	`skip3004 : $3400 13312`
	`skip3009 : $3418 13336`
	`skip3012 : $3422 13346`
	`skip3017 : $343c 13372`
	`skip3020 : $3446 13382`
	`skip3025 : $345e 13406`
	`skip3028 : $3468 13416`
	`skip3033 : $347e 13438`
	`skip3036 : $3488 13448`
	`skip3039 : $3494 13460`
	`skip3044 : $34b1 13489`
	`skip3047 : $34bb 13499`
	`skip3052 : $34d6 13526`
	`skip3055 : $34e0 13536`
	`skip3060 : $34fa 13562`
	`skip3063 : $3504 13572`
	`skip3068 : $351e 13598`
	`skip3071 : $3528 13608`
	`skip3076 : $3544 13636`
	`skip3079 : $354e 13646`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 20`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip3084 : $356a 13674`
	`skip3087 : $3574 13684`
	`skip3092 : $358a 13706`
	`skip3095 : $3594 13716`
	`skip3100 : $35aa 13738`
	`skip3103 : $35b4 13748`
	`skip3108 : $35cb 13771`
	`skip3111 : $35d5 13781`
	`skip3116 : $35ec 13804`
	`skip3119 : $35f6 13814`
	`skip3124 : $360d 13837`
	`skip3127 : $3617 13847`
	`skip3132 : $362e 13870`
	`skip3135 : $3638 13880`
	`skip3140 : $3650 13904`
	`skip3143 : $365a 13914`
	`skip3148 : $3674 13940`
	`skip3151 : $367e 13950`
	`skip3156 : $3696 13974`
	`skip3159 : $36a0 13984`
	`skip3164 : $36b6 14006`
	`skip3167 : $36c0 14016`
	`skip3170 : $36cc 14028`
	`skip3175 : $36e9 14057`
	`skip3178 : $36f3 14067`
	`skip3183 : $370e 14094`
	`skip3186 : $3718 14104`
	`skip3191 : $3732 14130`
	`skip3194 : $373c 14140`
	`skip3199 : $3756 14166`
	`skip3202 : $3760 14176`
	`skip3207 : $377c 14204`
	`skip3210 : $3786 14214`
	`skip3215 : $37a2 14242`
	`skip3218 : $37ac 14252`
	`skip3223 : $37c2 14274`
	`skip3226 : $37cc 14284`
	`skip3231 : $37e2 14306`
	`skip3234 : $37ec 14316`
	`skip3239 : $3803 14339`
	`skip3242 : $380d 14349`
	`skip3247 : $3824 14372`
	`skip3250 : $382e 14382`
	`skip3255 : $3845 14405`
	`skip3258 : $384f 14415`
	`skip3263 : $3866 14438`
	`skip3266 : $3870 14448`
	`skip3271 : $3888 14472`
	`skip3274 : $3892 14482`
	`skip3279 : $38ac 14508`
	`skip3282 : $38b6 14518`
	`skip3287 : $38ce 14542`
	`skip3290 : $38d8 14552`
	`skip3295 : $38ee 14574`
	`skip3298 : $38f8 14584`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 21`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip3301 : $390a 14602`
	`skip3304 : $3976 14710`
	`skip3306 : $3a1d 14877`
	`skip3310 : $3a2b 14891`
	`skip3312 : $3a34 14900`
	`skip3314 : $3a41 14913`
	`skip3316 : $3a4a 14922`
	`skip3318 : $3a58 14936`
	`skip3320 : $3a61 14945`
	`skip3322 : $3a6f 14959`
	`skip3324 : $3a78 14968`
	`skip3326 : $3a8a 14986`
	`skip3328 : $3a93 14995`
	`skip3330 : $3aa5 15013`
	`skip3332 : $3aae 15022`
	`skip3334 : $3abb 15035`
	`skip3336 : $3ac4 15044`
	`skip3338 : $3ad1 15057`
	`skip3340 : $3ada 15066`
	`skip3342 : $3ae8 15080`
	`skip3344 : $3af1 15089`
	`skip3346 : $3aff 15103`
	`skip3348 : $3b08 15112`
	`skip3350 : $3b16 15126`
	`skip3352 : $3b1f 15135`
	`skip3354 : $3b2d 15149`
	`skip3356 : $3b36 15158`
	`skip3358 : $3b43 15171`
	`skip3360 : $3b4c 15180`
	`skip3362 : $3b59 15193`
	`skip3364 : $3b62 15202`
	`skip3366 : $3b6f 15215`
	`skip3368 : $3b78 15224`
	`skip3370 : $3b85 15237`
	`skip3372 : $3b8e 15246`
	`skip3374 : $3bb4 15284`
	`skip3376 : $3bbd 15293`
	`skip3378 : $3bca 15306`
	`skip3380 : $3bd3 15315`
	`skip3382 : $3be1 15329`
	`skip3384 : $3bea 15338`
	`skip3386 : $3bf8 15352`
	`skip3388 : $3c01 15361`
	`skip3390 : $3c13 15379`
	`skip3392 : $3c1c 15388`
	`skip3394 : $3c2e 15406`
	`skip3396 : $3c37 15415`
	`skip3398 : $3c44 15428`
	`skip3400 : $3c4d 15437`
	`skip3402 : $3c5a 15450`
	`skip3404 : $3c63 15459`
	`skip3406 : $3c71 15473`
	`skip3408 : $3c7a 15482`
	`skip3410 : $3c88 15496`
	`skip3412 : $3c91 15505`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 22`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip3414 : $3c9f 15519`
	`skip3416 : $3ca8 15528`
	`skip3418 : $3cb6 15542`
	`skip3420 : $3cbf 15551`
	`skip3422 : $3ccc 15564`
	`skip3424 : $3cd5 15573`
	`skip3426 : $3ce2 15586`
	`skip3428 : $3ceb 15595`
	`skip3430 : $3cf8 15608`
	`skip3432 : $3d01 15617`
	`skip3434 : $3d0e 15630`
	`skip3436 : $3d17 15639`
	`skip3438 : $3d24 15652`
	`skip3440 : $3d28 15656`
	`skip3442 : $3d2c 15660`
	`skip3444 : $3d30 15664`
	`skip3446 : $3d36 15670`
	`skip3448 : $3d3c 15676`
	`skip3450 : $3d42 15682`
	`skip3452 : $3d4c 15692`
	`skip3457 : $3d6b 15723`
	`skip3459 : $3d6f 15727`
	`skip3461 : $3d73 15731`
	`skip3463 : $3d77 15735`
	`skip3465 : $3d7d 15741`
	`skip3467 : $3d83 15747`
	`skip3469 : $3d89 15753`
	`skip3471 : $3d93 15763`
	`skip3476 : $3dad 15789`
	`skip3478 : $3db1 15793`
	`skip3480 : $3db5 15797`
	`skip3482 : $3db9 15801`
	`skip3484 : $3dbf 15807`
	`skip3486 : $3dc5 15813`
	`skip3488 : $3dcb 15819`
	`skip3490 : $3dd5 15829`
	`skip3492 : $3dde 15838`
	`skip3494 : $3de7 15847`
	`skip3501 : $3e04 15876`
	`skip3503 : $3e0a 15882`
	`skip3505 : $3e10 15888`
	`skip3508 : $3e1e 15902`
	`skip3510 : $3e25 15909`
	`skip3512 : $3e2c 15916`
	`skip3514 : $3e35 15925`
	`skip3516 : $3e3e 15934`
	`skip_bin_test : $0000 0 *`
	`skip_dec_test : $0000 0 *`
`skip_part_1 : $0000 0 *`	`skip_part_1 : $0000 0 *`
	`stack_top : $01ff 511 *`
`start : $0400 1024`	`start : $0400 1024`
`success : $32cf 13007`	`success :`
`tadd : $31e6 12774`	`tadd : $392e 14638`
`tadd1 : $31f8 12792`	`tadd1 : $3940 14656`
`tand : $2be3 11235`	`tand : $3263 12899`
`tandi1 : $2bf0 11248`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 23`
`tandi2 : $2c11 11281`
`tand1 : $2c04 11268`
`tand10 : $2d1b 11547`
`tand11 : $2d38 11576`
`tand12 : $2d57 11607`
`tand13 : $2d77 11639`
`tand14 : $2d95 11669`
`tand15 : $2db1 11697`
`tand2 : $2c25 11301`
`tand3 : $2c45 11333`
`tand4 : $2c65 11365`
`tand5 : $2c87 11399`
`tand6 : $2ca9 11433`
`tand7 : $2cc5 11461`
`tand8 : $2ce1 11489`
`tand9 : $2cfe 11518`
`tasl : $2187 8583`
`tasl1 : $21a1 8609`
`tasl2 : $22cb 8907`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 4`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`tasl3 : $22ea 8938`	`tandi1 : $3270 12912`
`tasl4 : $244b 9291`	`tandi2 : $3295 12949`
`tasl5 : $246d 9325`	`tand1 : $3288 12936`
`tasl6 : $25ef 9711`	`tand10 : $33c3 13251`
`tasl7 : $260e 9742`	`tand11 : $33e4 13284`
`tasl8 : $276f 10095`	`tand12 : $3407 13319`
`tasl9 : $2791 10129`	`tand13 : $342b 13355`
`tdad : $324c 12876`	`tand14 : $344d 13389`
`tdad1 : $325e 12894`	`tand15 : $346d 13421`
`tdad2 : $326e 12910`	`tand2 : $32ad 12973`
`tdad3 : $3270 12912`	`tand3 : $32d1 13009`
`tdad4 : $328a 12938`	`tand4 : $32f5 13045`
`tdad5 : $328f 12943`	`tand5 : $331b 13083`
`tdad6 : $32b3 12979`	`tand6 : $3341 13121`
`tdad7 : $32c7 12999`	`tand7 : $3361 13153`
`tdec : $293d 10557`	`tand8 : $3381 13185`
`tdec1 : $2960 10592`	`tand9 : $33a2 13218`
`tdec10 : $298c 10636`	`tasl : $26c5 9925`
`tdec11 : $29af 10671`	`tasl1 : $26e3 9955`
`tdec12 : $2a43 10819`	`tasl2 : $283b 10299`
`tdec13 : $2a69 10857`	`tasl3 : $285e 10334`
`tdec14 : $2af2 10994`	`tasl4 : $29ed 10733`
`tdec15 : $2b17 11031`	`tasl5 : $2a13 10771`
`tdec16 : $2bac 11180`	`tasl6 : $2bc3 11203`
`tdec17 : $2bd5 11221`	`tasl7 : $2be6 11238`
`tdec2 : $29ec 10732`	`tasl8 : $2d75 11637`
`tdec3 : $2a12 10770`	`tasl9 : $2d9b 11675`
`tdec4 : $2aa1 10913`	`tdad : $3998 14744`
`tdec5 : $2ac6 10950`	`tdad1 : $39aa 14762`
`tdec6 : $2b53 11091`	`tdad2 : $39ba 14778`
`tdec7 : $2b7c 11132`	`tdad3 : $39bc 14780`
`teor : $2dd9 11737`	`tdad4 : $39d6 14806`
`teori1 : $2de6 11750`	`tdad5 : $39db 14811`
`teori2 : $2e07 11783`	`tdad6 : $39ff 14847`
`teor1 : $2dfa 11770`	`tdad7 : $3a13 14867`
`teor10 : $2f11 12049`	`tdec : $2f79 12153`
`teor11 : $2f2e 12078`	`tdec1 : $2fa0 12192`
`teor12 : $2f4d 12109`	`tdec10 : $2fd0 12240`
`teor13 : $2f6d 12141`	`tdec11 : $2ff7 12279`
`teor14 : $2f8b 12171`	`tdec12 : $3099 12441`
`teor15 : $2fa7 12199`	`tdec13 : $30c3 12483`
`teor2 : $2e1b 11803`	`tdec14 : $315a 12634`
`teor3 : $2e3b 11835`	`tdec15 : $3183 12675`
`teor4 : $2e5b 11867`	`tdec16 : $3226 12838`
`teor5 : $2e7d 11901`	`tdec17 : $3253 12883`
`teor6 : $2e9f 11935`	`tdec2 : $303a 12346`
`teor7 : $2ebb 11963`	`tdec3 : $3064 12388`
`teor8 : $2ed7 11991`	`tdec4 : $3101 12545`
`teor9 : $2ef4 12020`	`tdec5 : $312a 12586`
`test_bne : $0544 1348`	`tdec6 : $31c5 12741`
`test_case : $0200 512`	`tdec7 : $31f2 12786`
`test_far : $354e 13646`	`teor : $349b 13467`
`test_ind : $3585 13701`	`teori1 : $34a8 13480`
`test_jsr : $35b8 13752`	`teori2 : $34cd 13517`
`test_near : $081a 2074`	`teor1 : $34c0 13504`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 5`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 24`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`teor10 : $35fb 13819`
	`teor11 : $361c 13852`
	`teor12 : $363f 13887`
	`teor13 : $3663 13923`
	`teor14 : $3685 13957`
	`teor15 : $36a5 13989`
	`teor2 : $34e5 13541`
	`teor3 : $3509 13577`
	`teor4 : $352d 13613`
	`teor5 : $3553 13651`
	`teor6 : $3579 13689`
	`teor7 : $3599 13721`
	`teor8 : $35b9 13753`
	`teor9 : $35da 13786`
	`test_bne : $055b 1371`
	`test_case : $0200 512`
	`test_far : $3d1b 15643`
	`test_ind : $3d62 15714`
	`test_jsr : $3da4 15780`
	`test_near : $08db 2267`
`test_num : $002a 42 *`	`test_num : $002a 42 *`
`tinc : $2917 10519`	`tinc : $2f4f 12111`
`tinc1 : $2936 10550`	`tinc1 : $2f72 12146`
`tinc10 : $2966 10598`	`tinc10 : $2fa6 12198`
`tinc11 : $2985 10629`	`tinc11 : $2fc9 12233`
`tinc12 : $2a19 10777`	`tinc12 : $306b 12395`
`tinc13 : $2a3b 10811`	`tinc13 : $3091 12433`
`tinc14 : $2aca 10954`	`tinc14 : $312e 12590`
`tinc15 : $2aeb 10987`	`tinc15 : $3153 12627`
`tinc16 : $2b80 11136`	`tinc16 : $31f6 12790`
`tinc17 : $2ba5 11173`	`tinc17 : $321f 12831`
`tinc2 : $29c2 10690`	`tinc2 : $300c 12300`
`tinc3 : $29e4 10724`	`tinc3 : $3032 12338`
`tinc4 : $2a79 10873`	`tinc4 : $30d5 12501`
`tinc5 : $2a9a 10906`	`tinc5 : $30fa 12538`
`tinc6 : $2b27 11047`	`tinc6 : $3195 12693`
`tinc7 : $2b4c 11084`	`tinc7 : $31be 12734`
`tldax : $14fa 5370`	`tldax : $181c 6172`
`tldax1 : $151c 5404`	`tldax1 : $1842 6210`
`tldax2 : $153e 5438`	`tldax2 : $1868 6248`
`tldax3 : $155f 5471`	`tldax3 : $188d 6285`
`tldax4 : $165d 5725`	`tldax4 : $19a9 6569`
`tldax5 : $1682 5762`	`tldax5 : $19d2 6610`
`tldax6 : $16c6 5830`	`tldax6 : $1a1e 6686`
`tldax7 : $16d2 5842`	`tldax7 : $1a2a 6698`
`tlday : $15ab 5547`	`tlday : $18e3 6371`
`tlday1 : $15cd 5581`	`tlday1 : $1909 6409`
`tlday2 : $1604 5636`	`tlday2 : $1946 6470`
`tlday3 : $1625 5669`	`tlday3 : $196b 6507`
`tlday4 : $16fb 5883`	`tlday4 : $1a57 6743`
`tlday5 : $171c 5916`	`tlday5 : $1a7a 6778`
`tlday6 : $173d 5949`	`tlday6 : $1a9d 6813`
`tldx : $0d16 3350`	`tldx : $0f1c 3868`
`tldx1 : $0d39 3385`	`tldx1 : $0f43 3907`
`tldx2 : $0d5c 3420`	`tldx2 : $0f6a 3946`
`tldx3 : $0d80 3456`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 25`
`tldx4 : $0dd1 3537`
`tldx5 : $0dde 3550`
`tldy : $0e13 3603`
`tldy1 : $0e36 3638`
`tldy2 : $0e59 3673`
`tldy3 : $0e7c 3708`
`tldy4 : $0eca 3786`
`tldy5 : $0ed7 3799`
`tlsr : $21bb 8635`
`tlsr1 : $21d5 8661`
`tlsr2 : $2309 8969`
`tlsr3 : $2328 9000`
`tlsr4 : $248f 9359`
`tlsr5 : $24b1 9393`
`tlsr6 : $262d 9773`
`tlsr7 : $264c 9804`
`tlsr8 : $27b3 10163`
`tlsr9 : $27d5 10197`
`tora : $2fcf 12239`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 6`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`torai1 : $2fdc 12252`	`tldx3 : $0f92 3986`
`torai2 : $2ffd 12285`	`tldx4 : $0fed 4077`
`tora1 : $2ff0 12272`	`tldx5 : $0ffa 4090`
`tora10 : $3107 12551`	`tldy : $1035 4149`
`tora11 : $3124 12580`	`tldy1 : $105c 4188`
`tora12 : $3143 12611`	`tldy2 : $1083 4227`
`tora13 : $3163 12643`	`tldy3 : $10aa 4266`
`tora14 : $3181 12673`	`tldy4 : $1102 4354`
`tora15 : $319d 12701`	`tldy5 : $110f 4367`
`tora2 : $3011 12305`	`tlsr : $2701 9985`
`tora3 : $3031 12337`	`tlsr1 : $271f 10015`
`tora4 : $3051 12369`	`tlsr2 : $2881 10369`
`tora5 : $3073 12403`	`tlsr3 : $28a4 10404`
`tora6 : $3095 12437`	`tlsr4 : $2a39 10809`
`tora7 : $30b1 12465`	`tlsr5 : $2a5f 10847`
`tora8 : $30cd 12493`	`tlsr6 : $2c09 11273`
`tora9 : $30ea 12522`	`tlsr7 : $2c2c 11308`
	`tlsr8 : $2dc1 11713`
	`tlsr9 : $2de7 11751`
	`tora : $36d3 14035`
	`torai1 : $36e0 14048`
	`torai2 : $3705 14085`
	`tora1 : $36f8 14072`
	`tora10 : $3833 14387`
	`tora11 : $3854 14420`
	`tora12 : $3877 14455`
	`tora13 : $389b 14491`
	`tora14 : $38bd 14525`
	`tora15 : $38dd 14557`
	`tora2 : $371d 14109`
	`tora3 : $3741 14145`
	`tora4 : $3765 14181`
	`tora5 : $378b 14219`
	`tora6 : $37b1 14257`
	`tora7 : $37d1 14289`
	`tora8 : $37f1 14321`
	`tora9 : $3812 14354`
`trap :`	`trap :`
`trap_cc :`	`trap_cc :`
`trap_cs :`	`trap_cs :`
`trap_eq :`	`trap_eq :`
`trap_mi :`	`trap_mi :`
`trap_ne :`	`trap_ne :`
`trap_pl :`	`trap_pl :`
`trap_vc :`	`trap_vc :`
`trap_vs :`	`trap_vs :`
`trol : $21ef 8687`	`trol : $273d 10045`
`trolc : $2223 8739`	`trolc : $2779 10105`
`trolc1 : $223d 8765`	`trolc1 : $2797 10135`
`trolc2 : $2385 9093`	`trolc2 : $290d 10509`
`trolc3 : $23a4 9124`	`trolc3 : $2930 10544`
`trolc4 : $2517 9495`	`trolc4 : $2ad1 10961`
`trolc5 : $2539 9529`	`trolc5 : $2af7 10999`
`trolc6 : $26a9 9897`	`trolc6 : $2c95 11413`
`trolc7 : $26c8 9928`	`trolc7 : $2cb8 11448`
`trolc8 : $283b 10299`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 26`
`trolc9 : $285d 10333`
`trol1 : $2209 8713`
`trol2 : $2347 9031`
`trol3 : $2366 9062`
`trol4 : $24d3 9427`
`trol5 : $24f5 9461`
`trol6 : $266b 9835`
`trol7 : $268a 9866`
`trol8 : $27f7 10231`
`trol9 : $2819 10265`
`tror : $2257 8791`
`trorc : $228b 8843`
`trorc1 : $22a5 8869`
`trorc2 : $2401 9217`
`trorc3 : $2420 9248`
`trorc4 : $259f 9631`
`trorc5 : $25c1 9665`
`trorc6 : $2725 10021`
`trorc7 : $2744 10052`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 7`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`trorc8 : $28c3 10435`	`trolc8 : $2e59 11865`
`trorc9 : $28e5 10469`	`trolc9 : $2e7f 11903`
`tror1 : $2271 8817`	`trol1 : $275b 10075`
`tror2 : $23c3 9155`	`trol2 : $28c7 10439`
`tror3 : $23e2 9186`	`trol3 : $28ea 10474`
`tror4 : $255b 9563`	`trol4 : $2a85 10885`
`tror5 : $257d 9597`	`trol5 : $2aab 10923`
`tror6 : $26e7 9959`	`trol6 : $2c4f 11343`
`tror7 : $2706 9990`	`trol7 : $2c72 11378`
`tror8 : $287f 10367`	`trol8 : $2e0d 11789`
`tror9 : $28a1 10401`	`trol9 : $2e33 11827`
`tstax : $1582 5506`	`tror : $27b5 10165`
`tstax1 : $16e0 5856`	`trorc : $27f1 10225`
`tstay : $15f1 5617`	`trorc1 : $280f 10255`
`tstay1 : $1648 5704`	`trorc2 : $2999 10649`
`tstay2 : $16a7 5799`	`trorc3 : $29bc 10684`
`tstay4 : $170b 5899`	`trorc4 : $2b69 11113`
`tstay5 : $172a 5930`	`trorc5 : $2b8f 11151`
`tstay6 : $174c 5964`	`trorc6 : $2d21 11553`
`tstx : $0da6 3494`	`trorc7 : $2d44 11588`
`tstx1 : $0dec 3564`	`trorc8 : $2ef1 12017`
`tsty : $0ea1 3745`	`trorc9 : $2f17 12055`
`tsty1 : $0ee5 3813`	`tror1 : $27d3 10195`
	`tror2 : $2953 10579`
	`tror3 : $2976 10614`
	`tror4 : $2b1d 11037`
	`tror5 : $2b43 11075`
	`tror6 : $2cdb 11483`
	`tror7 : $2cfe 11518`
	`tror8 : $2ea5 11941`
	`tror9 : $2ecb 11979`
	`tstax : $18b4 6324`
	`tstax1 : $1a38 6712`
	`tstay : $1931 6449`
	`tstay1 : $1992 6546`
	`tstay2 : $19fb 6651`
	`tstay4 : $1a67 6759`
	`tstay5 : $1a88 6792`
	`tstay6 : $1aac 6828`
	`tstx : $0fbc 4028`
	`tstx1 : $1008 4104`
	`tsty : $10d3 4307`
	`tsty1 : $111d 4381`
`tst_a :`	`tst_a :`
`tst_abs :`	`tst_abs :`
`tst_absx :`	`tst_absx :`
`tst_ax :`	`tst_ax :`
`tst_ay :`	`tst_ay :`
`tst_stat :`	`tst_stat :`
`tst_x :`	`tst_x :`
`tst_y :`	`tst_y :`
`tst_z :`	`tst_z :`
`tst_zx :`	`tst_zx :`
	`vec_bss : $fffa 65530`
	`vec_init : $3ffa 16378`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 27`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`zero : $0002 2`	`zero : $0002 2`
`zero_page : $000a 10 *`	`zero_page : $00b0 176 *`
`zpAN : $001c 28`	`zpAN : $00c2 194`
`zpEO : $0020 32`	`zpAN_ : $3e55 15957`
`zpOR : $0018 24`	`zpEO : $00c6 198`
`zpt : $000c 12`	`zpEO_ : $3e59 15961`
`zp1 : $0013 19`	`zpOR : $00be 190`
`zp7f : $0017 23`	`zpOR_ : $3e51 15953`
`zp_bss : $0013 19`	`zpt : $00b2 178`
`zp_bss_end : $005a 90`	`zp1 : $00b9 185`
`__65SC02__ : $0001 1`	`zp1_ : $3e4c 15948`
	`zp7f : $00bd 189`
	`zp7f_ : $3e50 15952`
	`zp_bss : $00b9 185`
	`zp_bss_end : $0100 256`
	`zp_end : $3e93 16019`
	`zp_init : $3e4c 15948`
	`__6502__ : $0001 1`

`336 labels used`	`1409 labels used`

`5633 lines read, no errors in pass 1.`	`5937 lines read, no errors in pass 1.`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 8`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 28`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`;`	`;`
`; 6 5 0 2 F U N C T I O N A L T E S T`	`; 6 5 0 2 F U N C T I O N A L T E S T`
`;`	`;`
Line 415...	Line 1549...
`; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`	`; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
`; GNU General Public License for more details.`	`; GNU General Public License for more details.`
`;`	`;`
`; You should have received a copy of the GNU General Public License`	`; You should have received a copy of the GNU General Public License`
`; along with this program. If not, see .`	`; along with this program. If not, see .`
	`;`
	`;`
`; This program is designed to test all opcodes of a 6502 emulator using all`	`; This program is designed to test all opcodes of a 6502 emulator using all`
`; addressing modes with focus on propper setting of the processor status`	`; addressing modes with focus on propper setting of the processor status`
`; register bits.`	`; register bits.`
`;`	`;`
`; version 23-jul-2013`	`; version 23-jul-2013`
Line 453...	Line 1587...
`; immediately preceeding code for the instruction to be tested. Results are`	`; immediately preceeding code for the instruction to be tested. Results are`
`; tested first, flags are checked second by pushing them onto the stack and`	`; tested first, flags are checked second by pushing them onto the stack and`
`; pulling them to the accumulator after the result was checked. The "real"`	`; pulling them to the accumulator after the result was checked. The "real"`
`; flags are no longer valid for the tested instruction at this time!`	`; flags are no longer valid for the tested instruction at this time!`
`; If the tested instruction was indexed, the relevant index (X or Y) must`	`; If the tested instruction was indexed, the relevant index (X or Y) must`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 9`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 29`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`; also be checked. Opposed to the flags, X and Y registers are still valid.`	`; also be checked. Opposed to the flags, X and Y registers are still valid.`
`;`	`;`
`; versions:`	`; versions:`
Line 469...	Line 1603...
`; 01-dec-2012 fixed trap in branch field must be a branch`	`; 01-dec-2012 fixed trap in branch field must be a branch`
`; 02-mar-2013 fixed PLA flags not tested`	`; 02-mar-2013 fixed PLA flags not tested`
`; 19-jul-2013 allowed ROM vectors to be loaded when load_data_direct = 0`	`; 19-jul-2013 allowed ROM vectors to be loaded when load_data_direct = 0`
`; added test sequence check to detect if tests jump their fence`	`; added test sequence check to detect if tests jump their fence`
`; 23-jul-2013 added RAM integrity check`	`; 23-jul-2013 added RAM integrity check`
	`;`
	`; 30-Aug-2013 Modified by Michael A. Morris to allow selection of tests`
	`; 04-Jan-2014 Modified trap vectors to use sbc2oslite BRK handler for error`
	`; trapping. Enabled success macro, which returns to the monitor.`
	`; Disabled BRK trap test in order to trap out to the monitor.`
	`; 30-Jan-2014 Modified success macro to issue brk instruction instead of rts.`
	`; 27-Nov-2014 Modified success macro to use stp instruction instead of brk`
	`; 07-Dec-2014 Modified success macro to use brk instruction instead of stp`
	`;`
`; C O N F I G U R A T I O N`	`; C O N F I G U R A T I O N`
`;`	`;`
`;ROM_vectors writable (0=no, 1=yes)`	`;ROM_vectors writable (0=no, 1=yes)`
	`;`
`;if ROM vectors can not be used interrupts will not be trapped`	`;if ROM vectors can not be used interrupts will not be trapped`
`;as a consequence BRK can not be tested but will be emulated to test RTI`	`;as a consequence BRK can not be tested but will be emulated to test RTI`
`0001 = ROM_vectors = 1`	`;`
	`0000 = ROM_vectors = 0`
	`;`
`;load_data_direct (0=move from code segment, 1=load directly)`	`;load_data_direct (0=move from code segment, 1=load directly)`
`;loading directly is preferred but may not be supported by your platform`	`;loading directly is preferred but may not be supported by your platform`
`;0 produces only consecutive object code, 1 is not suitable for a binary image`	`;0 produces only consecutive object code, 1 is not suitable for a binary image`
`0001 = load_data_direct = 1`	`;`
	`0000 = load_data_direct = 0`
	`;`
`;I_flag behavior (0=force enabled, 1=force disabled, 2=prohibit change, 3=allow`	`;I_flag behavior (0=force enabled, 1=force disabled, 2=prohibit change, 3=allow`
`;change) 2 requires extra code and is not recommended. SEI & CLI can only be`	`;change) 2 requires extra code and is not recommended. SEI & CLI can only be`
`;tested if you allow changing the interrupt status (I_flag = 3)`	`;tested if you allow changing the interrupt status (I_flag = 3)`
	`;`
`0003 = I_flag = 3`	`0003 = I_flag = 3`
	`;`
`;configure memory - try to stay away from memory used by the system`	`;configure memory - try to stay away from memory used by the system`
`;zero_page memory start address, $50 (80) consecutive Bytes required`	`;zero_page memory start address, $50 (80) consecutive Bytes required`
`; add 2 if I_flag = 2`	`; add 2 if I_flag = 2`
`000a = zero_page = $a`	`;`
	`00b0 = zero_page = $B0`
	`;`
`;data_segment memory start address, $5B (91) consecutive Bytes required`	`;data_segment memory start address, $5B (91) consecutive Bytes required`
	`;`
`0200 = data_segment = $200`	`0200 = data_segment = $200`
`if (data_segment & $ff) != 0`	`if (data_segment & $ff) != 0`
`ERROR ERROR ERROR low byte of data_segment MUST be $00 !!`	`ERROR ERROR ERROR low byte of data_segment MUST be $00 !!`
`endif`	`endif`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 30`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`;`
`;code_segment memory start address, 13kB of consecutive space required`	`;code_segment memory start address, 13kB of consecutive space required`
`; add 2.5 kB if I_flag = 2`	`; add 2.5 kB if I_flag = 2`
`;parts of the code are self modifying and must reside in RAM`	`;parts of the code are self modifying and must reside in RAM`
	`;`
`0400 = code_segment = $400`	`0400 = code_segment = $400`
	`;`
`;RAM integrity test option. Checks for undesired RAM writes.`	`;RAM integrity test option. Checks for undesired RAM writes.`
`;set lowest non RAM or RAM mirror address page (-1=disable, 0=64k, $40=16k)`	`;set lowest non RAM or RAM mirror address page (-1=disable, 0=64k, $40=16k)`
`;leave disabled if a monitor, OS or background interrupt is allowed to alter RAM`	`;leave disabled if a monitor, OS or background interrupt is allowed to alter RAM`
	`;`
`ffff = ram_top = -1`	`ffff = ram_top = -1`
	`;ram_top = $40`
	`;`
	`; Define the top of stack location`
	`;`
	`01ff = stack_top = $1FF`
`;`	`;`
`;Skip to ADC/SBC tests`	`;Skip to ADC/SBC tests`
`;`	`;`
`0000 = skip_part_1 = 0`	`0000 = skip_part_1 = 0`
`;`	`;`
`;Skip Binary or Decimal mode ADC/SBC instruction tests`	`;Skip Binary or Decimal mode ADC/SBC instruction tests`
`;`	`;`
`0001 = skip_bin_test = 1`	`0000 = skip_bin_test = 0`
`0001 = skip_dec_test = 1`	`0000 = skip_dec_test = 0`
	`;`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 10`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`noopt ;do not take shortcuts`	`noopt ;do not take shortcuts`
	`;`
`;macros for error & success traps to allow user modification`	`;macros for error & success traps to allow user modification`
`;example:`	`;example:`
	`;`
`;trap macro`	`;trap macro`
`; jsr my_error_handler`	`; jsr my_error_handler`
`; endm`	`; endm`
	`;`
`;trap_eq macro`	`;trap_eq macro`
`; bne skip\?`	`; bne skip\?`
`; trap ;failed equal (zero)`	`; trap ;failed equal (zero)`
`;skip\?`	`;skip\?`
`; endm`	`; endm`
`;`	`;`
`; my_error_handler should pop the calling address from the stack and report it.`	`; my_error_handler should pop the calling address from the stack and report it.`
`; putting larger portions of code (more than 3 bytes) inside the trap macro`	`; putting larger portions of code (more than 3 bytes) inside the trap macro`
`; may lead to branch range problems for some tests.`	`; may lead to branch range problems for some tests.`

`trap macro`	`trap macro`
`jmp * ;failed anyway`	`; db $db ; M65C02/M65C02A SToP instruction`
	`brk ; Use BRK to return to the monitor`
	`db test_num`
`endm`	`endm`

`trap_eq macro`	`trap_eq macro`
`beq * ;failed equal (zero)`	`bne skip\?`
	`trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 31`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`skip\?`
`endm`	`endm`

`trap_ne macro`	`trap_ne macro`
`bne * ;failed not equal (non zero)`	`beq skip\?`
	`trap ;failed equal (zero)`
	`skip\?`
`endm`	`endm`

`trap_cs macro`	`trap_cs macro`
`bcs * ;failed carry set`	`bcc skip\?`
	`trap ;failed equal (zero)`
	`skip\?`
`endm`	`endm`

`trap_cc macro`	`trap_cc macro`
`bcc * ;failed carry clear`	`bcs skip\?`
	`trap ;failed equal (zero)`
	`skip\?`
`endm`	`endm`

`trap_mi macro`	`trap_mi macro`
`bmi * ;failed minus (bit 7 set)`	`bpl skip\?`
	`trap ;failed equal (zero)`
	`skip\?`
`endm`	`endm`

`trap_pl macro`	`trap_pl macro`
`bpl * ;failed plus (bit 7 clear)`	`bmi skip\?`
	`trap ;failed equal (zero)`
	`skip\?`
`endm`	`endm`

`trap_vs macro`	`trap_vs macro`
`bvs * ;failed overflow set`	`bvc skip\?`
	`trap ;failed equal (zero)`
	`skip\?`
`endm`	`endm`

`trap_vc macro`	`trap_vc macro`
`bvc * ;failed overflow clear`	`bvs skip\?`
	`trap ;failed equal (zero)`
	`skip\?`
`endm`	`endm`

`success macro`	`success macro`
`jmp * ;test passed, no errors`	`brk`
	`db test_num+1`
`endm`	`endm`


`0001 = carry equ %00000001 ;flag bits in status`	`0001 = carry equ %00000001 ;flag bits in status`
`0002 = zero equ %00000010`	`0002 = zero equ %00000010`
`0004 = intdis equ %00000100`	`0004 = intdis equ %00000100`
`0008 = decmode equ %00001000`	`0008 = decmode equ %00001000`
`0010 = break equ %00010000`	`0010 = break equ %00010000`
`0020 = reserv equ %00100000`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 32`
`0040 = overfl equ %01000000`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 11`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0020 = reserv equ %00100000`
	`0040 = overfl equ %01000000`
`0080 = minus equ %10000000`	`0080 = minus equ %10000000`

`0001 = fc equ carry`	`0001 = fc equ carry`
`0002 = fz equ zero`	`0002 = fz equ zero`
`0003 = fzc equ carry+zero`	`0003 = fzc equ carry+zero`
Line 593...	Line 1787...
`00fb = m8i equ $ff&~intdis ;8 bit mask - interrupt disable`	`00fb = m8i equ $ff&~intdis ;8 bit mask - interrupt disable`

`;macros to allow masking of status bits.`	`;macros to allow masking of status bits.`
`;masking of interrupt enable/disable on load and compare`	`;masking of interrupt enable/disable on load and compare`
`;masking of always on bits after PHP or BRK (unused & break) on compare`	`;masking of always on bits after PHP or BRK (unused & break) on compare`

`if I_flag = 0`	`if I_flag = 0`

`load_flag macro`	`load_flag macro`
`lda #\1&m8i ;force enable interrupts (mask I)`	`lda #\1&m8i ;force enable interrupts (mask I)`
`endm`	`endm`

`cmp_flag macro`	`cmp_flag macro`
`cmp #(\1\|fao)&m8i ;I_flag is always enabled + always on bits`	`cmp #(\1\|fao)&m8i ;I_flag is always enabled + always on bits`
`endm`	`endm`

`eor_flag macro`	`eor_flag macro`
`eor #(\1&m8i\|fao) ;mask I, invert expected flags + always on bits`	`eor #(\1&m8i\|fao) ;mask I, invert expected flags + always on bits`
`endm`	`endm`

`endif`	`endif`

`if I_flag = 1`	`if I_flag = 1`

`load_flag macro`	`load_flag macro`
`lda #\1\|intdis ;force disable interrupts`	`lda #\1\|intdis ;force disable interrupts`
`endm`	`endm`

`cmp_flag macro`	`cmp_flag macro`
`cmp #(\1\|fai)&m8 ;I_flag is always disabled + always on bits`	`cmp #(\1\|fai)&m8 ;I_flag is always disabled + always on bits`
`endm`	`endm`

`eor_flag macro`	`eor_flag macro`
`eor #(\1\|fai) ;invert expected flags + always on bits + I`	`eor #(\1\|fai) ;invert expected flags + always on bits + I`
`endm`	`endm`

`endif`	`endif`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 33`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`if I_flag = 2`	`if I_flag = 2`

`load_flag macro`	`load_flag macro`
`lda #\1`	`lda #\1`
`ora flag_I_on ;restore I-flag`	`ora flag_I_on ;restore I-flag`
`and flag_I_off`	`and flag_I_off`
`endm`	`endm`

`cmp_flag macro`	`cmp_flag macro`
`eor flag_I_on ;I_flag is never changed`	`eor flag_I_on ;I_flag is never changed`
`cmp #(\1\|fao)&m8i ;expected flags + always on bits, mask I`	`cmp #(\1\|fao)&m8i ;expected flags + always on bits, mask I`
`endm`	`endm`

`eor_flag macro`	`eor_flag macro`
`eor flag_I_on ;I_flag is never changed`	`eor flag_I_on ;I_flag is never changed`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 12`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`eor #(\1&m8i\|fao) ;mask I, invert expected flags + always on bits`	`eor #(\1&m8i\|fao) ;mask I, invert expected flags + always on bits`
`endm`	`endm`

`endif`	`endif`

`if I_flag = 3`	`if I_flag = 3`

`load_flag macro`	`load_flag macro`
`lda #\1 ;allow test to change I-flag (no mask)`	`lda #\1 ;allow test to change I-flag (no mask)`
`endm`	`endm`

`cmp_flag macro`	`cmp_flag macro`
`cmp #(\1\|fao)&m8 ;expected flags + always on bits`	`cmp #(\1\|fao)&m8 ;expected flags + always on bits`
`endm`	`endm`

`eor_flag macro`	`eor_flag macro`
`eor #\1\|fao ;invert expected flags + always on bits`	`eor #\1\|fao ;invert expected flags + always on bits`
`endm`	`endm`

`endif`	`endif`

`;macros to set (register\|memory\|zeropage) & status`	`;macros to set (register\|memory\|zeropage) & status`

`set_stat macro ;setting flags in the processor status register`	`set_stat macro ;setting flags in the processor status register`
`load_flag \1`	`load_flag \1`
`pha ;use stack to load status`	`pha ;use stack to load status`
`plp`	`plp`
`endm`	`endm`
Line 662...	Line 1877...
`endm`	`endm`

`set_x macro ;precharging index & status`	`set_x macro ;precharging index & status`
`load_flag \2`	`load_flag \2`
`pha ;use stack to load status`	`pha ;use stack to load status`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 34`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`ldx #\1 ;precharge index x`	`ldx #\1 ;precharge index x`
`plp`	`plp`
`endm`	`endm`

`set_y macro ;precharging index & status`	`set_y macro ;precharging index & status`
Line 685...	Line 1903...
`set_ay macro ;precharging indexed accu & immediate status`	`set_ay macro ;precharging indexed accu & immediate status`
`load_flag \2`	`load_flag \2`
`pha ;use stack to load status`	`pha ;use stack to load status`
`lda \1,y ;precharge accu`	`lda \1,y ;precharge accu`
`plp`	`plp`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 13`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`endm`	`endm`

`set_z macro ;precharging indexed zp & immediate status`	`set_z macro ;precharging indexed zp & immediate status`
`load_flag \2`	`load_flag \2`
`pha ;use stack to load status`	`pha ;use stack to load status`
Line 720...	Line 1935...
`load_flag \2`	`load_flag \2`
`pha ;use stack to load status`	`pha ;use stack to load status`
`lda \1,x ;load to indexed memory`	`lda \1,x ;load to indexed memory`
`sta abst,x`	`sta abst,x`
`plp`	`plp`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 35`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`endm`	`endm`

`;macros to test (register\|memory\|zeropage) & status & (mask)`	`;macros to test (register\|memory\|zeropage) & status & (mask)`

`tst_stat macro ;testing flags in the processor status register`	`tst_stat macro ;testing flags in the processor status register`
`php ;save status`	`php ;save status`
`php ;use stack to retrieve status`	`php ;use stack to retrieve status`
`pla`	`pla`
`cmp_flag \1`	`cmp_flag \1`
Line 743...	Line 1962...
`cmp_flag \2`	`cmp_flag \2`
`trap_ne`	`trap_ne`
`plp ;restore status`	`plp ;restore status`
`endm`	`endm`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 14`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`tst_x macro ;testing result in x index & flags`	`tst_x macro ;testing result in x index & flags`
`php ;save flags`	`php ;save flags`
`php`	`php`
`cpx #\1 ;test result`	`cpx #\1 ;test result`
`trap_ne`	`trap_ne`
Line 777...	Line 1993...
`pla ;load status`	`pla ;load status`
`eor_flag \3`	`eor_flag \3`
`cmp \2,x ;test flags`	`cmp \2,x ;test flags`
`trap_ne ;`	`trap_ne ;`
`endm`	`endm`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 36`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`tst_ay macro ;indexed testing result in accu & flags`	`tst_ay macro ;indexed testing result in accu & flags`
`php ;save flags`	`php ;save flags`
`cmp \1,y ;test result`	`cmp \1,y ;test result`
`trap_ne ;`	`trap_ne ;`
Line 801...	Line 2020...
`trap_ne`	`trap_ne`
`endm`	`endm`

`tst_zx macro ;testing result in zp,x & flags`	`tst_zx macro ;testing result in zp,x & flags`
`php ;save flags`	`php ;save flags`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 15`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`lda zpt,x`	`lda zpt,x`
`cmp \1,x ;test result`	`cmp \1,x ;test result`
`trap_ne`	`trap_ne`
`pla ;load status`	`pla ;load status`
`eor_flag \3`	`eor_flag \3`
Line 835...	Line 2051...
`eor_flag \3`	`eor_flag \3`
`cmp \2,x ;test flags`	`cmp \2,x ;test flags`
`trap_ne`	`trap_ne`
`endm`	`endm`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 37`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`; RAM integrity test`	`; RAM integrity test`
`; verifies that none of the previous tests has altered RAM outside of the`	`; verifies that none of the previous tests has altered RAM outside of the`
`; designated write areas.`	`; designated write areas.`
`; uses zpt word as indirect pointer, zpt+2 word as checksum`	`; uses zpt word as indirect pointer, zpt+2 word as checksum`

`if ram_top > -1`	`if ram_top > -1`

`check_ram macro`	`check_ram macro`
`cld`	`cld`
`lda #0`	`lda #0`
`sta zpt ;set low byte of indirect pointer`	`sta zpt ;set low byte of indirect pointer`
`sta zpt+3 ;checksum high byte`	`sta zpt+3 ;checksum high byte`
Line 859...	Line 2080...
`sta chkadi`	`sta chkadi`
`sta chksbi`	`sta chksbi`
`clc`	`clc`
`ldx #zp_bss-zero_page ;zeropage - write test area`	`ldx #zp_bss-zero_page ;zeropage - write test area`
`ccs3\? adc zero_page,x`	`ccs3\? adc zero_page,x`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 16`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`bcc ccs2\?`	`bcc ccs2\?`
`inc zpt+3 ;carry to high byte`	`inc zpt+3 ;carry to high byte`
`clc`	`clc`
`ccs2\? inx`	`ccs2\? inx`
`bne ccs3\?`	`bne ccs3\?`
Line 887...	Line 2105...
`trap_ne ;checksum mismatch`	`trap_ne ;checksum mismatch`
`lda zpt+3 ;checksum high is`	`lda zpt+3 ;checksum high is`
`cmp ram_chksm+1 ;checksum high expected`	`cmp ram_chksm+1 ;checksum high expected`
`trap_ne ;checksum mismatch`	`trap_ne ;checksum mismatch`
`endm`	`endm`

`else`	`else`

`check_ram macro`	`check_ram macro`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 38`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`;RAM check disabled - RAM size not set`	`;RAM check disabled - RAM size not set`
`endm`	`endm`

`endif`	`endif`

`next_test macro ;make sure, tests don't jump the fence`	`next_test macro ;make sure, tests don't jump the fence`
`lda test_case ;previous test`	`lda test_case ;previous test`
`cmp #test_num`	`cmp #test_num`
Line 904...	Line 2128...
`sta test_case`	`sta test_case`
`;check_ram ;uncomment to find altered RAM after each test`	`;check_ram ;uncomment to find altered RAM after each test`
`endm`	`endm`

`if load_data_direct = 1`	`if load_data_direct = 1`

`data`	`data`

`else`	`else`
`bss ;uninitialized segment, copy of data at end of code!`
`endif`	`; bss ;uninitialized segment, copy of data at end of code!`
`;`	`code`
`; org zero_page`
`0000 = org 0`	`0000 = org 0`
`0000 : 00000000000000.. ds zero_page`	`0000 : 00000000000000.. ds zero_page`

	`endif`
	`;`
	`00b0 = org zero_page`
	`;`
	`; org 0`
	`; ds zero_page`
	`;`
`;break test interrupt save`	`;break test interrupt save`
`000a : 00 irq_a ds 1 ;a register`	`;`
`000b : 00 irq_x ds 1 ;x register`
	`00b0 : 00 irq_a ds 1 ;a register`
	`00b1 : 00 irq_x ds 1 ;x register`

`if I_flag = 2`	`if I_flag = 2`

`;masking for I bit in status`	`;masking for I bit in status`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 17`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`flag_I_on ds 1 ;or mask to load flags`	`flag_I_on ds 1 ;or mask to load flags`
`flag_I_off ds 1 ;and mask to load flags`	`flag_I_off ds 1 ;and mask to load flags`

`endif`	`endif`
`000c : zpt ;5 bytes store/modify test area`
	`00b2 : zpt ;5 bytes store/modify test area`

`;add/subtract operand generation and result/flag prediction`	`;add/subtract operand generation and result/flag prediction`
`000c : 00 adfc ds 1 ;carry flag before op`
`000d : 00 ad1 ds 1 ;operand 1 - accumulator`	`00b2 : 00 adfc ds 1 ;carry flag before op`
`000e : 00 ad2 ds 1 ;operand 2 - memory / immediate`	`00b3 : 00 ad1 ds 1 ;operand 1 - accumulator`
`000f : 00 adrl ds 1 ;expected result bits 0-7`	`00b4 : 00 ad2 ds 1 ;operand 2 - memory / immediate`
`0010 : 00 adrh ds 1 ;expected result bit 8 (carry)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 39`
`0011 : 00 adrf ds 1 ;expected flags NV0000ZC (-V in decimal mode)`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`0012 : 00 sb2 ds 1 ;operand 2 complemented for subtract`
`0013 : zp_bss`	`00b5 : 00 adrl ds 1 ;expected result bits 0-7`
`0013 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR`	`00b6 : 00 adrh ds 1 ;expected result bit 8 (carry)`
`0017 : 7f zp7f db $7f ;test pattern for compare`	`00b7 : 00 adrf ds 1 ;expected flags NV0000ZC (-V in decimal mode)`
	`00b8 : 00 sb2 ds 1 ;operand 2 complemented for subtract`

	`00b9 : zp_bss`

	`00b9 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR`
	`00bd : 7f zp7f db $7f ;test pattern for compare`

`;logical zeropage operands`	`;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`	`00be : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR`
`0020 : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR`	`00c2 : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND`
	`00c6 : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR`

`;indirect addressing pointers`	`;indirect addressing pointers`
`0024 : 0802 ind1 dw abs1 ;indirect pointer to pattern in absolute memory`
`0026 : 0902 dw abs1+1`	`00ca : 0802 ind1 dw abs1 ;indirect pointer to pattern in absolute memory`
`0028 : 0a02 dw abs1+2`	`00cc : 0902 dw abs1+1`
`002a : 0b02 dw abs1+3`	`00ce : 0a02 dw abs1+2`
`002c : 0c02 dw abs7f`	`00d0 : 0b02 dw abs1+3`
`002e : 1001 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern`	`00d2 : 0c02 dw abs7f`
`0030 : 0302 indt dw abst ;indirect pointer to store area in absolute memory`	`00d4 : 1001 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern`
`0032 : 0402 dw abst+1`	`00d6 : 0302 indt dw abst ;indirect pointer to store area in absolute memory`
`0034 : 0502 dw abst+2`	`00d8 : 0402 dw abst+1`
`0036 : 0602 dw abst+3`	`00da : 0502 dw abst+2`
`0038 : 0b01 inwt dw abst-$f8 ;indirect pointer for wrap-test store`	`00dc : 0602 dw abst+3`
`003a : 3f02 indAN dw absAN ;indirect pointer to AND pattern in absolute memory`	`00de : 0b01 inwt dw abst-$f8 ;indirect pointer for wrap-test store`
`003c : 4002 dw absAN+1`	`00e0 : 3f02 indAN dw absAN ;indirect pointer to AND pattern in absolute memory`
`003e : 4102 dw absAN+2`	`00e2 : 4002 dw absAN+1`
`0040 : 4202 dw absAN+3`	`00e4 : 4102 dw absAN+2`
`0042 : 4302 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory`	`00e6 : 4202 dw absAN+3`
`0044 : 4402 dw absEO+1`	`00e8 : 4302 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory`
`0046 : 4502 dw absEO+2`	`00ea : 4402 dw absEO+1`
`0048 : 4602 dw absEO+3`	`00ec : 4502 dw absEO+2`
`004a : 3b02 indOR dw absOR ;indirect pointer to OR pattern in absolute memory`	`00ee : 4602 dw absEO+3`
`004c : 3c02 dw absOR+1`	`00f0 : 3b02 indOR dw absOR ;indirect pointer to OR pattern in absolute memory`
`004e : 3d02 dw absOR+2`	`00f2 : 3c02 dw absOR+1`
`0050 : 3e02 dw absOR+3`	`00f4 : 3d02 dw absOR+2`
	`00f6 : 3e02 dw absOR+3`

`;add/subtract indirect pointers`	`;add/subtract indirect pointers`
`0052 : 0302 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory`
`0054 : 0402 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC)`	`00f8 : 0302 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory`
`0056 : 0401 adiy2 dw ada2-$ff ;with offset for indirect indexed`	`00fa : 0402 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC)`
`0058 : 0501 sbiy2 dw sba2-$ff`	`00fc : 0401 adiy2 dw ada2-$ff ;with offset for indirect indexed`
`005a : zp_bss_end`	`00fe : 0501 sbiy2 dw sba2-$ff`

	`0100 : zp_bss_end`

`0200 = org data_segment`	`0200 = org data_segment`

`0200 : 00 test_case ds 1 ;current test number`	`0200 : 00 test_case ds 1 ;current test number`
`0201 : 0000 ram_chksm ds 2 ;checksum for RAM integrity test`	`0201 : 0000 ram_chksm ds 2 ;checksum for RAM integrity test`
`;add/subtract operand copy - abs tests write area`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 40`
`0203 : abst ;5 bytes store/modify test area`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 18`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


	`;add/subtract operand copy - abs tests write area`

	`0203 : abst ;5 bytes store/modify test area`
`0203 : 00 ada2 ds 1 ;operand 2`	`0203 : 00 ada2 ds 1 ;operand 2`
`0204 : 00 sba2 ds 1 ;operand 2 complemented for subtract`	`0204 : 00 sba2 ds 1 ;operand 2 complemented for subtract`
`0205 : 000000 ds 3 ;fill remaining bytes`	`0205 : 000000 ds 3 ;fill remaining bytes`

`0208 : data_bss`	`0208 : data_bss`

`0208 : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR`	`0208 : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR`
`020c : 7f abs7f db $7f ;test pattern for compare`	`020c : 7f abs7f db $7f ;test pattern for compare`

`;loads`	`;loads`

`020d : 80800002 fLDx db fn,fn,0,fz ;expected flags for load`	`020d : 80800002 fLDx db fn,fn,0,fz ;expected flags for load`

`;shifts`	`;shifts`

`0211 : rASL ;expected result ASL & ROL -carry`	`0211 : rASL ;expected result ASL & ROL -carry`
`0211 : 86048200 rROL db $86,$04,$82,0 ; "`	`0211 : 86048200 rROL db $86,$04,$82,0 ; "`
`0215 : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry`	`0215 : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry`
`0219 : rLSR ;expected result LSR & ROR -carry`	`0219 : rLSR ;expected result LSR & ROR -carry`
`0219 : 61412000 rROR db $61,$41,$20,0 ; "`	`0219 : 61412000 rROR db $61,$41,$20,0 ; "`
Line 999...	Line 2259...
`0221 : 81018002 fROL db fnc,fc,fn,fz ;no carry in`	`0221 : 81018002 fROL db fnc,fc,fn,fz ;no carry in`
`0225 : 81018000 fROLc db fnc,fc,fn,0 ;carry in`	`0225 : 81018000 fROLc db fnc,fc,fn,0 ;carry in`
`0229 : fLSR`	`0229 : fLSR`
`0229 : 01000102 fROR db fc,0,fc,fz ;no carry in`	`0229 : 01000102 fROR db fc,0,fc,fz ;no carry in`
`022d : 81808180 fRORc db fnc,fn,fnc,fn ;carry in`	`022d : 81808180 fRORc db fnc,fn,fnc,fn ;carry in`

`;increments (decrements)`	`;increments (decrements)`

`0231 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC`	`0231 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC`
`0236 : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC`	`0236 : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC`

`;logical memory operand`	`;logical memory operand`

`023b : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR`	`023b : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR`
`023f : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND`	`023f : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND`
`0243 : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR`	`0243 : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR`

`;logical accu operand`	`;logical accu operand`

`0247 : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR`	`0247 : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR`
`024b : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND`	`024b : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND`
`024f : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR`	`024f : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR`

`;logical results`	`;logical results`

`0253 : 00ff7f80 absrlo db 0,$ff,$7f,$80`	`0253 : 00ff7f80 absrlo db 0,$ff,$7f,$80`
`0257 : 02800080 absflo db fz,fn,0,fn`	`0257 : 02800080 absflo db fz,fn,0,fn`

`025b : data_bss_end`	`025b : data_bss_end`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 41`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`code`	`code`
`0400 = org code_segment`	`0400 = org code_segment`

`0400 : d8 [ 2] start cld`	`0400 : d8 [ 2] start cld`
`0401 : a900 [ 2] lda #0 ;*** test 0 = initialize`	`0401 : a900 [ 2] lda #0 ;*** test 0 = initialize`
`0403 : 8d0002 [ 4] sta test_case`	`0403 : 8d0002 [ 4] sta test_case`
`0000 = test_num = 0`	`0000 = test_num = 0`

`;stop interrupts before initializing BSS`	`;stop interrupts before initializing BSS`

`if I_flag = 1`	`if I_flag = 1`
`sei`	`sei`
`endif`	`endif`

`;initialize BSS segment`	`;initialize BSS segment`

`if load_data_direct != 1`	`if load_data_direct != 1`
`ldx #zp_end-zp_init-1`
`ld_zp lda zp_init,x`
`sta zp_bss,x`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 19`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`dex`	`0406 : a246 [ 2] ldx #zp_end-zp_init-1`
`bpl ld_zp`	`0408 : bd4c3e [ 4] ld_zp lda zp_init,x`
`ldx #data_end-data_init-1`	`040b : 95b9 [ 4] sta zp_bss,x`
`ld_data lda data_init,x`	`040d : ca [ 2] dex`
`sta data_bss,x`	`040e : 10f8 [ 3] bpl ld_zp`
`dex`	`0410 : a252 [ 2] ldx #data_end-data_init-1`
`bpl ld_data`	`0412 : bd933e [ 4] ld_data lda data_init,x`
	`0415 : 9d0802 [ 5] sta data_bss,x`
	`0418 : ca [ 2] dex`
	`0419 : 10f7 [ 3] bpl ld_data`

`if ROM_vectors = 1`	`if ROM_vectors = 1`

`ldx #5`	`ldx #5`
`ld_vect lda vec_init,x`	`ld_vect lda vec_init,x`
`sta vec_bss,x`	`sta vec_bss,x`
`dex`	`dex`
`bpl ld_vect`	`bpl ld_vect`

`endif`	`endif`

`endif`	`endif`

`;retain status of interrupt flag`	`;retain status of interrupt flag`

`if I_flag = 2`	`if I_flag = 2`

`php`	`php`
`pla`	`pla`
`and #4 ;isolate flag`	`and #4 ;isolate flag`
`sta flag_I_on ;or mask`	`sta flag_I_on ;or mask`
`eor #lo(~4) ;reverse`	`eor #lo(~4) ;reverse`
`sta flag_I_off ;and mask`	`sta flag_I_off ;and mask`

`endif`	`endif`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 42`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`;generate checksum for RAM integrity test`	`;generate checksum for RAM integrity test`

`if ram_top > -1`	`if ram_top > -1`

`lda #0`	`lda #0`
`sta zpt ;set low byte of indirect pointer`	`sta zpt ;set low byte of indirect pointer`
`sta ram_chksm+1 ;checksum high byte`	`sta ram_chksm+1 ;checksum high byte`
`sta range_adr ;reset self modifying code`	`sta range_adr ;reset self modifying code`
`sta tandi1`	`sta tandi1`
Line 1091...	Line 2375...
`ldx #hi(data_segment) ;set high byte of indirect pointer`	`ldx #hi(data_segment) ;set high byte of indirect pointer`
`stx zpt+1`	`stx zpt+1`
`ldy #lo(data_bss) ;data after write test area`	`ldy #lo(data_bss) ;data after write test area`
`gcs5 adc (zpt),y`	`gcs5 adc (zpt),y`
`bcc gcs4`	`bcc gcs4`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 20`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`inc ram_chksm+1 ;carry to high byte`	`inc ram_chksm+1 ;carry to high byte`
`clc`	`clc`
`gcs4 iny`	`gcs4 iny`
`bne gcs5`	`bne gcs5`
`inx ;advance RAM high address`	`inx ;advance RAM high address`
`stx zpt+1`	`stx zpt+1`
`cpx #ram_top`	`cpx #ram_top`
`bne gcs5`	`bne gcs5`
`sta ram_chksm ;checksum complete`	`sta ram_chksm ;checksum complete`

`endif`	`endif`

`if skip_part_1 = 1`	`if skip_part_1 = 1`

`jmp bin_test`	`jmp bin_test`

`endif`	`endif`

`next_test`	`next_test`
`0406 : ad0002 [ 4]> lda test_case ;previous test`	`041b : ad0002 [ 4]> lda test_case ;previous test`
`0409 : c900 [ 2]> cmp #test_num`	`041e : c900 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`040b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0420 : f002 [ 3]> beq skip0002`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 43`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0422 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0423 : 00 > db test_num`
	`>`
	`0424 : >skip0002`
`>`	`>`
`0001 = >test_num = test_num + 1`	`0001 = >test_num = test_num + 1`
`040d : a901 [ 2]> lda #test_num ;*** this tests' number`	`0424 : a901 [ 2]> lda #test_num ;*** this tests' number`
`040f : 8d0002 [ 4]> sta test_case`	`0426 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`;testing relative addressing with BEQ`	`;testing relative addressing with BEQ`
`0412 : a0fe [ 2] ldy #$fe ;testing maximum range, not -1/-2 (invalid/self adr)`
`0414 : range_loop`	`0429 : a0fe [ 2] ldy #$fe ;testing maximum range, not -1/-2 (invalid/self adr)`
`0414 : 88 [ 2] dey ;next relative address`	`042b : range_loop`
`0415 : 98 [ 2] tya`	`042b : 88 [ 2] dey ;next relative address`
`0416 : aa [ 2] tax ;precharge count to end of loop`	`042c : 98 [ 2] tya`
`0417 : 1003 [ 3] bpl range_fw ;calculate relative address`	`042d : aa [ 2] tax ;precharge count to end of loop`
`0419 : 18 [ 2] clc ;avoid branch self or to relative address of branch`	`042e : 1003 [ 3] bpl range_fw ;calculate relative address`
`041a : 6902 [ 2] adc #2`	`0430 : 18 [ 2] clc ;avoid branch self or to relative address of branch`
`041c : range_fw`	`0431 : 6902 [ 2] adc #2`
`041c : 497f [ 2] eor #$7f ;complement except sign`	`0433 : range_fw`
`041e : 8da504 [ 4] sta range_adr ;load into test target`	`0433 : 497f [ 2] eor #$7f ;complement except sign`
`0421 : a900 [ 2] lda #0 ;should set zero flag in status register`	`0435 : 8dbc04 [ 4] sta range_adr ;load into test target`
`0423 : 4ca404 [ 3] jmp range_op`	`0438 : a900 [ 2] lda #0 ;should set zero flag in status register`
	`043a : 4cbb04 [ 3] jmp range_op`

`;relative address target field with branch under test in the middle`	`;relative address target field with branch under test in the middle`
`0426 : ca [ 2] dex ;-128 - max backward`
`0427 : ca [ 2] dex`
`0428 : ca [ 2] dex`
`0429 : ca [ 2] dex`
`042a : ca [ 2] dex`
`042b : ca [ 2] dex`
`042c : ca [ 2] dex`
`042d : ca [ 2] dex`
`042e : ca [ 2] dex ;-120`
`042f : ca [ 2] dex`
`0430 : ca [ 2] dex`
`0431 : ca [ 2] dex`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 21`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0432 : ca [ 2] dex`	`043d : ca [ 2] dex ;-128 - max backward`
`0433 : ca [ 2] dex`
`0434 : ca [ 2] dex`
`0435 : ca [ 2] dex`
`0436 : ca [ 2] dex`
`0437 : ca [ 2] dex`
`0438 : ca [ 2] dex ;-110`
`0439 : ca [ 2] dex`
`043a : ca [ 2] dex`
`043b : ca [ 2] dex`
`043c : ca [ 2] dex`
`043d : ca [ 2] dex`
`043e : ca [ 2] dex`	`043e : ca [ 2] dex`
`043f : ca [ 2] dex`	`043f : ca [ 2] dex`
`0440 : ca [ 2] dex`	`0440 : ca [ 2] dex`
`0441 : ca [ 2] dex`	`0441 : ca [ 2] dex`
`0442 : ca [ 2] dex ;-100`	`0442 : ca [ 2] dex`
`0443 : ca [ 2] dex`	`0443 : ca [ 2] dex`
`0444 : ca [ 2] dex`	`0444 : ca [ 2] dex`
`0445 : ca [ 2] dex`	`0445 : ca [ 2] dex ;-120`
`0446 : ca [ 2] dex`	`0446 : ca [ 2] dex`
`0447 : ca [ 2] dex`	`0447 : ca [ 2] dex`
`0448 : ca [ 2] dex`	`0448 : ca [ 2] dex`
`0449 : ca [ 2] dex`	`0449 : ca [ 2] dex`
`044a : ca [ 2] dex`	`044a : ca [ 2] dex`
`044b : ca [ 2] dex`	`044b : ca [ 2] dex`
`044c : ca [ 2] dex ;-90`	`044c : ca [ 2] dex`
`044d : ca [ 2] dex`	`044d : ca [ 2] dex`
`044e : ca [ 2] dex`	`044e : ca [ 2] dex`
`044f : ca [ 2] dex`	`044f : ca [ 2] dex ;-110`
`0450 : ca [ 2] dex`	`0450 : ca [ 2] dex`
`0451 : ca [ 2] dex`	`0451 : ca [ 2] dex`
`0452 : ca [ 2] dex`	`0452 : ca [ 2] dex`
`0453 : ca [ 2] dex`	`0453 : ca [ 2] dex`
`0454 : ca [ 2] dex`	`0454 : ca [ 2] dex`
`0455 : ca [ 2] dex`	`0455 : ca [ 2] dex`
`0456 : ca [ 2] dex ;-80`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 44`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0456 : ca [ 2] dex`
`0457 : ca [ 2] dex`	`0457 : ca [ 2] dex`
`0458 : ca [ 2] dex`	`0458 : ca [ 2] dex`
`0459 : ca [ 2] dex`	`0459 : ca [ 2] dex ;-100`
`045a : ca [ 2] dex`	`045a : ca [ 2] dex`
`045b : ca [ 2] dex`	`045b : ca [ 2] dex`
`045c : ca [ 2] dex`	`045c : ca [ 2] dex`
`045d : ca [ 2] dex`	`045d : ca [ 2] dex`
`045e : ca [ 2] dex`	`045e : ca [ 2] dex`
`045f : ca [ 2] dex`	`045f : ca [ 2] dex`
`0460 : ca [ 2] dex ;-70`	`0460 : ca [ 2] dex`
`0461 : ca [ 2] dex`	`0461 : ca [ 2] dex`
`0462 : ca [ 2] dex`	`0462 : ca [ 2] dex`
`0463 : ca [ 2] dex`	`0463 : ca [ 2] dex ;-90`
`0464 : ca [ 2] dex`	`0464 : ca [ 2] dex`
`0465 : ca [ 2] dex`	`0465 : ca [ 2] dex`
`0466 : ca [ 2] dex`	`0466 : ca [ 2] dex`
`0467 : ca [ 2] dex`	`0467 : ca [ 2] dex`
`0468 : ca [ 2] dex`	`0468 : ca [ 2] dex`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 22`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0469 : ca [ 2] dex`	`0469 : ca [ 2] dex`
`046a : ca [ 2] dex ;-60`	`046a : ca [ 2] dex`
`046b : ca [ 2] dex`	`046b : ca [ 2] dex`
`046c : ca [ 2] dex`	`046c : ca [ 2] dex`
`046d : ca [ 2] dex`	`046d : ca [ 2] dex ;-80`
`046e : ca [ 2] dex`	`046e : ca [ 2] dex`
`046f : ca [ 2] dex`	`046f : ca [ 2] dex`
`0470 : ca [ 2] dex`	`0470 : ca [ 2] dex`
`0471 : ca [ 2] dex`	`0471 : ca [ 2] dex`
`0472 : ca [ 2] dex`	`0472 : ca [ 2] dex`
`0473 : ca [ 2] dex`	`0473 : ca [ 2] dex`
`0474 : ca [ 2] dex ;-50`	`0474 : ca [ 2] dex`
`0475 : ca [ 2] dex`	`0475 : ca [ 2] dex`
`0476 : ca [ 2] dex`	`0476 : ca [ 2] dex`
`0477 : ca [ 2] dex`	`0477 : ca [ 2] dex ;-70`
`0478 : ca [ 2] dex`	`0478 : ca [ 2] dex`
`0479 : ca [ 2] dex`	`0479 : ca [ 2] dex`
`047a : ca [ 2] dex`	`047a : ca [ 2] dex`
`047b : ca [ 2] dex`	`047b : ca [ 2] dex`
`047c : ca [ 2] dex`	`047c : ca [ 2] dex`
`047d : ca [ 2] dex`	`047d : ca [ 2] dex`
`047e : ca [ 2] dex ;-40`	`047e : ca [ 2] dex`
`047f : ca [ 2] dex`	`047f : ca [ 2] dex`
`0480 : ca [ 2] dex`	`0480 : ca [ 2] dex`
`0481 : ca [ 2] dex`	`0481 : ca [ 2] dex ;-60`
`0482 : ca [ 2] dex`	`0482 : ca [ 2] dex`
`0483 : ca [ 2] dex`	`0483 : ca [ 2] dex`
`0484 : ca [ 2] dex`	`0484 : ca [ 2] dex`
`0485 : ca [ 2] dex`	`0485 : ca [ 2] dex`
`0486 : ca [ 2] dex`	`0486 : ca [ 2] dex`
`0487 : ca [ 2] dex`	`0487 : ca [ 2] dex`
`0488 : ca [ 2] dex ;-30`	`0488 : ca [ 2] dex`
`0489 : ca [ 2] dex`	`0489 : ca [ 2] dex`
`048a : ca [ 2] dex`	`048a : ca [ 2] dex`
`048b : ca [ 2] dex`	`048b : ca [ 2] dex ;-50`
`048c : ca [ 2] dex`	`048c : ca [ 2] dex`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 45`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`048d : ca [ 2] dex`	`048d : ca [ 2] dex`
`048e : ca [ 2] dex`	`048e : ca [ 2] dex`
`048f : ca [ 2] dex`	`048f : ca [ 2] dex`
`0490 : ca [ 2] dex`	`0490 : ca [ 2] dex`
`0491 : ca [ 2] dex`	`0491 : ca [ 2] dex`
`0492 : ca [ 2] dex ;-20`	`0492 : ca [ 2] dex`
`0493 : ca [ 2] dex`	`0493 : ca [ 2] dex`
`0494 : ca [ 2] dex`	`0494 : ca [ 2] dex`
`0495 : ca [ 2] dex`	`0495 : ca [ 2] dex ;-40`
`0496 : ca [ 2] dex`	`0496 : ca [ 2] dex`
`0497 : ca [ 2] dex`	`0497 : ca [ 2] dex`
`0498 : ca [ 2] dex`	`0498 : ca [ 2] dex`
`0499 : ca [ 2] dex`	`0499 : ca [ 2] dex`
`049a : ca [ 2] dex`	`049a : ca [ 2] dex`
`049b : ca [ 2] dex`	`049b : ca [ 2] dex`
`049c : ca [ 2] dex ;-10`	`049c : ca [ 2] dex`
`049d : ca [ 2] dex`	`049d : ca [ 2] dex`
`049e : ca [ 2] dex`	`049e : ca [ 2] dex`
`049f : ca [ 2] dex`	`049f : ca [ 2] dex ;-30`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 23`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`04a0 : ca [ 2] dex`	`04a0 : ca [ 2] dex`
`04a1 : ca [ 2] dex`	`04a1 : ca [ 2] dex`
`04a2 : ca [ 2] dex`	`04a2 : ca [ 2] dex`
`04a3 : ca [ 2] dex ;-3`	`04a3 : ca [ 2] dex`
`04a4 : range_op ;test target with zero flag=0, z=1 if previous dex`	`04a4 : ca [ 2] dex`
`04a5 = range_adr = *+1 ;modifiable relative address`	`04a5 : ca [ 2] dex`
`04a4 : f03e [ 3] beq *+64 ;if called without modification`	`04a6 : ca [ 2] dex`
`04a6 : ca [ 2] dex ;+0`
`04a7 : ca [ 2] dex`	`04a7 : ca [ 2] dex`
`04a8 : ca [ 2] dex`	`04a8 : ca [ 2] dex`
`04a9 : ca [ 2] dex`	`04a9 : ca [ 2] dex ;-20`
`04aa : ca [ 2] dex`	`04aa : ca [ 2] dex`
`04ab : ca [ 2] dex`	`04ab : ca [ 2] dex`
`04ac : ca [ 2] dex`	`04ac : ca [ 2] dex`
`04ad : ca [ 2] dex`	`04ad : ca [ 2] dex`
`04ae : ca [ 2] dex`	`04ae : ca [ 2] dex`
`04af : ca [ 2] dex`	`04af : ca [ 2] dex`
`04b0 : ca [ 2] dex ;+10`	`04b0 : ca [ 2] dex`
`04b1 : ca [ 2] dex`	`04b1 : ca [ 2] dex`
`04b2 : ca [ 2] dex`	`04b2 : ca [ 2] dex`
`04b3 : ca [ 2] dex`	`04b3 : ca [ 2] dex ;-10`
`04b4 : ca [ 2] dex`	`04b4 : ca [ 2] dex`
`04b5 : ca [ 2] dex`	`04b5 : ca [ 2] dex`
`04b6 : ca [ 2] dex`	`04b6 : ca [ 2] dex`
`04b7 : ca [ 2] dex`	`04b7 : ca [ 2] dex`
`04b8 : ca [ 2] dex`	`04b8 : ca [ 2] dex`
`04b9 : ca [ 2] dex`	`04b9 : ca [ 2] dex`
`04ba : ca [ 2] dex ;+20`	`04ba : ca [ 2] dex ;-3`
`04bb : ca [ 2] dex`
`04bc : ca [ 2] dex`	`04bb : range_op ;test target with zero flag=0, z=1 if previous dex`
`04bd : ca [ 2] dex`	`04bc = range_adr = *+1 ;modifiable relative address`

	`04bb : f03e [ 3] beq *+64 ;if called without modification`
	`04bd : ca [ 2] dex ;+0`
`04be : ca [ 2] dex`	`04be : ca [ 2] dex`
`04bf : ca [ 2] dex`	`04bf : ca [ 2] dex`
`04c0 : ca [ 2] dex`	`04c0 : ca [ 2] dex`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 46`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`04c1 : ca [ 2] dex`	`04c1 : ca [ 2] dex`
`04c2 : ca [ 2] dex`	`04c2 : ca [ 2] dex`
`04c3 : ca [ 2] dex`	`04c3 : ca [ 2] dex`
`04c4 : ca [ 2] dex ;+30`	`04c4 : ca [ 2] dex`
`04c5 : ca [ 2] dex`	`04c5 : ca [ 2] dex`
`04c6 : ca [ 2] dex`	`04c6 : ca [ 2] dex`
`04c7 : ca [ 2] dex`	`04c7 : ca [ 2] dex ;+10`
`04c8 : ca [ 2] dex`	`04c8 : ca [ 2] dex`
`04c9 : ca [ 2] dex`	`04c9 : ca [ 2] dex`
`04ca : ca [ 2] dex`	`04ca : ca [ 2] dex`
`04cb : ca [ 2] dex`	`04cb : ca [ 2] dex`
`04cc : ca [ 2] dex`	`04cc : ca [ 2] dex`
`04cd : ca [ 2] dex`	`04cd : ca [ 2] dex`
`04ce : ca [ 2] dex ;+40`	`04ce : ca [ 2] dex`
`04cf : ca [ 2] dex`	`04cf : ca [ 2] dex`
`04d0 : ca [ 2] dex`	`04d0 : ca [ 2] dex`
`04d1 : ca [ 2] dex`	`04d1 : ca [ 2] dex ;+20`
`04d2 : ca [ 2] dex`	`04d2 : ca [ 2] dex`
`04d3 : ca [ 2] dex`	`04d3 : ca [ 2] dex`
`04d4 : ca [ 2] dex`	`04d4 : ca [ 2] dex`
`04d5 : ca [ 2] dex`	`04d5 : ca [ 2] dex`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 24`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`04d6 : ca [ 2] dex`	`04d6 : ca [ 2] dex`
`04d7 : ca [ 2] dex`	`04d7 : ca [ 2] dex`
`04d8 : ca [ 2] dex ;+50`	`04d8 : ca [ 2] dex`
`04d9 : ca [ 2] dex`	`04d9 : ca [ 2] dex`
`04da : ca [ 2] dex`	`04da : ca [ 2] dex`
`04db : ca [ 2] dex`	`04db : ca [ 2] dex ;+30`
`04dc : ca [ 2] dex`	`04dc : ca [ 2] dex`
`04dd : ca [ 2] dex`	`04dd : ca [ 2] dex`
`04de : ca [ 2] dex`	`04de : ca [ 2] dex`
`04df : ca [ 2] dex`	`04df : ca [ 2] dex`
`04e0 : ca [ 2] dex`	`04e0 : ca [ 2] dex`
`04e1 : ca [ 2] dex`	`04e1 : ca [ 2] dex`
`04e2 : ca [ 2] dex ;+60`	`04e2 : ca [ 2] dex`
`04e3 : ca [ 2] dex`	`04e3 : ca [ 2] dex`
`04e4 : ca [ 2] dex`	`04e4 : ca [ 2] dex`
`04e5 : ca [ 2] dex`	`04e5 : ca [ 2] dex ;+40`
`04e6 : ca [ 2] dex`	`04e6 : ca [ 2] dex`
`04e7 : ca [ 2] dex`	`04e7 : ca [ 2] dex`
`04e8 : ca [ 2] dex`	`04e8 : ca [ 2] dex`
`04e9 : ca [ 2] dex`	`04e9 : ca [ 2] dex`
`04ea : ca [ 2] dex`	`04ea : ca [ 2] dex`
`04eb : ca [ 2] dex`	`04eb : ca [ 2] dex`
`04ec : ca [ 2] dex ;+70`	`04ec : ca [ 2] dex`
`04ed : ca [ 2] dex`	`04ed : ca [ 2] dex`
`04ee : ca [ 2] dex`	`04ee : ca [ 2] dex`
`04ef : ca [ 2] dex`	`04ef : ca [ 2] dex ;+50`
`04f0 : ca [ 2] dex`	`04f0 : ca [ 2] dex`
`04f1 : ca [ 2] dex`	`04f1 : ca [ 2] dex`
`04f2 : ca [ 2] dex`	`04f2 : ca [ 2] dex`
`04f3 : ca [ 2] dex`	`04f3 : ca [ 2] dex`
`04f4 : ca [ 2] dex`	`04f4 : ca [ 2] dex`
`04f5 : ca [ 2] dex`	`04f5 : ca [ 2] dex`
`04f6 : ca [ 2] dex ;+80`	`04f6 : ca [ 2] dex`
`04f7 : ca [ 2] dex`	`04f7 : ca [ 2] dex`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 47`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`04f8 : ca [ 2] dex`	`04f8 : ca [ 2] dex`
`04f9 : ca [ 2] dex`	`04f9 : ca [ 2] dex ;+60`
`04fa : ca [ 2] dex`	`04fa : ca [ 2] dex`
`04fb : ca [ 2] dex`	`04fb : ca [ 2] dex`
`04fc : ca [ 2] dex`	`04fc : ca [ 2] dex`
`04fd : ca [ 2] dex`	`04fd : ca [ 2] dex`
`04fe : ca [ 2] dex`	`04fe : ca [ 2] dex`
`04ff : ca [ 2] dex`	`04ff : ca [ 2] dex`
`0500 : ca [ 2] dex ;+90`	`0500 : ca [ 2] dex`
`0501 : ca [ 2] dex`	`0501 : ca [ 2] dex`
`0502 : ca [ 2] dex`	`0502 : ca [ 2] dex`
`0503 : ca [ 2] dex`	`0503 : ca [ 2] dex ;+70`
`0504 : ca [ 2] dex`	`0504 : ca [ 2] dex`
`0505 : ca [ 2] dex`	`0505 : ca [ 2] dex`
`0506 : ca [ 2] dex`	`0506 : ca [ 2] dex`
`0507 : ca [ 2] dex`	`0507 : ca [ 2] dex`
`0508 : ca [ 2] dex`	`0508 : ca [ 2] dex`
`0509 : ca [ 2] dex`	`0509 : ca [ 2] dex`
`050a : ca [ 2] dex ;+100`	`050a : ca [ 2] dex`
`050b : ca [ 2] dex`	`050b : ca [ 2] dex`
`050c : ca [ 2] dex`	`050c : ca [ 2] dex`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 25`	`050d : ca [ 2] dex ;+80`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`050d : ca [ 2] dex`
`050e : ca [ 2] dex`	`050e : ca [ 2] dex`
`050f : ca [ 2] dex`	`050f : ca [ 2] dex`
`0510 : ca [ 2] dex`	`0510 : ca [ 2] dex`
`0511 : ca [ 2] dex`	`0511 : ca [ 2] dex`
`0512 : ca [ 2] dex`	`0512 : ca [ 2] dex`
`0513 : ca [ 2] dex`	`0513 : ca [ 2] dex`
`0514 : ca [ 2] dex ;+110`	`0514 : ca [ 2] dex`
`0515 : ca [ 2] dex`	`0515 : ca [ 2] dex`
`0516 : ca [ 2] dex`	`0516 : ca [ 2] dex`
`0517 : ca [ 2] dex`	`0517 : ca [ 2] dex ;+90`
`0518 : ca [ 2] dex`	`0518 : ca [ 2] dex`
`0519 : ca [ 2] dex`	`0519 : ca [ 2] dex`
`051a : ca [ 2] dex`	`051a : ca [ 2] dex`
`051b : ca [ 2] dex`	`051b : ca [ 2] dex`
`051c : ca [ 2] dex`	`051c : ca [ 2] dex`
`051d : ca [ 2] dex`	`051d : ca [ 2] dex`
`051e : ca [ 2] dex ;+120`	`051e : ca [ 2] dex`
`051f : ca [ 2] dex`	`051f : ca [ 2] dex`
`0520 : ca [ 2] dex`	`0520 : ca [ 2] dex`
`0521 : ca [ 2] dex`	`0521 : ca [ 2] dex ;+100`
`0522 : ca [ 2] dex`	`0522 : ca [ 2] dex`
`0523 : ca [ 2] dex`	`0523 : ca [ 2] dex`
`0524 : ca [ 2] dex`	`0524 : ca [ 2] dex`
`0525 : f003 [ 3] beq range_ok ;+127 - max forward`	`0525 : ca [ 2] dex`
	`0526 : ca [ 2] dex`
	`0527 : ca [ 2] dex`
	`0528 : ca [ 2] dex`
	`0529 : ca [ 2] dex`
	`052a : ca [ 2] dex`
	`052b : ca [ 2] dex ;+110`
	`052c : ca [ 2] dex`
	`052d : ca [ 2] dex`
	`052e : ca [ 2] dex`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 48`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`052f : ca [ 2] dex`
	`0530 : ca [ 2] dex`
	`0531 : ca [ 2] dex`
	`0532 : ca [ 2] dex`
	`0533 : ca [ 2] dex`
	`0534 : ca [ 2] dex`
	`0535 : ca [ 2] dex ;+120`
	`0536 : ca [ 2] dex`
	`0537 : ca [ 2] dex`
	`0538 : ca [ 2] dex`
	`0539 : ca [ 2] dex`
	`053a : ca [ 2] dex`
	`053b : ca [ 2] dex`

	`053c : f002 [ 3] beq range_ok ;+127 - max forward`
`trap ; bad range`	`trap ; bad range`
`0527 : 4c2705 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`053e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`053f : 01 > db test_num`

`052a : range_ok`
`052a : c000 [ 2] cpy #0`	`0540 : range_ok`
`052c : f003 [ 3] beq range_end`	`0540 : c000 [ 2] cpy #0`
`052e : 4c1404 [ 3] jmp range_loop`	`0542 : f003 [ 3] beq range_end`
`0531 : range_end ;range test successful`	`0544 : 4c2b04 [ 3] jmp range_loop`
	`0547 : range_end ;range test successful`
`next_test`	`next_test`
`0531 : ad0002 [ 4]> lda test_case ;previous test`	`0547 : ad0002 [ 4]> lda test_case ;previous test`
`0534 : c901 [ 2]> cmp #test_num`	`054a : c901 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`0536 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`054c : f002 [ 3]> beq skip0006`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`054e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`054f : 01 > db test_num`
	`>`
	`0550 : >skip0006`
`>`	`>`
`0002 = >test_num = test_num + 1`	`0002 = >test_num = test_num + 1`
`0538 : a902 [ 2]> lda #test_num ;*** this tests' number`	`0550 : a902 [ 2]> lda #test_num ;*** this tests' number`
`053a : 8d0002 [ 4]> sta test_case`	`0552 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`;partial test BNE & CMP, CPX, CPY immediate`	`;partial test BNE & CMP, CPX, CPY immediate`
`053d : c001 [ 2] cpy #1 ;testing BNE true`
`053f : d003 [ 3] bne test_bne`	`0555 : c001 [ 2] cpy #1 ;testing BNE true`
	`0557 : d002 [ 3] bne test_bne`
`trap`	`trap`
`0541 : 4c4105 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0559 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`055a : 02 > db test_num`

`0544 : test_bne`	`055b : test_bne`
`0544 : a900 [ 2] lda #0`	`055b : a900 [ 2] lda #0`
`0546 : c900 [ 2] cmp #0 ;test compare immediate`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 49`
`trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 26`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0548 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`055d : c900 [ 2] cmp #0 ;test compare immediate`
	`trap_ne`
	`055f : f002 [ 3]> beq skip0009`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0561 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0562 : 02 > db test_num`
	`>`
	`0563 : >skip0009`

`trap_cc`	`trap_cc`
`054a : 90fe [ 3]> bcc * ;failed carry clear`	`0563 : b002 [ 3]> bcs skip0011`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0565 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0566 : 02 > db test_num`
	`>`
	`0567 : >skip0011`

`trap_mi`	`trap_mi`
`054c : 30fe [ 3]> bmi * ;failed minus (bit 7 set)`	`0567 : 1002 [ 3]> bpl skip0013`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0569 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`056a : 02 > db test_num`
	`>`
	`056b : >skip0013`

`054e : c901 [ 2] cmp #1`	`056b : c901 [ 2] cmp #1`
`trap_eq`	`trap_eq`
`0550 : f0fe [ 3]> beq * ;failed equal (zero)`	`056d : d002 [ 3]> bne skip0015`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`056f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0570 : 02 > db test_num`
	`>`
	`0571 : >skip0015`

`trap_cs`	`trap_cs`
`0552 : b0fe [ 3]> bcs * ;failed carry set`	`0571 : 9002 [ 3]> bcc skip0017`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0573 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0574 : 02 > db test_num`
	`>`
	`0575 : >skip0017`

`trap_pl`	`trap_pl`
`0554 : 10fe [ 3]> bpl * ;failed plus (bit 7 clear)`	`0575 : 3002 [ 3]> bmi skip0019`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0577 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0578 : 02 > db test_num`
	`>`
	`0579 : >skip0019`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 50`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`0556 : aa [ 2] tax`	`0579 : aa [ 2] tax`
`0557 : e000 [ 2] cpx #0 ;test compare x immediate`	`057a : e000 [ 2] cpx #0 ;test compare x immediate`
`trap_ne`	`trap_ne`
`0559 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`057c : f002 [ 3]> beq skip0021`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`057e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`057f : 02 > db test_num`
	`>`
	`0580 : >skip0021`

`trap_cc`	`trap_cc`
`055b : 90fe [ 3]> bcc * ;failed carry clear`	`0580 : b002 [ 3]> bcs skip0023`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0582 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0583 : 02 > db test_num`
	`>`
	`0584 : >skip0023`

`trap_mi`	`trap_mi`
`055d : 30fe [ 3]> bmi * ;failed minus (bit 7 set)`	`0584 : 1002 [ 3]> bpl skip0025`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0586 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0587 : 02 > db test_num`
	`>`
	`0588 : >skip0025`

`055f : e001 [ 2] cpx #1`	`0588 : e001 [ 2] cpx #1`
`trap_eq`	`trap_eq`
`0561 : f0fe [ 3]> beq * ;failed equal (zero)`	`058a : d002 [ 3]> bne skip0027`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`058c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`058d : 02 > db test_num`
	`>`
	`058e : >skip0027`

`trap_cs`	`trap_cs`
`0563 : b0fe [ 3]> bcs * ;failed carry set`	`058e : 9002 [ 3]> bcc skip0029`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0590 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0591 : 02 > db test_num`
	`>`
	`0592 : >skip0029`

`trap_pl`	`trap_pl`
`0565 : 10fe [ 3]> bpl * ;failed plus (bit 7 clear)`	`0592 : 3002 [ 3]> bmi skip0031`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0594 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0595 : 02 > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 51`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>`
	`0596 : >skip0031`

`0567 : a8 [ 2] tay`	`0596 : a8 [ 2] tay`
`0568 : c000 [ 2] cpy #0 ;test compare y immediate`	`0597 : c000 [ 2] cpy #0 ;test compare y immediate`
`trap_ne`	`trap_ne`
`056a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0599 : f002 [ 3]> beq skip0033`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`059b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`059c : 02 > db test_num`
	`>`
	`059d : >skip0033`

`trap_cc`	`trap_cc`
`056c : 90fe [ 3]> bcc * ;failed carry clear`	`059d : b002 [ 3]> bcs skip0035`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`059f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05a0 : 02 > db test_num`
	`>`
	`05a1 : >skip0035`

`trap_mi`	`trap_mi`
`056e : 30fe [ 3]> bmi * ;failed minus (bit 7 set)`	`05a1 : 1002 [ 3]> bpl skip0037`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`05a3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05a4 : 02 > db test_num`
	`>`
	`05a5 : >skip0037`

`0570 : c001 [ 2] cpy #1`	`05a5 : c001 [ 2] cpy #1`
`trap_eq`	`trap_eq`
`0572 : f0fe [ 3]> beq * ;failed equal (zero)`	`05a7 : d002 [ 3]> bne skip0039`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`05a9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05aa : 02 > db test_num`
	`>`
	`05ab : >skip0039`

`trap_cs`	`trap_cs`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 27`	`05ab : 9002 [ 3]> bcc skip0041`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`0574 : b0fe [ 3]> bcs * ;failed carry set`	`05ad : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05ae : 02 > db test_num`
	`>`
	`05af : >skip0041`

`trap_pl`	`trap_pl`
`0576 : 10fe [ 3]> bpl * ;failed plus (bit 7 clear)`	`05af : 3002 [ 3]> bmi skip0043`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 52`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`05b1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05b2 : 02 > db test_num`
	`>`
	`05b3 : >skip0043`

`next_test`	`next_test`
`0578 : ad0002 [ 4]> lda test_case ;previous test`	`05b3 : ad0002 [ 4]> lda test_case ;previous test`
`057b : c902 [ 2]> cmp #test_num`	`05b6 : c902 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`057d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`05b8 : f002 [ 3]> beq skip0046`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`05ba : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05bb : 02 > db test_num`
	`>`
	`05bc : >skip0046`
`>`	`>`
`0003 = >test_num = test_num + 1`	`0003 = >test_num = test_num + 1`
`057f : a903 [ 2]> lda #test_num ;*** this tests' number`	`05bc : a903 [ 2]> lda #test_num ;*** this tests' number`
`0581 : 8d0002 [ 4]> sta test_case`	`05be : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`;testing stack operations PHA PHP PLA PLP`	`;testing stack operations PHA PHP PLA PLP`

`0584 : a2ff [ 2] ldx #$ff ;initialize stack`	`05c1 : a2ff [ 2] ldx #$ff ;initialize stack`
`0586 : 9a [ 2] txs`	`05c3 : 9a [ 2] txs`
`0587 : a955 [ 2] lda #$55`	`05c4 : a955 [ 2] lda #$55`
`0589 : 48 [ 3] pha`	`05c6 : 48 [ 3] pha`
`058a : a9aa [ 2] lda #$aa`	`05c7 : a9aa [ 2] lda #$aa`
`058c : 48 [ 3] pha`	`05c9 : 48 [ 3] pha`
`058d : cdfe01 [ 4] cmp $1fe ;on stack ?`	`05ca : cdfe01 [ 4] cmp $1fe ;on stack ?`
`trap_ne`	`trap_ne`
`0590 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`05cd : f002 [ 3]> beq skip0048`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`05cf : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05d0 : 03 > db test_num`
	`>`
	`05d1 : >skip0048`

	`05d1 : ba [ 2] tsx`
	`05d2 : 8a [ 2] txa ;overwrite accu`
	`05d3 : c9fd [ 2] cmp #$fd ;sp decremented?`
	`trap_ne`
	`05d5 : f002 [ 3]> beq skip0050`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`05d7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05d8 : 03 > db test_num`
	`>`
	`05d9 : >skip0050`

`0592 : ba [ 2] tsx`	`05d9 : 68 [ 4] pla`
`0593 : 8a [ 2] txa ;overwrite accu`	`05da : c9aa [ 2] cmp #$aa ;successful retreived from stack?`
`0594 : c9fd [ 2] cmp #$fd ;sp decremented?`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 53`
`trap_ne`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`0596 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`0598 : 68 [ 4] pla`
`0599 : c9aa [ 2] cmp #$aa ;successful retreived from stack?`
`trap_ne`	`trap_ne`
`059b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`05dc : f002 [ 3]> beq skip0052`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`05de : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05df : 03 > db test_num`
	`>`
	`05e0 : >skip0052`

`059d : 68 [ 4] pla`	`05e0 : 68 [ 4] pla`
`059e : c955 [ 2] cmp #$55`	`05e1 : c955 [ 2] cmp #$55`
`trap_ne`	`trap_ne`
`05a0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`05e3 : f002 [ 3]> beq skip0054`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`05e5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05e6 : 03 > db test_num`
	`>`
	`05e7 : >skip0054`

`05a2 : cdff01 [ 4] cmp $1ff ;remains on stack?`	`05e7 : cdff01 [ 4] cmp $1ff ;remains on stack?`
`trap_ne`	`trap_ne`
`05a5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`05ea : f002 [ 3]> beq skip0056`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`05ec : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05ed : 03 > db test_num`
	`>`
	`05ee : >skip0056`

`05a7 : ba [ 2] tsx`	`05ee : ba [ 2] tsx`
`05a8 : e0ff [ 2] cpx #$ff ;sp incremented?`	`05ef : e0ff [ 2] cpx #$ff ;sp incremented?`
`trap_ne`	`trap_ne`
`05aa : d0fe [ 3]> bne * ;failed not equal (non zero)`	`05f1 : f002 [ 3]> beq skip0058`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`05f3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05f4 : 03 > db test_num`
	`>`
	`05f5 : >skip0058`

`next_test`	`next_test`
`05ac : ad0002 [ 4]> lda test_case ;previous test`	`05f5 : ad0002 [ 4]> lda test_case ;previous test`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 28`	`05f8 : c903 [ 2]> cmp #test_num`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`05af : c903 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`05b1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`05fa : f002 [ 3]> beq skip0061`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`05fc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`05fd : 03 > db test_num`
	`>`
	`05fe : >skip0061`
`>`	`>`
`0004 = >test_num = test_num + 1`	`0004 = >test_num = test_num + 1`
`05b3 : a904 [ 2]> lda #test_num ;*** this tests' number`	`05fe : a904 [ 2]> lda #test_num ;*** this tests' number`
`05b5 : 8d0002 [ 4]> sta test_case`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 54`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0600 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`;testing branch decisions BPL BMI BVC BVS BCC BCS BNE BEQ`	`;testing branch decisions BPL BMI BVC BVS BCC BCS BNE BEQ`

`set_stat $ff ;all on`	`set_stat $ff ;all on`
`> load_flag $ff`	`> load_flag $ff`
`05b8 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0603 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`05ba : 48 [ 3]> pha ;use stack to load status`	`0605 : 48 [ 3]> pha ;use stack to load status`
`05bb : 28 [ 4]> plp`	`0606 : 28 [ 4]> plp`

`05bc : 101a [ 3] bpl nbr1 ;branches should not be taken`	`0607 : 1016 [ 3] bpl nbr1 ;branches should not be taken`
`05be : 501b [ 3] bvc nbr2`	`0609 : 5016 [ 3] bvc nbr2`
`05c0 : 901c [ 3] bcc nbr3`	`060b : 9016 [ 3] bcc nbr3`
`05c2 : d01d [ 3] bne nbr4`	`060d : d016 [ 3] bne nbr4`
`05c4 : 3003 [ 3] bmi br1 ;branches should be taken`	`060f : 3002 [ 3] bmi br1 ;branches should be taken`
`trap`	`trap`
`05c6 : 4cc605 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0611 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0612 : 04 > db test_num`

`05c9 : 7003 [ 3] br1 bvs br2`	`0613 : 7002 [ 3] br1 bvs br2`
`trap`	`trap`
`05cb : 4ccb05 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0615 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0616 : 04 > db test_num`

`05ce : b003 [ 3] br2 bcs br3`	`0617 : b002 [ 3] br2 bcs br3`
`trap`	`trap`
`05d0 : 4cd005 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0619 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`061a : 04 > db test_num`

`05d3 : f00f [ 3] br3 beq br4`	`061b : f00a [ 3] br3 beq br4`
`trap`	`trap`
`05d5 : 4cd505 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`061d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`061e : 04 > db test_num`

`05d8 : nbr1`	`061f : nbr1`
`trap ;previous bpl taken`	`trap ;previous bpl taken`
`05d8 : 4cd805 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`061f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0620 : 04 > db test_num`

`05db : nbr2`	`0621 : nbr2`
`trap ;previous bvc taken`	`trap ;previous bvc taken`
`05db : 4cdb05 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0621 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0622 : 04 > db test_num`

`05de : nbr3`	`0623 : nbr3`
`trap ;previous bcc taken`	`trap ;previous bcc taken`
`05de : 4cde05 [ 3]> jmp * ;failed anyway`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 55`

`05e1 : nbr4`
`trap ;previous bne taken`
`05e1 : 4ce105 [ 3]> jmp * ;failed anyway`

`05e4 : 08 [ 3] br4 php`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 29`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`05e5 : ba [ 2] tsx`	`>; db $db ; M65C02/M65C02A SToP instruction`
`05e6 : e0fe [ 2] cpx #$fe ;sp after php?`	`0623 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`trap_ne`	`0624 : 04 > db test_num`
`05e8 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`05ea : 68 [ 4] pla`	`0625 : nbr4`
	`trap ;previous bne taken`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0625 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0626 : 04 > db test_num`

	`0627 : 08 [ 3] br4 php`
	`0628 : ba [ 2] tsx`
	`0629 : e0fe [ 2] cpx #$fe ;sp after php?`
	`trap_ne`
	`062b : f002 [ 3]> beq skip0073`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`062d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`062e : 04 > db test_num`
	`>`
	`062f : >skip0073`

	`062f : 68 [ 4] pla`
`cmp_flag $ff ;returned all flags on?`	`cmp_flag $ff ;returned all flags on?`
`05eb : c9ff [ 2]> cmp #($ff \|fao)&m8 ;expected flags + always on bits`	`0630 : c9ff [ 2]> cmp #($ff \|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`05ed : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0632 : f002 [ 3]> beq skip0076`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0634 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0635 : 04 > db test_num`
	`>`
	`0636 : >skip0076`

`05ef : ba [ 2] tsx`	`0636 : ba [ 2] tsx`
`05f0 : e0ff [ 2] cpx #$ff ;sp after php?`	`0637 : e0ff [ 2] cpx #$ff ;sp after php?`
`trap_ne`	`trap_ne`
`05f2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0639 : f002 [ 3]> beq skip0078`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`063b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`063c : 04 > db test_num`
	`>`
	`063d : >skip0078`

`set_stat 0 ;all off`	`set_stat 0 ;all off`
`> load_flag 0`	`> load_flag 0`
`05f4 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`063d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`05f6 : 48 [ 3]> pha ;use stack to load status`	`063f : 48 [ 3]> pha ;use stack to load status`
`05f7 : 28 [ 4]> plp`	`0640 : 28 [ 4]> plp`

	`0641 : 3026 [ 3] bmi nbr11 ;branches should not be taken`
	`0643 : 7026 [ 3] bvs nbr12`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 56`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`05f8 : 3022 [ 4] bmi nbr11 ;branches should not be taken`	`0645 : b026 [ 3] bcs nbr13`
`05fa : 7023 [ 4] bvs nbr12`	`0647 : f026 [ 3] beq nbr14`
`05fc : b024 [ 4] bcs nbr13`
`05fe : f025 [ 4] beq nbr14`
`trap_mi`	`trap_mi`
`0600 : 30fe [ 3]> bmi * ;failed minus (bit 7 set)`	`0649 : 1002 [ 3]> bpl skip0082`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`064b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`064c : 04 > db test_num`
	`>`
	`064d : >skip0082`

`trap_vs`	`trap_vs`
`0602 : 70fe [ 3]> bvs * ;failed overflow set`	`064d : 5002 [ 3]> bvc skip0084`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`064f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0650 : 04 > db test_num`
	`>`
	`0651 : >skip0084`

`trap_cs`	`trap_cs`
`0604 : b0fe [ 3]> bcs * ;failed carry set`	`0651 : 9002 [ 3]> bcc skip0086`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0653 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0654 : 04 > db test_num`
	`>`
	`0655 : >skip0086`

`trap_eq`	`trap_eq`
`0606 : f0fe [ 3]> beq * ;failed equal (zero)`	`0655 : d002 [ 3]> bne skip0088`
	`> trap ;failed equal (zero)`
`0608 : 1003 [ 3] bpl br11 ;branches should be taken`	`>; db $db ; M65C02/M65C02A SToP instruction`
`trap`	`0657 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`060a : 4c0a06 [ 3]> jmp * ;failed anyway`	`0658 : 04 > db test_num`
	`>`
	`0659 : >skip0088`

`060d : 5003 [ 3] br11 bvc br12`	`0659 : 1002 [ 3] bpl br11 ;branches should be taken`
`trap`	`trap`
`060f : 4c0f06 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`065b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`065c : 04 > db test_num`

`0612 : 9003 [ 3] br12 bcc br13`	`065d : 5002 [ 3] br11 bvc br12`
`trap`	`trap`
`0614 : 4c1406 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`065f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0660 : 04 > db test_num`

`0617 : d00f [ 3] br13 bne br14`	`0661 : 9002 [ 3] br12 bcc br13`
`trap`	`trap`
`0619 : 4c1906 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 30`	`0663 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0664 : 04 > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 57`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`061c : nbr11`	`0665 : d00a [ 3] br13 bne br14`
	`trap`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0667 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0668 : 04 > db test_num`

	`0669 : nbr11`
`trap ;previous bmi taken`	`trap ;previous bmi taken`
`061c : 4c1c06 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0669 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`066a : 04 > db test_num`

`061f : nbr12`	`066b : nbr12`
`trap ;previous bvs taken`	`trap ;previous bvs taken`
`061f : 4c1f06 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`066b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`066c : 04 > db test_num`

`0622 : nbr13`	`066d : nbr13`
`trap ;previous bcs taken`	`trap ;previous bcs taken`
`0622 : 4c2206 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`066d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`066e : 04 > db test_num`

`0625 : nbr14`	`066f : nbr14`
`trap ;previous beq taken`	`trap ;previous beq taken`
`0625 : 4c2506 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`066f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0670 : 04 > db test_num`

`0628 : 08 [ 3] br14 php`	`0671 : 08 [ 3] br14 php`
`0629 : 68 [ 4] pla`	`0672 : 68 [ 4] pla`
`cmp_flag 0 ;flags off except break (pushed by sw) + reserved?`	`cmp_flag 0 ;flags off except break (pushed by sw) + reserved?`
`062a : c930 [ 2]> cmp #(0 \|fao)&m8 ;expected flags + always on bits`	`0673 : c930 [ 2]> cmp #(0 \|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`062c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0675 : f002 [ 3]> beq skip0099`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0677 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0678 : 04 > db test_num`
	`>`
	`0679 : >skip0099`


`;crosscheck flags`	`;crosscheck flags`

`set_stat carry`	`set_stat carry`
`> load_flag carry`	`> load_flag carry`
`062e : a901 [ 2]> lda #carry ;allow test to change I-flag (no mask)`	`0679 : a901 [ 2]> lda #carry ;allow test to change I-flag (no mask)`
`>`	`>`
`0630 : 48 [ 3]> pha ;use stack to load status`	`067b : 48 [ 3]> pha ;use stack to load status`
`0631 : 28 [ 4]> plp`	`067c : 28 [ 4]> plp`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 58`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`trap_cc`	`trap_cc`
`0632 : 90fe [ 3]> bcc * ;failed carry clear`	`067d : b002 [ 3]> bcs skip0103`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`067f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0680 : 04 > db test_num`
	`>`
	`0681 : >skip0103`

`set_stat zero`	`set_stat zero`
`> load_flag zero`	`> load_flag zero`
`0634 : a902 [ 2]> lda #zero ;allow test to change I-flag (no mask)`	`0681 : a902 [ 2]> lda #zero ;allow test to change I-flag (no mask)`
`>`	`>`
`0636 : 48 [ 3]> pha ;use stack to load status`	`0683 : 48 [ 3]> pha ;use stack to load status`
`0637 : 28 [ 4]> plp`	`0684 : 28 [ 4]> plp`

`trap_ne`	`trap_ne`
`0638 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0685 : f002 [ 3]> beq skip0107`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0687 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0688 : 04 > db test_num`
	`>`
	`0689 : >skip0107`

`set_stat overfl`	`set_stat overfl`
`> load_flag overfl`	`> load_flag overfl`
`063a : a940 [ 2]> lda #overfl ;allow test to change I-flag (no mask)`	`0689 : a940 [ 2]> lda #overfl ;allow test to change I-flag (no mask)`
`>`	`>`
`063c : 48 [ 3]> pha ;use stack to load status`	`068b : 48 [ 3]> pha ;use stack to load status`
`063d : 28 [ 4]> plp`	`068c : 28 [ 4]> plp`

`trap_vc`	`trap_vc`
`063e : 50fe [ 3]> bvc * ;failed overflow clear`	`068d : 7002 [ 3]> bvs skip0111`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 31`	`> trap ;failed equal (zero)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`068f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0690 : 04 > db test_num`
	`>`
	`0691 : >skip0111`

`set_stat minus`	`set_stat minus`
`> load_flag minus`	`> load_flag minus`
`0640 : a980 [ 2]> lda #minus ;allow test to change I-flag (no mask)`	`0691 : a980 [ 2]> lda #minus ;allow test to change I-flag (no mask)`
`>`	`>`
`0642 : 48 [ 3]> pha ;use stack to load status`	`0693 : 48 [ 3]> pha ;use stack to load status`
`0643 : 28 [ 4]> plp`	`0694 : 28 [ 4]> plp`

`trap_pl`	`trap_pl`
`0644 : 10fe [ 3]> bpl * ;failed plus (bit 7 clear)`	`0695 : 3002 [ 3]> bmi skip0115`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0697 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0698 : 04 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 59`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0699 : >skip0115`

`set_stat $ff-carry`	`set_stat $ff-carry`
`> load_flag $ff-carry`	`> load_flag $ff-carry`
`0646 : a9fe [ 2]> lda #$ff-carry ;allow test to change I-flag (no mask)`	`0699 : a9fe [ 2]> lda #$ff-carry ;allow test to change I-flag (no mask)`
`>`	`>`
`0648 : 48 [ 3]> pha ;use stack to load status`	`069b : 48 [ 3]> pha ;use stack to load status`
`0649 : 28 [ 4]> plp`	`069c : 28 [ 4]> plp`

`trap_cs`	`trap_cs`
`064a : b0fe [ 3]> bcs * ;failed carry set`	`069d : 9002 [ 3]> bcc skip0119`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`069f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`06a0 : 04 > db test_num`
	`>`
	`06a1 : >skip0119`

`set_stat $ff-zero`	`set_stat $ff-zero`
`> load_flag $ff-zero`	`> load_flag $ff-zero`
`064c : a9fd [ 2]> lda #$ff-zero ;allow test to change I-flag (no mask)`	`06a1 : a9fd [ 2]> lda #$ff-zero ;allow test to change I-flag (no mask)`
`>`	`>`
`064e : 48 [ 3]> pha ;use stack to load status`	`06a3 : 48 [ 3]> pha ;use stack to load status`
`064f : 28 [ 4]> plp`	`06a4 : 28 [ 4]> plp`

`trap_eq`	`trap_eq`
`0650 : f0fe [ 3]> beq * ;failed equal (zero)`	`06a5 : d002 [ 3]> bne skip0123`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`06a7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`06a8 : 04 > db test_num`
	`>`
	`06a9 : >skip0123`

`set_stat $ff-overfl`	`set_stat $ff-overfl`
`> load_flag $ff-overfl`	`> load_flag $ff-overfl`
`0652 : a9bf [ 2]> lda #$ff-overfl ;allow test to change I-flag (no mask)`	`06a9 : a9bf [ 2]> lda #$ff-overfl ;allow test to change I-flag (no mask)`
`>`	`>`
`0654 : 48 [ 3]> pha ;use stack to load status`	`06ab : 48 [ 3]> pha ;use stack to load status`
`0655 : 28 [ 4]> plp`	`06ac : 28 [ 4]> plp`

`trap_vs`	`trap_vs`
`0656 : 70fe [ 3]> bvs * ;failed overflow set`	`06ad : 5002 [ 3]> bvc skip0127`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`06af : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`06b0 : 04 > db test_num`
	`>`
	`06b1 : >skip0127`

`set_stat $ff-minus`	`set_stat $ff-minus`
`> load_flag $ff-minus`	`> load_flag $ff-minus`
`0658 : a97f [ 2]> lda #$ff-minus ;allow test to change I-flag (no mask)`	`06b1 : a97f [ 2]> lda #$ff-minus ;allow test to change I-flag (no mask)`
`>`	`>`
`065a : 48 [ 3]> pha ;use stack to load status`	`06b3 : 48 [ 3]> pha ;use stack to load status`
`065b : 28 [ 4]> plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 60`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`06b4 : 28 [ 4]> plp`

`trap_mi`	`trap_mi`
`065c : 30fe [ 3]> bmi * ;failed minus (bit 7 set)`	`06b5 : 1002 [ 3]> bpl skip0131`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`06b7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`06b8 : 04 > db test_num`
	`>`
	`06b9 : >skip0131`

`next_test`	`next_test`
`065e : ad0002 [ 4]> lda test_case ;previous test`	`06b9 : ad0002 [ 4]> lda test_case ;previous test`
`0661 : c904 [ 2]> cmp #test_num`	`06bc : c904 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 32`	`06be : f002 [ 3]> beq skip0134`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`0663 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`06c0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`06c1 : 04 > db test_num`
	`>`
	`06c2 : >skip0134`
`>`	`>`
`0005 = >test_num = test_num + 1`	`0005 = >test_num = test_num + 1`
`0665 : a905 [ 2]> lda #test_num ;*** this tests' number`	`06c2 : a905 [ 2]> lda #test_num ;*** this tests' number`
`0667 : 8d0002 [ 4]> sta test_case`	`06c4 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; test PHA does not alter flags or accumulator but PLA does`	`; test PHA does not alter flags or accumulator but PLA does`
`066a : a255 [ 2] ldx #$55 ;x & y protected`
`066c : a0aa [ 2] ldy #$aa`	`06c7 : a255 [ 2] ldx #$55 ;x & y protected`
	`06c9 : a0aa [ 2] ldy #$aa`
`set_a 1,$ff ;push`	`set_a 1,$ff ;push`
`> load_flag $ff`	`> load_flag $ff`
`066e : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`06cb : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0670 : 48 [ 3]> pha ;use stack to load status`	`06cd : 48 [ 3]> pha ;use stack to load status`
`0671 : a901 [ 2]> lda #1 ;precharge accu`	`06ce : a901 [ 2]> lda #1 ;precharge accu`
`0673 : 28 [ 4]> plp`	`06d0 : 28 [ 4]> plp`

`0674 : 48 [ 3] pha`	`06d1 : 48 [ 3] pha`
`tst_a 1,$ff`	`tst_a 1,$ff`
`0675 : 08 [ 3]> php ;save flags`	`06d2 : 08 [ 3]> php ;save flags`
`0676 : 08 [ 3]> php`	`06d3 : 08 [ 3]> php`
`0677 : c901 [ 2]> cmp #1 ;test result`	`06d4 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`0679 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`06d6 : f002 [ 3]> beq skip0139`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`06d8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`06d9 : 05 > db test_num`
	`>`
	`06da : >skip0139`
`>`	`>`
`067b : 68 [ 4]> pla ;load status`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 61`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`06da : 68 [ 4]> pla ;load status`
`> cmp_flag $ff`	`> cmp_flag $ff`
`067c : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`	`06db : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`067e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`06dd : f002 [ 3]> beq skip0142`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`06df : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`06e0 : 05 > db test_num`
`>`	`>`
`0680 : 28 [ 4]> plp ;restore status`	`06e1 : >skip0142`
	`>`
	`06e1 : 28 [ 4]> plp ;restore status`

`set_a 0,0`	`set_a 0,0`
`> load_flag 0`	`> load_flag 0`
`0681 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`06e2 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0683 : 48 [ 3]> pha ;use stack to load status`	`06e4 : 48 [ 3]> pha ;use stack to load status`
`0684 : a900 [ 2]> lda #0 ;precharge accu`	`06e5 : a900 [ 2]> lda #0 ;precharge accu`
`0686 : 28 [ 4]> plp`	`06e7 : 28 [ 4]> plp`

`0687 : 48 [ 3] pha`	`06e8 : 48 [ 3] pha`
`tst_a 0,0`	`tst_a 0,0`
`0688 : 08 [ 3]> php ;save flags`	`06e9 : 08 [ 3]> php ;save flags`
`0689 : 08 [ 3]> php`	`06ea : 08 [ 3]> php`
`068a : c900 [ 2]> cmp #0 ;test result`	`06eb : c900 [ 2]> cmp #0 ;test result`
`> trap_ne`	`> trap_ne`
`068c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`06ed : f002 [ 3]> beq skip0147`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`06ef : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`06f0 : 05 > db test_num`
	`>`
	`06f1 : >skip0147`
`>`	`>`
`068e : 68 [ 4]> pla ;load status`	`06f1 : 68 [ 4]> pla ;load status`
`> cmp_flag 0`	`> cmp_flag 0`
`068f : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`06f2 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 33`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`> trap_ne`	`> trap_ne`
`0691 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`06f4 : f002 [ 3]> beq skip0150`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`06f6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`06f7 : 05 > db test_num`
	`>`
	`06f8 : >skip0150`
`>`	`>`
`0693 : 28 [ 4]> plp ;restore status`	`06f8 : 28 [ 4]> plp ;restore status`

`set_a $ff,$ff`	`set_a $ff,$ff`
`> load_flag $ff`	`> load_flag $ff`
`0694 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`06f9 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 62`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`0696 : 48 [ 3]> pha ;use stack to load status`	`06fb : 48 [ 3]> pha ;use stack to load status`
`0697 : a9ff [ 2]> lda #$ff ;precharge accu`	`06fc : a9ff [ 2]> lda #$ff ;precharge accu`
`0699 : 28 [ 4]> plp`	`06fe : 28 [ 4]> plp`

`069a : 48 [ 3] pha`	`06ff : 48 [ 3] pha`
`tst_a $ff,$ff`	`tst_a $ff,$ff`
`069b : 08 [ 3]> php ;save flags`	`0700 : 08 [ 3]> php ;save flags`
`069c : 08 [ 3]> php`	`0701 : 08 [ 3]> php`
`069d : c9ff [ 2]> cmp #$ff ;test result`	`0702 : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`> trap_ne`
`069f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0704 : f002 [ 3]> beq skip0155`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0706 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0707 : 05 > db test_num`
`>`	`>`
`06a1 : 68 [ 4]> pla ;load status`	`0708 : >skip0155`
	`>`
	`0708 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff`	`> cmp_flag $ff`
`06a2 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`	`0709 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`06a4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`070b : f002 [ 3]> beq skip0158`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`070d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`070e : 05 > db test_num`
	`>`
	`070f : >skip0158`
`>`	`>`
`06a6 : 28 [ 4]> plp ;restore status`	`070f : 28 [ 4]> plp ;restore status`

`set_a 1,0`	`set_a 1,0`
`> load_flag 0`	`> load_flag 0`
`06a7 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0710 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`06a9 : 48 [ 3]> pha ;use stack to load status`	`0712 : 48 [ 3]> pha ;use stack to load status`
`06aa : a901 [ 2]> lda #1 ;precharge accu`	`0713 : a901 [ 2]> lda #1 ;precharge accu`
`06ac : 28 [ 4]> plp`	`0715 : 28 [ 4]> plp`

`06ad : 48 [ 3] pha`	`0716 : 48 [ 3] pha`
`tst_a 1,0`	`tst_a 1,0`
`06ae : 08 [ 3]> php ;save flags`	`0717 : 08 [ 3]> php ;save flags`
`06af : 08 [ 3]> php`	`0718 : 08 [ 3]> php`
`06b0 : c901 [ 2]> cmp #1 ;test result`	`0719 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`06b2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`071b : f002 [ 3]> beq skip0163`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`071d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`071e : 05 > db test_num`
	`>`
	`071f : >skip0163`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 63`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`06b4 : 68 [ 4]> pla ;load status`	`071f : 68 [ 4]> pla ;load status`
`> cmp_flag 0`	`> cmp_flag 0`
`06b5 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`0720 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`06b7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0722 : f002 [ 3]> beq skip0166`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0724 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0725 : 05 > db test_num`
`>`	`>`
`06b9 : 28 [ 4]> plp ;restore status`	`0726 : >skip0166`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 34`	`>`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`0726 : 28 [ 4]> plp ;restore status`


`set_a 0,$ff`	`set_a 0,$ff`
`> load_flag $ff`	`> load_flag $ff`
`06ba : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0727 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`06bc : 48 [ 3]> pha ;use stack to load status`	`0729 : 48 [ 3]> pha ;use stack to load status`
`06bd : a900 [ 2]> lda #0 ;precharge accu`	`072a : a900 [ 2]> lda #0 ;precharge accu`
`06bf : 28 [ 4]> plp`	`072c : 28 [ 4]> plp`

`06c0 : 48 [ 3] pha`	`072d : 48 [ 3] pha`
`tst_a 0,$ff`	`tst_a 0,$ff`
`06c1 : 08 [ 3]> php ;save flags`	`072e : 08 [ 3]> php ;save flags`
`06c2 : 08 [ 3]> php`	`072f : 08 [ 3]> php`
`06c3 : c900 [ 2]> cmp #0 ;test result`	`0730 : c900 [ 2]> cmp #0 ;test result`
`> trap_ne`	`> trap_ne`
`06c5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0732 : f002 [ 3]> beq skip0171`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0734 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0735 : 05 > db test_num`
	`>`
	`0736 : >skip0171`
`>`	`>`
`06c7 : 68 [ 4]> pla ;load status`	`0736 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff`	`> cmp_flag $ff`
`06c8 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`	`0737 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`06ca : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0739 : f002 [ 3]> beq skip0174`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`073b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`073c : 05 > db test_num`
`>`	`>`
`06cc : 28 [ 4]> plp ;restore status`	`073d : >skip0174`
	`>`
	`073d : 28 [ 4]> plp ;restore status`

`set_a $ff,0`	`set_a $ff,0`
`> load_flag 0`	`> load_flag 0`
`06cd : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 64`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`073e : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`06cf : 48 [ 3]> pha ;use stack to load status`	`0740 : 48 [ 3]> pha ;use stack to load status`
`06d0 : a9ff [ 2]> lda #$ff ;precharge accu`	`0741 : a9ff [ 2]> lda #$ff ;precharge accu`
`06d2 : 28 [ 4]> plp`	`0743 : 28 [ 4]> plp`

`06d3 : 48 [ 3] pha`	`0744 : 48 [ 3] pha`
`tst_a $ff,0`	`tst_a $ff,0`
`06d4 : 08 [ 3]> php ;save flags`	`0745 : 08 [ 3]> php ;save flags`
`06d5 : 08 [ 3]> php`	`0746 : 08 [ 3]> php`
`06d6 : c9ff [ 2]> cmp #$ff ;test result`	`0747 : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`> trap_ne`
`06d8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0749 : f002 [ 3]> beq skip0179`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`074b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`074c : 05 > db test_num`
`>`	`>`
`06da : 68 [ 4]> pla ;load status`	`074d : >skip0179`
	`>`
	`074d : 68 [ 4]> pla ;load status`
`> cmp_flag 0`	`> cmp_flag 0`
`06db : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`074e : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`06dd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0750 : f002 [ 3]> beq skip0182`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0752 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0753 : 05 > db test_num`
	`>`
	`0754 : >skip0182`
`>`	`>`
`06df : 28 [ 4]> plp ;restore status`	`0754 : 28 [ 4]> plp ;restore status`

`set_a 0,$ff ;pull`	`set_a 0,$ff ;pull`
`> load_flag $ff`	`> load_flag $ff`
`06e0 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0755 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 35`	`0757 : 48 [ 3]> pha ;use stack to load status`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`0758 : a900 [ 2]> lda #0 ;precharge accu`
	`075a : 28 [ 4]> plp`

`06e2 : 48 [ 3]> pha ;use stack to load status`	`075b : 68 [ 4] pla`
`06e3 : a900 [ 2]> lda #0 ;precharge accu`
`06e5 : 28 [ 4]> plp`

`06e6 : 68 [ 4] pla`
`tst_a $ff,$ff-zero`	`tst_a $ff,$ff-zero`
`06e7 : 08 [ 3]> php ;save flags`	`075c : 08 [ 3]> php ;save flags`
`06e8 : 08 [ 3]> php`	`075d : 08 [ 3]> php`
`06e9 : c9ff [ 2]> cmp #$ff ;test result`	`075e : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`> trap_ne`
`06eb : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0760 : f002 [ 3]> beq skip0187`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0762 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0763 : 05 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 65`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0764 : >skip0187`
`>`	`>`
`06ed : 68 [ 4]> pla ;load status`	`0764 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-zero`	`> cmp_flag $ff-zero`
`06ee : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`	`0765 : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`06f0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0767 : f002 [ 3]> beq skip0190`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0769 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`076a : 05 > db test_num`
`>`	`>`
`06f2 : 28 [ 4]> plp ;restore status`	`076b : >skip0190`
	`>`
	`076b : 28 [ 4]> plp ;restore status`

`set_a $ff,0`	`set_a $ff,0`
`> load_flag 0`	`> load_flag 0`
`06f3 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`076c : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`06f5 : 48 [ 3]> pha ;use stack to load status`	`076e : 48 [ 3]> pha ;use stack to load status`
`06f6 : a9ff [ 2]> lda #$ff ;precharge accu`	`076f : a9ff [ 2]> lda #$ff ;precharge accu`
`06f8 : 28 [ 4]> plp`	`0771 : 28 [ 4]> plp`

`06f9 : 68 [ 4] pla`	`0772 : 68 [ 4] pla`
`tst_a 0,zero`	`tst_a 0,zero`
`06fa : 08 [ 3]> php ;save flags`	`0773 : 08 [ 3]> php ;save flags`
`06fb : 08 [ 3]> php`	`0774 : 08 [ 3]> php`
`06fc : c900 [ 2]> cmp #0 ;test result`	`0775 : c900 [ 2]> cmp #0 ;test result`
`> trap_ne`	`> trap_ne`
`06fe : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0777 : f002 [ 3]> beq skip0195`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0779 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`077a : 05 > db test_num`
`>`	`>`
`0700 : 68 [ 4]> pla ;load status`	`077b : >skip0195`
	`>`
	`077b : 68 [ 4]> pla ;load status`
`> cmp_flag zero`	`> cmp_flag zero`
`0701 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`	`077c : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0703 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`077e : f002 [ 3]> beq skip0198`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0780 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0781 : 05 > db test_num`
	`>`
	`0782 : >skip0198`
`>`	`>`
`0705 : 28 [ 4]> plp ;restore status`	`0782 : 28 [ 4]> plp ;restore status`

`set_a $fe,$ff`	`set_a $fe,$ff`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 66`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag $ff`	`> load_flag $ff`
`0706 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0783 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0708 : 48 [ 3]> pha ;use stack to load status`	`0785 : 48 [ 3]> pha ;use stack to load status`
`0709 : a9fe [ 2]> lda #$fe ;precharge accu`	`0786 : a9fe [ 2]> lda #$fe ;precharge accu`
`070b : 28 [ 4]> plp`	`0788 : 28 [ 4]> plp`

`070c : 68 [ 4] pla`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 36`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0789 : 68 [ 4] pla`
`tst_a 1,$ff-zero-minus`	`tst_a 1,$ff-zero-minus`
`070d : 08 [ 3]> php ;save flags`	`078a : 08 [ 3]> php ;save flags`
`070e : 08 [ 3]> php`	`078b : 08 [ 3]> php`
`070f : c901 [ 2]> cmp #1 ;test result`	`078c : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`0711 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`078e : f002 [ 3]> beq skip0203`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0790 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0791 : 05 > db test_num`
	`>`
	`0792 : >skip0203`
`>`	`>`
`0713 : 68 [ 4]> pla ;load status`	`0792 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-zero-minus`	`> cmp_flag $ff-zero-minus`
`0714 : c97d [ 2]> cmp #($ff-zero-minus\|fao)&m8 ;expected flags + always on bits`	`0793 : c97d [ 2]> cmp #($ff-zero-minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0716 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0795 : f002 [ 3]> beq skip0206`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0797 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0798 : 05 > db test_num`
`>`	`>`
`0718 : 28 [ 4]> plp ;restore status`	`0799 : >skip0206`
	`>`
	`0799 : 28 [ 4]> plp ;restore status`

`set_a 0,0`	`set_a 0,0`
`> load_flag 0`	`> load_flag 0`
`0719 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`079a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`071b : 48 [ 3]> pha ;use stack to load status`	`079c : 48 [ 3]> pha ;use stack to load status`
`071c : a900 [ 2]> lda #0 ;precharge accu`	`079d : a900 [ 2]> lda #0 ;precharge accu`
`071e : 28 [ 4]> plp`	`079f : 28 [ 4]> plp`

`071f : 68 [ 4] pla`	`07a0 : 68 [ 4] pla`
`tst_a $ff,minus`	`tst_a $ff,minus`
`0720 : 08 [ 3]> php ;save flags`	`07a1 : 08 [ 3]> php ;save flags`
`0721 : 08 [ 3]> php`	`07a2 : 08 [ 3]> php`
`0722 : c9ff [ 2]> cmp #$ff ;test result`	`07a3 : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0724 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`07a5 : f002 [ 3]> beq skip0211`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`07a7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`07a8 : 05 > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 67`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>`
	`07a9 : >skip0211`
`>`	`>`
`0726 : 68 [ 4]> pla ;load status`	`07a9 : 68 [ 4]> pla ;load status`
`> cmp_flag minus`	`> cmp_flag minus`
`0727 : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`	`07aa : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0729 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`07ac : f002 [ 3]> beq skip0214`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`07ae : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`07af : 05 > db test_num`
`>`	`>`
`072b : 28 [ 4]> plp ;restore status`	`07b0 : >skip0214`
	`>`
	`07b0 : 28 [ 4]> plp ;restore status`

`set_a $ff,$ff`	`set_a $ff,$ff`
`> load_flag $ff`	`> load_flag $ff`
`072c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`07b1 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`072e : 48 [ 3]> pha ;use stack to load status`	`07b3 : 48 [ 3]> pha ;use stack to load status`
`072f : a9ff [ 2]> lda #$ff ;precharge accu`	`07b4 : a9ff [ 2]> lda #$ff ;precharge accu`
`0731 : 28 [ 4]> plp`	`07b6 : 28 [ 4]> plp`

`0732 : 68 [ 4] pla`	`07b7 : 68 [ 4] pla`
`tst_a 0,$ff-minus`	`tst_a 0,$ff-minus`
`0733 : 08 [ 3]> php ;save flags`	`07b8 : 08 [ 3]> php ;save flags`
`0734 : 08 [ 3]> php`	`07b9 : 08 [ 3]> php`
`0735 : c900 [ 2]> cmp #0 ;test result`	`07ba : c900 [ 2]> cmp #0 ;test result`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 37`	`07bc : f002 [ 3]> beq skip0219`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`0737 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`07be : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`07bf : 05 > db test_num`
`>`	`>`
`0739 : 68 [ 4]> pla ;load status`	`07c0 : >skip0219`
	`>`
	`07c0 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus`	`> cmp_flag $ff-minus`
`073a : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`	`07c1 : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`073c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`07c3 : f002 [ 3]> beq skip0222`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`07c5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`07c6 : 05 > db test_num`
	`>`
	`07c7 : >skip0222`
`>`	`>`
`073e : 28 [ 4]> plp ;restore status`	`07c7 : 28 [ 4]> plp ;restore status`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 68`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`set_a $fe,0`	`set_a $fe,0`
`> load_flag 0`	`> load_flag 0`
`073f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`07c8 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0741 : 48 [ 3]> pha ;use stack to load status`	`07ca : 48 [ 3]> pha ;use stack to load status`
`0742 : a9fe [ 2]> lda #$fe ;precharge accu`	`07cb : a9fe [ 2]> lda #$fe ;precharge accu`
`0744 : 28 [ 4]> plp`	`07cd : 28 [ 4]> plp`

`0745 : 68 [ 4] pla`	`07ce : 68 [ 4] pla`
`tst_a 1,0`	`tst_a 1,0`
`0746 : 08 [ 3]> php ;save flags`	`07cf : 08 [ 3]> php ;save flags`
`0747 : 08 [ 3]> php`	`07d0 : 08 [ 3]> php`
`0748 : c901 [ 2]> cmp #1 ;test result`	`07d1 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`074a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`07d3 : f002 [ 3]> beq skip0227`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`07d5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`07d6 : 05 > db test_num`
`>`	`>`
`074c : 68 [ 4]> pla ;load status`	`07d7 : >skip0227`
	`>`
	`07d7 : 68 [ 4]> pla ;load status`
`> cmp_flag 0`	`> cmp_flag 0`
`074d : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`07d8 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`074f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`07da : f002 [ 3]> beq skip0230`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`07dc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`07dd : 05 > db test_num`
	`>`
	`07de : >skip0230`
`>`	`>`
`0751 : 28 [ 4]> plp ;restore status`	`07de : 28 [ 4]> plp ;restore status`

`0752 : e055 [ 2] cpx #$55 ;x & y unchanged?`	`07df : e055 [ 2] cpx #$55 ;x & y unchanged?`
`trap_ne`	`trap_ne`
`0754 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`07e1 : f002 [ 3]> beq skip0232`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`07e3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`07e4 : 05 > db test_num`
	`>`
	`07e5 : >skip0232`

`0756 : c0aa [ 2] cpy #$aa`	`07e5 : c0aa [ 2] cpy #$aa`
`trap_ne`	`trap_ne`
`0758 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`07e7 : f002 [ 3]> beq skip0234`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`07e9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`07ea : 05 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 69`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`07eb : >skip0234`

`next_test`	`next_test`
`075a : ad0002 [ 4]> lda test_case ;previous test`	`07eb : ad0002 [ 4]> lda test_case ;previous test`
`075d : c905 [ 2]> cmp #test_num`	`07ee : c905 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`075f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`07f0 : f002 [ 3]> beq skip0237`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`07f2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`07f3 : 05 > db test_num`
	`>`
	`07f4 : >skip0237`
`>`	`>`
`0006 = >test_num = test_num + 1`	`0006 = >test_num = test_num + 1`
`0761 : a906 [ 2]> lda #test_num ;*** this tests' number`	`07f4 : a906 [ 2]> lda #test_num ;*** this tests' number`
`0763 : 8d0002 [ 4]> sta test_case`	`07f6 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 38`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`; partial pretest EOR #`	`; partial pretest EOR #`

`set_a $3c,0`	`set_a $3c,0`
`> load_flag 0`	`> load_flag 0`
`0766 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`07f9 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0768 : 48 [ 3]> pha ;use stack to load status`	`07fb : 48 [ 3]> pha ;use stack to load status`
`0769 : a93c [ 2]> lda #$3c ;precharge accu`	`07fc : a93c [ 2]> lda #$3c ;precharge accu`
`076b : 28 [ 4]> plp`	`07fe : 28 [ 4]> plp`

`076c : 49c3 [ 2] eor #$c3`	`07ff : 49c3 [ 2] eor #$c3`
`tst_a $ff,fn`	`tst_a $ff,fn`
`076e : 08 [ 3]> php ;save flags`	`0801 : 08 [ 3]> php ;save flags`
`076f : 08 [ 3]> php`	`0802 : 08 [ 3]> php`
`0770 : c9ff [ 2]> cmp #$ff ;test result`	`0803 : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0772 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0805 : f002 [ 3]> beq skip0242`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0807 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0808 : 06 > db test_num`
	`>`
	`0809 : >skip0242`
`>`	`>`
`0774 : 68 [ 4]> pla ;load status`	`0809 : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`0775 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`080a : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0777 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`080c : f002 [ 3]> beq skip0245`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`080e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`080f : 06 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 70`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0810 : >skip0245`
`>`	`>`
`0779 : 28 [ 4]> plp ;restore status`	`0810 : 28 [ 4]> plp ;restore status`

`set_a $c3,0`	`set_a $c3,0`
`> load_flag 0`	`> load_flag 0`
`077a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0811 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`077c : 48 [ 3]> pha ;use stack to load status`	`0813 : 48 [ 3]> pha ;use stack to load status`
`077d : a9c3 [ 2]> lda #$c3 ;precharge accu`	`0814 : a9c3 [ 2]> lda #$c3 ;precharge accu`
`077f : 28 [ 4]> plp`	`0816 : 28 [ 4]> plp`

`0780 : 49c3 [ 2] eor #$c3`	`0817 : 49c3 [ 2] eor #$c3`
`tst_a 0,fz`	`tst_a 0,fz`
`0782 : 08 [ 3]> php ;save flags`	`0819 : 08 [ 3]> php ;save flags`
`0783 : 08 [ 3]> php`	`081a : 08 [ 3]> php`
`0784 : c900 [ 2]> cmp #0 ;test result`	`081b : c900 [ 2]> cmp #0 ;test result`
`> trap_ne`	`> trap_ne`
`0786 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`081d : f002 [ 3]> beq skip0250`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`081f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0820 : 06 > db test_num`
	`>`
	`0821 : >skip0250`
`>`	`>`
`0788 : 68 [ 4]> pla ;load status`	`0821 : 68 [ 4]> pla ;load status`
`> cmp_flag fz`	`> cmp_flag fz`
`0789 : c932 [ 2]> cmp #(fz\|fao)&m8 ;expected flags + always on bits`	`0822 : c932 [ 2]> cmp #(fz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`078b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0824 : f002 [ 3]> beq skip0253`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0826 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0827 : 06 > db test_num`
`>`	`>`
`078d : 28 [ 4]> plp ;restore status`	`0828 : >skip0253`
	`>`
	`0828 : 28 [ 4]> plp ;restore status`

`next_test`	`next_test`
`078e : ad0002 [ 4]> lda test_case ;previous test`	`0829 : ad0002 [ 4]> lda test_case ;previous test`
`0791 : c906 [ 2]> cmp #test_num`	`082c : c906 [ 2]> cmp #test_num`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 39`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`0793 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`082e : f002 [ 3]> beq skip0256`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0830 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0831 : 06 > db test_num`
	`>`
	`0832 : >skip0256`
`>`	`>`
`0007 = >test_num = test_num + 1`	`0007 = >test_num = test_num + 1`
`0795 : a907 [ 2]> lda #test_num ;*** this tests' number`	`0832 : a907 [ 2]> lda #test_num ;*** this tests' number`
`0797 : 8d0002 [ 4]> sta test_case`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 71`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0834 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; PC modifying instructions except branches (NOP, JMP, JSR, RTS, BRK, RTI)`	`; PC modifying instructions except branches (NOP, JMP, JSR, RTS, BRK, RTI)`
`; testing NOP`	`; testing NOP`
`079a : a224 [ 2] ldx #$24`
`079c : a042 [ 2] ldy #$42`	`0837 : a224 [ 2] ldx #$24`
	`0839 : a042 [ 2] ldy #$42`
`set_a $18,0`	`set_a $18,0`
`> load_flag 0`	`> load_flag 0`
`079e : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`083b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`07a0 : 48 [ 3]> pha ;use stack to load status`	`083d : 48 [ 3]> pha ;use stack to load status`
`07a1 : a918 [ 2]> lda #$18 ;precharge accu`	`083e : a918 [ 2]> lda #$18 ;precharge accu`
`07a3 : 28 [ 4]> plp`	`0840 : 28 [ 4]> plp`

`07a4 : ea [ 2] nop`	`0841 : ea [ 2] nop`
`tst_a $18,0`	`tst_a $18,0`
`07a5 : 08 [ 3]> php ;save flags`	`0842 : 08 [ 3]> php ;save flags`
`07a6 : 08 [ 3]> php`	`0843 : 08 [ 3]> php`
`07a7 : c918 [ 2]> cmp #$18 ;test result`	`0844 : c918 [ 2]> cmp #$18 ;test result`
`> trap_ne`	`> trap_ne`
`07a9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0846 : f002 [ 3]> beq skip0261`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0848 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0849 : 07 > db test_num`
`>`	`>`
`07ab : 68 [ 4]> pla ;load status`	`084a : >skip0261`
	`>`
	`084a : 68 [ 4]> pla ;load status`
`> cmp_flag 0`	`> cmp_flag 0`
`07ac : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`084b : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`07ae : d0fe [ 3]> bne * ;failed not equal (non zero)`	`084d : f002 [ 3]> beq skip0264`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`084f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0850 : 07 > db test_num`
`>`	`>`
`07b0 : 28 [ 4]> plp ;restore status`	`0851 : >skip0264`
	`>`
	`0851 : 28 [ 4]> plp ;restore status`

`07b1 : e024 [ 2] cpx #$24`	`0852 : e024 [ 2] cpx #$24`
`trap_ne`	`trap_ne`
`07b3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0854 : f002 [ 3]> beq skip0266`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0856 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0857 : 07 > db test_num`
	`>`
	`0858 : >skip0266`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 72`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`07b5 : c042 [ 2] cpy #$42`
	`0858 : c042 [ 2] cpy #$42`
`trap_ne`	`trap_ne`
`07b7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`085a : f002 [ 3]> beq skip0268`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`085c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`085d : 07 > db test_num`
	`>`
	`085e : >skip0268`

`07b9 : a2db [ 2] ldx #$db`	`085e : a2db [ 2] ldx #$db`
`07bb : a0bd [ 2] ldy #$bd`	`0860 : a0bd [ 2] ldy #$bd`
`set_a $e7,$ff`	`set_a $e7,$ff`
`> load_flag $ff`	`> load_flag $ff`
`07bd : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0862 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`07bf : 48 [ 3]> pha ;use stack to load status`	`0864 : 48 [ 3]> pha ;use stack to load status`
`07c0 : a9e7 [ 2]> lda #$e7 ;precharge accu`	`0865 : a9e7 [ 2]> lda #$e7 ;precharge accu`
`07c2 : 28 [ 4]> plp`	`0867 : 28 [ 4]> plp`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 40`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0868 : ea [ 2] nop`
`07c3 : ea [ 2] nop`
`tst_a $e7,$ff`	`tst_a $e7,$ff`
`07c4 : 08 [ 3]> php ;save flags`	`0869 : 08 [ 3]> php ;save flags`
`07c5 : 08 [ 3]> php`	`086a : 08 [ 3]> php`
`07c6 : c9e7 [ 2]> cmp #$e7 ;test result`	`086b : c9e7 [ 2]> cmp #$e7 ;test result`
`> trap_ne`	`> trap_ne`
`07c8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`086d : f002 [ 3]> beq skip0273`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`086f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0870 : 07 > db test_num`
`>`	`>`
`07ca : 68 [ 4]> pla ;load status`	`0871 : >skip0273`
	`>`
	`0871 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff`	`> cmp_flag $ff`
`07cb : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`	`0872 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`07cd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0874 : f002 [ 3]> beq skip0276`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0876 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0877 : 07 > db test_num`
	`>`
	`0878 : >skip0276`
`>`	`>`
`07cf : 28 [ 4]> plp ;restore status`	`0878 : 28 [ 4]> plp ;restore status`

`07d0 : e0db [ 2] cpx #$db`	`0879 : e0db [ 2] cpx #$db`
`trap_ne`	`trap_ne`
`07d2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`087b : f002 [ 3]> beq skip0278`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 73`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`07d4 : c0bd [ 2] cpy #$bd`	`087d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`087e : 07 > db test_num`
	`>`
	`087f : >skip0278`

	`087f : c0bd [ 2] cpy #$bd`
`trap_ne`	`trap_ne`
`07d6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0881 : f002 [ 3]> beq skip0280`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0883 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0884 : 07 > db test_num`
	`>`
	`0885 : >skip0280`

`next_test`	`next_test`
`07d8 : ad0002 [ 4]> lda test_case ;previous test`	`0885 : ad0002 [ 4]> lda test_case ;previous test`
`07db : c907 [ 2]> cmp #test_num`	`0888 : c907 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`07dd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`088a : f002 [ 3]> beq skip0283`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`088c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`088d : 07 > db test_num`
	`>`
	`088e : >skip0283`
`>`	`>`
`0008 = >test_num = test_num + 1`	`0008 = >test_num = test_num + 1`
`07df : a908 [ 2]> lda #test_num ;*** this tests' number`	`088e : a908 [ 2]> lda #test_num ;*** this tests' number`
`07e1 : 8d0002 [ 4]> sta test_case`	`0890 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; jump absolute`	`; jump absolute`

`set_stat $0`	`set_stat $0`
`> load_flag $0`	`> load_flag $0`
`07e4 : a900 [ 2]> lda #$0 ;allow test to change I-flag (no mask)`	`0893 : a900 [ 2]> lda #$0 ;allow test to change I-flag (no mask)`
`>`	`>`
`07e6 : 48 [ 3]> pha ;use stack to load status`	`0895 : 48 [ 3]> pha ;use stack to load status`
`07e7 : 28 [ 4]> plp`	`0896 : 28 [ 4]> plp`

`07e8 : a946 [ 2] lda #'F'`	`0897 : a946 [ 2] lda #'F'`
`07ea : a241 [ 2] ldx #'A'`	`0899 : a241 [ 2] ldx #'A'`
`07ec : a052 [ 2] ldy #'R' ;N=0, V=0, Z=0, C=0`	`089b : a052 [ 2] ldy #'R' ;N=0, V=0, Z=0, C=0`
`07ee : 4c4e35 [ 3] jmp test_far`	`089d : 4c1b3d [ 3] jmp test_far`
`07f1 : ea [ 2] nop`	`08a0 : ea [ 2] nop`
`07f2 : ea [ 2] nop`	`08a1 : ea [ 2] nop`
`trap_ne ;runover protection`	`trap_ne ;runover protection`
`07f3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`08a2 : f002 [ 3]> beq skip0287`
	`> trap ;failed equal (zero)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 41`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`08a4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08a5 : 08 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 74`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`07f5 : e8 [ 2] inx`	`08a6 : >skip0287`
`07f6 : e8 [ 2] inx`
`07f7 : far_ret`	`08a6 : e8 [ 2] inx`
	`08a7 : e8 [ 2] inx`
	`08a8 : far_ret`
`trap_eq ;returned flags OK?`	`trap_eq ;returned flags OK?`
`07f7 : f0fe [ 3]> beq * ;failed equal (zero)`	`08a8 : d002 [ 3]> bne skip0289`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`08aa : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08ab : 08 > db test_num`
	`>`
	`08ac : >skip0289`

`trap_pl`	`trap_pl`
`07f9 : 10fe [ 3]> bpl * ;failed plus (bit 7 clear)`	`08ac : 3002 [ 3]> bmi skip0291`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`08ae : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08af : 08 > db test_num`
	`>`
	`08b0 : >skip0291`

`trap_cc`	`trap_cc`
`07fb : 90fe [ 3]> bcc * ;failed carry clear`	`08b0 : b002 [ 3]> bcs skip0293`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`08b2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08b3 : 08 > db test_num`
	`>`
	`08b4 : >skip0293`

`trap_vc`	`trap_vc`
`07fd : 50fe [ 3]> bvc * ;failed overflow clear`	`08b4 : 7002 [ 3]> bvs skip0295`
	`> trap ;failed equal (zero)`
`07ff : c9ec [ 2] cmp #('F'^$aa) ;returned registers OK?`	`>; db $db ; M65C02/M65C02A SToP instruction`
`trap_ne`	`08b6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`0801 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`08b7 : 08 > db test_num`
	`>`
	`08b8 : >skip0295`

`0803 : e042 [ 2] cpx #('A'+1)`	`08b8 : c9ec [ 2] cmp #('F'^$aa) ;returned registers OK?`
`trap_ne`	`trap_ne`
`0805 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`08ba : f002 [ 3]> beq skip0297`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`08bc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08bd : 08 > db test_num`
	`>`
	`08be : >skip0297`

`0807 : c04f [ 2] cpy #('R'-3)`	`08be : e042 [ 2] cpx #('A'+1)`
`trap_ne`	`trap_ne`
`0809 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`08c0 : f002 [ 3]> beq skip0299`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 75`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`080b : ca [ 2] dex`	`>; db $db ; M65C02/M65C02A SToP instruction`
`080c : c8 [ 2] iny`	`08c2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`080d : c8 [ 2] iny`	`08c3 : 08 > db test_num`
`080e : c8 [ 2] iny`	`>`
`080f : 49aa [ 2] eor #$aa ;N=0, V=1, Z=0, C=1`	`08c4 : >skip0299`
`0811 : 4c1a08 [ 3] jmp test_near`
`0814 : ea [ 2] nop`	`08c4 : c04f [ 2] cpy #('R'-3)`
`0815 : ea [ 2] nop`	`trap_ne`
	`08c6 : f002 [ 3]> beq skip0301`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`08c8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08c9 : 08 > db test_num`
	`>`
	`08ca : >skip0301`

	`08ca : ca [ 2] dex`
	`08cb : c8 [ 2] iny`
	`08cc : c8 [ 2] iny`
	`08cd : c8 [ 2] iny`
	`08ce : 49aa [ 2] eor #$aa ;N=0, V=1, Z=0, C=1`
	`08d0 : 4cdb08 [ 3] jmp test_near`
	`08d3 : ea [ 2] nop`
	`08d4 : ea [ 2] nop`
`trap_ne ;runover protection`	`trap_ne ;runover protection`
`0816 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`08d5 : f002 [ 3]> beq skip0303`
	`> trap ;failed equal (zero)`
`0818 : e8 [ 2] inx`	`>; db $db ; M65C02/M65C02A SToP instruction`
`0819 : e8 [ 2] inx`	`08d7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`081a : test_near`	`08d8 : 08 > db test_num`
	`>`
	`08d9 : >skip0303`

	`08d9 : e8 [ 2] inx`
	`08da : e8 [ 2] inx`
	`08db : test_near`
`trap_eq ;passed flags OK?`	`trap_eq ;passed flags OK?`
`081a : f0fe [ 3]> beq * ;failed equal (zero)`	`08db : d002 [ 3]> bne skip0305`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`08dd : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08de : 08 > db test_num`
	`>`
	`08df : >skip0305`

`trap_mi`	`trap_mi`
`081c : 30fe [ 3]> bmi * ;failed minus (bit 7 set)`	`08df : 1002 [ 3]> bpl skip0307`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`08e1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08e2 : 08 > db test_num`
	`>`
	`08e3 : >skip0307`

`trap_cc`	`trap_cc`
`081e : 90fe [ 3]> bcc * ;failed carry clear`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 76`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`08e3 : b002 [ 3]> bcs skip0309`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`08e5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08e6 : 08 > db test_num`
	`>`
	`08e7 : >skip0309`

`trap_vc`	`trap_vc`
`0820 : 50fe [ 3]> bvc * ;failed overflow clear`	`08e7 : 7002 [ 3]> bvs skip0311`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`08e9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08ea : 08 > db test_num`
	`>`
	`08eb : >skip0311`

`0822 : c946 [ 2] cmp #'F' ;passed registers OK?`	`08eb : c946 [ 2] cmp #'F' ;passed registers OK?`
`trap_ne`	`trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 42`	`08ed : f002 [ 3]> beq skip0313`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`0824 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`08ef : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08f0 : 08 > db test_num`
	`>`
	`08f1 : >skip0313`

`0826 : e041 [ 2] cpx #'A'`	`08f1 : e041 [ 2] cpx #'A'`
`trap_ne`	`trap_ne`
`0828 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`08f3 : f002 [ 3]> beq skip0315`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`08f5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08f6 : 08 > db test_num`
	`>`
	`08f7 : >skip0315`

`082a : c052 [ 2] cpy #'R'`	`08f7 : c052 [ 2] cpy #'R'`
`trap_ne`	`trap_ne`
`082c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`08f9 : f002 [ 3]> beq skip0317`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`08fb : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`08fc : 08 > db test_num`
	`>`
	`08fd : >skip0317`

`next_test`	`next_test`
`082e : ad0002 [ 4]> lda test_case ;previous test`	`08fd : ad0002 [ 4]> lda test_case ;previous test`
`0831 : c908 [ 2]> cmp #test_num`	`0900 : c908 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`0833 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0902 : f002 [ 3]> beq skip0320`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0904 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 77`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0905 : 08 > db test_num`
	`>`
	`0906 : >skip0320`
`>`	`>`
`0009 = >test_num = test_num + 1`	`0009 = >test_num = test_num + 1`
`0835 : a909 [ 2]> lda #test_num ;*** this tests' number`	`0906 : a909 [ 2]> lda #test_num ;*** this tests' number`
`0837 : 8d0002 [ 4]> sta test_case`	`0908 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; jump indirect`	`; jump indirect`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`083a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`090b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`083c : 48 [ 3]> pha ;use stack to load status`	`090d : 48 [ 3]> pha ;use stack to load status`
`083d : 28 [ 4]> plp`	`090e : 28 [ 4]> plp`

`083e : a949 [ 2] lda #'I'`	`090f : a949 [ 2] lda #'I'`
`0840 : a24e [ 2] ldx #'N'`	`0911 : a24e [ 2] ldx #'N'`
`0842 : a044 [ 2] ldy #'D' ;N=0, V=0, Z=0, C=0`	`0913 : a044 [ 2] ldy #'D' ;N=0, V=0, Z=0, C=0`
`0844 : 6c7c35 [ 6] jmp (ptr_tst_ind)`	`0915 : 6c5a3d [ 6] jmp (ptr_tst_ind)`
`0847 : ea [ 2] nop`	`0918 : ea [ 2] nop`
`trap_ne ;runover protection`	`trap_ne ;runover protection`
`0848 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0919 : f002 [ 3]> beq skip0324`
	`> trap ;failed equal (zero)`
`084a : 88 [ 2] dey`	`>; db $db ; M65C02/M65C02A SToP instruction`
`084b : 88 [ 2] dey`	`091b : 00 [ 7]> brk ; Use BRK to return to the monitor`
`084c : ind_ret`	`091c : 09 > db test_num`
`084c : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`	`>`
`084d : 88 [ 2] dey`	`091d : >skip0324`
`084e : 88 [ 2] dey`
`084f : 88 [ 2] dey`	`091d : 88 [ 2] dey`
`0850 : 28 [ 4] plp`	`091e : 88 [ 2] dey`
	`091f : ind_ret`
	`091f : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`
	`0920 : 88 [ 2] dey`
	`0921 : 88 [ 2] dey`
	`0922 : 88 [ 2] dey`
	`0923 : 28 [ 4] plp`
`trap_eq ;returned flags OK?`	`trap_eq ;returned flags OK?`
`0851 : f0fe [ 3]> beq * ;failed equal (zero)`	`0924 : d002 [ 3]> bne skip0326`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0926 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0927 : 09 > db test_num`
	`>`
	`0928 : >skip0326`

`trap_pl`	`trap_pl`
`0853 : 10fe [ 3]> bpl * ;failed plus (bit 7 clear)`	`0928 : 3002 [ 3]> bmi skip0328`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`092a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 78`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`trap_cc`	`092b : 09 > db test_num`
`0855 : 90fe [ 3]> bcc * ;failed carry clear`	`>`
	`092c : >skip0328`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 43`	`trap_cc`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`092c : b002 [ 3]> bcs skip0330`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`092e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`092f : 09 > db test_num`
	`>`
	`0930 : >skip0330`

`trap_vc`	`trap_vc`
`0857 : 50fe [ 3]> bvc * ;failed overflow clear`	`0930 : 7002 [ 3]> bvs skip0332`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0932 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0933 : 09 > db test_num`
	`>`
	`0934 : >skip0332`

`0859 : c9e3 [ 2] cmp #('I'^$aa) ;returned registers OK?`	`0934 : c9e3 [ 2] cmp #('I'^$aa) ;returned registers OK?`
`trap_ne`	`trap_ne`
`085b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0936 : f002 [ 3]> beq skip0334`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0938 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0939 : 09 > db test_num`
	`>`
	`093a : >skip0334`

`085d : e04f [ 2] cpx #('N'+1)`	`093a : e04f [ 2] cpx #('N'+1)`
`trap_ne`	`trap_ne`
`085f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`093c : f002 [ 3]> beq skip0336`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`093e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`093f : 09 > db test_num`
	`>`
	`0940 : >skip0336`

`0861 : c03e [ 2] cpy #('D'-6)`	`0940 : c03e [ 2] cpy #('D'-6)`
`trap_ne`	`trap_ne`
`0863 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0942 : f002 [ 3]> beq skip0338`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0944 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0945 : 09 > db test_num`
	`>`
	`0946 : >skip0338`

`0865 : ba [ 2] tsx ;SP check`	`0946 : ba [ 2] tsx ;SP check`
`0866 : e0ff [ 2] cpx #$ff`	`0947 : e0ff [ 2] cpx #$ff`
`trap_ne`	`trap_ne`
`0868 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 79`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0949 : f002 [ 3]> beq skip0340`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`094b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`094c : 09 > db test_num`
	`>`
	`094d : >skip0340`

`next_test`	`next_test`
`086a : ad0002 [ 4]> lda test_case ;previous test`	`094d : ad0002 [ 4]> lda test_case ;previous test`
`086d : c909 [ 2]> cmp #test_num`	`0950 : c909 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`086f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0952 : f002 [ 3]> beq skip0343`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0954 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0955 : 09 > db test_num`
	`>`
	`0956 : >skip0343`
`>`	`>`
`000a = >test_num = test_num + 1`	`000a = >test_num = test_num + 1`
`0871 : a90a [ 2]> lda #test_num ;*** this tests' number`	`0956 : a90a [ 2]> lda #test_num ;*** this tests' number`
`0873 : 8d0002 [ 4]> sta test_case`	`0958 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; jump subroutine & return from subroutine`	`; jump subroutine & return from subroutine`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0876 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`095b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0878 : 48 [ 3]> pha ;use stack to load status`	`095d : 48 [ 3]> pha ;use stack to load status`
`0879 : 28 [ 4]> plp`	`095e : 28 [ 4]> plp`

`087a : a94a [ 2] lda #'J'`	`095f : a94a [ 2] lda #'J'`
`087c : a253 [ 2] ldx #'S'`	`0961 : a253 [ 2] ldx #'S'`
`087e : a052 [ 2] ldy #'R' ;N=0, V=0, Z=0, C=0`	`0963 : a052 [ 2] ldy #'R' ;N=0, V=0, Z=0, C=0`
`0880 : 20b835 [ 6] jsr test_jsr`	`0965 : 20a43d [ 6] jsr test_jsr`
`0882 = jsr_ret = *-1 ;last address of jsr = return address`	`0967 = jsr_ret = *-1 ;last address of jsr = return address`
`0883 : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`	`0968 : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`
`0884 : 88 [ 2] dey`	`0969 : 88 [ 2] dey`
`0885 : 88 [ 2] dey`	`096a : 88 [ 2] dey`
`0886 : 88 [ 2] dey`	`096b : 88 [ 2] dey`
`0887 : 28 [ 4] plp`	`096c : 28 [ 4] plp`
`trap_eq ;returned flags OK?`	`trap_eq ;returned flags OK?`
`0888 : f0fe [ 3]> beq * ;failed equal (zero)`	`096d : d002 [ 3]> bne skip0347`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`096f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0970 : 0a > db test_num`
	`>`
	`0971 : >skip0347`

`trap_pl`	`trap_pl`
`088a : 10fe [ 3]> bpl * ;failed plus (bit 7 clear)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 80`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 44`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0971 : 3002 [ 3]> bmi skip0349`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0973 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0974 : 0a > db test_num`
	`>`
	`0975 : >skip0349`

`trap_cc`	`trap_cc`
`088c : 90fe [ 3]> bcc * ;failed carry clear`	`0975 : b002 [ 3]> bcs skip0351`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0977 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0978 : 0a > db test_num`
	`>`
	`0979 : >skip0351`

`trap_vc`	`trap_vc`
`088e : 50fe [ 3]> bvc * ;failed overflow clear`	`0979 : 7002 [ 3]> bvs skip0353`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`097b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`097c : 0a > db test_num`
	`>`
	`097d : >skip0353`

`0890 : c9e0 [ 2] cmp #('J'^$aa) ;returned registers OK?`	`097d : c9e0 [ 2] cmp #('J'^$aa) ;returned registers OK?`
`trap_ne`	`trap_ne`
`0892 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`097f : f002 [ 3]> beq skip0355`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0981 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0982 : 0a > db test_num`
	`>`
	`0983 : >skip0355`

`0894 : e054 [ 2] cpx #('S'+1)`	`0983 : e054 [ 2] cpx #('S'+1)`
`trap_ne`	`trap_ne`
`0896 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0985 : f002 [ 3]> beq skip0357`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0987 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0988 : 0a > db test_num`
	`>`
	`0989 : >skip0357`

`0898 : c04c [ 2] cpy #('R'-6)`	`0989 : c04c [ 2] cpy #('R'-6)`
`trap_ne`	`trap_ne`
`089a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`098b : f002 [ 3]> beq skip0359`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`098d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`098e : 0a > db test_num`
	`>`
	`098f : >skip0359`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 81`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`089c : ba [ 2] tsx ;sp?`	`098f : ba [ 2] tsx ;sp?`
`089d : e0ff [ 2] cpx #$ff`	`0990 : e0ff [ 2] cpx #$ff`
`trap_ne`	`trap_ne`
`089f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0992 : f002 [ 3]> beq skip0361`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0994 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0995 : 0a > db test_num`
	`>`
	`0996 : >skip0361`

`next_test`	`next_test`
`08a1 : ad0002 [ 4]> lda test_case ;previous test`	`0996 : ad0002 [ 4]> lda test_case ;previous test`
`08a4 : c90a [ 2]> cmp #test_num`	`0999 : c90a [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`08a6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`099b : f002 [ 3]> beq skip0364`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`099d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`099e : 0a > db test_num`
	`>`
	`099f : >skip0364`
`>`	`>`
`000b = >test_num = test_num + 1`	`000b = >test_num = test_num + 1`
`08a8 : a90b [ 2]> lda #test_num ;*** this tests' number`	`099f : a90b [ 2]> lda #test_num ;*** this tests' number`
`08aa : 8d0002 [ 4]> sta test_case`	`09a1 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; break & return from interrupt`	`; break & return from interrupt`

`if ROM_vectors = 1`	`if ROM_vectors = 1`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`lda #'B'`
`08ad : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`ldx #'R'`
`>`	`ldy #'K' ;N=0, V=0, Z=0, C=0`
`08af : 48 [ 3]> pha ;use stack to load status`	`brk`
`08b0 : 28 [ 4]> plp`

`08b1 : a942 [ 2] lda #'B'`
`08b3 : a252 [ 2] ldx #'R'`
`08b5 : a04b [ 2] ldy #'K' ;N=0, V=0, Z=0, C=0`
`08b7 : 00 [ 7] brk`
`else`	`else`
`lda #hi brk_ret ;emulated break`
`pha`
`lda #lo brk_ret`
`pha`
`lda #fao ;set break & unused on stack`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 45`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`pha`	`09a4 : a909 [ 2] lda #hi(brk_ret) ;emulated break`
	`09a6 : 48 [ 3] pha`
	`09a7 : a9ba [ 2] lda #lo(brk_ret-1) ; M65C02 pushes BRK+1 not BRK+2`
	`09a9 : 48 [ 3] pha`
	`09aa : a930 [ 2] lda #fao ;set break & unused on stack`
	`09ac : 48 [ 3] pha`
`set_stat intdis`	`set_stat intdis`
`lda #'B'`	`> load_flag intdis`
`ldx #'R'`	`09ad : a904 [ 2]> lda #intdis ;allow test to change I-flag (no mask)`
`ldy #'K' ;N=0, V=0, Z=0, C=0`	`>`
`jmp irq_trap`	`09af : 48 [ 3]> pha ;use stack to load status`
`endif`	`09b0 : 28 [ 4]> plp`
`08b8 : 88 [ 2] dey ;should not be executed`
`08b9 : brk_ret ;address of break return`
`08b9 : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`
`08ba : 88 [ 2] dey`
`08bb : 88 [ 2] dey`
`08bc : 88 [ 2] dey`
`08bd : c9e8 [ 2] cmp #('B'^$aa) ;returned registers OK?`
`trap_ne`
`08bf : d0fe [ 3]> bne * ;failed not equal (non zero)`

`08c1 : e053 [ 2] cpx #('R'+1)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 82`
`trap_ne`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`08c3 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`08c5 : c045 [ 2] cpy #('K'-6)`	`09b1 : a942 [ 2] lda #'B'`
`trap_ne`	`09b3 : a252 [ 2] ldx #'R'`
`08c7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`09b5 : a04b [ 2] ldy #'K' ;N=0, V=0, Z=0, C=0`
	`09b7 : 4cfa3d [ 3] jmp irq_trap`

	`endif`

	`09ba : 88 [ 2] dey ;should not be executed`
	`09bb : brk_ret ;address of break return`
	`09bb : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`
	`09bc : 88 [ 2] dey`
	`09bd : 88 [ 2] dey`
	`09be : 88 [ 2] dey`
	`09bf : c9e8 [ 2] cmp #('B'^$aa) ;returned registers OK?`
	`trap_ne`
	`09c1 : f002 [ 3]> beq skip0368`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`09c3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`09c4 : 0b > db test_num`
	`>`
	`09c5 : >skip0368`

	`09c5 : e053 [ 2] cpx #('R'+1)`
	`trap_ne`
	`09c7 : f002 [ 3]> beq skip0370`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`09c9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`09ca : 0b > db test_num`
	`>`
	`09cb : >skip0370`

	`09cb : c045 [ 2] cpy #('K'-6)`
	`trap_ne`
	`09cd : f002 [ 3]> beq skip0372`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`09cf : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`09d0 : 0b > db test_num`
	`>`
	`09d1 : >skip0372`

`08c9 : 68 [ 4] pla ;returned flags OK (unchanged)?`	`09d1 : 68 [ 4] pla ;returned flags OK (unchanged)?`
`cmp_flag 0`	`cmp_flag 0`
`08ca : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`09d2 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`08cc : d0fe [ 3]> bne * ;failed not equal (non zero)`	`09d4 : f002 [ 3]> beq skip0375`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`09d6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`09d7 : 0b > db test_num`
	`>`
	`09d8 : >skip0375`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 83`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`08ce : ba [ 2] tsx ;sp?`
`08cf : e0ff [ 2] cpx #$ff`	`09d8 : ba [ 2] tsx ;sp?`
	`09d9 : e0ff [ 2] cpx #$ff`
`trap_ne`	`trap_ne`
`08d1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`09db : f002 [ 3]> beq skip0377`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`09dd : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`09de : 0b > db test_num`
	`>`
	`09df : >skip0377`

`next_test`	`next_test`
`08d3 : ad0002 [ 4]> lda test_case ;previous test`	`09df : ad0002 [ 4]> lda test_case ;previous test`
`08d6 : c90b [ 2]> cmp #test_num`	`09e2 : c90b [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`08d8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`09e4 : f002 [ 3]> beq skip0380`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`09e6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`09e7 : 0b > db test_num`
	`>`
	`09e8 : >skip0380`
`>`	`>`
`000c = >test_num = test_num + 1`	`000c = >test_num = test_num + 1`
`08da : a90c [ 2]> lda #test_num ;*** this tests' number`	`09e8 : a90c [ 2]> lda #test_num ;*** this tests' number`
`08dc : 8d0002 [ 4]> sta test_case`	`09ea : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; test set and clear flags CLC CLI CLD CLV SEC SEI SED`	`; test set and clear flags CLC CLI CLD CLV SEC SEI SED`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`08df : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`09ed : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`08e1 : 48 [ 3]> pha ;use stack to load status`	`09ef : 48 [ 3]> pha ;use stack to load status`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 46`	`09f0 : 28 [ 4]> plp`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`08e2 : 28 [ 4]> plp`	`09f1 : 18 [ 2] clc`

`08e3 : 18 [ 2] clc`
`tst_stat $ff-carry`	`tst_stat $ff-carry`
`08e4 : 08 [ 3]> php ;save status`	`09f2 : 08 [ 3]> php ;save status`
`08e5 : 08 [ 3]> php ;use stack to retrieve status`	`09f3 : 08 [ 3]> php ;use stack to retrieve status`
`08e6 : 68 [ 4]> pla`	`09f4 : 68 [ 4]> pla`
`> cmp_flag $ff-carry`	`> cmp_flag $ff-carry`
`08e7 : c9fe [ 2]> cmp #($ff-carry\|fao)&m8 ;expected flags + always on bits`	`09f5 : c9fe [ 2]> cmp #($ff-carry\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`08e9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`09f7 : f002 [ 3]> beq skip0386`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`09f9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`09fa : 0c > db test_num`
	`>`
	`09fb : >skip0386`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 84`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`08eb : 28 [ 4]> plp ;restore status`	`09fb : 28 [ 4]> plp ;restore status`

`08ec : 38 [ 2] sec`	`09fc : 38 [ 2] sec`
`tst_stat $ff`	`tst_stat $ff`
`08ed : 08 [ 3]> php ;save status`	`09fd : 08 [ 3]> php ;save status`
`08ee : 08 [ 3]> php ;use stack to retrieve status`	`09fe : 08 [ 3]> php ;use stack to retrieve status`
`08ef : 68 [ 4]> pla`	`09ff : 68 [ 4]> pla`
`> cmp_flag $ff`	`> cmp_flag $ff`
`08f0 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`	`0a00 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`08f2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a02 : f002 [ 3]> beq skip0390`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0a04 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a05 : 0c > db test_num`
	`>`
	`0a06 : >skip0390`
`>`	`>`
`08f4 : 28 [ 4]> plp ;restore status`	`0a06 : 28 [ 4]> plp ;restore status`


`if I_flag = 3`	`if I_flag = 3`
`08f5 : 58 [ 2] cli`
	`0a07 : 58 [ 2] cli`
`tst_stat $ff-intdis`	`tst_stat $ff-intdis`
`08f6 : 08 [ 3]> php ;save status`	`0a08 : 08 [ 3]> php ;save status`
`08f7 : 08 [ 3]> php ;use stack to retrieve status`	`0a09 : 08 [ 3]> php ;use stack to retrieve status`
`08f8 : 68 [ 4]> pla`	`0a0a : 68 [ 4]> pla`
`> cmp_flag $ff-intdis`	`> cmp_flag $ff-intdis`
`08f9 : c9fb [ 2]> cmp #($ff-intdis\|fao)&m8 ;expected flags + always on bits`	`0a0b : c9fb [ 2]> cmp #($ff-intdis\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`08fb : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a0d : f002 [ 3]> beq skip0394`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0a0f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a10 : 0c > db test_num`
`>`	`>`
`08fd : 28 [ 4]> plp ;restore status`	`0a11 : >skip0394`
	`>`
	`0a11 : 28 [ 4]> plp ;restore status`

`08fe : 78 [ 2] sei`	`0a12 : 78 [ 2] sei`
`tst_stat $ff`	`tst_stat $ff`
`08ff : 08 [ 3]> php ;save status`	`0a13 : 08 [ 3]> php ;save status`
`0900 : 08 [ 3]> php ;use stack to retrieve status`	`0a14 : 08 [ 3]> php ;use stack to retrieve status`
`0901 : 68 [ 4]> pla`	`0a15 : 68 [ 4]> pla`
`> cmp_flag $ff`	`> cmp_flag $ff`
`0902 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`	`0a16 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0904 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a18 : f002 [ 3]> beq skip0398`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 85`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0a1a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a1b : 0c > db test_num`
	`>`
	`0a1c : >skip0398`
`>`	`>`
`0906 : 28 [ 4]> plp ;restore status`	`0a1c : 28 [ 4]> plp ;restore status`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 47`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`endif`	`endif`
`0907 : d8 [ 2] cld`
	`0a1d : d8 [ 2] cld`
`tst_stat $ff-decmode`	`tst_stat $ff-decmode`
`0908 : 08 [ 3]> php ;save status`	`0a1e : 08 [ 3]> php ;save status`
`0909 : 08 [ 3]> php ;use stack to retrieve status`	`0a1f : 08 [ 3]> php ;use stack to retrieve status`
`090a : 68 [ 4]> pla`	`0a20 : 68 [ 4]> pla`
`> cmp_flag $ff-decmode`	`> cmp_flag $ff-decmode`
`090b : c9f7 [ 2]> cmp #($ff-decmode\|fao)&m8 ;expected flags + always on bits`	`0a21 : c9f7 [ 2]> cmp #($ff-decmode\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`090d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a23 : f002 [ 3]> beq skip0402`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0a25 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a26 : 0c > db test_num`
	`>`
	`0a27 : >skip0402`
`>`	`>`
`090f : 28 [ 4]> plp ;restore status`	`0a27 : 28 [ 4]> plp ;restore status`

`0910 : f8 [ 2] sed`	`0a28 : f8 [ 2] sed`
`tst_stat $ff`	`tst_stat $ff`
`0911 : 08 [ 3]> php ;save status`	`0a29 : 08 [ 3]> php ;save status`
`0912 : 08 [ 3]> php ;use stack to retrieve status`	`0a2a : 08 [ 3]> php ;use stack to retrieve status`
`0913 : 68 [ 4]> pla`	`0a2b : 68 [ 4]> pla`
`> cmp_flag $ff`	`> cmp_flag $ff`
`0914 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`	`0a2c : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0916 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a2e : f002 [ 3]> beq skip0406`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0a30 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a31 : 0c > db test_num`
`>`	`>`
`0918 : 28 [ 4]> plp ;restore status`	`0a32 : >skip0406`
	`>`
	`0a32 : 28 [ 4]> plp ;restore status`

`0919 : b8 [ 2] clv`	`0a33 : b8 [ 2] clv`
`tst_stat $ff-overfl`	`tst_stat $ff-overfl`
`091a : 08 [ 3]> php ;save status`	`0a34 : 08 [ 3]> php ;save status`
`091b : 08 [ 3]> php ;use stack to retrieve status`	`0a35 : 08 [ 3]> php ;use stack to retrieve status`
`091c : 68 [ 4]> pla`	`0a36 : 68 [ 4]> pla`
`> cmp_flag $ff-overfl`	`> cmp_flag $ff-overfl`
`091d : c9bf [ 2]> cmp #($ff-overfl\|fao)&m8 ;expected flags + always on bits`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 86`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0a37 : c9bf [ 2]> cmp #($ff-overfl\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`091f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a39 : f002 [ 3]> beq skip0410`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0a3b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a3c : 0c > db test_num`
`>`	`>`
`0921 : 28 [ 4]> plp ;restore status`	`0a3d : >skip0410`
	`>`
	`0a3d : 28 [ 4]> plp ;restore status`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0922 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0a3e : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0924 : 48 [ 3]> pha ;use stack to load status`	`0a40 : 48 [ 3]> pha ;use stack to load status`
`0925 : 28 [ 4]> plp`	`0a41 : 28 [ 4]> plp`

`tst_stat 0`	`tst_stat 0`
`0926 : 08 [ 3]> php ;save status`	`0a42 : 08 [ 3]> php ;save status`
`0927 : 08 [ 3]> php ;use stack to retrieve status`	`0a43 : 08 [ 3]> php ;use stack to retrieve status`
`0928 : 68 [ 4]> pla`	`0a44 : 68 [ 4]> pla`
`> cmp_flag 0`	`> cmp_flag 0`
`0929 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`0a45 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 48`	`0a47 : f002 [ 3]> beq skip0416`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`092b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a49 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a4a : 0c > db test_num`
`>`	`>`
`092d : 28 [ 4]> plp ;restore status`	`0a4b : >skip0416`
	`>`
	`0a4b : 28 [ 4]> plp ;restore status`

`092e : 38 [ 2] sec`	`0a4c : 38 [ 2] sec`
`tst_stat carry`	`tst_stat carry`
`092f : 08 [ 3]> php ;save status`	`0a4d : 08 [ 3]> php ;save status`
`0930 : 08 [ 3]> php ;use stack to retrieve status`	`0a4e : 08 [ 3]> php ;use stack to retrieve status`
`0931 : 68 [ 4]> pla`	`0a4f : 68 [ 4]> pla`
`> cmp_flag carry`	`> cmp_flag carry`
`0932 : c931 [ 2]> cmp #(carry\|fao)&m8 ;expected flags + always on bits`	`0a50 : c931 [ 2]> cmp #(carry\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0934 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a52 : f002 [ 3]> beq skip0420`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0a54 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a55 : 0c > db test_num`
`>`	`>`
`0936 : 28 [ 4]> plp ;restore status`	`0a56 : >skip0420`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 87`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0a56 : 28 [ 4]> plp ;restore status`

`0937 : 18 [ 2] clc`	`0a57 : 18 [ 2] clc`
`tst_stat 0`	`tst_stat 0`
`0938 : 08 [ 3]> php ;save status`	`0a58 : 08 [ 3]> php ;save status`
`0939 : 08 [ 3]> php ;use stack to retrieve status`	`0a59 : 08 [ 3]> php ;use stack to retrieve status`
`093a : 68 [ 4]> pla`	`0a5a : 68 [ 4]> pla`
`> cmp_flag 0`	`> cmp_flag 0`
`093b : c930 [ 2]> cmp #(0 \|fao)&m8 ;expected flags + always on bits`	`0a5b : c930 [ 2]> cmp #(0 \|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`093d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a5d : f002 [ 3]> beq skip0424`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0a5f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a60 : 0c > db test_num`
`>`	`>`
`093f : 28 [ 4]> plp ;restore status`	`0a61 : >skip0424`
	`>`
	`0a61 : 28 [ 4]> plp ;restore status`


`if I_flag = 3`	`if I_flag = 3`
`0940 : 78 [ 2] sei`
	`0a62 : 78 [ 2] sei`
`tst_stat intdis`	`tst_stat intdis`
`0941 : 08 [ 3]> php ;save status`	`0a63 : 08 [ 3]> php ;save status`
`0942 : 08 [ 3]> php ;use stack to retrieve status`	`0a64 : 08 [ 3]> php ;use stack to retrieve status`
`0943 : 68 [ 4]> pla`	`0a65 : 68 [ 4]> pla`
`> cmp_flag intdis`	`> cmp_flag intdis`
`0944 : c934 [ 2]> cmp #(intdis\|fao)&m8 ;expected flags + always on bits`	`0a66 : c934 [ 2]> cmp #(intdis\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0946 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a68 : f002 [ 3]> beq skip0428`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0a6a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a6b : 0c > db test_num`
	`>`
	`0a6c : >skip0428`
`>`	`>`
`0948 : 28 [ 4]> plp ;restore status`	`0a6c : 28 [ 4]> plp ;restore status`

`0949 : 58 [ 2] cli`	`0a6d : 58 [ 2] cli`
`tst_stat 0`	`tst_stat 0`
`094a : 08 [ 3]> php ;save status`	`0a6e : 08 [ 3]> php ;save status`
`094b : 08 [ 3]> php ;use stack to retrieve status`	`0a6f : 08 [ 3]> php ;use stack to retrieve status`
`094c : 68 [ 4]> pla`	`0a70 : 68 [ 4]> pla`
`> cmp_flag 0`	`> cmp_flag 0`
`094d : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`0a71 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`094f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a73 : f002 [ 3]> beq skip0432`
`>`	`> trap ;failed equal (zero)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 49`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 88`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0951 : 28 [ 4]> plp ;restore status`	`0a75 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a76 : 0c > db test_num`
	`>`
	`0a77 : >skip0432`
	`>`
	`0a77 : 28 [ 4]> plp ;restore status`


`endif`	`endif`
`0952 : f8 [ 2] sed`
	`0a78 : f8 [ 2] sed`
`tst_stat decmode`	`tst_stat decmode`
`0953 : 08 [ 3]> php ;save status`	`0a79 : 08 [ 3]> php ;save status`
`0954 : 08 [ 3]> php ;use stack to retrieve status`	`0a7a : 08 [ 3]> php ;use stack to retrieve status`
`0955 : 68 [ 4]> pla`	`0a7b : 68 [ 4]> pla`
`> cmp_flag decmode`	`> cmp_flag decmode`
`0956 : c938 [ 2]> cmp #(decmode\|fao)&m8 ;expected flags + always on bits`	`0a7c : c938 [ 2]> cmp #(decmode\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0958 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a7e : f002 [ 3]> beq skip0436`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0a80 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a81 : 0c > db test_num`
`>`	`>`
`095a : 28 [ 4]> plp ;restore status`	`0a82 : >skip0436`
	`>`
	`0a82 : 28 [ 4]> plp ;restore status`

`095b : d8 [ 2] cld`	`0a83 : d8 [ 2] cld`
`tst_stat 0`	`tst_stat 0`
`095c : 08 [ 3]> php ;save status`	`0a84 : 08 [ 3]> php ;save status`
`095d : 08 [ 3]> php ;use stack to retrieve status`	`0a85 : 08 [ 3]> php ;use stack to retrieve status`
`095e : 68 [ 4]> pla`	`0a86 : 68 [ 4]> pla`
`> cmp_flag 0`	`> cmp_flag 0`
`095f : c930 [ 2]> cmp #(0 \|fao)&m8 ;expected flags + always on bits`	`0a87 : c930 [ 2]> cmp #(0 \|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0961 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a89 : f002 [ 3]> beq skip0440`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0a8b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a8c : 0c > db test_num`
	`>`
	`0a8d : >skip0440`
`>`	`>`
`0963 : 28 [ 4]> plp ;restore status`	`0a8d : 28 [ 4]> plp ;restore status`

`set_stat overfl`	`set_stat overfl`
`> load_flag overfl`	`> load_flag overfl`
`0964 : a940 [ 2]> lda #overfl ;allow test to change I-flag (no mask)`	`0a8e : a940 [ 2]> lda #overfl ;allow test to change I-flag (no mask)`
`>`	`>`
`0966 : 48 [ 3]> pha ;use stack to load status`	`0a90 : 48 [ 3]> pha ;use stack to load status`
`0967 : 28 [ 4]> plp`	`0a91 : 28 [ 4]> plp`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 89`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`tst_stat overfl`	`tst_stat overfl`
`0968 : 08 [ 3]> php ;save status`	`0a92 : 08 [ 3]> php ;save status`
`0969 : 08 [ 3]> php ;use stack to retrieve status`	`0a93 : 08 [ 3]> php ;use stack to retrieve status`
`096a : 68 [ 4]> pla`	`0a94 : 68 [ 4]> pla`
`> cmp_flag overfl`	`> cmp_flag overfl`
`096b : c970 [ 2]> cmp #(overfl\|fao)&m8 ;expected flags + always on bits`	`0a95 : c970 [ 2]> cmp #(overfl\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`096d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0a97 : f002 [ 3]> beq skip0446`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0a99 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0a9a : 0c > db test_num`
	`>`
	`0a9b : >skip0446`
`>`	`>`
`096f : 28 [ 4]> plp ;restore status`	`0a9b : 28 [ 4]> plp ;restore status`

`0970 : b8 [ 2] clv`	`0a9c : b8 [ 2] clv`
`tst_stat 0`	`tst_stat 0`
`0971 : 08 [ 3]> php ;save status`	`0a9d : 08 [ 3]> php ;save status`
`0972 : 08 [ 3]> php ;use stack to retrieve status`	`0a9e : 08 [ 3]> php ;use stack to retrieve status`
`0973 : 68 [ 4]> pla`	`0a9f : 68 [ 4]> pla`
`> cmp_flag 0`	`> cmp_flag 0`
`0974 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`0aa0 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 50`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`> trap_ne`	`> trap_ne`
`0976 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0aa2 : f002 [ 3]> beq skip0450`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0aa4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0aa5 : 0c > db test_num`
	`>`
	`0aa6 : >skip0450`
`>`	`>`
`0978 : 28 [ 4]> plp ;restore status`	`0aa6 : 28 [ 4]> plp ;restore status`

`next_test`	`next_test`
`0979 : ad0002 [ 4]> lda test_case ;previous test`	`0aa7 : ad0002 [ 4]> lda test_case ;previous test`
`097c : c90c [ 2]> cmp #test_num`	`0aaa : c90c [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`097e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0aac : f002 [ 3]> beq skip0453`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0aae : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0aaf : 0c > db test_num`
	`>`
	`0ab0 : >skip0453`
`>`	`>`
`000d = >test_num = test_num + 1`	`000d = >test_num = test_num + 1`
`0980 : a90d [ 2]> lda #test_num ;*** this tests' number`	`0ab0 : a90d [ 2]> lda #test_num ;*** this tests' number`
`0982 : 8d0002 [ 4]> sta test_case`	`0ab2 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 90`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`; testing index register increment/decrement and transfer`	`; testing index register increment/decrement and transfer`
`; INX INY DEX DEY TAX TXA TAY TYA`	`; INX INY DEX DEY TAX TXA TAY TYA`
`0985 : a2fe [ 2] ldx #$fe`
	`0ab5 : a2fe [ 2] ldx #$fe`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0987 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0ab7 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0989 : 48 [ 3]> pha ;use stack to load status`	`0ab9 : 48 [ 3]> pha ;use stack to load status`
`098a : 28 [ 4]> plp`	`0aba : 28 [ 4]> plp`

`098b : e8 [ 2] inx ;ff`	`0abb : e8 [ 2] inx ;ff`
`tst_x $ff,$ff-zero`	`tst_x $ff,$ff-zero`
`098c : 08 [ 3]> php ;save flags`	`0abc : 08 [ 3]> php ;save flags`
`098d : 08 [ 3]> php`	`0abd : 08 [ 3]> php`
`098e : e0ff [ 2]> cpx #$ff ;test result`	`0abe : e0ff [ 2]> cpx #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0990 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ac0 : f002 [ 3]> beq skip0458`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ac2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ac3 : 0d > db test_num`
	`>`
	`0ac4 : >skip0458`
`>`	`>`
`0992 : 68 [ 4]> pla ;load status`	`0ac4 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-zero`	`> cmp_flag $ff-zero`
`0993 : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`	`0ac5 : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0995 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ac7 : f002 [ 3]> beq skip0461`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ac9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0aca : 0d > db test_num`
`>`	`>`
`0997 : 28 [ 4]> plp ;restore status`	`0acb : >skip0461`
	`>`
	`0acb : 28 [ 4]> plp ;restore status`

`0998 : e8 [ 2] inx ;00`	`0acc : e8 [ 2] inx ;00`
`tst_x 0,$ff-minus`	`tst_x 0,$ff-minus`
`0999 : 08 [ 3]> php ;save flags`	`0acd : 08 [ 3]> php ;save flags`
`099a : 08 [ 3]> php`	`0ace : 08 [ 3]> php`
`099b : e000 [ 2]> cpx #0 ;test result`	`0acf : e000 [ 2]> cpx #0 ;test result`
`> trap_ne`	`> trap_ne`
`099d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ad1 : f002 [ 3]> beq skip0464`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ad3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ad4 : 0d > db test_num`
`>`	`>`
`099f : 68 [ 4]> pla ;load status`	`0ad5 : >skip0464`
`> cmp_flag $ff-minus`	`>`
`09a0 : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`	`0ad5 : 68 [ 4]> pla ;load status`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 51`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 91`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> cmp_flag $ff-minus`
	`0ad6 : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`09a2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ad8 : f002 [ 3]> beq skip0467`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ada : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0adb : 0d > db test_num`
	`>`
	`0adc : >skip0467`
`>`	`>`
`09a4 : 28 [ 4]> plp ;restore status`	`0adc : 28 [ 4]> plp ;restore status`

`09a5 : e8 [ 2] inx ;01`	`0add : e8 [ 2] inx ;01`
`tst_x 1,$ff-minus-zero`	`tst_x 1,$ff-minus-zero`
`09a6 : 08 [ 3]> php ;save flags`	`0ade : 08 [ 3]> php ;save flags`
`09a7 : 08 [ 3]> php`	`0adf : 08 [ 3]> php`
`09a8 : e001 [ 2]> cpx #1 ;test result`	`0ae0 : e001 [ 2]> cpx #1 ;test result`
`> trap_ne`	`> trap_ne`
`09aa : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ae2 : f002 [ 3]> beq skip0470`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ae4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ae5 : 0d > db test_num`
	`>`
	`0ae6 : >skip0470`
`>`	`>`
`09ac : 68 [ 4]> pla ;load status`	`0ae6 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus-zero`	`> cmp_flag $ff-minus-zero`
`09ad : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`	`0ae7 : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`09af : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ae9 : f002 [ 3]> beq skip0473`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0aeb : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0aec : 0d > db test_num`
`>`	`>`
`09b1 : 28 [ 4]> plp ;restore status`	`0aed : >skip0473`
	`>`
	`0aed : 28 [ 4]> plp ;restore status`

`09b2 : ca [ 2] dex ;00`	`0aee : ca [ 2] dex ;00`
`tst_x 0,$ff-minus`	`tst_x 0,$ff-minus`
`09b3 : 08 [ 3]> php ;save flags`	`0aef : 08 [ 3]> php ;save flags`
`09b4 : 08 [ 3]> php`	`0af0 : 08 [ 3]> php`
`09b5 : e000 [ 2]> cpx #0 ;test result`	`0af1 : e000 [ 2]> cpx #0 ;test result`
`> trap_ne`	`> trap_ne`
`09b7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0af3 : f002 [ 3]> beq skip0476`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0af5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0af6 : 0d > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 92`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0af7 : >skip0476`
`>`	`>`
`09b9 : 68 [ 4]> pla ;load status`	`0af7 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus`	`> cmp_flag $ff-minus`
`09ba : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`	`0af8 : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`09bc : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0afa : f002 [ 3]> beq skip0479`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0afc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0afd : 0d > db test_num`
`>`	`>`
`09be : 28 [ 4]> plp ;restore status`	`0afe : >skip0479`
	`>`
	`0afe : 28 [ 4]> plp ;restore status`

`09bf : ca [ 2] dex ;ff`	`0aff : ca [ 2] dex ;ff`
`tst_x $ff,$ff-zero`	`tst_x $ff,$ff-zero`
`09c0 : 08 [ 3]> php ;save flags`	`0b00 : 08 [ 3]> php ;save flags`
`09c1 : 08 [ 3]> php`	`0b01 : 08 [ 3]> php`
`09c2 : e0ff [ 2]> cpx #$ff ;test result`	`0b02 : e0ff [ 2]> cpx #$ff ;test result`
`> trap_ne`	`> trap_ne`
`09c4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b04 : f002 [ 3]> beq skip0482`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b06 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b07 : 0d > db test_num`
`>`	`>`
`09c6 : 68 [ 4]> pla ;load status`	`0b08 : >skip0482`
	`>`
	`0b08 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-zero`	`> cmp_flag $ff-zero`
`09c7 : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`	`0b09 : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`09c9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b0b : f002 [ 3]> beq skip0485`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b0d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b0e : 0d > db test_num`
`>`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 52`	`0b0f : >skip0485`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`>`
	`0b0f : 28 [ 4]> plp ;restore status`
`09cb : 28 [ 4]> plp ;restore status`

`09cc : ca [ 2] dex ;fe`	`0b10 : ca [ 2] dex ;fe`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`09cd : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0b11 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`09cf : 48 [ 3]> pha ;use stack to load status`	`0b13 : 48 [ 3]> pha ;use stack to load status`
`09d0 : 28 [ 4]> plp`	`0b14 : 28 [ 4]> plp`

	`0b15 : e8 [ 2] inx ;ff`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 93`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`09d1 : e8 [ 2] inx ;ff`
`tst_x $ff,minus`	`tst_x $ff,minus`
`09d2 : 08 [ 3]> php ;save flags`	`0b16 : 08 [ 3]> php ;save flags`
`09d3 : 08 [ 3]> php`	`0b17 : 08 [ 3]> php`
`09d4 : e0ff [ 2]> cpx #$ff ;test result`	`0b18 : e0ff [ 2]> cpx #$ff ;test result`
`> trap_ne`	`> trap_ne`
`09d6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b1a : f002 [ 3]> beq skip0490`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b1c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b1d : 0d > db test_num`
	`>`
	`0b1e : >skip0490`
`>`	`>`
`09d8 : 68 [ 4]> pla ;load status`	`0b1e : 68 [ 4]> pla ;load status`
`> cmp_flag minus`	`> cmp_flag minus`
`09d9 : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`	`0b1f : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`09db : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b21 : f002 [ 3]> beq skip0493`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b23 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b24 : 0d > db test_num`
`>`	`>`
`09dd : 28 [ 4]> plp ;restore status`	`0b25 : >skip0493`
	`>`
	`0b25 : 28 [ 4]> plp ;restore status`

`09de : e8 [ 2] inx ;00`	`0b26 : e8 [ 2] inx ;00`
`tst_x 0,zero`	`tst_x 0,zero`
`09df : 08 [ 3]> php ;save flags`	`0b27 : 08 [ 3]> php ;save flags`
`09e0 : 08 [ 3]> php`	`0b28 : 08 [ 3]> php`
`09e1 : e000 [ 2]> cpx #0 ;test result`	`0b29 : e000 [ 2]> cpx #0 ;test result`
`> trap_ne`	`> trap_ne`
`09e3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b2b : f002 [ 3]> beq skip0496`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b2d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b2e : 0d > db test_num`
	`>`
	`0b2f : >skip0496`
`>`	`>`
`09e5 : 68 [ 4]> pla ;load status`	`0b2f : 68 [ 4]> pla ;load status`
`> cmp_flag zero`	`> cmp_flag zero`
`09e6 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`	`0b30 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`09e8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b32 : f002 [ 3]> beq skip0499`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b34 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b35 : 0d > db test_num`
`>`	`>`
`09ea : 28 [ 4]> plp ;restore status`	`0b36 : >skip0499`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 94`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0b36 : 28 [ 4]> plp ;restore status`

`09eb : e8 [ 2] inx ;01`	`0b37 : e8 [ 2] inx ;01`
`tst_x 1,0`	`tst_x 1,0`
`09ec : 08 [ 3]> php ;save flags`	`0b38 : 08 [ 3]> php ;save flags`
`09ed : 08 [ 3]> php`	`0b39 : 08 [ 3]> php`
`09ee : e001 [ 2]> cpx #1 ;test result`	`0b3a : e001 [ 2]> cpx #1 ;test result`
`> trap_ne`	`> trap_ne`
`09f0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b3c : f002 [ 3]> beq skip0502`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b3e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b3f : 0d > db test_num`
	`>`
	`0b40 : >skip0502`
`>`	`>`
`09f2 : 68 [ 4]> pla ;load status`	`0b40 : 68 [ 4]> pla ;load status`
`> cmp_flag 0`	`> cmp_flag 0`
`09f3 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`0b41 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 53`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`> trap_ne`	`> trap_ne`
`09f5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b43 : f002 [ 3]> beq skip0505`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b45 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b46 : 0d > db test_num`
	`>`
	`0b47 : >skip0505`
`>`	`>`
`09f7 : 28 [ 4]> plp ;restore status`	`0b47 : 28 [ 4]> plp ;restore status`

`09f8 : ca [ 2] dex ;00`	`0b48 : ca [ 2] dex ;00`
`tst_x 0,zero`	`tst_x 0,zero`
`09f9 : 08 [ 3]> php ;save flags`	`0b49 : 08 [ 3]> php ;save flags`
`09fa : 08 [ 3]> php`	`0b4a : 08 [ 3]> php`
`09fb : e000 [ 2]> cpx #0 ;test result`	`0b4b : e000 [ 2]> cpx #0 ;test result`
`> trap_ne`	`> trap_ne`
`09fd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b4d : f002 [ 3]> beq skip0508`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b4f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b50 : 0d > db test_num`
	`>`
	`0b51 : >skip0508`
`>`	`>`
`09ff : 68 [ 4]> pla ;load status`	`0b51 : 68 [ 4]> pla ;load status`
`> cmp_flag zero`	`> cmp_flag zero`
`0a00 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`	`0b52 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0a02 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b54 : f002 [ 3]> beq skip0511`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b56 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b57 : 0d > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 95`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>`
	`0b58 : >skip0511`
`>`	`>`
`0a04 : 28 [ 4]> plp ;restore status`	`0b58 : 28 [ 4]> plp ;restore status`

`0a05 : ca [ 2] dex ;ff`	`0b59 : ca [ 2] dex ;ff`
`tst_x $ff,minus`	`tst_x $ff,minus`
`0a06 : 08 [ 3]> php ;save flags`	`0b5a : 08 [ 3]> php ;save flags`
`0a07 : 08 [ 3]> php`	`0b5b : 08 [ 3]> php`
`0a08 : e0ff [ 2]> cpx #$ff ;test result`	`0b5c : e0ff [ 2]> cpx #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0a0a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b5e : f002 [ 3]> beq skip0514`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b60 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b61 : 0d > db test_num`
	`>`
	`0b62 : >skip0514`
`>`	`>`
`0a0c : 68 [ 4]> pla ;load status`	`0b62 : 68 [ 4]> pla ;load status`
`> cmp_flag minus`	`> cmp_flag minus`
`0a0d : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`	`0b63 : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0a0f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b65 : f002 [ 3]> beq skip0517`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b67 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b68 : 0d > db test_num`
`>`	`>`
`0a11 : 28 [ 4]> plp ;restore status`	`0b69 : >skip0517`
	`>`
	`0b69 : 28 [ 4]> plp ;restore status`


`0a12 : a0fe [ 2] ldy #$fe`	`0b6a : a0fe [ 2] ldy #$fe`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0a14 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0b6c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0a16 : 48 [ 3]> pha ;use stack to load status`	`0b6e : 48 [ 3]> pha ;use stack to load status`
`0a17 : 28 [ 4]> plp`	`0b6f : 28 [ 4]> plp`

`0a18 : c8 [ 2] iny ;ff`	`0b70 : c8 [ 2] iny ;ff`
`tst_y $ff,$ff-zero`	`tst_y $ff,$ff-zero`
`0a19 : 08 [ 3]> php ;save flags`	`0b71 : 08 [ 3]> php ;save flags`
`0a1a : 08 [ 3]> php`	`0b72 : 08 [ 3]> php`
`0a1b : c0ff [ 2]> cpy #$ff ;test result`	`0b73 : c0ff [ 2]> cpy #$ff ;test result`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 54`	`0b75 : f002 [ 3]> beq skip0522`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b77 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b78 : 0d > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 96`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0a1d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b79 : >skip0522`
`>`	`>`
`0a1f : 68 [ 4]> pla ;load status`	`0b79 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-zero`	`> cmp_flag $ff-zero`
`0a20 : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`	`0b7a : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0a22 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b7c : f002 [ 3]> beq skip0525`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b7e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b7f : 0d > db test_num`
`>`	`>`
`0a24 : 28 [ 4]> plp ;restore status`	`0b80 : >skip0525`
	`>`
	`0b80 : 28 [ 4]> plp ;restore status`

`0a25 : c8 [ 2] iny ;00`	`0b81 : c8 [ 2] iny ;00`
`tst_y 0,$ff-minus`	`tst_y 0,$ff-minus`
`0a26 : 08 [ 3]> php ;save flags`	`0b82 : 08 [ 3]> php ;save flags`
`0a27 : 08 [ 3]> php`	`0b83 : 08 [ 3]> php`
`0a28 : c000 [ 2]> cpy #0 ;test result`	`0b84 : c000 [ 2]> cpy #0 ;test result`
`> trap_ne`	`> trap_ne`
`0a2a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b86 : f002 [ 3]> beq skip0528`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b88 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b89 : 0d > db test_num`
`>`	`>`
`0a2c : 68 [ 4]> pla ;load status`	`0b8a : >skip0528`
	`>`
	`0b8a : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus`	`> cmp_flag $ff-minus`
`0a2d : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`	`0b8b : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0a2f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b8d : f002 [ 3]> beq skip0531`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0b8f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b90 : 0d > db test_num`
	`>`
	`0b91 : >skip0531`
`>`	`>`
`0a31 : 28 [ 4]> plp ;restore status`	`0b91 : 28 [ 4]> plp ;restore status`

`0a32 : c8 [ 2] iny ;01`	`0b92 : c8 [ 2] iny ;01`
`tst_y 1,$ff-minus-zero`	`tst_y 1,$ff-minus-zero`
`0a33 : 08 [ 3]> php ;save flags`	`0b93 : 08 [ 3]> php ;save flags`
`0a34 : 08 [ 3]> php`	`0b94 : 08 [ 3]> php`
`0a35 : c001 [ 2]> cpy #1 ;test result`	`0b95 : c001 [ 2]> cpy #1 ;test result`
`> trap_ne`	`> trap_ne`
`0a37 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b97 : f002 [ 3]> beq skip0534`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 97`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0b99 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0b9a : 0d > db test_num`
`>`	`>`
`0a39 : 68 [ 4]> pla ;load status`	`0b9b : >skip0534`
	`>`
	`0b9b : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus-zero`	`> cmp_flag $ff-minus-zero`
`0a3a : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`	`0b9c : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0a3c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0b9e : f002 [ 3]> beq skip0537`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ba0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ba1 : 0d > db test_num`
	`>`
	`0ba2 : >skip0537`
`>`	`>`
`0a3e : 28 [ 4]> plp ;restore status`	`0ba2 : 28 [ 4]> plp ;restore status`

`0a3f : 88 [ 2] dey ;00`	`0ba3 : 88 [ 2] dey ;00`
`tst_y 0,$ff-minus`	`tst_y 0,$ff-minus`
`0a40 : 08 [ 3]> php ;save flags`	`0ba4 : 08 [ 3]> php ;save flags`
`0a41 : 08 [ 3]> php`	`0ba5 : 08 [ 3]> php`
`0a42 : c000 [ 2]> cpy #0 ;test result`	`0ba6 : c000 [ 2]> cpy #0 ;test result`
`> trap_ne`	`> trap_ne`
`0a44 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ba8 : f002 [ 3]> beq skip0540`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0baa : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0bab : 0d > db test_num`
	`>`
	`0bac : >skip0540`
`>`	`>`
`0a46 : 68 [ 4]> pla ;load status`	`0bac : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus`	`> cmp_flag $ff-minus`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 55`	`0bad : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0a47 : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0a49 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0baf : f002 [ 3]> beq skip0543`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0bb1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0bb2 : 0d > db test_num`
`>`	`>`
`0a4b : 28 [ 4]> plp ;restore status`	`0bb3 : >skip0543`
	`>`
	`0bb3 : 28 [ 4]> plp ;restore status`

`0a4c : 88 [ 2] dey ;ff`	`0bb4 : 88 [ 2] dey ;ff`
`tst_y $ff,$ff-zero`	`tst_y $ff,$ff-zero`
`0a4d : 08 [ 3]> php ;save flags`	`0bb5 : 08 [ 3]> php ;save flags`
`0a4e : 08 [ 3]> php`	`0bb6 : 08 [ 3]> php`
`0a4f : c0ff [ 2]> cpy #$ff ;test result`	`0bb7 : c0ff [ 2]> cpy #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0a51 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 98`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0bb9 : f002 [ 3]> beq skip0546`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0bbb : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0bbc : 0d > db test_num`
`>`	`>`
`0a53 : 68 [ 4]> pla ;load status`	`0bbd : >skip0546`
	`>`
	`0bbd : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-zero`	`> cmp_flag $ff-zero`
`0a54 : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`	`0bbe : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0a56 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0bc0 : f002 [ 3]> beq skip0549`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0bc2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0bc3 : 0d > db test_num`
	`>`
	`0bc4 : >skip0549`
`>`	`>`
`0a58 : 28 [ 4]> plp ;restore status`	`0bc4 : 28 [ 4]> plp ;restore status`

`0a59 : 88 [ 2] dey ;fe`	`0bc5 : 88 [ 2] dey ;fe`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0a5a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0bc6 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0a5c : 48 [ 3]> pha ;use stack to load status`	`0bc8 : 48 [ 3]> pha ;use stack to load status`
`0a5d : 28 [ 4]> plp`	`0bc9 : 28 [ 4]> plp`

`0a5e : c8 [ 2] iny ;ff`	`0bca : c8 [ 2] iny ;ff`
`tst_y $ff,0+minus`	`tst_y $ff,0+minus`
`0a5f : 08 [ 3]> php ;save flags`	`0bcb : 08 [ 3]> php ;save flags`
`0a60 : 08 [ 3]> php`	`0bcc : 08 [ 3]> php`
`0a61 : c0ff [ 2]> cpy #$ff ;test result`	`0bcd : c0ff [ 2]> cpy #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0a63 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0bcf : f002 [ 3]> beq skip0554`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0bd1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0bd2 : 0d > db test_num`
	`>`
	`0bd3 : >skip0554`
`>`	`>`
`0a65 : 68 [ 4]> pla ;load status`	`0bd3 : 68 [ 4]> pla ;load status`
`> cmp_flag 0+minus`	`> cmp_flag 0+minus`
`0a66 : c9b0 [ 2]> cmp #(0+minus\|fao)&m8 ;expected flags + always on bits`	`0bd4 : c9b0 [ 2]> cmp #(0+minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0a68 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0bd6 : f002 [ 3]> beq skip0557`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0bd8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0bd9 : 0d > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 99`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>`
	`0bda : >skip0557`
`>`	`>`
`0a6a : 28 [ 4]> plp ;restore status`	`0bda : 28 [ 4]> plp ;restore status`

`0a6b : c8 [ 2] iny ;00`	`0bdb : c8 [ 2] iny ;00`
`tst_y 0,zero`	`tst_y 0,zero`
`0a6c : 08 [ 3]> php ;save flags`	`0bdc : 08 [ 3]> php ;save flags`
`0a6d : 08 [ 3]> php`	`0bdd : 08 [ 3]> php`
`0a6e : c000 [ 2]> cpy #0 ;test result`	`0bde : c000 [ 2]> cpy #0 ;test result`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 56`	`0be0 : f002 [ 3]> beq skip0560`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`0a70 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0be2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0be3 : 0d > db test_num`
`>`	`>`
`0a72 : 68 [ 4]> pla ;load status`	`0be4 : >skip0560`
	`>`
	`0be4 : 68 [ 4]> pla ;load status`
`> cmp_flag zero`	`> cmp_flag zero`
`0a73 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`	`0be5 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0a75 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0be7 : f002 [ 3]> beq skip0563`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0be9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0bea : 0d > db test_num`
`>`	`>`
`0a77 : 28 [ 4]> plp ;restore status`	`0beb : >skip0563`
	`>`
	`0beb : 28 [ 4]> plp ;restore status`

`0a78 : c8 [ 2] iny ;01`	`0bec : c8 [ 2] iny ;01`
`tst_y 1,0`	`tst_y 1,0`
`0a79 : 08 [ 3]> php ;save flags`	`0bed : 08 [ 3]> php ;save flags`
`0a7a : 08 [ 3]> php`	`0bee : 08 [ 3]> php`
`0a7b : c001 [ 2]> cpy #1 ;test result`	`0bef : c001 [ 2]> cpy #1 ;test result`
`> trap_ne`	`> trap_ne`
`0a7d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0bf1 : f002 [ 3]> beq skip0566`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0bf3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0bf4 : 0d > db test_num`
`>`	`>`
`0a7f : 68 [ 4]> pla ;load status`	`0bf5 : >skip0566`
	`>`
	`0bf5 : 68 [ 4]> pla ;load status`
`> cmp_flag 0`	`> cmp_flag 0`
`0a80 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`0bf6 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0a82 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0bf8 : f002 [ 3]> beq skip0569`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 100`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0bfa : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0bfb : 0d > db test_num`
`>`	`>`
`0a84 : 28 [ 4]> plp ;restore status`	`0bfc : >skip0569`
	`>`
	`0bfc : 28 [ 4]> plp ;restore status`

`0a85 : 88 [ 2] dey ;00`	`0bfd : 88 [ 2] dey ;00`
`tst_y 0,zero`	`tst_y 0,zero`
`0a86 : 08 [ 3]> php ;save flags`	`0bfe : 08 [ 3]> php ;save flags`
`0a87 : 08 [ 3]> php`	`0bff : 08 [ 3]> php`
`0a88 : c000 [ 2]> cpy #0 ;test result`	`0c00 : c000 [ 2]> cpy #0 ;test result`
`> trap_ne`	`> trap_ne`
`0a8a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c02 : f002 [ 3]> beq skip0572`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c04 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c05 : 0d > db test_num`
`>`	`>`
`0a8c : 68 [ 4]> pla ;load status`	`0c06 : >skip0572`
	`>`
	`0c06 : 68 [ 4]> pla ;load status`
`> cmp_flag zero`	`> cmp_flag zero`
`0a8d : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`	`0c07 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0a8f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c09 : f002 [ 3]> beq skip0575`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c0b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c0c : 0d > db test_num`
	`>`
	`0c0d : >skip0575`
`>`	`>`
`0a91 : 28 [ 4]> plp ;restore status`	`0c0d : 28 [ 4]> plp ;restore status`

`0a92 : 88 [ 2] dey ;ff`	`0c0e : 88 [ 2] dey ;ff`
`tst_y $ff,minus`	`tst_y $ff,minus`
`0a93 : 08 [ 3]> php ;save flags`	`0c0f : 08 [ 3]> php ;save flags`
`0a94 : 08 [ 3]> php`	`0c10 : 08 [ 3]> php`
`0a95 : c0ff [ 2]> cpy #$ff ;test result`	`0c11 : c0ff [ 2]> cpy #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0a97 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c13 : f002 [ 3]> beq skip0578`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c15 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c16 : 0d > db test_num`
	`>`
	`0c17 : >skip0578`
`>`	`>`
`0a99 : 68 [ 4]> pla ;load status`	`0c17 : 68 [ 4]> pla ;load status`
`> cmp_flag minus`	`> cmp_flag minus`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 57`	`0c18 : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 101`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0a9a : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`
`>`
`> trap_ne`	`> trap_ne`
`0a9c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c1a : f002 [ 3]> beq skip0581`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c1c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c1d : 0d > db test_num`
	`>`
	`0c1e : >skip0581`
`>`	`>`
`0a9e : 28 [ 4]> plp ;restore status`	`0c1e : 28 [ 4]> plp ;restore status`


`0a9f : a2ff [ 2] ldx #$ff`	`0c1f : a2ff [ 2] ldx #$ff`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0aa1 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0c21 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0aa3 : 48 [ 3]> pha ;use stack to load status`	`0c23 : 48 [ 3]> pha ;use stack to load status`
`0aa4 : 28 [ 4]> plp`	`0c24 : 28 [ 4]> plp`

`0aa5 : 8a [ 2] txa`	`0c25 : 8a [ 2] txa`
`tst_a $ff,$ff-zero`	`tst_a $ff,$ff-zero`
`0aa6 : 08 [ 3]> php ;save flags`	`0c26 : 08 [ 3]> php ;save flags`
`0aa7 : 08 [ 3]> php`	`0c27 : 08 [ 3]> php`
`0aa8 : c9ff [ 2]> cmp #$ff ;test result`	`0c28 : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0aaa : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c2a : f002 [ 3]> beq skip0586`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c2c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c2d : 0d > db test_num`
	`>`
	`0c2e : >skip0586`
`>`	`>`
`0aac : 68 [ 4]> pla ;load status`	`0c2e : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-zero`	`> cmp_flag $ff-zero`
`0aad : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`	`0c2f : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0aaf : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c31 : f002 [ 3]> beq skip0589`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c33 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c34 : 0d > db test_num`
`>`	`>`
`0ab1 : 28 [ 4]> plp ;restore status`	`0c35 : >skip0589`
	`>`
	`0c35 : 28 [ 4]> plp ;restore status`

`0ab2 : 08 [ 3] php`	`0c36 : 08 [ 3] php`
`0ab3 : e8 [ 2] inx ;00`	`0c37 : e8 [ 2] inx ;00`
`0ab4 : 28 [ 4] plp`	`0c38 : 28 [ 4] plp`
`0ab5 : 8a [ 2] txa`	`0c39 : 8a [ 2] txa`
`tst_a 0,$ff-minus`	`tst_a 0,$ff-minus`
`0ab6 : 08 [ 3]> php ;save flags`	`0c3a : 08 [ 3]> php ;save flags`
`0ab7 : 08 [ 3]> php`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 102`
`0ab8 : c900 [ 2]> cmp #0 ;test result`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0c3b : 08 [ 3]> php`
	`0c3c : c900 [ 2]> cmp #0 ;test result`
`> trap_ne`	`> trap_ne`
`0aba : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c3e : f002 [ 3]> beq skip0592`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c40 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c41 : 0d > db test_num`
`>`	`>`
`0abc : 68 [ 4]> pla ;load status`	`0c42 : >skip0592`
	`>`
	`0c42 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus`	`> cmp_flag $ff-minus`
`0abd : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`	`0c43 : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0abf : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c45 : f002 [ 3]> beq skip0595`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c47 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c48 : 0d > db test_num`
`>`	`>`
`0ac1 : 28 [ 4]> plp ;restore status`	`0c49 : >skip0595`
	`>`
`0ac2 : 08 [ 3] php`	`0c49 : 28 [ 4]> plp ;restore status`
`0ac3 : e8 [ 2] inx ;01`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 58`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0ac4 : 28 [ 4] plp`	`0c4a : 08 [ 3] php`
`0ac5 : 8a [ 2] txa`	`0c4b : e8 [ 2] inx ;01`
	`0c4c : 28 [ 4] plp`
	`0c4d : 8a [ 2] txa`
`tst_a 1,$ff-minus-zero`	`tst_a 1,$ff-minus-zero`
`0ac6 : 08 [ 3]> php ;save flags`	`0c4e : 08 [ 3]> php ;save flags`
`0ac7 : 08 [ 3]> php`	`0c4f : 08 [ 3]> php`
`0ac8 : c901 [ 2]> cmp #1 ;test result`	`0c50 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`0aca : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c52 : f002 [ 3]> beq skip0598`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c54 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c55 : 0d > db test_num`
`>`	`>`
`0acc : 68 [ 4]> pla ;load status`	`0c56 : >skip0598`
	`>`
	`0c56 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus-zero`	`> cmp_flag $ff-minus-zero`
`0acd : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`	`0c57 : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0acf : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c59 : f002 [ 3]> beq skip0601`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c5b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c5c : 0d > db test_num`
	`>`
	`0c5d : >skip0601`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 103`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`0ad1 : 28 [ 4]> plp ;restore status`	`0c5d : 28 [ 4]> plp ;restore status`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0ad2 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0c5e : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0ad4 : 48 [ 3]> pha ;use stack to load status`	`0c60 : 48 [ 3]> pha ;use stack to load status`
`0ad5 : 28 [ 4]> plp`	`0c61 : 28 [ 4]> plp`

`0ad6 : 8a [ 2] txa`	`0c62 : 8a [ 2] txa`
`tst_a 1,0`	`tst_a 1,0`
`0ad7 : 08 [ 3]> php ;save flags`	`0c63 : 08 [ 3]> php ;save flags`
`0ad8 : 08 [ 3]> php`	`0c64 : 08 [ 3]> php`
`0ad9 : c901 [ 2]> cmp #1 ;test result`	`0c65 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`0adb : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c67 : f002 [ 3]> beq skip0606`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c69 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c6a : 0d > db test_num`
`>`	`>`
`0add : 68 [ 4]> pla ;load status`	`0c6b : >skip0606`
	`>`
	`0c6b : 68 [ 4]> pla ;load status`
`> cmp_flag 0`	`> cmp_flag 0`
`0ade : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`0c6c : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0ae0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c6e : f002 [ 3]> beq skip0609`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c70 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c71 : 0d > db test_num`
	`>`
	`0c72 : >skip0609`
`>`	`>`
`0ae2 : 28 [ 4]> plp ;restore status`	`0c72 : 28 [ 4]> plp ;restore status`

`0ae3 : 08 [ 3] php`	`0c73 : 08 [ 3] php`
`0ae4 : ca [ 2] dex ;00`	`0c74 : ca [ 2] dex ;00`
`0ae5 : 28 [ 4] plp`	`0c75 : 28 [ 4] plp`
`0ae6 : 8a [ 2] txa`	`0c76 : 8a [ 2] txa`
`tst_a 0,zero`	`tst_a 0,zero`
`0ae7 : 08 [ 3]> php ;save flags`	`0c77 : 08 [ 3]> php ;save flags`
`0ae8 : 08 [ 3]> php`	`0c78 : 08 [ 3]> php`
`0ae9 : c900 [ 2]> cmp #0 ;test result`	`0c79 : c900 [ 2]> cmp #0 ;test result`
`> trap_ne`	`> trap_ne`
`0aeb : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c7b : f002 [ 3]> beq skip0612`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c7d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c7e : 0d > db test_num`
`>`	`>`
`0aed : 68 [ 4]> pla ;load status`	`0c7f : >skip0612`
`> cmp_flag zero`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 104`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 59`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0aee : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`	`>`
	`0c7f : 68 [ 4]> pla ;load status`
	`> cmp_flag zero`
	`0c80 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0af0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c82 : f002 [ 3]> beq skip0615`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c84 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c85 : 0d > db test_num`
`>`	`>`
`0af2 : 28 [ 4]> plp ;restore status`	`0c86 : >skip0615`
	`>`
	`0c86 : 28 [ 4]> plp ;restore status`

`0af3 : 08 [ 3] php`	`0c87 : 08 [ 3] php`
`0af4 : ca [ 2] dex ;ff`	`0c88 : ca [ 2] dex ;ff`
`0af5 : 28 [ 4] plp`	`0c89 : 28 [ 4] plp`
`0af6 : 8a [ 2] txa`	`0c8a : 8a [ 2] txa`
`tst_a $ff,minus`	`tst_a $ff,minus`
`0af7 : 08 [ 3]> php ;save flags`	`0c8b : 08 [ 3]> php ;save flags`
`0af8 : 08 [ 3]> php`	`0c8c : 08 [ 3]> php`
`0af9 : c9ff [ 2]> cmp #$ff ;test result`	`0c8d : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0afb : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c8f : f002 [ 3]> beq skip0618`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c91 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c92 : 0d > db test_num`
`>`	`>`
`0afd : 68 [ 4]> pla ;load status`	`0c93 : >skip0618`
	`>`
	`0c93 : 68 [ 4]> pla ;load status`
`> cmp_flag minus`	`> cmp_flag minus`
`0afe : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`	`0c94 : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0b00 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0c96 : f002 [ 3]> beq skip0621`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0c98 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0c99 : 0d > db test_num`
	`>`
	`0c9a : >skip0621`
`>`	`>`
`0b02 : 28 [ 4]> plp ;restore status`	`0c9a : 28 [ 4]> plp ;restore status`


`0b03 : a0ff [ 2] ldy #$ff`	`0c9b : a0ff [ 2] ldy #$ff`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0b05 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0c9d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0b07 : 48 [ 3]> pha ;use stack to load status`	`0c9f : 48 [ 3]> pha ;use stack to load status`
`0b08 : 28 [ 4]> plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 105`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0b09 : 98 [ 2] tya`	`0ca0 : 28 [ 4]> plp`

	`0ca1 : 98 [ 2] tya`
`tst_a $ff,$ff-zero`	`tst_a $ff,$ff-zero`
`0b0a : 08 [ 3]> php ;save flags`	`0ca2 : 08 [ 3]> php ;save flags`
`0b0b : 08 [ 3]> php`	`0ca3 : 08 [ 3]> php`
`0b0c : c9ff [ 2]> cmp #$ff ;test result`	`0ca4 : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0b0e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ca6 : f002 [ 3]> beq skip0626`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ca8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ca9 : 0d > db test_num`
`>`	`>`
`0b10 : 68 [ 4]> pla ;load status`	`0caa : >skip0626`
	`>`
	`0caa : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-zero`	`> cmp_flag $ff-zero`
`0b11 : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`	`0cab : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0b13 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0cad : f002 [ 3]> beq skip0629`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0caf : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0cb0 : 0d > db test_num`
`>`	`>`
`0b15 : 28 [ 4]> plp ;restore status`	`0cb1 : >skip0629`
	`>`
`0b16 : 08 [ 3] php`	`0cb1 : 28 [ 4]> plp ;restore status`
`0b17 : c8 [ 2] iny ;00`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 60`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0b18 : 28 [ 4] plp`	`0cb2 : 08 [ 3] php`
`0b19 : 98 [ 2] tya`	`0cb3 : c8 [ 2] iny ;00`
	`0cb4 : 28 [ 4] plp`
	`0cb5 : 98 [ 2] tya`
`tst_a 0,$ff-minus`	`tst_a 0,$ff-minus`
`0b1a : 08 [ 3]> php ;save flags`	`0cb6 : 08 [ 3]> php ;save flags`
`0b1b : 08 [ 3]> php`	`0cb7 : 08 [ 3]> php`
`0b1c : c900 [ 2]> cmp #0 ;test result`	`0cb8 : c900 [ 2]> cmp #0 ;test result`
`> trap_ne`	`> trap_ne`
`0b1e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0cba : f002 [ 3]> beq skip0632`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0cbc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0cbd : 0d > db test_num`
`>`	`>`
`0b20 : 68 [ 4]> pla ;load status`	`0cbe : >skip0632`
	`>`
	`0cbe : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus`	`> cmp_flag $ff-minus`
`0b21 : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`	`0cbf : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0b23 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0cc1 : f002 [ 3]> beq skip0635`
`>`	`> trap ;failed equal (zero)`
`0b25 : 28 [ 4]> plp ;restore status`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 106`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0b26 : 08 [ 3] php`	`>; db $db ; M65C02/M65C02A SToP instruction`
`0b27 : c8 [ 2] iny ;01`	`0cc3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`0b28 : 28 [ 4] plp`	`0cc4 : 0d > db test_num`
`0b29 : 98 [ 2] tya`	`>`
	`0cc5 : >skip0635`
	`>`
	`0cc5 : 28 [ 4]> plp ;restore status`

	`0cc6 : 08 [ 3] php`
	`0cc7 : c8 [ 2] iny ;01`
	`0cc8 : 28 [ 4] plp`
	`0cc9 : 98 [ 2] tya`
`tst_a 1,$ff-minus-zero`	`tst_a 1,$ff-minus-zero`
`0b2a : 08 [ 3]> php ;save flags`	`0cca : 08 [ 3]> php ;save flags`
`0b2b : 08 [ 3]> php`	`0ccb : 08 [ 3]> php`
`0b2c : c901 [ 2]> cmp #1 ;test result`	`0ccc : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`0b2e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0cce : f002 [ 3]> beq skip0638`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0cd0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0cd1 : 0d > db test_num`
`>`	`>`
`0b30 : 68 [ 4]> pla ;load status`	`0cd2 : >skip0638`
	`>`
	`0cd2 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus-zero`	`> cmp_flag $ff-minus-zero`
`0b31 : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`	`0cd3 : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0b33 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0cd5 : f002 [ 3]> beq skip0641`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0cd7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0cd8 : 0d > db test_num`
	`>`
	`0cd9 : >skip0641`
`>`	`>`
`0b35 : 28 [ 4]> plp ;restore status`	`0cd9 : 28 [ 4]> plp ;restore status`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0b36 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0cda : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0b38 : 48 [ 3]> pha ;use stack to load status`	`0cdc : 48 [ 3]> pha ;use stack to load status`
`0b39 : 28 [ 4]> plp`	`0cdd : 28 [ 4]> plp`

`0b3a : 98 [ 2] tya`	`0cde : 98 [ 2] tya`
`tst_a 1,0`	`tst_a 1,0`
`0b3b : 08 [ 3]> php ;save flags`	`0cdf : 08 [ 3]> php ;save flags`
`0b3c : 08 [ 3]> php`	`0ce0 : 08 [ 3]> php`
`0b3d : c901 [ 2]> cmp #1 ;test result`	`0ce1 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`0b3f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ce3 : f002 [ 3]> beq skip0646`
`>`	`> trap ;failed equal (zero)`
`0b41 : 68 [ 4]> pla ;load status`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 107`
`> cmp_flag 0`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 61`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0b42 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ce5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ce6 : 0d > db test_num`
	`>`
	`0ce7 : >skip0646`
	`>`
	`0ce7 : 68 [ 4]> pla ;load status`
	`> cmp_flag 0`
	`0ce8 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0b44 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0cea : f002 [ 3]> beq skip0649`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0cec : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ced : 0d > db test_num`
	`>`
	`0cee : >skip0649`
`>`	`>`
`0b46 : 28 [ 4]> plp ;restore status`	`0cee : 28 [ 4]> plp ;restore status`

`0b47 : 08 [ 3] php`	`0cef : 08 [ 3] php`
`0b48 : 88 [ 2] dey ;00`	`0cf0 : 88 [ 2] dey ;00`
`0b49 : 28 [ 4] plp`	`0cf1 : 28 [ 4] plp`
`0b4a : 98 [ 2] tya`	`0cf2 : 98 [ 2] tya`
`tst_a 0,zero`	`tst_a 0,zero`
`0b4b : 08 [ 3]> php ;save flags`	`0cf3 : 08 [ 3]> php ;save flags`
`0b4c : 08 [ 3]> php`	`0cf4 : 08 [ 3]> php`
`0b4d : c900 [ 2]> cmp #0 ;test result`	`0cf5 : c900 [ 2]> cmp #0 ;test result`
`> trap_ne`	`> trap_ne`
`0b4f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0cf7 : f002 [ 3]> beq skip0652`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0cf9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0cfa : 0d > db test_num`
`>`	`>`
`0b51 : 68 [ 4]> pla ;load status`	`0cfb : >skip0652`
	`>`
	`0cfb : 68 [ 4]> pla ;load status`
`> cmp_flag zero`	`> cmp_flag zero`
`0b52 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`	`0cfc : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0b54 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0cfe : f002 [ 4]> beq skip0655`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d00 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d01 : 0d > db test_num`
`>`	`>`
`0b56 : 28 [ 4]> plp ;restore status`	`0d02 : >skip0655`
	`>`
	`0d02 : 28 [ 4]> plp ;restore status`

	`0d03 : 08 [ 3] php`
	`0d04 : 88 [ 2] dey ;ff`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 108`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0b57 : 08 [ 3] php`	`0d05 : 28 [ 4] plp`
`0b58 : 88 [ 2] dey ;ff`	`0d06 : 98 [ 2] tya`
`0b59 : 28 [ 4] plp`
`0b5a : 98 [ 2] tya`
`tst_a $ff,minus`	`tst_a $ff,minus`
`0b5b : 08 [ 3]> php ;save flags`	`0d07 : 08 [ 3]> php ;save flags`
`0b5c : 08 [ 3]> php`	`0d08 : 08 [ 3]> php`
`0b5d : c9ff [ 2]> cmp #$ff ;test result`	`0d09 : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0b5f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0d0b : f002 [ 3]> beq skip0658`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d0d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d0e : 0d > db test_num`
	`>`
	`0d0f : >skip0658`
`>`	`>`
`0b61 : 68 [ 4]> pla ;load status`	`0d0f : 68 [ 4]> pla ;load status`
`> cmp_flag minus`	`> cmp_flag minus`
`0b62 : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`	`0d10 : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0b64 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0d12 : f002 [ 3]> beq skip0661`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d14 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d15 : 0d > db test_num`
`>`	`>`
`0b66 : 28 [ 4]> plp ;restore status`	`0d16 : >skip0661`
	`>`
	`0d16 : 28 [ 4]> plp ;restore status`


`load_flag $ff`	`load_flag $ff`
`0b67 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0d17 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`

`0b69 : 48 [ 3] pha`
`0b6a : a2ff [ 2] ldx #$ff ;ff`
`0b6c : 8a [ 2] txa`
`0b6d : 28 [ 4] plp`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 62`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0b6e : a8 [ 2] tay`	`0d19 : 48 [ 3] pha`
	`0d1a : a2ff [ 2] ldx #$ff ;ff`
	`0d1c : 8a [ 2] txa`
	`0d1d : 28 [ 4] plp`
	`0d1e : a8 [ 2] tay`
`tst_y $ff,$ff-zero`	`tst_y $ff,$ff-zero`
`0b6f : 08 [ 3]> php ;save flags`	`0d1f : 08 [ 3]> php ;save flags`
`0b70 : 08 [ 3]> php`	`0d20 : 08 [ 3]> php`
`0b71 : c0ff [ 2]> cpy #$ff ;test result`	`0d21 : c0ff [ 2]> cpy #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0b73 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0d23 : f002 [ 3]> beq skip0665`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d25 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d26 : 0d > db test_num`
	`>`
	`0d27 : >skip0665`
`>`	`>`
`0b75 : 68 [ 4]> pla ;load status`	`0d27 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-zero`	`> cmp_flag $ff-zero`
`0b76 : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`	`0d28 : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 109`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`> trap_ne`	`> trap_ne`
`0b78 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0d2a : f002 [ 3]> beq skip0668`
`>`	`> trap ;failed equal (zero)`
`0b7a : 28 [ 4]> plp ;restore status`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d2c : 00 [ 7]> brk ; Use BRK to return to the monitor`
`0b7b : 08 [ 3] php`	`0d2d : 0d > db test_num`
`0b7c : e8 [ 2] inx ;00`	`>`
`0b7d : 8a [ 2] txa`	`0d2e : >skip0668`
`0b7e : 28 [ 4] plp`	`>`
`0b7f : a8 [ 2] tay`	`0d2e : 28 [ 4]> plp ;restore status`

	`0d2f : 08 [ 3] php`
	`0d30 : e8 [ 2] inx ;00`
	`0d31 : 8a [ 2] txa`
	`0d32 : 28 [ 4] plp`
	`0d33 : a8 [ 2] tay`
`tst_y 0,$ff-minus`	`tst_y 0,$ff-minus`
`0b80 : 08 [ 3]> php ;save flags`	`0d34 : 08 [ 3]> php ;save flags`
`0b81 : 08 [ 3]> php`	`0d35 : 08 [ 3]> php`
`0b82 : c000 [ 2]> cpy #0 ;test result`	`0d36 : c000 [ 2]> cpy #0 ;test result`
`> trap_ne`	`> trap_ne`
`0b84 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0d38 : f002 [ 3]> beq skip0671`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d3a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d3b : 0d > db test_num`
`>`	`>`
`0b86 : 68 [ 4]> pla ;load status`	`0d3c : >skip0671`
	`>`
	`0d3c : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus`	`> cmp_flag $ff-minus`
`0b87 : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`	`0d3d : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0b89 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0d3f : f002 [ 3]> beq skip0674`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d41 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d42 : 0d > db test_num`
	`>`
	`0d43 : >skip0674`
`>`	`>`
`0b8b : 28 [ 4]> plp ;restore status`	`0d43 : 28 [ 4]> plp ;restore status`

`0b8c : 08 [ 3] php`	`0d44 : 08 [ 3] php`
`0b8d : e8 [ 2] inx ;01`	`0d45 : e8 [ 2] inx ;01`
`0b8e : 8a [ 2] txa`	`0d46 : 8a [ 2] txa`
`0b8f : 28 [ 4] plp`	`0d47 : 28 [ 4] plp`
`0b90 : a8 [ 2] tay`	`0d48 : a8 [ 2] tay`
`tst_y 1,$ff-minus-zero`	`tst_y 1,$ff-minus-zero`
`0b91 : 08 [ 3]> php ;save flags`	`0d49 : 08 [ 3]> php ;save flags`
`0b92 : 08 [ 3]> php`	`0d4a : 08 [ 3]> php`
`0b93 : c001 [ 2]> cpy #1 ;test result`	`0d4b : c001 [ 2]> cpy #1 ;test result`
`> trap_ne`	`> trap_ne`
`0b95 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 110`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0d4d : f002 [ 3]> beq skip0677`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d4f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d50 : 0d > db test_num`
	`>`
	`0d51 : >skip0677`
`>`	`>`
`0b97 : 68 [ 4]> pla ;load status`	`0d51 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus-zero`	`> cmp_flag $ff-minus-zero`
`0b98 : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`	`0d52 : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 63`	`0d54 : f002 [ 3]> beq skip0680`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`0b9a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0d56 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d57 : 0d > db test_num`
	`>`
	`0d58 : >skip0680`
`>`	`>`
`0b9c : 28 [ 4]> plp ;restore status`	`0d58 : 28 [ 4]> plp ;restore status`

`load_flag 0`	`load_flag 0`
`0b9d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0d59 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`

`0b9f : 48 [ 3] pha`	`0d5b : 48 [ 3] pha`
`0ba0 : a900 [ 2] lda #0`	`0d5c : a900 [ 2] lda #0`
`0ba2 : 8a [ 2] txa`	`0d5e : 8a [ 2] txa`
`0ba3 : 28 [ 4] plp`	`0d5f : 28 [ 4] plp`
`0ba4 : a8 [ 2] tay`	`0d60 : a8 [ 2] tay`
`tst_y 1,0`	`tst_y 1,0`
`0ba5 : 08 [ 3]> php ;save flags`	`0d61 : 08 [ 3]> php ;save flags`
`0ba6 : 08 [ 3]> php`	`0d62 : 08 [ 3]> php`
`0ba7 : c001 [ 2]> cpy #1 ;test result`	`0d63 : c001 [ 2]> cpy #1 ;test result`
`> trap_ne`	`> trap_ne`
`0ba9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0d65 : f002 [ 3]> beq skip0684`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d67 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d68 : 0d > db test_num`
	`>`
	`0d69 : >skip0684`
`>`	`>`
`0bab : 68 [ 4]> pla ;load status`	`0d69 : 68 [ 4]> pla ;load status`
`> cmp_flag 0`	`> cmp_flag 0`
`0bac : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`0d6a : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0bae : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0d6c : f002 [ 3]> beq skip0687`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d6e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d6f : 0d > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 111`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0d70 : >skip0687`
`>`	`>`
`0bb0 : 28 [ 4]> plp ;restore status`	`0d70 : 28 [ 4]> plp ;restore status`

`0bb1 : 08 [ 3] php`	`0d71 : 08 [ 3] php`
`0bb2 : ca [ 2] dex ;00`	`0d72 : ca [ 2] dex ;00`
`0bb3 : 8a [ 2] txa`	`0d73 : 8a [ 2] txa`
`0bb4 : 28 [ 4] plp`	`0d74 : 28 [ 4] plp`
`0bb5 : a8 [ 2] tay`	`0d75 : a8 [ 2] tay`
`tst_y 0,zero`	`tst_y 0,zero`
`0bb6 : 08 [ 3]> php ;save flags`	`0d76 : 08 [ 3]> php ;save flags`
`0bb7 : 08 [ 3]> php`	`0d77 : 08 [ 3]> php`
`0bb8 : c000 [ 2]> cpy #0 ;test result`	`0d78 : c000 [ 2]> cpy #0 ;test result`
`> trap_ne`	`> trap_ne`
`0bba : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0d7a : f002 [ 3]> beq skip0690`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d7c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d7d : 0d > db test_num`
	`>`
	`0d7e : >skip0690`
`>`	`>`
`0bbc : 68 [ 4]> pla ;load status`	`0d7e : 68 [ 4]> pla ;load status`
`> cmp_flag zero`	`> cmp_flag zero`
`0bbd : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`	`0d7f : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0bbf : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0d81 : f002 [ 3]> beq skip0693`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d83 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d84 : 0d > db test_num`
`>`	`>`
`0bc1 : 28 [ 4]> plp ;restore status`	`0d85 : >skip0693`
	`>`
	`0d85 : 28 [ 4]> plp ;restore status`

`0bc2 : 08 [ 3] php`	`0d86 : 08 [ 3] php`
`0bc3 : ca [ 2] dex ;ff`	`0d87 : ca [ 2] dex ;ff`
`0bc4 : 8a [ 2] txa`	`0d88 : 8a [ 2] txa`
`0bc5 : 28 [ 4] plp`	`0d89 : 28 [ 4] plp`
`0bc6 : a8 [ 2] tay`	`0d8a : a8 [ 2] tay`
`tst_y $ff,minus`	`tst_y $ff,minus`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 64`	`0d8b : 08 [ 3]> php ;save flags`
	`0d8c : 08 [ 3]> php`
	`0d8d : c0ff [ 2]> cpy #$ff ;test result`
	`> trap_ne`
	`0d8f : f002 [ 3]> beq skip0696`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d91 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d92 : 0d > db test_num`
	`>`
	`0d93 : >skip0696`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 112`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0bc7 : 08 [ 3]> php ;save flags`	`0d93 : 68 [ 4]> pla ;load status`
`0bc8 : 08 [ 3]> php`
`0bc9 : c0ff [ 2]> cpy #$ff ;test result`
`> trap_ne`
`0bcb : d0fe [ 3]> bne * ;failed not equal (non zero)`
`>`
`0bcd : 68 [ 4]> pla ;load status`
`> cmp_flag minus`	`> cmp_flag minus`
`0bce : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`	`0d94 : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0bd0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0d96 : f002 [ 3]> beq skip0699`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0d98 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0d99 : 0d > db test_num`
`>`	`>`
`0bd2 : 28 [ 4]> plp ;restore status`	`0d9a : >skip0699`
	`>`
	`0d9a : 28 [ 4]> plp ;restore status`



`load_flag $ff`	`load_flag $ff`
`0bd3 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0d9b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`

`0bd5 : 48 [ 3] pha`	`0d9d : 48 [ 3] pha`
`0bd6 : a0ff [ 2] ldy #$ff ;ff`	`0d9e : a0ff [ 2] ldy #$ff ;ff`
`0bd8 : 98 [ 2] tya`	`0da0 : 98 [ 2] tya`
`0bd9 : 28 [ 4] plp`	`0da1 : 28 [ 4] plp`
`0bda : aa [ 2] tax`	`0da2 : aa [ 2] tax`
`tst_x $ff,$ff-zero`	`tst_x $ff,$ff-zero`
`0bdb : 08 [ 3]> php ;save flags`	`0da3 : 08 [ 3]> php ;save flags`
`0bdc : 08 [ 3]> php`	`0da4 : 08 [ 3]> php`
`0bdd : e0ff [ 2]> cpx #$ff ;test result`	`0da5 : e0ff [ 2]> cpx #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0bdf : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0da7 : f002 [ 3]> beq skip0703`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0da9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0daa : 0d > db test_num`
`>`	`>`
`0be1 : 68 [ 4]> pla ;load status`	`0dab : >skip0703`
	`>`
	`0dab : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-zero`	`> cmp_flag $ff-zero`
`0be2 : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`	`0dac : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0be4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0dae : f002 [ 3]> beq skip0706`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0db0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0db1 : 0d > db test_num`
	`>`
	`0db2 : >skip0706`
`>`	`>`
`0be6 : 28 [ 4]> plp ;restore status`	`0db2 : 28 [ 4]> plp ;restore status`

`0be7 : 08 [ 3] php`	`0db3 : 08 [ 3] php`
`0be8 : c8 [ 2] iny ;00`	`0db4 : c8 [ 2] iny ;00`
`0be9 : 98 [ 2] tya`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 113`
`0bea : 28 [ 4] plp`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`0beb : aa [ 2] tax`
	`0db5 : 98 [ 2] tya`
	`0db6 : 28 [ 4] plp`
	`0db7 : aa [ 2] tax`
`tst_x 0,$ff-minus`	`tst_x 0,$ff-minus`
`0bec : 08 [ 3]> php ;save flags`	`0db8 : 08 [ 3]> php ;save flags`
`0bed : 08 [ 3]> php`	`0db9 : 08 [ 3]> php`
`0bee : e000 [ 2]> cpx #0 ;test result`	`0dba : e000 [ 2]> cpx #0 ;test result`
`> trap_ne`	`> trap_ne`
`0bf0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0dbc : f002 [ 3]> beq skip0709`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0dbe : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0dbf : 0d > db test_num`
`>`	`>`
`0bf2 : 68 [ 4]> pla ;load status`	`0dc0 : >skip0709`
	`>`
	`0dc0 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus`	`> cmp_flag $ff-minus`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 65`	`0dc1 : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0bf3 : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0bf5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0dc3 : f002 [ 3]> beq skip0712`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0dc5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0dc6 : 0d > db test_num`
`>`	`>`
`0bf7 : 28 [ 4]> plp ;restore status`	`0dc7 : >skip0712`
	`>`
	`0dc7 : 28 [ 4]> plp ;restore status`

`0bf8 : 08 [ 3] php`	`0dc8 : 08 [ 3] php`
`0bf9 : c8 [ 2] iny ;01`	`0dc9 : c8 [ 2] iny ;01`
`0bfa : 98 [ 2] tya`	`0dca : 98 [ 2] tya`
`0bfb : 28 [ 4] plp`	`0dcb : 28 [ 4] plp`
`0bfc : aa [ 2] tax`	`0dcc : aa [ 2] tax`
`tst_x 1,$ff-minus-zero`	`tst_x 1,$ff-minus-zero`
`0bfd : 08 [ 3]> php ;save flags`	`0dcd : 08 [ 3]> php ;save flags`
`0bfe : 08 [ 3]> php`	`0dce : 08 [ 3]> php`
`0bff : e001 [ 2]> cpx #1 ;test result`	`0dcf : e001 [ 2]> cpx #1 ;test result`
`> trap_ne`	`> trap_ne`
`0c01 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0dd1 : f002 [ 3]> beq skip0715`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0dd3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0dd4 : 0d > db test_num`
`>`	`>`
`0c03 : 68 [ 4]> pla ;load status`	`0dd5 : >skip0715`
	`>`
	`0dd5 : 68 [ 4]> pla ;load status`
`> cmp_flag $ff-minus-zero`	`> cmp_flag $ff-minus-zero`
`0c04 : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`	`0dd6 : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0c06 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0dd8 : f002 [ 3]> beq skip0718`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 114`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0dda : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ddb : 0d > db test_num`
`>`	`>`
`0c08 : 28 [ 4]> plp ;restore status`	`0ddc : >skip0718`
	`>`
	`0ddc : 28 [ 4]> plp ;restore status`

`load_flag 0`	`load_flag 0`
`0c09 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0ddd : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`

`0c0b : 48 [ 3] pha`	`0ddf : 48 [ 3] pha`
`0c0c : a900 [ 2] lda #0 ;preset status`	`0de0 : a900 [ 2] lda #0 ;preset status`
`0c0e : 98 [ 2] tya`	`0de2 : 98 [ 2] tya`
`0c0f : 28 [ 4] plp`	`0de3 : 28 [ 4] plp`
`0c10 : aa [ 2] tax`	`0de4 : aa [ 2] tax`
`tst_x 1,0`	`tst_x 1,0`
`0c11 : 08 [ 3]> php ;save flags`	`0de5 : 08 [ 3]> php ;save flags`
`0c12 : 08 [ 3]> php`	`0de6 : 08 [ 3]> php`
`0c13 : e001 [ 2]> cpx #1 ;test result`	`0de7 : e001 [ 2]> cpx #1 ;test result`
`> trap_ne`	`> trap_ne`
`0c15 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0de9 : f002 [ 3]> beq skip0722`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0deb : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0dec : 0d > db test_num`
`>`	`>`
`0c17 : 68 [ 4]> pla ;load status`	`0ded : >skip0722`
	`>`
	`0ded : 68 [ 4]> pla ;load status`
`> cmp_flag 0`	`> cmp_flag 0`
`0c18 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`0dee : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0c1a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0df0 : f002 [ 3]> beq skip0725`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0df2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0df3 : 0d > db test_num`
`>`	`>`
`0c1c : 28 [ 4]> plp ;restore status`	`0df4 : >skip0725`
	`>`
`0c1d : 08 [ 3] php`	`0df4 : 28 [ 4]> plp ;restore status`
`0c1e : 88 [ 2] dey ;00`
`0c1f : 98 [ 2] tya`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 66`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0c20 : 28 [ 4] plp`	`0df5 : 08 [ 3] php`
`0c21 : aa [ 2] tax`	`0df6 : 88 [ 2] dey ;00`
	`0df7 : 98 [ 2] tya`
	`0df8 : 28 [ 4] plp`
	`0df9 : aa [ 2] tax`
`tst_x 0,zero`	`tst_x 0,zero`
`0c22 : 08 [ 3]> php ;save flags`	`0dfa : 08 [ 3]> php ;save flags`
`0c23 : 08 [ 3]> php`	`0dfb : 08 [ 3]> php`
`0c24 : e000 [ 2]> cpx #0 ;test result`	`0dfc : e000 [ 2]> cpx #0 ;test result`
`> trap_ne`	`> trap_ne`
`0c26 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 115`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0dfe : f002 [ 4]> beq skip0728`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0e00 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0e01 : 0d > db test_num`
	`>`
	`0e02 : >skip0728`
`>`	`>`
`0c28 : 68 [ 4]> pla ;load status`	`0e02 : 68 [ 4]> pla ;load status`
`> cmp_flag zero`	`> cmp_flag zero`
`0c29 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`	`0e03 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0c2b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0e05 : f002 [ 3]> beq skip0731`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0e07 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0e08 : 0d > db test_num`
`>`	`>`
`0c2d : 28 [ 4]> plp ;restore status`	`0e09 : >skip0731`
	`>`
	`0e09 : 28 [ 4]> plp ;restore status`

`0c2e : 08 [ 3] php`	`0e0a : 08 [ 3] php`
`0c2f : 88 [ 2] dey ;ff`	`0e0b : 88 [ 2] dey ;ff`
`0c30 : 98 [ 2] tya`	`0e0c : 98 [ 2] tya`
`0c31 : 28 [ 4] plp`	`0e0d : 28 [ 4] plp`
`0c32 : aa [ 2] tax`	`0e0e : aa [ 2] tax`
`tst_x $ff,minus`	`tst_x $ff,minus`
`0c33 : 08 [ 3]> php ;save flags`	`0e0f : 08 [ 3]> php ;save flags`
`0c34 : 08 [ 3]> php`	`0e10 : 08 [ 3]> php`
`0c35 : e0ff [ 2]> cpx #$ff ;test result`	`0e11 : e0ff [ 2]> cpx #$ff ;test result`
`> trap_ne`	`> trap_ne`
`0c37 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0e13 : f002 [ 3]> beq skip0734`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0e15 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0e16 : 0d > db test_num`
`>`	`>`
`0c39 : 68 [ 4]> pla ;load status`	`0e17 : >skip0734`
	`>`
	`0e17 : 68 [ 4]> pla ;load status`
`> cmp_flag minus`	`> cmp_flag minus`
`0c3a : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`	`0e18 : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`0c3c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0e1a : f002 [ 3]> beq skip0737`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0e1c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0e1d : 0d > db test_num`
	`>`
	`0e1e : >skip0737`
`>`	`>`
`0c3e : 28 [ 4]> plp ;restore status`	`0e1e : 28 [ 4]> plp ;restore status`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 116`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`next_test`	`next_test`
`0c3f : ad0002 [ 4]> lda test_case ;previous test`	`0e1f : ad0002 [ 4]> lda test_case ;previous test`
`0c42 : c90d [ 2]> cmp #test_num`	`0e22 : c90d [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`0c44 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0e24 : f002 [ 3]> beq skip0740`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0e26 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0e27 : 0d > db test_num`
	`>`
	`0e28 : >skip0740`
`>`	`>`
`000e = >test_num = test_num + 1`	`000e = >test_num = test_num + 1`
`0c46 : a90e [ 2]> lda #test_num ;*** this tests' number`	`0e28 : a90e [ 2]> lda #test_num ;*** this tests' number`
`0c48 : 8d0002 [ 4]> sta test_case`	`0e2a : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`;TSX sets NZ - TXS does not`	`;TSX sets NZ - TXS does not`
`0c4b : a201 [ 2] ldx #1 ;01`
	`0e2d : a201 [ 2] ldx #1 ;01`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 67`	`0e2f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0c4d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0c4f : 48 [ 3]> pha ;use stack to load status`	`0e31 : 48 [ 3]> pha ;use stack to load status`
`0c50 : 28 [ 4]> plp`	`0e32 : 28 [ 4]> plp`

`0c51 : 9a [ 2] txs`	`0e33 : 9a [ 2] txs`
`0c52 : 08 [ 3] php`	`0e34 : 08 [ 3] php`
`0c53 : ad0101 [ 4] lda $101`	`0e35 : ad0101 [ 4] lda $101`
`cmp_flag $ff`	`cmp_flag $ff`
`0c56 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`	`0e38 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`0c58 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0e3a : f002 [ 3]> beq skip0745`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0e3c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0e3d : 0e > db test_num`
	`>`
	`0e3e : >skip0745`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0c5a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0e3e : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0c5c : 48 [ 3]> pha ;use stack to load status`	`0e40 : 48 [ 3]> pha ;use stack to load status`
`0c5d : 28 [ 4]> plp`	`0e41 : 28 [ 4]> plp`

`0c5e : 9a [ 2] txs`	`0e42 : 9a [ 2] txs`
`0c5f : 08 [ 3] php`	`0e43 : 08 [ 3] php`
`0c60 : ad0101 [ 4] lda $101`	`0e44 : ad0101 [ 4] lda $101`
`cmp_flag 0`	`cmp_flag 0`
`0c63 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 117`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0e47 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`0c65 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0e49 : f002 [ 3]> beq skip0750`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0e4b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0e4c : 0e > db test_num`
	`>`
	`0e4d : >skip0750`

`0c67 : ca [ 2] dex ;00`	`0e4d : ca [ 2] dex ;00`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0c68 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0e4e : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0c6a : 48 [ 3]> pha ;use stack to load status`	`0e50 : 48 [ 3]> pha ;use stack to load status`
`0c6b : 28 [ 4]> plp`	`0e51 : 28 [ 4]> plp`

`0c6c : 9a [ 2] txs`	`0e52 : 9a [ 2] txs`
`0c6d : 08 [ 3] php`	`0e53 : 08 [ 3] php`
`0c6e : ad0001 [ 4] lda $100`	`0e54 : ad0001 [ 4] lda $100`
`cmp_flag $ff`	`cmp_flag $ff`
`0c71 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`	`0e57 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`0c73 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0e59 : f002 [ 3]> beq skip0755`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0e5b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0e5c : 0e > db test_num`
	`>`
	`0e5d : >skip0755`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0c75 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0e5d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0c77 : 48 [ 3]> pha ;use stack to load status`	`0e5f : 48 [ 3]> pha ;use stack to load status`
`0c78 : 28 [ 4]> plp`	`0e60 : 28 [ 4]> plp`

`0c79 : 9a [ 2] txs`	`0e61 : 9a [ 2] txs`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 68`	`0e62 : 08 [ 3] php`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`0e63 : ad0001 [ 4] lda $100`

`0c7a : 08 [ 3] php`
`0c7b : ad0001 [ 4] lda $100`
`cmp_flag 0`	`cmp_flag 0`
`0c7e : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`0e66 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`0c80 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0e68 : f002 [ 3]> beq skip0760`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0e6a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0e6b : 0e > db test_num`
	`>`
	`0e6c : >skip0760`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 118`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0c82 : ca [ 2] dex ;ff`
	`0e6c : ca [ 2] dex ;ff`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0c83 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0e6d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0c85 : 48 [ 3]> pha ;use stack to load status`	`0e6f : 48 [ 3]> pha ;use stack to load status`
`0c86 : 28 [ 4]> plp`	`0e70 : 28 [ 4]> plp`

`0c87 : 9a [ 2] txs`	`0e71 : 9a [ 2] txs`
`0c88 : 08 [ 3] php`	`0e72 : 08 [ 3] php`
`0c89 : adff01 [ 4] lda $1ff`	`0e73 : adff01 [ 4] lda $1ff`
`cmp_flag $ff`	`cmp_flag $ff`
`0c8c : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`	`0e76 : c9ff [ 2]> cmp #($ff\|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`0c8e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0e78 : f002 [ 3]> beq skip0765`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0e7a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0e7b : 0e > db test_num`
	`>`
	`0e7c : >skip0765`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0c90 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0e7c : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0c92 : 48 [ 3]> pha ;use stack to load status`	`0e7e : 48 [ 3]> pha ;use stack to load status`
`0c93 : 28 [ 4]> plp`	`0e7f : 28 [ 4]> plp`

`0c94 : 9a [ 2] txs`	`0e80 : 9a [ 2] txs`
`0c95 : 08 [ 3] php`	`0e81 : 08 [ 3] php`
`0c96 : adff01 [ 4] lda $1ff`	`0e82 : adff01 [ 4] lda $1ff`
`cmp_flag 0`	`cmp_flag 0`
`0c99 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`0e85 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`


`0c9b : a201 [ 2] ldx #1`	`0e87 : a201 [ 2] ldx #1`
`0c9d : 9a [ 2] txs ;sp=01`	`0e89 : 9a [ 2] txs ;sp=01`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0c9e : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0e8a : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0ca0 : 48 [ 3]> pha ;use stack to load status`	`0e8c : 48 [ 3]> pha ;use stack to load status`
`0ca1 : 28 [ 4]> plp`	`0e8d : 28 [ 4]> plp`

`0ca2 : ba [ 2] tsx ;clears Z, N`
`0ca3 : 08 [ 3] php ;sp=00`
`0ca4 : e001 [ 2] cpx #1`
`trap_ne`
`0ca6 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`0ca8 : ad0101 [ 4] lda $101`	`0e8e : ba [ 2] tsx ;clears Z, N`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 69`	`0e8f : 08 [ 3] php ;sp=00`
	`0e90 : e001 [ 2] cpx #1`
	`trap_ne`
	`0e92 : f002 [ 3]> beq skip0772`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0e94 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 119`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0e95 : 0e > db test_num`
	`>`
	`0e96 : >skip0772`

	`0e96 : ad0101 [ 4] lda $101`
`cmp_flag $ff-minus-zero`	`cmp_flag $ff-minus-zero`
`0cab : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`	`0e99 : c97d [ 2]> cmp #($ff-minus-zero\|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`0cad : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0e9b : f002 [ 3]> beq skip0775`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0e9d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0e9e : 0e > db test_num`
	`>`
	`0e9f : >skip0775`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0caf : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0e9f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0cb1 : 48 [ 3]> pha ;use stack to load status`	`0ea1 : 48 [ 3]> pha ;use stack to load status`
`0cb2 : 28 [ 4]> plp`	`0ea2 : 28 [ 4]> plp`

`0cb3 : ba [ 2] tsx ;clears N, sets Z`	`0ea3 : ba [ 2] tsx ;clears N, sets Z`
`0cb4 : 08 [ 3] php ;sp=ff`	`0ea4 : 08 [ 3] php ;sp=ff`
`0cb5 : e000 [ 2] cpx #0`	`0ea5 : e000 [ 2] cpx #0`
`trap_ne`	`trap_ne`
`0cb7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ea7 : f002 [ 3]> beq skip0779`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ea9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0eaa : 0e > db test_num`
	`>`
	`0eab : >skip0779`

`0cb9 : ad0001 [ 4] lda $100`	`0eab : ad0001 [ 4] lda $100`
`cmp_flag $ff-minus`	`cmp_flag $ff-minus`
`0cbc : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`	`0eae : c97f [ 2]> cmp #($ff-minus\|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`0cbe : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0eb0 : f002 [ 3]> beq skip0782`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0eb2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0eb3 : 0e > db test_num`
	`>`
	`0eb4 : >skip0782`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0cc0 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0eb4 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0cc2 : 48 [ 3]> pha ;use stack to load status`	`0eb6 : 48 [ 3]> pha ;use stack to load status`
`0cc3 : 28 [ 4]> plp`	`0eb7 : 28 [ 4]> plp`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 120`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0cc4 : ba [ 2] tsx ;clears N, sets Z`
`0cc5 : 08 [ 3] php ;sp=fe`
`0cc6 : e0ff [ 2] cpx #$ff`
`trap_ne`
`0cc8 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`0cca : adff01 [ 4] lda $1ff`	`0eb8 : ba [ 2] tsx ;clears N, sets Z`
	`0eb9 : 08 [ 3] php ;sp=fe`
	`0eba : e0ff [ 2] cpx #$ff`
	`trap_ne`
	`0ebc : f002 [ 3]> beq skip0786`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ebe : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ebf : 0e > db test_num`
	`>`
	`0ec0 : >skip0786`

	`0ec0 : adff01 [ 4] lda $1ff`
`cmp_flag $ff-zero`	`cmp_flag $ff-zero`
`0ccd : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`	`0ec3 : c9fd [ 2]> cmp #($ff-zero\|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`0ccf : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ec5 : f002 [ 3]> beq skip0789`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ec7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ec8 : 0e > db test_num`
	`>`
	`0ec9 : >skip0789`


`0cd1 : a201 [ 2] ldx #1`	`0ec9 : a201 [ 2] ldx #1`
`0cd3 : 9a [ 2] txs ;sp=01`	`0ecb : 9a [ 2] txs ;sp=01`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0cd4 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0ecc : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0cd6 : 48 [ 3]> pha ;use stack to load status`	`0ece : 48 [ 3]> pha ;use stack to load status`
`0cd7 : 28 [ 4]> plp`	`0ecf : 28 [ 4]> plp`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 70`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`0cd8 : ba [ 2] tsx ;clears Z, N`	`0ed0 : ba [ 2] tsx ;clears Z, N`
`0cd9 : 08 [ 3] php ;sp=00`	`0ed1 : 08 [ 3] php ;sp=00`
`0cda : e001 [ 2] cpx #1`	`0ed2 : e001 [ 2] cpx #1`
`trap_ne`	`trap_ne`
`0cdc : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ed4 : f002 [ 3]> beq skip0793`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ed6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ed7 : 0e > db test_num`
	`>`
	`0ed8 : >skip0793`

`0cde : ad0101 [ 4] lda $101`	`0ed8 : ad0101 [ 4] lda $101`
`cmp_flag 0`	`cmp_flag 0`
`0ce1 : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`	`0edb : c930 [ 2]> cmp #(0\|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`0ce3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0edd : f002 [ 3]> beq skip0796`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 121`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0edf : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ee0 : 0e > db test_num`
	`>`
	`0ee1 : >skip0796`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0ce5 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0ee1 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0ce7 : 48 [ 3]> pha ;use stack to load status`	`0ee3 : 48 [ 3]> pha ;use stack to load status`
`0ce8 : 28 [ 4]> plp`	`0ee4 : 28 [ 4]> plp`

`0ce9 : ba [ 2] tsx ;clears N, sets Z`	`0ee5 : ba [ 2] tsx ;clears N, sets Z`
`0cea : 08 [ 3] php ;sp=ff`	`0ee6 : 08 [ 3] php ;sp=ff`
`0ceb : e000 [ 2] cpx #0`	`0ee7 : e000 [ 2] cpx #0`
`trap_ne`	`trap_ne`
`0ced : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ee9 : f002 [ 3]> beq skip0800`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0eeb : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0eec : 0e > db test_num`
	`>`
	`0eed : >skip0800`

`0cef : ad0001 [ 4] lda $100`	`0eed : ad0001 [ 4] lda $100`
`cmp_flag zero`	`cmp_flag zero`
`0cf2 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`	`0ef0 : c932 [ 2]> cmp #(zero\|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`0cf4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ef2 : f002 [ 3]> beq skip0803`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0ef4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0ef5 : 0e > db test_num`
	`>`
	`0ef6 : >skip0803`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0cf6 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0ef6 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0cf8 : 48 [ 3]> pha ;use stack to load status`	`0ef8 : 48 [ 3]> pha ;use stack to load status`
`0cf9 : 28 [ 4]> plp`	`0ef9 : 28 [ 4]> plp`

`0cfa : ba [ 2] tsx ;clears N, sets Z`	`0efa : ba [ 2] tsx ;clears N, sets Z`
`0cfb : 08 [ 3] php ;sp=fe`	`0efb : 08 [ 3] php ;sp=fe`
`0cfc : e0ff [ 2] cpx #$ff`	`0efc : e0ff [ 2] cpx #$ff`
`trap_ne`	`trap_ne`
`0cfe : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0efe : f002 [ 4]> beq skip0807`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0f00 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0f01 : 0e > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 122`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0f02 : >skip0807`

`0d00 : adff01 [ 4] lda $1ff`	`0f02 : adff01 [ 4] lda $1ff`
`cmp_flag minus`	`cmp_flag minus`
`0d03 : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`	`0f05 : c9b0 [ 2]> cmp #(minus\|fao)&m8 ;expected flags + always on bits`

`trap_ne`	`trap_ne`
`0d05 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0f07 : f002 [ 3]> beq skip0810`
	`> trap ;failed equal (zero)`
`0d07 : 68 [ 4] pla ;sp=ff`	`>; db $db ; M65C02/M65C02A SToP instruction`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 71`	`0f09 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`0f0a : 0e > db test_num`
	`>`
	`0f0b : >skip0810`

	`0f0b : 68 [ 4] pla ;sp=ff`
`next_test`	`next_test`
`0d08 : ad0002 [ 4]> lda test_case ;previous test`	`0f0c : ad0002 [ 4]> lda test_case ;previous test`
`0d0b : c90e [ 2]> cmp #test_num`	`0f0f : c90e [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`0d0d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0f11 : f002 [ 3]> beq skip0813`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0f13 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0f14 : 0e > db test_num`
	`>`
	`0f15 : >skip0813`
`>`	`>`
`000f = >test_num = test_num + 1`	`000f = >test_num = test_num + 1`
`0d0f : a90f [ 2]> lda #test_num ;*** this tests' number`	`0f15 : a90f [ 2]> lda #test_num ;*** this tests' number`
`0d11 : 8d0002 [ 4]> sta test_case`	`0f17 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; testing index register load & store LDY LDX STY STX all addressing modes`	`; testing index register load & store LDY LDX STY STX all addressing modes`
`; LDX / STX - zp,y / abs,y`	`; LDX / STX - zp,y / abs,y`
`0d14 : a003 [ 2] ldy #3`
`0d16 : tldx`	`0f1a : a003 [ 2] ldy #3`
	`0f1c : tldx`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0d16 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0f1c : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0d18 : 48 [ 3]> pha ;use stack to load status`	`0f1e : 48 [ 3]> pha ;use stack to load status`
`0d19 : 28 [ 4]> plp`	`0f1f : 28 [ 4]> plp`

	`0f20 : b6b9 [ 4] ldx zp1,y`
	`0f22 : 08 [ 3] php ;test stores do not alter flags`
	`0f23 : 8a [ 2] txa`
	`0f24 : 49c3 [ 2] eor #$c3`
	`0f26 : 28 [ 4] plp`
	`0f27 : 990302 [ 5] sta abst,y`
	`0f2a : 08 [ 3] php ;flags after load/store sequence`
	`0f2b : 49c3 [ 2] eor #$c3`
	`0f2d : d90802 [ 4] cmp abs1,y ;test result`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 123`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0d1a : b613 [ 4] ldx zp1,y`
`0d1c : 08 [ 3] php ;test stores do not alter flags`
`0d1d : 8a [ 2] txa`
`0d1e : 49c3 [ 2] eor #$c3`
`0d20 : 28 [ 4] plp`
`0d21 : 990302 [ 5] sta abst,y`
`0d24 : 08 [ 3] php ;flags after load/store sequence`
`0d25 : 49c3 [ 2] eor #$c3`
`0d27 : d90802 [ 4] cmp abs1,y ;test result`
`trap_ne`	`trap_ne`
`0d2a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0f30 : f002 [ 3]> beq skip0817`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0f32 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0f33 : 0f > db test_num`
	`>`
	`0f34 : >skip0817`

`0d2c : 68 [ 4] pla ;load status`	`0f34 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`0d2d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`0f35 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`0d2f : d90d02 [ 4] cmp fLDx,y ;test flags`	`0f37 : d90d02 [ 4] cmp fLDx,y ;test flags`
`trap_ne`	`trap_ne`
`0d32 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0f3a : f002 [ 3]> beq skip0820`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0f3c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0f3d : 0f > db test_num`
	`>`
	`0f3e : >skip0820`

`0d34 : 88 [ 2] dey`	`0f3e : 88 [ 2] dey`
`0d35 : 10df [ 3] bpl tldx`	`0f3f : 10db [ 3] bpl tldx`

`0d37 : a003 [ 2] ldy #3`	`0f41 : a003 [ 2] ldy #3`
`0d39 : tldx1`	`0f43 : tldx1`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0d39 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0f43 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0d3b : 48 [ 3]> pha ;use stack to load status`	`0f45 : 48 [ 3]> pha ;use stack to load status`
`0d3c : 28 [ 4]> plp`	`0f46 : 28 [ 4]> plp`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 72`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0d3d : b613 [ 4] ldx zp1,y`	`0f47 : b6b9 [ 4] ldx zp1,y`
`0d3f : 08 [ 3] php ;test stores do not alter flags`	`0f49 : 08 [ 3] php ;test stores do not alter flags`
`0d40 : 8a [ 2] txa`	`0f4a : 8a [ 2] txa`
`0d41 : 49c3 [ 2] eor #$c3`	`0f4b : 49c3 [ 2] eor #$c3`
`0d43 : 28 [ 4] plp`	`0f4d : 28 [ 4] plp`
`0d44 : 990302 [ 5] sta abst,y`	`0f4e : 990302 [ 5] sta abst,y`
`0d47 : 08 [ 3] php ;flags after load/store sequence`	`0f51 : 08 [ 3] php ;flags after load/store sequence`
`0d48 : 49c3 [ 2] eor #$c3`	`0f52 : 49c3 [ 2] eor #$c3`
`0d4a : d90802 [ 4] cmp abs1,y ;test result`	`0f54 : d90802 [ 4] cmp abs1,y ;test result`
`trap_ne`	`trap_ne`
`0d4d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0f57 : f002 [ 3]> beq skip0824`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0f59 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0f5a : 0f > db test_num`
	`>`
	`0f5b : >skip0824`

`0d4f : 68 [ 4] pla ;load status`	`0f5b : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`0d50 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 124`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0d52 : d90d02 [ 4] cmp fLDx,y ;test flags`	`0f5c : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

	`0f5e : d90d02 [ 4] cmp fLDx,y ;test flags`
`trap_ne`	`trap_ne`
`0d55 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0f61 : f002 [ 3]> beq skip0827`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0f63 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0f64 : 0f > db test_num`
	`>`
	`0f65 : >skip0827`

`0d57 : 88 [ 2] dey`	`0f65 : 88 [ 2] dey`
`0d58 : 10df [ 3] bpl tldx1`	`0f66 : 10db [ 3] bpl tldx1`

`0d5a : a003 [ 2] ldy #3`	`0f68 : a003 [ 2] ldy #3`
`0d5c : tldx2`	`0f6a : tldx2`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0d5c : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`0f6a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0d5e : 48 [ 3]> pha ;use stack to load status`	`0f6c : 48 [ 3]> pha ;use stack to load status`
`0d5f : 28 [ 4]> plp`	`0f6d : 28 [ 4]> plp`

`0d60 : be0802 [ 4] ldx abs1,y`	`0f6e : be0802 [ 4] ldx abs1,y`
`0d63 : 08 [ 3] php ;test stores do not alter flags`	`0f71 : 08 [ 3] php ;test stores do not alter flags`
`0d64 : 8a [ 2] txa`	`0f72 : 8a [ 2] txa`
`0d65 : 49c3 [ 2] eor #$c3`	`0f73 : 49c3 [ 2] eor #$c3`
`0d67 : aa [ 2] tax`	`0f75 : aa [ 2] tax`
`0d68 : 28 [ 4] plp`	`0f76 : 28 [ 4] plp`
`0d69 : 960c [ 4] stx zpt,y`	`0f77 : 96b2 [ 4] stx zpt,y`
`0d6b : 08 [ 3] php ;flags after load/store sequence`	`0f79 : 08 [ 3] php ;flags after load/store sequence`
`0d6c : 49c3 [ 2] eor #$c3`	`0f7a : 49c3 [ 2] eor #$c3`
`0d6e : d91300 [ 4] cmp zp1,y ;test result`	`0f7c : d9b900 [ 4] cmp zp1,y ;test result`
`trap_ne`	`trap_ne`
`0d71 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0f7f : f002 [ 3]> beq skip0831`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0f81 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0f82 : 0f > db test_num`
	`>`
	`0f83 : >skip0831`

`0d73 : 68 [ 4] pla ;load status`	`0f83 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`0d74 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`0f84 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`0d76 : d90d02 [ 4] cmp fLDx,y ;test flags`	`0f86 : d90d02 [ 4] cmp fLDx,y ;test flags`
`trap_ne`	`trap_ne`
`0d79 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0f89 : f002 [ 3]> beq skip0834`
	`> trap ;failed equal (zero)`
`0d7b : 88 [ 2] dey`	`>; db $db ; M65C02/M65C02A SToP instruction`
`0d7c : 10de [ 3] bpl tldx2`	`0f8b : 00 [ 7]> brk ; Use BRK to return to the monitor`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 73`	`0f8c : 0f > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 125`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`0f8d : >skip0834`

`0d7e : a003 [ 2] ldy #3`	`0f8d : 88 [ 2] dey`
`0d80 : tldx3`	`0f8e : 10da [ 3] bpl tldx2`

	`0f90 : a003 [ 2] ldy #3`
	`0f92 : tldx3`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0d80 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`0f92 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0d82 : 48 [ 3]> pha ;use stack to load status`	`0f94 : 48 [ 3]> pha ;use stack to load status`
`0d83 : 28 [ 4]> plp`	`0f95 : 28 [ 4]> plp`

`0d84 : be0802 [ 4] ldx abs1,y`	`0f96 : be0802 [ 4] ldx abs1,y`
`0d87 : 08 [ 3] php ;test stores do not alter flags`	`0f99 : 08 [ 3] php ;test stores do not alter flags`
`0d88 : 8a [ 2] txa`	`0f9a : 8a [ 2] txa`
`0d89 : 49c3 [ 2] eor #$c3`	`0f9b : 49c3 [ 2] eor #$c3`
`0d8b : aa [ 2] tax`	`0f9d : aa [ 2] tax`
`0d8c : 28 [ 4] plp`	`0f9e : 28 [ 4] plp`
`0d8d : 960c [ 4] stx zpt,y`	`0f9f : 96b2 [ 4] stx zpt,y`
`0d8f : 08 [ 3] php ;flags after load/store sequence`	`0fa1 : 08 [ 3] php ;flags after load/store sequence`
`0d90 : 49c3 [ 2] eor #$c3`	`0fa2 : 49c3 [ 2] eor #$c3`
`0d92 : d91300 [ 4] cmp zp1,y ;test result`	`0fa4 : d9b900 [ 4] cmp zp1,y ;test result`
`trap_ne`	`trap_ne`
`0d95 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0fa7 : f002 [ 3]> beq skip0838`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0fa9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0faa : 0f > db test_num`
	`>`
	`0fab : >skip0838`

`0d97 : 68 [ 4] pla ;load status`	`0fab : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`0d98 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`0fac : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`0d9a : d90d02 [ 4] cmp fLDx,y ;test flags`	`0fae : d90d02 [ 4] cmp fLDx,y ;test flags`
`trap_ne`	`trap_ne`
`0d9d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0fb1 : f002 [ 3]> beq skip0841`
	`> trap ;failed equal (zero)`
`0d9f : 88 [ 2] dey`	`>; db $db ; M65C02/M65C02A SToP instruction`
`0da0 : 10de [ 3] bpl tldx3`	`0fb3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0fb4 : 0f > db test_num`
	`>`
	`0fb5 : >skip0841`

	`0fb5 : 88 [ 2] dey`
	`0fb6 : 10da [ 3] bpl tldx3`

	`0fb8 : a003 [ 2] ldy #3 ;testing store result`
	`0fba : a200 [ 2] ldx #0`
	`0fbc : b9b200 [ 4] tstx lda zpt,y`
	`0fbf : 49c3 [ 2] eor #$c3`
	`0fc1 : d9b900 [ 4] cmp zp1,y`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 126`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0da2 : a003 [ 2] ldy #3 ;testing store result`
`0da4 : a200 [ 2] ldx #0`
`0da6 : b90c00 [ 4] tstx lda zpt,y`
`0da9 : 49c3 [ 2] eor #$c3`
`0dab : d91300 [ 4] cmp zp1,y`
`trap_ne ;store to zp data`	`trap_ne ;store to zp data`
`0dae : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0fc4 : f002 [ 3]> beq skip0843`
	`> trap ;failed equal (zero)`
`0db0 : 960c [ 4] stx zpt,y ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`0db2 : b90302 [ 4] lda abst,y`	`0fc6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`0db5 : 49c3 [ 2] eor #$c3`	`0fc7 : 0f > db test_num`
`0db7 : d90802 [ 4] cmp abs1,y`	`>`
	`0fc8 : >skip0843`

	`0fc8 : 96b2 [ 4] stx zpt,y ;clear`
	`0fca : b90302 [ 4] lda abst,y`
	`0fcd : 49c3 [ 2] eor #$c3`
	`0fcf : d90802 [ 4] cmp abs1,y`
`trap_ne ;store to abs data`	`trap_ne ;store to abs data`
`0dba : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0fd2 : f002 [ 3]> beq skip0845`
	`> trap ;failed equal (zero)`
`0dbc : 8a [ 2] txa`	`>; db $db ; M65C02/M65C02A SToP instruction`
`0dbd : 990302 [ 5] sta abst,y ;clear`	`0fd4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`0dc0 : 88 [ 2] dey`	`0fd5 : 0f > db test_num`
`0dc1 : 10e3 [ 3] bpl tstx`	`>`
	`0fd6 : >skip0845`

	`0fd6 : 8a [ 2] txa`
	`0fd7 : 990302 [ 5] sta abst,y ;clear`
	`0fda : 88 [ 2] dey`
	`0fdb : 10df [ 3] bpl tstx`
`next_test`	`next_test`
`0dc3 : ad0002 [ 4]> lda test_case ;previous test`	`0fdd : ad0002 [ 4]> lda test_case ;previous test`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 74`	`0fe0 : c90f [ 2]> cmp #test_num`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0dc6 : c90f [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`0dc8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0fe2 : f002 [ 3]> beq skip0848`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`0fe4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`0fe5 : 0f > db test_num`
	`>`
	`0fe6 : >skip0848`
`>`	`>`
`0010 = >test_num = test_num + 1`	`0010 = >test_num = test_num + 1`
`0dca : a910 [ 2]> lda #test_num ;*** this tests' number`	`0fe6 : a910 [ 2]> lda #test_num ;*** this tests' number`
`0dcc : 8d0002 [ 4]> sta test_case`	`0fe8 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; indexed wraparound test (only zp should wrap)`	`; indexed wraparound test (only zp should wrap)`
`0dcf : a0fd [ 2] ldy #3+$fa`
`0dd1 : b619 [ 4] tldx4 ldx zp1-$fa&$ff,y ;wrap on indexed zp`
`0dd3 : 8a [ 2] txa`
`0dd4 : 990901 [ 5] sta abst-$fa,y ;no STX abs,y!`
`0dd7 : 88 [ 2] dey`
`0dd8 : c0fa [ 2] cpy #$fa`
`0dda : b0f5 [ 3] bcs tldx4`
`0ddc : a0fd [ 2] ldy #3+$fa`
`0dde : be0e01 [ 4] tldx5 ldx abs1-$fa,y ;no wrap on indexed abs`
`0de1 : 9612 [ 4] stx zpt-$fa&$ff,y`
`0de3 : 88 [ 2] dey`
`0de4 : c0fa [ 2] cpy #$fa`
`0de6 : b0f6 [ 3] bcs tldx5`
`0de8 : a003 [ 2] ldy #3 ;testing wraparound result`
`0dea : a200 [ 2] ldx #0`
`0dec : b90c00 [ 4] tstx1 lda zpt,y`
`0def : d91300 [ 4] cmp zp1,y`
`trap_ne ;store to zp data`
`0df2 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`0df4 : 960c [ 4] stx zpt,y ;clear`	`0feb : a0fd [ 2] ldy #3+$fa`
`0df6 : b90302 [ 4] lda abst,y`	`0fed : b6bf [ 4] tldx4 ldx zp1-$fa&$ff,y ;wrap on indexed zp`
`0df9 : d90802 [ 4] cmp abs1,y`	`0fef : 8a [ 2] txa`
`trap_ne ;store to abs data`	`0ff0 : 990901 [ 5] sta abst-$fa,y ;no STX abs,y!`
`0dfc : d0fe [ 3]> bne * ;failed not equal (non zero)`	`0ff3 : 88 [ 2] dey`
	`0ff4 : c0fa [ 2] cpy #$fa`
	`0ff6 : b0f5 [ 3] bcs tldx4`
	`0ff8 : a0fd [ 2] ldy #3+$fa`
	`0ffa : be0e01 [ 4] tldx5 ldx abs1-$fa,y ;no wrap on indexed abs`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 127`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0dfe : 8a [ 2] txa`	`0ffd : 96b8 [ 4] stx zpt-$fa&$ff,y`
`0dff : 990302 [ 5] sta abst,y ;clear`	`0fff : 88 [ 2] dey`
`0e02 : 88 [ 2] dey`	`1000 : c0fa [ 2] cpy #$fa`
`0e03 : 10e7 [ 4] bpl tstx1`	`1002 : b0f6 [ 4] bcs tldx5`
	`1004 : a003 [ 2] ldy #3 ;testing wraparound result`
	`1006 : a200 [ 2] ldx #0`
	`1008 : b9b200 [ 4] tstx1 lda zpt,y`
	`100b : d9b900 [ 4] cmp zp1,y`
	`trap_ne ;store to zp data`
	`100e : f002 [ 3]> beq skip0850`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1010 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1011 : 10 > db test_num`
	`>`
	`1012 : >skip0850`

	`1012 : 96b2 [ 4] stx zpt,y ;clear`
	`1014 : b90302 [ 4] lda abst,y`
	`1017 : d90802 [ 4] cmp abs1,y`
	`trap_ne ;store to abs data`
	`101a : f002 [ 3]> beq skip0852`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`101c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`101d : 10 > db test_num`
	`>`
	`101e : >skip0852`

	`101e : 8a [ 2] txa`
	`101f : 990302 [ 5] sta abst,y ;clear`
	`1022 : 88 [ 2] dey`
	`1023 : 10e3 [ 3] bpl tstx1`
`next_test`	`next_test`
`0e05 : ad0002 [ 4]> lda test_case ;previous test`	`1025 : ad0002 [ 4]> lda test_case ;previous test`
`0e08 : c910 [ 2]> cmp #test_num`	`1028 : c910 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`0e0a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`102a : f002 [ 3]> beq skip0855`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`102c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`102d : 10 > db test_num`
	`>`
	`102e : >skip0855`
`>`	`>`
`0011 = >test_num = test_num + 1`	`0011 = >test_num = test_num + 1`
`0e0c : a911 [ 2]> lda #test_num ;*** this tests' number`	`102e : a911 [ 2]> lda #test_num ;*** this tests' number`
`0e0e : 8d0002 [ 4]> sta test_case`	`1030 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; LDY / STY - zp,x / abs,x`	`; LDY / STY - zp,x / abs,x`
`0e11 : a203 [ 2] ldx #3`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 75`	`1033 : a203 [ 2] ldx #3`
	`1035 : tldy`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 128`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0e13 : tldy`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0e13 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1035 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0e15 : 48 [ 3]> pha ;use stack to load status`	`1037 : 48 [ 3]> pha ;use stack to load status`
`0e16 : 28 [ 4]> plp`	`1038 : 28 [ 4]> plp`

`0e17 : b413 [ 4] ldy zp1,x`	`1039 : b4b9 [ 4] ldy zp1,x`
`0e19 : 08 [ 3] php ;test stores do not alter flags`	`103b : 08 [ 3] php ;test stores do not alter flags`
`0e1a : 98 [ 2] tya`	`103c : 98 [ 2] tya`
`0e1b : 49c3 [ 2] eor #$c3`	`103d : 49c3 [ 2] eor #$c3`
`0e1d : 28 [ 4] plp`	`103f : 28 [ 4] plp`
`0e1e : 9d0302 [ 5] sta abst,x`	`1040 : 9d0302 [ 5] sta abst,x`
`0e21 : 08 [ 3] php ;flags after load/store sequence`	`1043 : 08 [ 3] php ;flags after load/store sequence`
`0e22 : 49c3 [ 2] eor #$c3`	`1044 : 49c3 [ 2] eor #$c3`
`0e24 : dd0802 [ 4] cmp abs1,x ;test result`	`1046 : dd0802 [ 4] cmp abs1,x ;test result`
`trap_ne`	`trap_ne`
`0e27 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1049 : f002 [ 3]> beq skip0859`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`104b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`104c : 11 > db test_num`
	`>`
	`104d : >skip0859`

`0e29 : 68 [ 4] pla ;load status`	`104d : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`0e2a : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`104e : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`0e2c : dd0d02 [ 4] cmp fLDx,x ;test flags`	`1050 : dd0d02 [ 4] cmp fLDx,x ;test flags`
`trap_ne`	`trap_ne`
`0e2f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1053 : f002 [ 3]> beq skip0862`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1055 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1056 : 11 > db test_num`
	`>`
	`1057 : >skip0862`

`0e31 : ca [ 2] dex`	`1057 : ca [ 2] dex`
`0e32 : 10df [ 3] bpl tldy`	`1058 : 10db [ 3] bpl tldy`

`0e34 : a203 [ 2] ldx #3`	`105a : a203 [ 2] ldx #3`
`0e36 : tldy1`	`105c : tldy1`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0e36 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`105c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0e38 : 48 [ 3]> pha ;use stack to load status`	`105e : 48 [ 3]> pha ;use stack to load status`
`0e39 : 28 [ 4]> plp`	`105f : 28 [ 4]> plp`

`0e3a : b413 [ 4] ldy zp1,x`	`1060 : b4b9 [ 4] ldy zp1,x`
`0e3c : 08 [ 3] php ;test stores do not alter flags`	`1062 : 08 [ 3] php ;test stores do not alter flags`
`0e3d : 98 [ 2] tya`	`1063 : 98 [ 2] tya`
`0e3e : 49c3 [ 2] eor #$c3`	`1064 : 49c3 [ 2] eor #$c3`
`0e40 : 28 [ 4] plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 129`
`0e41 : 9d0302 [ 5] sta abst,x`
`0e44 : 08 [ 3] php ;flags after load/store sequence`
`0e45 : 49c3 [ 2] eor #$c3`
`0e47 : dd0802 [ 4] cmp abs1,x ;test result`
`trap_ne`
`0e4a : d0fe [ 3]> bne * ;failed not equal (non zero)`

`0e4c : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`
`0e4d : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 76`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1066 : 28 [ 4] plp`
	`1067 : 9d0302 [ 5] sta abst,x`
	`106a : 08 [ 3] php ;flags after load/store sequence`
	`106b : 49c3 [ 2] eor #$c3`
	`106d : dd0802 [ 4] cmp abs1,x ;test result`
	`trap_ne`
	`1070 : f002 [ 3]> beq skip0866`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1072 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1073 : 11 > db test_num`
	`>`
	`1074 : >skip0866`

	`1074 : 68 [ 4] pla ;load status`
	`eor_flag lo~fnz ;mask bits not altered`
	`1075 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`0e4f : dd0d02 [ 4] cmp fLDx,x ;test flags`	`1077 : dd0d02 [ 4] cmp fLDx,x ;test flags`
`trap_ne`	`trap_ne`
`0e52 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`107a : f002 [ 3]> beq skip0869`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`107c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`107d : 11 > db test_num`
	`>`
	`107e : >skip0869`

`0e54 : ca [ 2] dex`	`107e : ca [ 2] dex`
`0e55 : 10df [ 3] bpl tldy1`	`107f : 10db [ 3] bpl tldy1`

`0e57 : a203 [ 2] ldx #3`	`1081 : a203 [ 2] ldx #3`
`0e59 : tldy2`	`1083 : tldy2`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0e59 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1083 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0e5b : 48 [ 3]> pha ;use stack to load status`	`1085 : 48 [ 3]> pha ;use stack to load status`
`0e5c : 28 [ 4]> plp`	`1086 : 28 [ 4]> plp`

`0e5d : bc0802 [ 4] ldy abs1,x`	`1087 : bc0802 [ 4] ldy abs1,x`
`0e60 : 08 [ 3] php ;test stores do not alter flags`	`108a : 08 [ 3] php ;test stores do not alter flags`
`0e61 : 98 [ 2] tya`	`108b : 98 [ 2] tya`
`0e62 : 49c3 [ 2] eor #$c3`	`108c : 49c3 [ 2] eor #$c3`
`0e64 : a8 [ 2] tay`	`108e : a8 [ 2] tay`
`0e65 : 28 [ 4] plp`	`108f : 28 [ 4] plp`
`0e66 : 940c [ 4] sty zpt,x`	`1090 : 94b2 [ 4] sty zpt,x`
`0e68 : 08 [ 3] php ;flags after load/store sequence`	`1092 : 08 [ 3] php ;flags after load/store sequence`
`0e69 : 49c3 [ 2] eor #$c3`	`1093 : 49c3 [ 2] eor #$c3`
`0e6b : d513 [ 4] cmp zp1,x ;test result`	`1095 : d5b9 [ 4] cmp zp1,x ;test result`
`trap_ne`	`trap_ne`
`0e6d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1097 : f002 [ 3]> beq skip0873`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1099 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 130`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`109a : 11 > db test_num`
	`>`
	`109b : >skip0873`

`0e6f : 68 [ 4] pla ;load status`	`109b : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`0e70 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`109c : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`0e72 : dd0d02 [ 4] cmp fLDx,x ;test flags`	`109e : dd0d02 [ 4] cmp fLDx,x ;test flags`
`trap_ne`	`trap_ne`
`0e75 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`10a1 : f002 [ 3]> beq skip0876`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`10a3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`10a4 : 11 > db test_num`
	`>`
	`10a5 : >skip0876`

`0e77 : ca [ 2] dex`	`10a5 : ca [ 2] dex`
`0e78 : 10df [ 3] bpl tldy2`	`10a6 : 10db [ 3] bpl tldy2`

`0e7a : a203 [ 2] ldx #3`	`10a8 : a203 [ 2] ldx #3`
`0e7c : tldy3`	`10aa : tldy3`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0e7c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`10aa : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0e7e : 48 [ 3]> pha ;use stack to load status`	`10ac : 48 [ 3]> pha ;use stack to load status`
`0e7f : 28 [ 4]> plp`	`10ad : 28 [ 4]> plp`

`0e80 : bc0802 [ 4] ldy abs1,x`
`0e83 : 08 [ 3] php ;test stores do not alter flags`
`0e84 : 98 [ 2] tya`
`0e85 : 49c3 [ 2] eor #$c3`
`0e87 : a8 [ 2] tay`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 77`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0e88 : 28 [ 4] plp`	`10ae : bc0802 [ 4] ldy abs1,x`
`0e89 : 940c [ 4] sty zpt,x`	`10b1 : 08 [ 3] php ;test stores do not alter flags`
`0e8b : 08 [ 3] php ;flags after load/store sequence`	`10b2 : 98 [ 2] tya`
`0e8c : 49c3 [ 2] eor #$c3`	`10b3 : 49c3 [ 2] eor #$c3`
`0e8e : d513 [ 4] cmp zp1,x ;test result`	`10b5 : a8 [ 2] tay`
`trap_ne`	`10b6 : 28 [ 4] plp`
`0e90 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`10b7 : 94b2 [ 4] sty zpt,x`
	`10b9 : 08 [ 3] php ;flags after load/store sequence`
	`10ba : 49c3 [ 2] eor #$c3`
	`10bc : d5b9 [ 4] cmp zp1,x ;test result`
	`trap_ne`
	`10be : f002 [ 3]> beq skip0880`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`10c0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`10c1 : 11 > db test_num`
	`>`
	`10c2 : >skip0880`

`0e92 : 68 [ 4] pla ;load status`	`10c2 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`0e93 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`10c3 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`0e95 : dd0d02 [ 4] cmp fLDx,x ;test flags`	`10c5 : dd0d02 [ 4] cmp fLDx,x ;test flags`
`trap_ne`	`trap_ne`
`0e98 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 131`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`0e9a : ca [ 2] dex`
`0e9b : 10df [ 3] bpl tldy3`

`0e9d : a203 [ 2] ldx #3 ;testing store result`	`10c8 : f002 [ 3]> beq skip0883`
`0e9f : a000 [ 2] ldy #0`	`> trap ;failed equal (zero)`
`0ea1 : b50c [ 4] tsty lda zpt,x`	`>; db $db ; M65C02/M65C02A SToP instruction`
`0ea3 : 49c3 [ 2] eor #$c3`	`10ca : 00 [ 7]> brk ; Use BRK to return to the monitor`
`0ea5 : d513 [ 4] cmp zp1,x`	`10cb : 11 > db test_num`
	`>`
	`10cc : >skip0883`

	`10cc : ca [ 2] dex`
	`10cd : 10db [ 3] bpl tldy3`

	`10cf : a203 [ 2] ldx #3 ;testing store result`
	`10d1 : a000 [ 2] ldy #0`
	`10d3 : b5b2 [ 4] tsty lda zpt,x`
	`10d5 : 49c3 [ 2] eor #$c3`
	`10d7 : d5b9 [ 4] cmp zp1,x`
`trap_ne ;store to zp,x data`	`trap_ne ;store to zp,x data`
`0ea7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`10d9 : f002 [ 3]> beq skip0885`
	`> trap ;failed equal (zero)`
`0ea9 : 940c [ 4] sty zpt,x ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`0eab : bd0302 [ 4] lda abst,x`	`10db : 00 [ 7]> brk ; Use BRK to return to the monitor`
`0eae : 49c3 [ 2] eor #$c3`	`10dc : 11 > db test_num`
`0eb0 : dd0802 [ 4] cmp abs1,x`	`>`
	`10dd : >skip0885`

	`10dd : 94b2 [ 4] sty zpt,x ;clear`
	`10df : bd0302 [ 4] lda abst,x`
	`10e2 : 49c3 [ 2] eor #$c3`
	`10e4 : dd0802 [ 4] cmp abs1,x`
`trap_ne ;store to abs,x data`	`trap_ne ;store to abs,x data`
`0eb3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`10e7 : f002 [ 3]> beq skip0887`
	`> trap ;failed equal (zero)`
`0eb5 : 8a [ 2] txa`	`>; db $db ; M65C02/M65C02A SToP instruction`
`0eb6 : 9d0302 [ 5] sta abst,x ;clear`	`10e9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`0eb9 : ca [ 2] dex`	`10ea : 11 > db test_num`
`0eba : 10e5 [ 3] bpl tsty`	`>`
	`10eb : >skip0887`

	`10eb : 8a [ 2] txa`
	`10ec : 9d0302 [ 5] sta abst,x ;clear`
	`10ef : ca [ 2] dex`
	`10f0 : 10e1 [ 3] bpl tsty`
`next_test`	`next_test`
`0ebc : ad0002 [ 4]> lda test_case ;previous test`	`10f2 : ad0002 [ 4]> lda test_case ;previous test`
`0ebf : c911 [ 2]> cmp #test_num`	`10f5 : c911 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`0ec1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`10f7 : f002 [ 3]> beq skip0890`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`10f9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`10fa : 11 > db test_num`
	`>`
	`10fb : >skip0890`
`>`	`>`
`0012 = >test_num = test_num + 1`	`0012 = >test_num = test_num + 1`
`0ec3 : a912 [ 2]> lda #test_num ;*** this tests' number`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 132`
`0ec5 : 8d0002 [ 4]> sta test_case`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`10fb : a912 [ 2]> lda #test_num ;*** this tests' number`
	`10fd : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; indexed wraparound test (only zp should wrap)`	`; indexed wraparound test (only zp should wrap)`
`0ec8 : a2fd [ 2] ldx #3+$fa`
`0eca : b419 [ 4] tldy4 ldy zp1-$fa&$ff,x ;wrap on indexed zp`
`0ecc : 98 [ 2] tya`
`0ecd : 9d0901 [ 5] sta abst-$fa,x ;no STX abs,x!`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 78`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0ed0 : ca [ 2] dex`	`1100 : a2fd [ 2] ldx #3+$fa`
`0ed1 : e0fa [ 2] cpx #$fa`	`1102 : b4bf [ 4] tldy4 ldy zp1-$fa&$ff,x ;wrap on indexed zp`
`0ed3 : b0f5 [ 3] bcs tldy4`	`1104 : 98 [ 2] tya`
`0ed5 : a2fd [ 2] ldx #3+$fa`	`1105 : 9d0901 [ 5] sta abst-$fa,x ;no STX abs,x!`
`0ed7 : bc0e01 [ 4] tldy5 ldy abs1-$fa,x ;no wrap on indexed abs`	`1108 : ca [ 2] dex`
`0eda : 9412 [ 4] sty zpt-$fa&$ff,x`	`1109 : e0fa [ 2] cpx #$fa`
`0edc : ca [ 2] dex`	`110b : b0f5 [ 3] bcs tldy4`
`0edd : e0fa [ 2] cpx #$fa`	`110d : a2fd [ 2] ldx #3+$fa`
`0edf : b0f6 [ 3] bcs tldy5`	`110f : bc0e01 [ 4] tldy5 ldy abs1-$fa,x ;no wrap on indexed abs`
`0ee1 : a203 [ 2] ldx #3 ;testing wraparound result`	`1112 : 94b8 [ 4] sty zpt-$fa&$ff,x`
`0ee3 : a000 [ 2] ldy #0`	`1114 : ca [ 2] dex`
`0ee5 : b50c [ 4] tsty1 lda zpt,x`	`1115 : e0fa [ 2] cpx #$fa`
`0ee7 : d513 [ 4] cmp zp1,x`	`1117 : b0f6 [ 3] bcs tldy5`
	`1119 : a203 [ 2] ldx #3 ;testing wraparound result`
	`111b : a000 [ 2] ldy #0`
	`111d : b5b2 [ 4] tsty1 lda zpt,x`
	`111f : d5b9 [ 4] cmp zp1,x`
`trap_ne ;store to zp,x data`	`trap_ne ;store to zp,x data`
`0ee9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1121 : f002 [ 3]> beq skip0892`
	`> trap ;failed equal (zero)`
`0eeb : 940c [ 4] sty zpt,x ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`0eed : bd0302 [ 4] lda abst,x`	`1123 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`0ef0 : dd0802 [ 4] cmp abs1,x`	`1124 : 12 > db test_num`
	`>`
	`1125 : >skip0892`

	`1125 : 94b2 [ 4] sty zpt,x ;clear`
	`1127 : bd0302 [ 4] lda abst,x`
	`112a : dd0802 [ 4] cmp abs1,x`
`trap_ne ;store to abs,x data`	`trap_ne ;store to abs,x data`
`0ef3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`112d : f002 [ 3]> beq skip0894`
	`> trap ;failed equal (zero)`
`0ef5 : 8a [ 2] txa`	`>; db $db ; M65C02/M65C02A SToP instruction`
`0ef6 : 9d0302 [ 5] sta abst,x ;clear`	`112f : 00 [ 7]> brk ; Use BRK to return to the monitor`
`0ef9 : ca [ 2] dex`	`1130 : 12 > db test_num`
`0efa : 10e9 [ 3] bpl tsty1`	`>`
	`1131 : >skip0894`

	`1131 : 8a [ 2] txa`
	`1132 : 9d0302 [ 5] sta abst,x ;clear`
	`1135 : ca [ 2] dex`
	`1136 : 10e5 [ 3] bpl tsty1`
`next_test`	`next_test`
`0efc : ad0002 [ 4]> lda test_case ;previous test`	`1138 : ad0002 [ 4]> lda test_case ;previous test`
`0eff : c912 [ 2]> cmp #test_num`	`113b : c912 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`0f01 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`113d : f002 [ 3]> beq skip0897`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 133`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>; db $db ; M65C02/M65C02A SToP instruction`
	`113f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1140 : 12 > db test_num`
	`>`
	`1141 : >skip0897`
`>`	`>`
`0013 = >test_num = test_num + 1`	`0013 = >test_num = test_num + 1`
`0f03 : a913 [ 2]> lda #test_num ;*** this tests' number`	`1141 : a913 [ 2]> lda #test_num ;*** this tests' number`
`0f05 : 8d0002 [ 4]> sta test_case`	`1143 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; LDX / STX - zp / abs / #`	`; LDX / STX - zp / abs / #`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0f08 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1146 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0f0a : 48 [ 3]> pha ;use stack to load status`	`1148 : 48 [ 3]> pha ;use stack to load status`
`0f0b : 28 [ 4]> plp`	`1149 : 28 [ 4]> plp`

`0f0c : a613 [ 3] ldx zp1`
`0f0e : 08 [ 3] php ;test stores do not alter flags`
`0f0f : 8a [ 2] txa`
`0f10 : 49c3 [ 2] eor #$c3`
`0f12 : aa [ 2] tax`
`0f13 : 28 [ 4] plp`
`0f14 : 8e0302 [ 4] stx abst`
`0f17 : 08 [ 3] php ;flags after load/store sequence`
`0f18 : 49c3 [ 2] eor #$c3`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 79`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0f1a : aa [ 2] tax`	`114a : a6b9 [ 3] ldx zp1`
`0f1b : e0c3 [ 2] cpx #$c3 ;test result`	`114c : 08 [ 3] php ;test stores do not alter flags`
`trap_ne`	`114d : 8a [ 2] txa`
`0f1d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`114e : 49c3 [ 2] eor #$c3`
	`1150 : aa [ 2] tax`
	`1151 : 28 [ 4] plp`
	`1152 : 8e0302 [ 4] stx abst`
	`1155 : 08 [ 3] php ;flags after load/store sequence`
	`1156 : 49c3 [ 2] eor #$c3`
	`1158 : aa [ 2] tax`
	`1159 : e0c3 [ 2] cpx #$c3 ;test result`
	`trap_ne`
	`115b : f002 [ 3]> beq skip0901`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`115d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`115e : 13 > db test_num`
	`>`
	`115f : >skip0901`

`0f1f : 68 [ 4] pla ;load status`	`115f : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`0f20 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1160 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`0f22 : cd0d02 [ 4] cmp fLDx ;test flags`	`1162 : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`0f25 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1165 : f002 [ 3]> beq skip0904`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1167 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1168 : 13 > db test_num`
	`>`
	`1169 : >skip0904`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 134`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0f27 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1169 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0f29 : 48 [ 3]> pha ;use stack to load status`	`116b : 48 [ 3]> pha ;use stack to load status`
`0f2a : 28 [ 4]> plp`	`116c : 28 [ 4]> plp`

`0f2b : a614 [ 3] ldx zp1+1`	`116d : a6ba [ 3] ldx zp1+1`
`0f2d : 08 [ 3] php ;test stores do not alter flags`	`116f : 08 [ 3] php ;test stores do not alter flags`
`0f2e : 8a [ 2] txa`	`1170 : 8a [ 2] txa`
`0f2f : 49c3 [ 2] eor #$c3`	`1171 : 49c3 [ 2] eor #$c3`
`0f31 : aa [ 2] tax`	`1173 : aa [ 2] tax`
`0f32 : 28 [ 4] plp`	`1174 : 28 [ 4] plp`
`0f33 : 8e0402 [ 4] stx abst+1`	`1175 : 8e0402 [ 4] stx abst+1`
`0f36 : 08 [ 3] php ;flags after load/store sequence`	`1178 : 08 [ 3] php ;flags after load/store sequence`
`0f37 : 49c3 [ 2] eor #$c3`	`1179 : 49c3 [ 2] eor #$c3`
`0f39 : aa [ 2] tax`	`117b : aa [ 2] tax`
`0f3a : e082 [ 2] cpx #$82 ;test result`	`117c : e082 [ 2] cpx #$82 ;test result`
`trap_ne`	`trap_ne`
`0f3c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`117e : f002 [ 3]> beq skip0908`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1180 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1181 : 13 > db test_num`
	`>`
	`1182 : >skip0908`

`0f3e : 68 [ 4] pla ;load status`	`1182 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`0f3f : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1183 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`0f41 : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1185 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`0f44 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1188 : f002 [ 3]> beq skip0911`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`118a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`118b : 13 > db test_num`
	`>`
	`118c : >skip0911`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0f46 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`118c : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0f48 : 48 [ 3]> pha ;use stack to load status`	`118e : 48 [ 3]> pha ;use stack to load status`
`0f49 : 28 [ 4]> plp`	`118f : 28 [ 4]> plp`

`0f4a : a615 [ 3] ldx zp1+2`	`1190 : a6bb [ 3] ldx zp1+2`
`0f4c : 08 [ 3] php ;test stores do not alter flags`	`1192 : 08 [ 3] php ;test stores do not alter flags`
`0f4d : 8a [ 2] txa`	`1193 : 8a [ 2] txa`
`0f4e : 49c3 [ 2] eor #$c3`	`1194 : 49c3 [ 2] eor #$c3`
`0f50 : aa [ 2] tax`	`1196 : aa [ 2] tax`
`0f51 : 28 [ 4] plp`	`1197 : 28 [ 4] plp`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 80`	`1198 : 8e0502 [ 4] stx abst+2`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 135`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0f52 : 8e0502 [ 4] stx abst+2`	`119b : 08 [ 3] php ;flags after load/store sequence`
`0f55 : 08 [ 3] php ;flags after load/store sequence`	`119c : 49c3 [ 2] eor #$c3`
`0f56 : 49c3 [ 2] eor #$c3`	`119e : aa [ 2] tax`
`0f58 : aa [ 2] tax`	`119f : e041 [ 2] cpx #$41 ;test result`
`0f59 : e041 [ 2] cpx #$41 ;test result`	`trap_ne`
`trap_ne`	`11a1 : f002 [ 3]> beq skip0915`
`0f5b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`11a3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`11a4 : 13 > db test_num`
	`>`
	`11a5 : >skip0915`

`0f5d : 68 [ 4] pla ;load status`	`11a5 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`0f5e : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`11a6 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`0f60 : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`11a8 : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`0f63 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`11ab : f002 [ 3]> beq skip0918`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`11ad : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`11ae : 13 > db test_num`
	`>`
	`11af : >skip0918`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`0f65 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`11af : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`0f67 : 48 [ 3]> pha ;use stack to load status`	`11b1 : 48 [ 3]> pha ;use stack to load status`
`0f68 : 28 [ 4]> plp`	`11b2 : 28 [ 4]> plp`

`0f69 : a616 [ 3] ldx zp1+3`	`11b3 : a6bc [ 3] ldx zp1+3`
`0f6b : 08 [ 3] php ;test stores do not alter flags`	`11b5 : 08 [ 3] php ;test stores do not alter flags`
`0f6c : 8a [ 2] txa`	`11b6 : 8a [ 2] txa`
`0f6d : 49c3 [ 2] eor #$c3`	`11b7 : 49c3 [ 2] eor #$c3`
`0f6f : aa [ 2] tax`	`11b9 : aa [ 2] tax`
`0f70 : 28 [ 4] plp`	`11ba : 28 [ 4] plp`
`0f71 : 8e0602 [ 4] stx abst+3`	`11bb : 8e0602 [ 4] stx abst+3`
`0f74 : 08 [ 3] php ;flags after load/store sequence`	`11be : 08 [ 3] php ;flags after load/store sequence`
`0f75 : 49c3 [ 2] eor #$c3`	`11bf : 49c3 [ 2] eor #$c3`
`0f77 : aa [ 2] tax`	`11c1 : aa [ 2] tax`
`0f78 : e000 [ 2] cpx #0 ;test result`	`11c2 : e000 [ 2] cpx #0 ;test result`
`trap_ne`	`trap_ne`
`0f7a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`11c4 : f002 [ 3]> beq skip0922`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`11c6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`11c7 : 13 > db test_num`
	`>`
	`11c8 : >skip0922`

	`11c8 : 68 [ 4] pla ;load status`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 136`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0f7c : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`0f7d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`11c9 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`0f7f : cd1002 [ 4] cmp fLDx+3 ;test flags`	`11cb : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`0f82 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`11ce : f002 [ 3]> beq skip0925`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`11d0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`11d1 : 13 > db test_num`
	`>`
	`11d2 : >skip0925`


`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0f84 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`11d2 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0f86 : 48 [ 3]> pha ;use stack to load status`	`11d4 : 48 [ 3]> pha ;use stack to load status`
`0f87 : 28 [ 4]> plp`	`11d5 : 28 [ 4]> plp`

`0f88 : a613 [ 3] ldx zp1`	`11d6 : a6b9 [ 3] ldx zp1`
`0f8a : 08 [ 3] php ;test stores do not alter flags`	`11d8 : 08 [ 3] php ;test stores do not alter flags`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 81`	`11d9 : 8a [ 2] txa`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`11da : 49c3 [ 2] eor #$c3`
	`11dc : aa [ 2] tax`
`0f8b : 8a [ 2] txa`	`11dd : 28 [ 4] plp`
`0f8c : 49c3 [ 2] eor #$c3`	`11de : 8e0302 [ 4] stx abst`
`0f8e : aa [ 2] tax`	`11e1 : 08 [ 3] php ;flags after load/store sequence`
`0f8f : 28 [ 4] plp`	`11e2 : 49c3 [ 2] eor #$c3`
`0f90 : 8e0302 [ 4] stx abst`	`11e4 : aa [ 2] tax`
`0f93 : 08 [ 3] php ;flags after load/store sequence`	`11e5 : e0c3 [ 2] cpx #$c3 ;test result`
`0f94 : 49c3 [ 2] eor #$c3`
`0f96 : aa [ 2] tax`
`0f97 : e0c3 [ 2] cpx #$c3 ;test result`
`trap_ne ;`	`trap_ne ;`
`0f99 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`11e7 : f002 [ 3]> beq skip0929`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`11e9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`11ea : 13 > db test_num`
	`>`
	`11eb : >skip0929`

`0f9b : 68 [ 4] pla ;load status`	`11eb : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`0f9c : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`11ec : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`0f9e : cd0d02 [ 4] cmp fLDx ;test flags`	`11ee : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`0fa1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`11f1 : f002 [ 3]> beq skip0932`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`11f3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`11f4 : 13 > db test_num`
	`>`
	`11f5 : >skip0932`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 137`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0fa3 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`11f5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0fa5 : 48 [ 3]> pha ;use stack to load status`	`11f7 : 48 [ 3]> pha ;use stack to load status`
`0fa6 : 28 [ 4]> plp`	`11f8 : 28 [ 4]> plp`

`0fa7 : a614 [ 3] ldx zp1+1`	`11f9 : a6ba [ 3] ldx zp1+1`
`0fa9 : 08 [ 3] php ;test stores do not alter flags`	`11fb : 08 [ 3] php ;test stores do not alter flags`
`0faa : 8a [ 2] txa`	`11fc : 8a [ 2] txa`
`0fab : 49c3 [ 2] eor #$c3`	`11fd : 49c3 [ 2] eor #$c3`
`0fad : aa [ 2] tax`	`11ff : aa [ 2] tax`
`0fae : 28 [ 4] plp`	`1200 : 28 [ 4] plp`
`0faf : 8e0402 [ 4] stx abst+1`	`1201 : 8e0402 [ 4] stx abst+1`
`0fb2 : 08 [ 3] php ;flags after load/store sequence`	`1204 : 08 [ 3] php ;flags after load/store sequence`
`0fb3 : 49c3 [ 2] eor #$c3`	`1205 : 49c3 [ 2] eor #$c3`
`0fb5 : aa [ 2] tax`	`1207 : aa [ 2] tax`
`0fb6 : e082 [ 2] cpx #$82 ;test result`	`1208 : e082 [ 2] cpx #$82 ;test result`
`trap_ne`	`trap_ne`
`0fb8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`120a : f002 [ 3]> beq skip0936`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`120c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`120d : 13 > db test_num`
	`>`
	`120e : >skip0936`

`0fba : 68 [ 4] pla ;load status`	`120e : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`0fbb : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`120f : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`0fbd : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1211 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`0fc0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1214 : f002 [ 3]> beq skip0939`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1216 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1217 : 13 > db test_num`
	`>`
	`1218 : >skip0939`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0fc2 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1218 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0fc4 : 48 [ 3]> pha ;use stack to load status`	`121a : 48 [ 3]> pha ;use stack to load status`
`0fc5 : 28 [ 4]> plp`	`121b : 28 [ 4]> plp`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 82`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`121c : a6bb [ 3] ldx zp1+2`
	`121e : 08 [ 3] php ;test stores do not alter flags`
	`121f : 8a [ 2] txa`
	`1220 : 49c3 [ 2] eor #$c3`
	`1222 : aa [ 2] tax`
	`1223 : 28 [ 4] plp`
	`1224 : 8e0502 [ 4] stx abst+2`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 138`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0fc6 : a615 [ 3] ldx zp1+2`	`1227 : 08 [ 3] php ;flags after load/store sequence`
`0fc8 : 08 [ 3] php ;test stores do not alter flags`	`1228 : 49c3 [ 2] eor #$c3`
`0fc9 : 8a [ 2] txa`	`122a : aa [ 2] tax`
`0fca : 49c3 [ 2] eor #$c3`	`122b : e041 [ 2] cpx #$41 ;test result`
`0fcc : aa [ 2] tax`
`0fcd : 28 [ 4] plp`
`0fce : 8e0502 [ 4] stx abst+2`
`0fd1 : 08 [ 3] php ;flags after load/store sequence`
`0fd2 : 49c3 [ 2] eor #$c3`
`0fd4 : aa [ 2] tax`
`0fd5 : e041 [ 2] cpx #$41 ;test result`
`trap_ne ;`	`trap_ne ;`
`0fd7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`122d : f002 [ 3]> beq skip0943`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`122f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1230 : 13 > db test_num`
	`>`
	`1231 : >skip0943`

`0fd9 : 68 [ 4] pla ;load status`	`1231 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`0fda : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1232 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`0fdc : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`1234 : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`0fdf : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1237 : f002 [ 3]> beq skip0946`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1239 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`123a : 13 > db test_num`
	`>`
	`123b : >skip0946`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`0fe1 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`123b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`0fe3 : 48 [ 3]> pha ;use stack to load status`	`123d : 48 [ 3]> pha ;use stack to load status`
`0fe4 : 28 [ 4]> plp`	`123e : 28 [ 4]> plp`

`0fe5 : a616 [ 3] ldx zp1+3`	`123f : a6bc [ 3] ldx zp1+3`
`0fe7 : 08 [ 3] php ;test stores do not alter flags`	`1241 : 08 [ 3] php ;test stores do not alter flags`
`0fe8 : 8a [ 2] txa`	`1242 : 8a [ 2] txa`
`0fe9 : 49c3 [ 2] eor #$c3`	`1243 : 49c3 [ 2] eor #$c3`
`0feb : aa [ 2] tax`	`1245 : aa [ 2] tax`
`0fec : 28 [ 4] plp`	`1246 : 28 [ 4] plp`
`0fed : 8e0602 [ 4] stx abst+3`	`1247 : 8e0602 [ 4] stx abst+3`
`0ff0 : 08 [ 3] php ;flags after load/store sequence`	`124a : 08 [ 3] php ;flags after load/store sequence`
`0ff1 : 49c3 [ 2] eor #$c3`	`124b : 49c3 [ 2] eor #$c3`
`0ff3 : aa [ 2] tax`	`124d : aa [ 2] tax`
`0ff4 : e000 [ 2] cpx #0 ;test result`	`124e : e000 [ 2] cpx #0 ;test result`
`trap_ne`	`trap_ne`
`0ff6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1250 : f002 [ 3]> beq skip0950`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1252 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1253 : 13 > db test_num`
	`>`
	`1254 : >skip0950`

	`1254 : 68 [ 4] pla ;load status`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 139`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`0ff8 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`0ff9 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1255 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`0ffb : cd1002 [ 4] cmp fLDx+3 ;test flags`	`1257 : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`0ffe : d0fe [ 3]> bne * ;failed not equal (non zero)`	`125a : f002 [ 3]> beq skip0953`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`125c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`125d : 13 > db test_num`
	`>`
	`125e : >skip0953`


`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 83`	`125e : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1000 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1002 : 48 [ 3]> pha ;use stack to load status`	`1260 : 48 [ 3]> pha ;use stack to load status`
`1003 : 28 [ 4]> plp`	`1261 : 28 [ 4]> plp`

`1004 : ae0802 [ 4] ldx abs1`	`1262 : ae0802 [ 4] ldx abs1`
`1007 : 08 [ 3] php ;test stores do not alter flags`	`1265 : 08 [ 3] php ;test stores do not alter flags`
`1008 : 8a [ 2] txa`	`1266 : 8a [ 2] txa`
`1009 : 49c3 [ 2] eor #$c3`	`1267 : 49c3 [ 2] eor #$c3`
`100b : aa [ 2] tax`	`1269 : aa [ 2] tax`
`100c : 28 [ 4] plp`	`126a : 28 [ 4] plp`
`100d : 860c [ 3] stx zpt`	`126b : 86b2 [ 3] stx zpt`
`100f : 08 [ 3] php ;flags after load/store sequence`	`126d : 08 [ 3] php ;flags after load/store sequence`
`1010 : 49c3 [ 2] eor #$c3`	`126e : 49c3 [ 2] eor #$c3`
`1012 : c513 [ 3] cmp zp1 ;test result`	`1270 : c5b9 [ 3] cmp zp1 ;test result`
`trap_ne`	`trap_ne`
`1014 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1272 : f002 [ 3]> beq skip0957`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1274 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1275 : 13 > db test_num`
	`>`
	`1276 : >skip0957`

`1016 : 68 [ 4] pla ;load status`	`1276 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1017 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1277 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1019 : cd0d02 [ 4] cmp fLDx ;test flags`	`1279 : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`101c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`127c : f002 [ 3]> beq skip0960`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`127e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`127f : 13 > db test_num`
	`>`
	`1280 : >skip0960`

`set_stat 0`	`set_stat 0`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 140`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag 0`	`> load_flag 0`
`101e : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1280 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1020 : 48 [ 3]> pha ;use stack to load status`	`1282 : 48 [ 3]> pha ;use stack to load status`
`1021 : 28 [ 4]> plp`	`1283 : 28 [ 4]> plp`

`1022 : ae0902 [ 4] ldx abs1+1`	`1284 : ae0902 [ 4] ldx abs1+1`
`1025 : 08 [ 3] php ;test stores do not alter flags`	`1287 : 08 [ 3] php ;test stores do not alter flags`
`1026 : 8a [ 2] txa`	`1288 : 8a [ 2] txa`
`1027 : 49c3 [ 2] eor #$c3`	`1289 : 49c3 [ 2] eor #$c3`
`1029 : aa [ 2] tax`	`128b : aa [ 2] tax`
`102a : 28 [ 4] plp`	`128c : 28 [ 4] plp`
`102b : 860d [ 3] stx zpt+1`	`128d : 86b3 [ 3] stx zpt+1`
`102d : 08 [ 3] php ;flags after load/store sequence`	`128f : 08 [ 3] php ;flags after load/store sequence`
`102e : 49c3 [ 2] eor #$c3`	`1290 : 49c3 [ 2] eor #$c3`
`1030 : c514 [ 3] cmp zp1+1 ;test result`	`1292 : c5ba [ 3] cmp zp1+1 ;test result`
`trap_ne`	`trap_ne`
`1032 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1294 : f002 [ 3]> beq skip0964`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1296 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1297 : 13 > db test_num`
	`>`
	`1298 : >skip0964`

`1034 : 68 [ 4] pla ;load status`	`1298 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1035 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1299 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1037 : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`129b : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`103a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`129e : f002 [ 3]> beq skip0967`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`12a0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`12a1 : 13 > db test_num`
	`>`
	`12a2 : >skip0967`

`set_stat 0`	`set_stat 0`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 84`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag 0`	`> load_flag 0`
`103c : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`12a2 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`103e : 48 [ 3]> pha ;use stack to load status`	`12a4 : 48 [ 3]> pha ;use stack to load status`
`103f : 28 [ 4]> plp`	`12a5 : 28 [ 4]> plp`

	`12a6 : ae0a02 [ 4] ldx abs1+2`
	`12a9 : 08 [ 3] php ;test stores do not alter flags`
	`12aa : 8a [ 2] txa`
	`12ab : 49c3 [ 2] eor #$c3`
	`12ad : aa [ 2] tax`
	`12ae : 28 [ 4] plp`
	`12af : 86b4 [ 3] stx zpt+2`
	`12b1 : 08 [ 3] php ;flags after load/store sequence`
	`12b2 : 49c3 [ 2] eor #$c3`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 141`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1040 : ae0a02 [ 4] ldx abs1+2`	`12b4 : c5bb [ 3] cmp zp1+2 ;test result`
`1043 : 08 [ 3] php ;test stores do not alter flags`
`1044 : 8a [ 2] txa`
`1045 : 49c3 [ 2] eor #$c3`
`1047 : aa [ 2] tax`
`1048 : 28 [ 4] plp`
`1049 : 860e [ 3] stx zpt+2`
`104b : 08 [ 3] php ;flags after load/store sequence`
`104c : 49c3 [ 2] eor #$c3`
`104e : c515 [ 3] cmp zp1+2 ;test result`
`trap_ne`	`trap_ne`
`1050 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`12b6 : f002 [ 3]> beq skip0971`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`12b8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`12b9 : 13 > db test_num`
	`>`
	`12ba : >skip0971`

`1052 : 68 [ 4] pla ;load status`	`12ba : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1053 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`12bb : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1055 : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`12bd : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`1058 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`12c0 : f002 [ 3]> beq skip0974`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`12c2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`12c3 : 13 > db test_num`
	`>`
	`12c4 : >skip0974`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`105a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`12c4 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`105c : 48 [ 3]> pha ;use stack to load status`	`12c6 : 48 [ 3]> pha ;use stack to load status`
`105d : 28 [ 4]> plp`	`12c7 : 28 [ 4]> plp`

`105e : ae0b02 [ 4] ldx abs1+3`	`12c8 : ae0b02 [ 4] ldx abs1+3`
`1061 : 08 [ 3] php ;test stores do not alter flags`	`12cb : 08 [ 3] php ;test stores do not alter flags`
`1062 : 8a [ 2] txa`	`12cc : 8a [ 2] txa`
`1063 : 49c3 [ 2] eor #$c3`	`12cd : 49c3 [ 2] eor #$c3`
`1065 : aa [ 2] tax`	`12cf : aa [ 2] tax`
`1066 : 28 [ 4] plp`	`12d0 : 28 [ 4] plp`
`1067 : 860f [ 3] stx zpt+3`	`12d1 : 86b5 [ 3] stx zpt+3`
`1069 : 08 [ 3] php ;flags after load/store sequence`	`12d3 : 08 [ 3] php ;flags after load/store sequence`
`106a : 49c3 [ 2] eor #$c3`	`12d4 : 49c3 [ 2] eor #$c3`
`106c : c516 [ 3] cmp zp1+3 ;test result`	`12d6 : c5bc [ 3] cmp zp1+3 ;test result`
`trap_ne`	`trap_ne`
`106e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`12d8 : f002 [ 3]> beq skip0978`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`12da : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`12db : 13 > db test_num`
	`>`
	`12dc : >skip0978`

`1070 : 68 [ 4] pla ;load status`	`12dc : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1071 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`12dd : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1073 : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`
`1076 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 85`	`12df : cd1002 [ 4] cmp fLDx+3 ;test flags`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 142`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`trap_ne`
	`12e2 : f002 [ 3]> beq skip0981`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`12e4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`12e5 : 13 > db test_num`
	`>`
	`12e6 : >skip0981`


`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`1078 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`12e6 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`107a : 48 [ 3]> pha ;use stack to load status`	`12e8 : 48 [ 3]> pha ;use stack to load status`
`107b : 28 [ 4]> plp`	`12e9 : 28 [ 4]> plp`

`107c : ae0802 [ 4] ldx abs1`	`12ea : ae0802 [ 4] ldx abs1`
`107f : 08 [ 3] php ;test stores do not alter flags`	`12ed : 08 [ 3] php ;test stores do not alter flags`
`1080 : 8a [ 2] txa`	`12ee : 8a [ 2] txa`
`1081 : 49c3 [ 2] eor #$c3`	`12ef : 49c3 [ 2] eor #$c3`
`1083 : aa [ 2] tax`	`12f1 : aa [ 2] tax`
`1084 : 28 [ 4] plp`	`12f2 : 28 [ 4] plp`
`1085 : 860c [ 3] stx zpt`	`12f3 : 86b2 [ 3] stx zpt`
`1087 : 08 [ 3] php ;flags after load/store sequence`	`12f5 : 08 [ 3] php ;flags after load/store sequence`
`1088 : 49c3 [ 2] eor #$c3`	`12f6 : 49c3 [ 2] eor #$c3`
`108a : aa [ 2] tax`	`12f8 : aa [ 2] tax`
`108b : e413 [ 3] cpx zp1 ;test result`	`12f9 : e4b9 [ 3] cpx zp1 ;test result`
`trap_ne`	`trap_ne`
`108d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`12fb : f002 [ 3]> beq skip0985`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`12fd : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`12fe : 13 > db test_num`
	`>`
	`12ff : >skip0985`

`108f : 68 [ 4] pla ;load status`	`12ff : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1090 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1300 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1092 : cd0d02 [ 4] cmp fLDx ;test flags`	`1302 : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`1095 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1305 : f002 [ 3]> beq skip0988`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1307 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1308 : 13 > db test_num`
	`>`
	`1309 : >skip0988`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`1097 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1309 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1099 : 48 [ 3]> pha ;use stack to load status`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 143`
`109a : 28 [ 4]> plp`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`109b : ae0902 [ 4] ldx abs1+1`	`130b : 48 [ 3]> pha ;use stack to load status`
`109e : 08 [ 3] php ;test stores do not alter flags`	`130c : 28 [ 4]> plp`
`109f : 8a [ 2] txa`
`10a0 : 49c3 [ 2] eor #$c3`
`10a2 : aa [ 2] tax`
`10a3 : 28 [ 4] plp`
`10a4 : 860d [ 3] stx zpt+1`
`10a6 : 08 [ 3] php ;flags after load/store sequence`
`10a7 : 49c3 [ 2] eor #$c3`
`10a9 : aa [ 2] tax`
`10aa : e414 [ 3] cpx zp1+1 ;test result`
`trap_ne`
`10ac : d0fe [ 3]> bne * ;failed not equal (non zero)`

`10ae : 68 [ 4] pla ;load status`	`130d : ae0902 [ 4] ldx abs1+1`
`eor_flag lo~fnz ;mask bits not altered`	`1310 : 08 [ 3] php ;test stores do not alter flags`
`10af : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1311 : 8a [ 2] txa`
	`1312 : 49c3 [ 2] eor #$c3`
	`1314 : aa [ 2] tax`
	`1315 : 28 [ 4] plp`
	`1316 : 86b3 [ 3] stx zpt+1`
	`1318 : 08 [ 3] php ;flags after load/store sequence`
	`1319 : 49c3 [ 2] eor #$c3`
	`131b : aa [ 2] tax`
	`131c : e4ba [ 3] cpx zp1+1 ;test result`
	`trap_ne`
	`131e : f002 [ 3]> beq skip0992`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1320 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1321 : 13 > db test_num`
	`>`
	`1322 : >skip0992`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 86`	`1322 : 68 [ 4] pla ;load status`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`eor_flag lo~fnz ;mask bits not altered`
	`1323 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`10b1 : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1325 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`10b4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1328 : f002 [ 3]> beq skip0995`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`132a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`132b : 13 > db test_num`
	`>`
	`132c : >skip0995`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`10b6 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`132c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`10b8 : 48 [ 3]> pha ;use stack to load status`	`132e : 48 [ 3]> pha ;use stack to load status`
`10b9 : 28 [ 4]> plp`	`132f : 28 [ 4]> plp`

	`1330 : ae0a02 [ 4] ldx abs1+2`
	`1333 : 08 [ 3] php ;test stores do not alter flags`
	`1334 : 8a [ 2] txa`
	`1335 : 49c3 [ 2] eor #$c3`
	`1337 : aa [ 2] tax`
	`1338 : 28 [ 4] plp`
	`1339 : 86b4 [ 3] stx zpt+2`
	`133b : 08 [ 3] php ;flags after load/store sequence`
	`133c : 49c3 [ 2] eor #$c3`
	`133e : aa [ 2] tax`
	`133f : e4bb [ 3] cpx zp1+2 ;test result`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 144`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`10ba : ae0a02 [ 4] ldx abs1+2`
`10bd : 08 [ 3] php ;test stores do not alter flags`
`10be : 8a [ 2] txa`
`10bf : 49c3 [ 2] eor #$c3`
`10c1 : aa [ 2] tax`
`10c2 : 28 [ 4] plp`
`10c3 : 860e [ 3] stx zpt+2`
`10c5 : 08 [ 3] php ;flags after load/store sequence`
`10c6 : 49c3 [ 2] eor #$c3`
`10c8 : aa [ 2] tax`
`10c9 : e415 [ 3] cpx zp1+2 ;test result`
`trap_ne`	`trap_ne`
`10cb : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1341 : f002 [ 3]> beq skip0999`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1343 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1344 : 13 > db test_num`
	`>`
	`1345 : >skip0999`

`10cd : 68 [ 4] pla ;load status`	`1345 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`10ce : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1346 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`10d0 : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`1348 : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`10d3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`134b : f002 [ 3]> beq skip1002`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`134d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`134e : 13 > db test_num`
	`>`
	`134f : >skip1002`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`10d5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`134f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`10d7 : 48 [ 3]> pha ;use stack to load status`	`1351 : 48 [ 3]> pha ;use stack to load status`
`10d8 : 28 [ 4]> plp`	`1352 : 28 [ 4]> plp`

`10d9 : ae0b02 [ 4] ldx abs1+3`
`10dc : 08 [ 3] php ;test stores do not alter flags`
`10dd : 8a [ 2] txa`
`10de : 49c3 [ 2] eor #$c3`
`10e0 : aa [ 2] tax`
`10e1 : 28 [ 4] plp`
`10e2 : 860f [ 3] stx zpt+3`
`10e4 : 08 [ 3] php ;flags after load/store sequence`
`10e5 : 49c3 [ 2] eor #$c3`
`10e7 : aa [ 2] tax`
`10e8 : e416 [ 3] cpx zp1+3 ;test result`
`trap_ne`
`10ea : d0fe [ 3]> bne * ;failed not equal (non zero)`

`10ec : 68 [ 4] pla ;load status`	`1353 : ae0b02 [ 4] ldx abs1+3`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 87`	`1356 : 08 [ 3] php ;test stores do not alter flags`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`1357 : 8a [ 2] txa`
	`1358 : 49c3 [ 2] eor #$c3`
	`135a : aa [ 2] tax`
	`135b : 28 [ 4] plp`
	`135c : 86b5 [ 3] stx zpt+3`
	`135e : 08 [ 3] php ;flags after load/store sequence`
	`135f : 49c3 [ 2] eor #$c3`
	`1361 : aa [ 2] tax`
	`1362 : e4bc [ 3] cpx zp1+3 ;test result`
	`trap_ne`
	`1364 : f002 [ 3]> beq skip1006`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1366 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1367 : 13 > db test_num`
	`>`
	`1368 : >skip1006`

	`1368 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`10ed : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1369 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

	`136b : cd1002 [ 4] cmp fLDx+3 ;test flags`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 145`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`10ef : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`10f2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`136e : f002 [ 3]> beq skip1009`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1370 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1371 : 13 > db test_num`
	`>`
	`1372 : >skip1009`


`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`10f4 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1372 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`10f6 : 48 [ 3]> pha ;use stack to load status`	`1374 : 48 [ 3]> pha ;use stack to load status`
`10f7 : 28 [ 4]> plp`	`1375 : 28 [ 4]> plp`

`10f8 : a2c3 [ 2] ldx #$c3`	`1376 : a2c3 [ 2] ldx #$c3`
`10fa : 08 [ 3] php`	`1378 : 08 [ 3] php`
`10fb : ec0802 [ 4] cpx abs1 ;test result`	`1379 : ec0802 [ 4] cpx abs1 ;test result`
`trap_ne`	`trap_ne`
`10fe : d0fe [ 3]> bne * ;failed not equal (non zero)`	`137c : f002 [ 3]> beq skip1013`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`137e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`137f : 13 > db test_num`
	`>`
	`1380 : >skip1013`

`1100 : 68 [ 4] pla ;load status`	`1380 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1101 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1381 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1103 : cd0d02 [ 4] cmp fLDx ;test flags`	`1383 : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`1106 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1386 : f002 [ 3]> beq skip1016`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1388 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1389 : 13 > db test_num`
	`>`
	`138a : >skip1016`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1108 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`138a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`110a : 48 [ 3]> pha ;use stack to load status`	`138c : 48 [ 3]> pha ;use stack to load status`
`110b : 28 [ 4]> plp`	`138d : 28 [ 4]> plp`

`110c : a282 [ 2] ldx #$82`	`138e : a282 [ 2] ldx #$82`
`110e : 08 [ 3] php`	`1390 : 08 [ 3] php`
`110f : ec0902 [ 4] cpx abs1+1 ;test result`	`1391 : ec0902 [ 4] cpx abs1+1 ;test result`
`trap_ne`	`trap_ne`
`1112 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1394 : f002 [ 3]> beq skip1020`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 146`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1396 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1397 : 13 > db test_num`
	`>`
	`1398 : >skip1020`

`1114 : 68 [ 4] pla ;load status`	`1398 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1115 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1399 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1117 : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`139b : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`111a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`139e : f002 [ 3]> beq skip1023`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`13a0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`13a1 : 13 > db test_num`
	`>`
	`13a2 : >skip1023`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`111c : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`13a2 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`111e : 48 [ 3]> pha ;use stack to load status`	`13a4 : 48 [ 3]> pha ;use stack to load status`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 88`	`13a5 : 28 [ 4]> plp`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`111f : 28 [ 4]> plp`

`1120 : a241 [ 2] ldx #$41`	`13a6 : a241 [ 2] ldx #$41`
`1122 : 08 [ 3] php`	`13a8 : 08 [ 3] php`
`1123 : ec0a02 [ 4] cpx abs1+2 ;test result`	`13a9 : ec0a02 [ 4] cpx abs1+2 ;test result`
`trap_ne`	`trap_ne`
`1126 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`13ac : f002 [ 3]> beq skip1027`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`13ae : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`13af : 13 > db test_num`
	`>`
	`13b0 : >skip1027`

`1128 : 68 [ 4] pla ;load status`	`13b0 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1129 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`13b1 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`112b : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`13b3 : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`112e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`13b6 : f002 [ 3]> beq skip1030`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`13b8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`13b9 : 13 > db test_num`
	`>`
	`13ba : >skip1030`

`set_stat 0`	`set_stat 0`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 147`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag 0`	`> load_flag 0`
`1130 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`13ba : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1132 : 48 [ 3]> pha ;use stack to load status`	`13bc : 48 [ 3]> pha ;use stack to load status`
`1133 : 28 [ 4]> plp`	`13bd : 28 [ 4]> plp`

`1134 : a200 [ 2] ldx #0`	`13be : a200 [ 2] ldx #0`
`1136 : 08 [ 3] php`	`13c0 : 08 [ 3] php`
`1137 : ec0b02 [ 4] cpx abs1+3 ;test result`	`13c1 : ec0b02 [ 4] cpx abs1+3 ;test result`
`trap_ne`	`trap_ne`
`113a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`13c4 : f002 [ 3]> beq skip1034`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`13c6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`13c7 : 13 > db test_num`
	`>`
	`13c8 : >skip1034`

`113c : 68 [ 4] pla ;load status`	`13c8 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`113d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`13c9 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`113f : cd1002 [ 4] cmp fLDx+3 ;test flags`	`13cb : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`1142 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`13ce : f002 [ 3]> beq skip1037`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`13d0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`13d1 : 13 > db test_num`
	`>`
	`13d2 : >skip1037`


`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`1144 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`13d2 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1146 : 48 [ 3]> pha ;use stack to load status`	`13d4 : 48 [ 3]> pha ;use stack to load status`
`1147 : 28 [ 4]> plp`	`13d5 : 28 [ 4]> plp`

`1148 : a2c3 [ 2] ldx #$c3`	`13d6 : a2c3 [ 2] ldx #$c3`
`114a : 08 [ 3] php`	`13d8 : 08 [ 3] php`
`114b : ec0802 [ 4] cpx abs1 ;test result`	`13d9 : ec0802 [ 4] cpx abs1 ;test result`
`trap_ne`	`trap_ne`
`114e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`13dc : f002 [ 3]> beq skip1041`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`13de : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`13df : 13 > db test_num`
	`>`
	`13e0 : >skip1041`

`1150 : 68 [ 4] pla ;load status`	`13e0 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1151 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`13e1 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 148`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 89`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1153 : cd0d02 [ 4] cmp fLDx ;test flags`
	`13e3 : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`1156 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`13e6 : f002 [ 3]> beq skip1044`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`13e8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`13e9 : 13 > db test_num`
	`>`
	`13ea : >skip1044`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`1158 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`13ea : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`115a : 48 [ 3]> pha ;use stack to load status`	`13ec : 48 [ 3]> pha ;use stack to load status`
`115b : 28 [ 4]> plp`	`13ed : 28 [ 4]> plp`

`115c : a282 [ 2] ldx #$82`	`13ee : a282 [ 2] ldx #$82`
`115e : 08 [ 3] php`	`13f0 : 08 [ 3] php`
`115f : ec0902 [ 4] cpx abs1+1 ;test result`	`13f1 : ec0902 [ 4] cpx abs1+1 ;test result`
`trap_ne`	`trap_ne`
`1162 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`13f4 : f002 [ 3]> beq skip1048`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`13f6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`13f7 : 13 > db test_num`
	`>`
	`13f8 : >skip1048`

`1164 : 68 [ 4] pla ;load status`	`13f8 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1165 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`13f9 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1167 : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`13fb : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`116a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`13fe : f002 [ 4]> beq skip1051`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1400 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1401 : 13 > db test_num`
	`>`
	`1402 : >skip1051`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`116c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1402 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`116e : 48 [ 3]> pha ;use stack to load status`	`1404 : 48 [ 3]> pha ;use stack to load status`
`116f : 28 [ 4]> plp`	`1405 : 28 [ 4]> plp`

`1170 : a241 [ 2] ldx #$41`	`1406 : a241 [ 2] ldx #$41`
`1172 : 08 [ 3] php`	`1408 : 08 [ 3] php`
`1173 : ec0a02 [ 4] cpx abs1+2 ;test result`	`1409 : ec0a02 [ 4] cpx abs1+2 ;test result`
`trap_ne`	`trap_ne`
`1176 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 149`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1178 : 68 [ 4] pla ;load status`	`140c : f002 [ 3]> beq skip1055`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`140e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`140f : 13 > db test_num`
	`>`
	`1410 : >skip1055`

	`1410 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1179 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1411 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`117b : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`1413 : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`117e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1416 : f002 [ 3]> beq skip1058`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1418 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1419 : 13 > db test_num`
	`>`
	`141a : >skip1058`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`1180 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`141a : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1182 : 48 [ 3]> pha ;use stack to load status`	`141c : 48 [ 3]> pha ;use stack to load status`
`1183 : 28 [ 4]> plp`	`141d : 28 [ 4]> plp`

`1184 : a200 [ 2] ldx #0`
`1186 : 08 [ 3] php`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 90`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1187 : ec0b02 [ 4] cpx abs1+3 ;test result`	`141e : a200 [ 2] ldx #0`
	`1420 : 08 [ 3] php`
	`1421 : ec0b02 [ 4] cpx abs1+3 ;test result`
`trap_ne`	`trap_ne`
`118a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1424 : f002 [ 3]> beq skip1062`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1426 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1427 : 13 > db test_num`
	`>`
	`1428 : >skip1062`

`118c : 68 [ 4] pla ;load status`	`1428 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`118d : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1429 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`118f : cd1002 [ 4] cmp fLDx+3 ;test flags`	`142b : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`1192 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`142e : f002 [ 3]> beq skip1065`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1430 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1431 : 13 > db test_num`
	`>`
	`1432 : >skip1065`

`1194 : a200 [ 2] ldx #0`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 150`
`1196 : a50c [ 3] lda zpt`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`1198 : 49c3 [ 2] eor #$c3`
`119a : c513 [ 3] cmp zp1`
`trap_ne ;store to zp data`
`119c : d0fe [ 3]> bne * ;failed not equal (non zero)`

`119e : 860c [ 3] stx zpt ;clear`
`11a0 : ad0302 [ 4] lda abst`
`11a3 : 49c3 [ 2] eor #$c3`
`11a5 : cd0802 [ 4] cmp abs1`
`trap_ne ;store to abs data`
`11a8 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`11aa : 8e0302 [ 4] stx abst ;clear`	`1432 : a200 [ 2] ldx #0`
`11ad : a50d [ 3] lda zpt+1`	`1434 : a5b2 [ 3] lda zpt`
`11af : 49c3 [ 2] eor #$c3`	`1436 : 49c3 [ 2] eor #$c3`
`11b1 : c514 [ 3] cmp zp1+1`	`1438 : c5b9 [ 3] cmp zp1`
`trap_ne ;store to zp data`	`trap_ne ;store to zp data`
`11b3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`143a : f002 [ 3]> beq skip1067`
	`> trap ;failed equal (zero)`
`11b5 : 860d [ 3] stx zpt+1 ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`11b7 : ad0402 [ 4] lda abst+1`	`143c : 00 [ 7]> brk ; Use BRK to return to the monitor`
`11ba : 49c3 [ 2] eor #$c3`	`143d : 13 > db test_num`
`11bc : cd0902 [ 4] cmp abs1+1`	`>`
	`143e : >skip1067`

	`143e : 86b2 [ 3] stx zpt ;clear`
	`1440 : ad0302 [ 4] lda abst`
	`1443 : 49c3 [ 2] eor #$c3`
	`1445 : cd0802 [ 4] cmp abs1`
`trap_ne ;store to abs data`	`trap_ne ;store to abs data`
`11bf : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1448 : f002 [ 3]> beq skip1069`
	`> trap ;failed equal (zero)`
`11c1 : 8e0402 [ 4] stx abst+1 ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`11c4 : a50e [ 3] lda zpt+2`	`144a : 00 [ 7]> brk ; Use BRK to return to the monitor`
`11c6 : 49c3 [ 2] eor #$c3`	`144b : 13 > db test_num`
`11c8 : c515 [ 3] cmp zp1+2`	`>`
	`144c : >skip1069`

	`144c : 8e0302 [ 4] stx abst ;clear`
	`144f : a5b3 [ 3] lda zpt+1`
	`1451 : 49c3 [ 2] eor #$c3`
	`1453 : c5ba [ 3] cmp zp1+1`
`trap_ne ;store to zp data`	`trap_ne ;store to zp data`
`11ca : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1455 : f002 [ 3]> beq skip1071`
	`> trap ;failed equal (zero)`
`11cc : 860e [ 3] stx zpt+2 ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`11ce : ad0502 [ 4] lda abst+2`	`1457 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`11d1 : 49c3 [ 2] eor #$c3`	`1458 : 13 > db test_num`
`11d3 : cd0a02 [ 4] cmp abs1+2`	`>`
	`1459 : >skip1071`

	`1459 : 86b3 [ 3] stx zpt+1 ;clear`
	`145b : ad0402 [ 4] lda abst+1`
	`145e : 49c3 [ 2] eor #$c3`
	`1460 : cd0902 [ 4] cmp abs1+1`
`trap_ne ;store to abs data`	`trap_ne ;store to abs data`
`11d6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1463 : f002 [ 3]> beq skip1073`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1465 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1466 : 13 > db test_num`
	`>`
	`1467 : >skip1073`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 91`	`1467 : 8e0402 [ 4] stx abst+1 ;clear`
	`146a : a5b4 [ 3] lda zpt+2`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 151`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`11d8 : 8e0502 [ 4] stx abst+2 ;clear`	`146c : 49c3 [ 2] eor #$c3`
`11db : a50f [ 3] lda zpt+3`	`146e : c5bb [ 3] cmp zp1+2`
`11dd : 49c3 [ 2] eor #$c3`
`11df : c516 [ 3] cmp zp1+3`
`trap_ne ;store to zp data`	`trap_ne ;store to zp data`
`11e1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1470 : f002 [ 3]> beq skip1075`
	`> trap ;failed equal (zero)`
`11e3 : 860f [ 3] stx zpt+3 ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`11e5 : ad0602 [ 4] lda abst+3`	`1472 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`11e8 : 49c3 [ 2] eor #$c3`	`1473 : 13 > db test_num`
`11ea : cd0b02 [ 4] cmp abs1+3`	`>`
	`1474 : >skip1075`

	`1474 : 86b4 [ 3] stx zpt+2 ;clear`
	`1476 : ad0502 [ 4] lda abst+2`
	`1479 : 49c3 [ 2] eor #$c3`
	`147b : cd0a02 [ 4] cmp abs1+2`
`trap_ne ;store to abs data`	`trap_ne ;store to abs data`
`11ed : d0fe [ 3]> bne * ;failed not equal (non zero)`	`147e : f002 [ 3]> beq skip1077`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1480 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1481 : 13 > db test_num`
	`>`
	`1482 : >skip1077`

	`1482 : 8e0502 [ 4] stx abst+2 ;clear`
	`1485 : a5b5 [ 3] lda zpt+3`
	`1487 : 49c3 [ 2] eor #$c3`
	`1489 : c5bc [ 3] cmp zp1+3`
	`trap_ne ;store to zp data`
	`148b : f002 [ 3]> beq skip1079`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`148d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`148e : 13 > db test_num`
	`>`
	`148f : >skip1079`

	`148f : 86b5 [ 3] stx zpt+3 ;clear`
	`1491 : ad0602 [ 4] lda abst+3`
	`1494 : 49c3 [ 2] eor #$c3`
	`1496 : cd0b02 [ 4] cmp abs1+3`
	`trap_ne ;store to abs data`
	`1499 : f002 [ 3]> beq skip1081`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`149b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`149c : 13 > db test_num`
	`>`
	`149d : >skip1081`

`11ef : 8e0602 [ 4] stx abst+3 ;clear`	`149d : 8e0602 [ 4] stx abst+3 ;clear`
`next_test`	`next_test`
`11f2 : ad0002 [ 4]> lda test_case ;previous test`	`14a0 : ad0002 [ 4]> lda test_case ;previous test`
`11f5 : c913 [ 2]> cmp #test_num`	`14a3 : c913 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`11f7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 152`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`14a5 : f002 [ 3]> beq skip1084`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`14a7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`14a8 : 13 > db test_num`
	`>`
	`14a9 : >skip1084`
`>`	`>`
`0014 = >test_num = test_num + 1`	`0014 = >test_num = test_num + 1`
`11f9 : a914 [ 2]> lda #test_num ;*** this tests' number`	`14a9 : a914 [ 2]> lda #test_num ;*** this tests' number`
`11fb : 8d0002 [ 4]> sta test_case`	`14ab : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; LDY / STY - zp / abs / #`	`; LDY / STY - zp / abs / #`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`11fe : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`14ae : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1200 : 48 [ 3]> pha ;use stack to load status`	`14b0 : 48 [ 3]> pha ;use stack to load status`
`1201 : 28 [ 4]> plp`	`14b1 : 28 [ 4]> plp`

`1202 : a413 [ 3] ldy zp1`	`14b2 : a4b9 [ 3] ldy zp1`
`1204 : 08 [ 3] php ;test stores do not alter flags`	`14b4 : 08 [ 3] php ;test stores do not alter flags`
`1205 : 98 [ 2] tya`	`14b5 : 98 [ 2] tya`
`1206 : 49c3 [ 2] eor #$c3`	`14b6 : 49c3 [ 2] eor #$c3`
`1208 : a8 [ 2] tay`	`14b8 : a8 [ 2] tay`
`1209 : 28 [ 4] plp`	`14b9 : 28 [ 4] plp`
`120a : 8c0302 [ 4] sty abst`	`14ba : 8c0302 [ 4] sty abst`
`120d : 08 [ 3] php ;flags after load/store sequence`	`14bd : 08 [ 3] php ;flags after load/store sequence`
`120e : 49c3 [ 2] eor #$c3`	`14be : 49c3 [ 2] eor #$c3`
`1210 : a8 [ 2] tay`	`14c0 : a8 [ 2] tay`
`1211 : c0c3 [ 2] cpy #$c3 ;test result`	`14c1 : c0c3 [ 2] cpy #$c3 ;test result`
`trap_ne`	`trap_ne`
`1213 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`14c3 : f002 [ 3]> beq skip1088`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`14c5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`14c6 : 14 > db test_num`
	`>`
	`14c7 : >skip1088`

`1215 : 68 [ 4] pla ;load status`	`14c7 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1216 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`14c8 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1218 : cd0d02 [ 4] cmp fLDx ;test flags`	`14ca : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 92`	`14cd : f002 [ 3]> beq skip1091`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`14cf : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`14d0 : 14 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 153`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`121b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`14d1 : >skip1091`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`121d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`14d1 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`121f : 48 [ 3]> pha ;use stack to load status`	`14d3 : 48 [ 3]> pha ;use stack to load status`
`1220 : 28 [ 4]> plp`	`14d4 : 28 [ 4]> plp`

`1221 : a414 [ 3] ldy zp1+1`	`14d5 : a4ba [ 3] ldy zp1+1`
`1223 : 08 [ 3] php ;test stores do not alter flags`	`14d7 : 08 [ 3] php ;test stores do not alter flags`
`1224 : 98 [ 2] tya`	`14d8 : 98 [ 2] tya`
`1225 : 49c3 [ 2] eor #$c3`	`14d9 : 49c3 [ 2] eor #$c3`
`1227 : a8 [ 2] tay`	`14db : a8 [ 2] tay`
`1228 : 28 [ 4] plp`	`14dc : 28 [ 4] plp`
`1229 : 8c0402 [ 4] sty abst+1`	`14dd : 8c0402 [ 4] sty abst+1`
`122c : 08 [ 3] php ;flags after load/store sequence`	`14e0 : 08 [ 3] php ;flags after load/store sequence`
`122d : 49c3 [ 2] eor #$c3`	`14e1 : 49c3 [ 2] eor #$c3`
`122f : a8 [ 2] tay`	`14e3 : a8 [ 2] tay`
`1230 : c082 [ 2] cpy #$82 ;test result`	`14e4 : c082 [ 2] cpy #$82 ;test result`
`trap_ne`	`trap_ne`
`1232 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`14e6 : f002 [ 3]> beq skip1095`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`14e8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`14e9 : 14 > db test_num`
	`>`
	`14ea : >skip1095`

`1234 : 68 [ 4] pla ;load status`	`14ea : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1235 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`14eb : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1237 : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`14ed : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`123a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`14f0 : f002 [ 3]> beq skip1098`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`14f2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`14f3 : 14 > db test_num`
	`>`
	`14f4 : >skip1098`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`123c : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`14f4 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`123e : 48 [ 3]> pha ;use stack to load status`	`14f6 : 48 [ 3]> pha ;use stack to load status`
`123f : 28 [ 4]> plp`	`14f7 : 28 [ 4]> plp`

`1240 : a415 [ 3] ldy zp1+2`	`14f8 : a4bb [ 3] ldy zp1+2`
`1242 : 08 [ 3] php ;test stores do not alter flags`	`14fa : 08 [ 3] php ;test stores do not alter flags`
`1243 : 98 [ 2] tya`	`14fb : 98 [ 2] tya`
`1244 : 49c3 [ 2] eor #$c3`	`14fc : 49c3 [ 2] eor #$c3`
`1246 : a8 [ 2] tay`	`14fe : a8 [ 2] tay`
`1247 : 28 [ 4] plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 154`
`1248 : 8c0502 [ 4] sty abst+2`
`124b : 08 [ 3] php ;flags after load/store sequence`
`124c : 49c3 [ 2] eor #$c3`
`124e : a8 [ 2] tay`
`124f : c041 [ 2] cpy #$41 ;test result`
`trap_ne`
`1251 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`1253 : 68 [ 4] pla ;load status`
`eor_flag 0`
`1254 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 93`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`14ff : 28 [ 4] plp`
	`1500 : 8c0502 [ 4] sty abst+2`
	`1503 : 08 [ 3] php ;flags after load/store sequence`
	`1504 : 49c3 [ 2] eor #$c3`
	`1506 : a8 [ 2] tay`
	`1507 : c041 [ 2] cpy #$41 ;test result`
	`trap_ne`
	`1509 : f002 [ 3]> beq skip1102`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`150b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`150c : 14 > db test_num`
	`>`
	`150d : >skip1102`

	`150d : 68 [ 4] pla ;load status`
	`eor_flag 0`
	`150e : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1256 : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`1510 : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`1259 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1513 : f002 [ 3]> beq skip1105`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1515 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1516 : 14 > db test_num`
	`>`
	`1517 : >skip1105`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`125b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1517 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`125d : 48 [ 3]> pha ;use stack to load status`	`1519 : 48 [ 3]> pha ;use stack to load status`
`125e : 28 [ 4]> plp`	`151a : 28 [ 4]> plp`

	`151b : a4bc [ 3] ldy zp1+3`
	`151d : 08 [ 3] php ;test stores do not alter flags`
	`151e : 98 [ 2] tya`
	`151f : 49c3 [ 2] eor #$c3`
	`1521 : a8 [ 2] tay`
	`1522 : 28 [ 4] plp`
	`1523 : 8c0602 [ 4] sty abst+3`
	`1526 : 08 [ 3] php ;flags after load/store sequence`
	`1527 : 49c3 [ 2] eor #$c3`
	`1529 : a8 [ 2] tay`
	`152a : c000 [ 2] cpy #0 ;test result`
	`trap_ne`
	`152c : f002 [ 3]> beq skip1109`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`152e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`152f : 14 > db test_num`
	`>`
	`1530 : >skip1109`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 155`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`125f : a416 [ 3] ldy zp1+3`
`1261 : 08 [ 3] php ;test stores do not alter flags`
`1262 : 98 [ 2] tya`
`1263 : 49c3 [ 2] eor #$c3`
`1265 : a8 [ 2] tay`
`1266 : 28 [ 4] plp`
`1267 : 8c0602 [ 4] sty abst+3`
`126a : 08 [ 3] php ;flags after load/store sequence`
`126b : 49c3 [ 2] eor #$c3`
`126d : a8 [ 2] tay`
`126e : c000 [ 2] cpy #0 ;test result`
`trap_ne`
`1270 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`1272 : 68 [ 4] pla ;load status`	`1530 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1273 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1531 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1275 : cd1002 [ 4] cmp fLDx+3 ;test flags`	`1533 : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`1278 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1536 : f002 [ 3]> beq skip1112`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1538 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1539 : 14 > db test_num`
	`>`
	`153a : >skip1112`


`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`127a : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`153a : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`127c : 48 [ 3]> pha ;use stack to load status`	`153c : 48 [ 3]> pha ;use stack to load status`
`127d : 28 [ 4]> plp`	`153d : 28 [ 4]> plp`

`127e : a413 [ 3] ldy zp1`
`1280 : 08 [ 3] php ;test stores do not alter flags`
`1281 : 98 [ 2] tya`
`1282 : 49c3 [ 2] eor #$c3`
`1284 : a8 [ 2] tay`
`1285 : 28 [ 4] plp`
`1286 : 8c0302 [ 4] sty abst`
`1289 : 08 [ 3] php ;flags after load/store sequence`
`128a : 49c3 [ 2] eor #$c3`
`128c : a8 [ 2] tay`
`128d : c0c3 [ 2] cpy #$c3 ;test result`
`trap_ne`
`128f : d0fe [ 3]> bne * ;failed not equal (non zero)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 94`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`153e : a4b9 [ 3] ldy zp1`
	`1540 : 08 [ 3] php ;test stores do not alter flags`
	`1541 : 98 [ 2] tya`
	`1542 : 49c3 [ 2] eor #$c3`
	`1544 : a8 [ 2] tay`
	`1545 : 28 [ 4] plp`
	`1546 : 8c0302 [ 4] sty abst`
	`1549 : 08 [ 3] php ;flags after load/store sequence`
	`154a : 49c3 [ 2] eor #$c3`
	`154c : a8 [ 2] tay`
	`154d : c0c3 [ 2] cpy #$c3 ;test result`
	`trap_ne`
	`154f : f002 [ 3]> beq skip1116`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1551 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1552 : 14 > db test_num`
	`>`
	`1553 : >skip1116`

`1291 : 68 [ 4] pla ;load status`	`1553 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1292 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1554 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1294 : cd0d02 [ 4] cmp fLDx ;test flags`	`1556 : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`1297 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1559 : f002 [ 3]> beq skip1119`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`155b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`155c : 14 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 156`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`155d : >skip1119`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`1299 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`155d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`129b : 48 [ 3]> pha ;use stack to load status`	`155f : 48 [ 3]> pha ;use stack to load status`
`129c : 28 [ 4]> plp`	`1560 : 28 [ 4]> plp`

`129d : a414 [ 3] ldy zp1+1`	`1561 : a4ba [ 3] ldy zp1+1`
`129f : 08 [ 3] php ;test stores do not alter flags`	`1563 : 08 [ 3] php ;test stores do not alter flags`
`12a0 : 98 [ 2] tya`	`1564 : 98 [ 2] tya`
`12a1 : 49c3 [ 2] eor #$c3`	`1565 : 49c3 [ 2] eor #$c3`
`12a3 : a8 [ 2] tay`	`1567 : a8 [ 2] tay`
`12a4 : 28 [ 4] plp`	`1568 : 28 [ 4] plp`
`12a5 : 8c0402 [ 4] sty abst+1`	`1569 : 8c0402 [ 4] sty abst+1`
`12a8 : 08 [ 3] php ;flags after load/store sequence`	`156c : 08 [ 3] php ;flags after load/store sequence`
`12a9 : 49c3 [ 2] eor #$c3`	`156d : 49c3 [ 2] eor #$c3`
`12ab : a8 [ 2] tay`	`156f : a8 [ 2] tay`
`12ac : c082 [ 2] cpy #$82 ;test result`	`1570 : c082 [ 2] cpy #$82 ;test result`
`trap_ne`	`trap_ne`
`12ae : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1572 : f002 [ 3]> beq skip1123`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1574 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1575 : 14 > db test_num`
	`>`
	`1576 : >skip1123`

`12b0 : 68 [ 4] pla ;load status`	`1576 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`12b1 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1577 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`12b3 : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1579 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`12b6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`157c : f002 [ 3]> beq skip1126`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`157e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`157f : 14 > db test_num`
	`>`
	`1580 : >skip1126`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`12b8 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1580 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`12ba : 48 [ 3]> pha ;use stack to load status`	`1582 : 48 [ 3]> pha ;use stack to load status`
`12bb : 28 [ 4]> plp`	`1583 : 28 [ 4]> plp`

`12bc : a415 [ 3] ldy zp1+2`	`1584 : a4bb [ 3] ldy zp1+2`
`12be : 08 [ 3] php ;test stores do not alter flags`	`1586 : 08 [ 3] php ;test stores do not alter flags`
`12bf : 98 [ 2] tya`	`1587 : 98 [ 2] tya`
`12c0 : 49c3 [ 2] eor #$c3`	`1588 : 49c3 [ 2] eor #$c3`
`12c2 : a8 [ 2] tay`	`158a : a8 [ 2] tay`
`12c3 : 28 [ 4] plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 157`
`12c4 : 8c0502 [ 4] sty abst+2`
`12c7 : 08 [ 3] php ;flags after load/store sequence`
`12c8 : 49c3 [ 2] eor #$c3`
`12ca : a8 [ 2] tay`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 95`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`12cb : c041 [ 2] cpy #$41 ;test result`	`158b : 28 [ 4] plp`
`trap_ne`	`158c : 8c0502 [ 4] sty abst+2`
`12cd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`158f : 08 [ 3] php ;flags after load/store sequence`
	`1590 : 49c3 [ 2] eor #$c3`
	`1592 : a8 [ 2] tay`
	`1593 : c041 [ 2] cpy #$41 ;test result`
	`trap_ne`
	`1595 : f002 [ 3]> beq skip1130`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1597 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1598 : 14 > db test_num`
	`>`
	`1599 : >skip1130`

`12cf : 68 [ 4] pla ;load status`	`1599 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`12d0 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`159a : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`12d2 : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`159c : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`12d5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`159f : f002 [ 3]> beq skip1133`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`15a1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`15a2 : 14 > db test_num`
	`>`
	`15a3 : >skip1133`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`12d7 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`15a3 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`12d9 : 48 [ 3]> pha ;use stack to load status`	`15a5 : 48 [ 3]> pha ;use stack to load status`
`12da : 28 [ 4]> plp`	`15a6 : 28 [ 4]> plp`

	`15a7 : a4bc [ 3] ldy zp1+3`
	`15a9 : 08 [ 3] php ;test stores do not alter flags`
	`15aa : 98 [ 2] tya`
	`15ab : 49c3 [ 2] eor #$c3`
	`15ad : a8 [ 2] tay`
	`15ae : 28 [ 4] plp`
	`15af : 8c0602 [ 4] sty abst+3`
	`15b2 : 08 [ 3] php ;flags after load/store sequence`
	`15b3 : 49c3 [ 2] eor #$c3`
	`15b5 : a8 [ 2] tay`
	`15b6 : c000 [ 2] cpy #0 ;test result`
	`trap_ne`
	`15b8 : f002 [ 3]> beq skip1137`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`15ba : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`15bb : 14 > db test_num`
	`>`
	`15bc : >skip1137`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 158`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`12db : a416 [ 3] ldy zp1+3`
`12dd : 08 [ 3] php ;test stores do not alter flags`
`12de : 98 [ 2] tya`
`12df : 49c3 [ 2] eor #$c3`
`12e1 : a8 [ 2] tay`
`12e2 : 28 [ 4] plp`
`12e3 : 8c0602 [ 4] sty abst+3`
`12e6 : 08 [ 3] php ;flags after load/store sequence`
`12e7 : 49c3 [ 2] eor #$c3`
`12e9 : a8 [ 2] tay`
`12ea : c000 [ 2] cpy #0 ;test result`
`trap_ne`
`12ec : d0fe [ 3]> bne * ;failed not equal (non zero)`

`12ee : 68 [ 4] pla ;load status`	`15bc : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`12ef : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`15bd : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`12f1 : cd1002 [ 4] cmp fLDx+3 ;test flags`	`15bf : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`12f4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`15c2 : f002 [ 3]> beq skip1140`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`15c4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`15c5 : 14 > db test_num`
	`>`
	`15c6 : >skip1140`


`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`12f6 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`15c6 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`12f8 : 48 [ 3]> pha ;use stack to load status`	`15c8 : 48 [ 3]> pha ;use stack to load status`
`12f9 : 28 [ 4]> plp`	`15c9 : 28 [ 4]> plp`

`12fa : ac0802 [ 4] ldy abs1`
`12fd : 08 [ 3] php ;test stores do not alter flags`
`12fe : 98 [ 2] tya`
`12ff : 49c3 [ 2] eor #$c3`
`1301 : a8 [ 2] tay`
`1302 : 28 [ 4] plp`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 96`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1303 : 840c [ 3] sty zpt`	`15ca : ac0802 [ 4] ldy abs1`
`1305 : 08 [ 3] php ;flags after load/store sequence`	`15cd : 08 [ 3] php ;test stores do not alter flags`
`1306 : 49c3 [ 2] eor #$c3`	`15ce : 98 [ 2] tya`
`1308 : a8 [ 2] tay`	`15cf : 49c3 [ 2] eor #$c3`
`1309 : c413 [ 3] cpy zp1 ;test result`	`15d1 : a8 [ 2] tay`
`trap_ne`	`15d2 : 28 [ 4] plp`
`130b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`15d3 : 84b2 [ 3] sty zpt`
	`15d5 : 08 [ 3] php ;flags after load/store sequence`
	`15d6 : 49c3 [ 2] eor #$c3`
	`15d8 : a8 [ 2] tay`
	`15d9 : c4b9 [ 3] cpy zp1 ;test result`
	`trap_ne`
	`15db : f002 [ 3]> beq skip1144`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`15dd : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`15de : 14 > db test_num`
	`>`
	`15df : >skip1144`

`130d : 68 [ 4] pla ;load status`	`15df : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`130e : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`15e0 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1310 : cd0d02 [ 4] cmp fLDx ;test flags`	`15e2 : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`1313 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`15e5 : f002 [ 3]> beq skip1147`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`15e7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`15e8 : 14 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 159`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`15e9 : >skip1147`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1315 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`15e9 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1317 : 48 [ 3]> pha ;use stack to load status`	`15eb : 48 [ 3]> pha ;use stack to load status`
`1318 : 28 [ 4]> plp`	`15ec : 28 [ 4]> plp`

`1319 : ac0902 [ 4] ldy abs1+1`	`15ed : ac0902 [ 4] ldy abs1+1`
`131c : 08 [ 3] php ;test stores do not alter flags`	`15f0 : 08 [ 3] php ;test stores do not alter flags`
`131d : 98 [ 2] tya`	`15f1 : 98 [ 2] tya`
`131e : 49c3 [ 2] eor #$c3`	`15f2 : 49c3 [ 2] eor #$c3`
`1320 : a8 [ 2] tay`	`15f4 : a8 [ 2] tay`
`1321 : 28 [ 4] plp`	`15f5 : 28 [ 4] plp`
`1322 : 840d [ 3] sty zpt+1`	`15f6 : 84b3 [ 3] sty zpt+1`
`1324 : 08 [ 3] php ;flags after load/store sequence`	`15f8 : 08 [ 3] php ;flags after load/store sequence`
`1325 : 49c3 [ 2] eor #$c3`	`15f9 : 49c3 [ 2] eor #$c3`
`1327 : a8 [ 2] tay`	`15fb : a8 [ 2] tay`
`1328 : c414 [ 3] cpy zp1+1 ;test result`	`15fc : c4ba [ 3] cpy zp1+1 ;test result`
`trap_ne`	`trap_ne`
`132a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`15fe : f002 [ 4]> beq skip1151`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1600 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1601 : 14 > db test_num`
	`>`
	`1602 : >skip1151`

`132c : 68 [ 4] pla ;load status`	`1602 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`132d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1603 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`132f : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1605 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`1332 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1608 : f002 [ 3]> beq skip1154`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`160a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`160b : 14 > db test_num`
	`>`
	`160c : >skip1154`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1334 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`160c : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1336 : 48 [ 3]> pha ;use stack to load status`	`160e : 48 [ 3]> pha ;use stack to load status`
`1337 : 28 [ 4]> plp`	`160f : 28 [ 4]> plp`

`1338 : ac0a02 [ 4] ldy abs1+2`	`1610 : ac0a02 [ 4] ldy abs1+2`
`133b : 08 [ 3] php ;test stores do not alter flags`	`1613 : 08 [ 3] php ;test stores do not alter flags`
`133c : 98 [ 2] tya`	`1614 : 98 [ 2] tya`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 97`	`1615 : 49c3 [ 2] eor #$c3`
	`1617 : a8 [ 2] tay`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 160`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`133d : 49c3 [ 2] eor #$c3`	`1618 : 28 [ 4] plp`
`133f : a8 [ 2] tay`	`1619 : 84b4 [ 3] sty zpt+2`
`1340 : 28 [ 4] plp`	`161b : 08 [ 3] php ;flags after load/store sequence`
`1341 : 840e [ 3] sty zpt+2`	`161c : 49c3 [ 2] eor #$c3`
`1343 : 08 [ 3] php ;flags after load/store sequence`	`161e : a8 [ 2] tay`
`1344 : 49c3 [ 2] eor #$c3`	`161f : c4bb [ 3] cpy zp1+2 ;test result`
`1346 : a8 [ 2] tay`	`trap_ne`
`1347 : c415 [ 3] cpy zp1+2 ;test result`	`1621 : f002 [ 3]> beq skip1158`
`trap_ne`	`> trap ;failed equal (zero)`
`1349 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1623 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1624 : 14 > db test_num`
	`>`
	`1625 : >skip1158`

`134b : 68 [ 4] pla ;load status`	`1625 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`134c : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1626 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`134e : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`1628 : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`1351 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`162b : f002 [ 3]> beq skip1161`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`162d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`162e : 14 > db test_num`
	`>`
	`162f : >skip1161`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1353 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`162f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1355 : 48 [ 3]> pha ;use stack to load status`	`1631 : 48 [ 3]> pha ;use stack to load status`
`1356 : 28 [ 4]> plp`	`1632 : 28 [ 4]> plp`

`1357 : ac0b02 [ 4] ldy abs1+3`	`1633 : ac0b02 [ 4] ldy abs1+3`
`135a : 08 [ 3] php ;test stores do not alter flags`	`1636 : 08 [ 3] php ;test stores do not alter flags`
`135b : 98 [ 2] tya`	`1637 : 98 [ 2] tya`
`135c : 49c3 [ 2] eor #$c3`	`1638 : 49c3 [ 2] eor #$c3`
`135e : a8 [ 2] tay`	`163a : a8 [ 2] tay`
`135f : 28 [ 4] plp`	`163b : 28 [ 4] plp`
`1360 : 840f [ 3] sty zpt+3`	`163c : 84b5 [ 3] sty zpt+3`
`1362 : 08 [ 3] php ;flags after load/store sequence`	`163e : 08 [ 3] php ;flags after load/store sequence`
`1363 : 49c3 [ 2] eor #$c3`	`163f : 49c3 [ 2] eor #$c3`
`1365 : a8 [ 2] tay`	`1641 : a8 [ 2] tay`
`1366 : c416 [ 3] cpy zp1+3 ;test result`	`1642 : c4bc [ 3] cpy zp1+3 ;test result`
`trap_ne`	`trap_ne`
`1368 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1644 : f002 [ 3]> beq skip1165`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1646 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1647 : 14 > db test_num`
	`>`
	`1648 : >skip1165`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 161`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`136a : 68 [ 4] pla ;load status`
	`1648 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`136b : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1649 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`136d : cd1002 [ 4] cmp fLDx+3 ;test flags`	`164b : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`1370 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`164e : f002 [ 3]> beq skip1168`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1650 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1651 : 14 > db test_num`
	`>`
	`1652 : >skip1168`


`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`1372 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1652 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1374 : 48 [ 3]> pha ;use stack to load status`	`1654 : 48 [ 3]> pha ;use stack to load status`
`1375 : 28 [ 4]> plp`	`1655 : 28 [ 4]> plp`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 98`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1656 : ac0802 [ 4] ldy abs1`
	`1659 : 08 [ 3] php ;test stores do not alter flags`
	`165a : 98 [ 2] tya`
	`165b : 49c3 [ 2] eor #$c3`
	`165d : a8 [ 2] tay`
	`165e : 28 [ 4] plp`
	`165f : 84b2 [ 3] sty zpt`
	`1661 : 08 [ 3] php ;flags after load/store sequence`
	`1662 : 49c3 [ 2] eor #$c3`
	`1664 : a8 [ 2] tay`
	`1665 : c5b9 [ 3] cmp zp1 ;test result`
	`trap_ne`
	`1667 : f002 [ 3]> beq skip1172`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1669 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`166a : 14 > db test_num`
	`>`
	`166b : >skip1172`

`1376 : ac0802 [ 4] ldy abs1`	`166b : 68 [ 4] pla ;load status`
`1379 : 08 [ 3] php ;test stores do not alter flags`
`137a : 98 [ 2] tya`
`137b : 49c3 [ 2] eor #$c3`
`137d : a8 [ 2] tay`
`137e : 28 [ 4] plp`
`137f : 840c [ 3] sty zpt`
`1381 : 08 [ 3] php ;flags after load/store sequence`
`1382 : 49c3 [ 2] eor #$c3`
`1384 : a8 [ 2] tay`
`1385 : c513 [ 3] cmp zp1 ;test result`
`trap_ne`
`1387 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`1389 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`138a : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`166c : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`138c : cd0d02 [ 4] cmp fLDx ;test flags`	`166e : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`138f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1671 : f002 [ 3]> beq skip1175`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1673 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1674 : 14 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 162`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1675 : >skip1175`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`1391 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1675 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1393 : 48 [ 3]> pha ;use stack to load status`	`1677 : 48 [ 3]> pha ;use stack to load status`
`1394 : 28 [ 4]> plp`	`1678 : 28 [ 4]> plp`

`1395 : ac0902 [ 4] ldy abs1+1`	`1679 : ac0902 [ 4] ldy abs1+1`
`1398 : 08 [ 3] php ;test stores do not alter flags`	`167c : 08 [ 3] php ;test stores do not alter flags`
`1399 : 98 [ 2] tya`	`167d : 98 [ 2] tya`
`139a : 49c3 [ 2] eor #$c3`	`167e : 49c3 [ 2] eor #$c3`
`139c : a8 [ 2] tay`	`1680 : a8 [ 2] tay`
`139d : 28 [ 4] plp`	`1681 : 28 [ 4] plp`
`139e : 840d [ 3] sty zpt+1`	`1682 : 84b3 [ 3] sty zpt+1`
`13a0 : 08 [ 3] php ;flags after load/store sequence`	`1684 : 08 [ 3] php ;flags after load/store sequence`
`13a1 : 49c3 [ 2] eor #$c3`	`1685 : 49c3 [ 2] eor #$c3`
`13a3 : a8 [ 2] tay`	`1687 : a8 [ 2] tay`
`13a4 : c514 [ 3] cmp zp1+1 ;test result`	`1688 : c5ba [ 3] cmp zp1+1 ;test result`
`trap_ne`	`trap_ne`
`13a6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`168a : f002 [ 3]> beq skip1179`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`168c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`168d : 14 > db test_num`
	`>`
	`168e : >skip1179`

`13a8 : 68 [ 4] pla ;load status`	`168e : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`13a9 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`168f : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`13ab : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1691 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`13ae : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1694 : f002 [ 3]> beq skip1182`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1696 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1697 : 14 > db test_num`
	`>`
	`1698 : >skip1182`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`13b0 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1698 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 99`	`>`
	`169a : 48 [ 3]> pha ;use stack to load status`
	`169b : 28 [ 4]> plp`

	`169c : ac0a02 [ 4] ldy abs1+2`
	`169f : 08 [ 3] php ;test stores do not alter flags`
	`16a0 : 98 [ 2] tya`
	`16a1 : 49c3 [ 2] eor #$c3`
	`16a3 : a8 [ 2] tay`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 163`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`16a4 : 28 [ 4] plp`
	`16a5 : 84b4 [ 3] sty zpt+2`
	`16a7 : 08 [ 3] php ;flags after load/store sequence`
	`16a8 : 49c3 [ 2] eor #$c3`
	`16aa : a8 [ 2] tay`
	`16ab : c5bb [ 3] cmp zp1+2 ;test result`
	`trap_ne`
	`16ad : f002 [ 3]> beq skip1186`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`16af : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`16b0 : 14 > db test_num`
`>`	`>`
`13b2 : 48 [ 3]> pha ;use stack to load status`	`16b1 : >skip1186`
`13b3 : 28 [ 4]> plp`

`13b4 : ac0a02 [ 4] ldy abs1+2`	`16b1 : 68 [ 4] pla ;load status`
`13b7 : 08 [ 3] php ;test stores do not alter flags`
`13b8 : 98 [ 2] tya`
`13b9 : 49c3 [ 2] eor #$c3`
`13bb : a8 [ 2] tay`
`13bc : 28 [ 4] plp`
`13bd : 840e [ 3] sty zpt+2`
`13bf : 08 [ 3] php ;flags after load/store sequence`
`13c0 : 49c3 [ 2] eor #$c3`
`13c2 : a8 [ 2] tay`
`13c3 : c515 [ 3] cmp zp1+2 ;test result`
`trap_ne`
`13c5 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`13c7 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`13c8 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`16b2 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`13ca : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`16b4 : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`13cd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`16b7 : f002 [ 3]> beq skip1189`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`16b9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`16ba : 14 > db test_num`
	`>`
	`16bb : >skip1189`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`13cf : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`16bb : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`13d1 : 48 [ 3]> pha ;use stack to load status`	`16bd : 48 [ 3]> pha ;use stack to load status`
`13d2 : 28 [ 4]> plp`	`16be : 28 [ 4]> plp`

	`16bf : ac0b02 [ 4] ldy abs1+3`
	`16c2 : 08 [ 3] php ;test stores do not alter flags`
	`16c3 : 98 [ 2] tya`
	`16c4 : 49c3 [ 2] eor #$c3`
	`16c6 : a8 [ 2] tay`
	`16c7 : 28 [ 4] plp`
	`16c8 : 84b5 [ 3] sty zpt+3`
	`16ca : 08 [ 3] php ;flags after load/store sequence`
	`16cb : 49c3 [ 2] eor #$c3`
	`16cd : a8 [ 2] tay`
	`16ce : c5bc [ 3] cmp zp1+3 ;test result`
	`trap_ne`
	`16d0 : f002 [ 3]> beq skip1193`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`16d2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`16d3 : 14 > db test_num`
	`>`
	`16d4 : >skip1193`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 164`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`13d3 : ac0b02 [ 4] ldy abs1+3`
`13d6 : 08 [ 3] php ;test stores do not alter flags`
`13d7 : 98 [ 2] tya`
`13d8 : 49c3 [ 2] eor #$c3`
`13da : a8 [ 2] tay`
`13db : 28 [ 4] plp`
`13dc : 840f [ 3] sty zpt+3`
`13de : 08 [ 3] php ;flags after load/store sequence`
`13df : 49c3 [ 2] eor #$c3`
`13e1 : a8 [ 2] tay`
`13e2 : c516 [ 3] cmp zp1+3 ;test result`
`trap_ne`
`13e4 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`13e6 : 68 [ 4] pla ;load status`	`16d4 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`13e7 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`16d5 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`13e9 : cd1002 [ 4] cmp fLDx+3 ;test flags`	`16d7 : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`13ec : d0fe [ 3]> bne * ;failed not equal (non zero)`	`16da : f002 [ 3]> beq skip1196`
	`> trap ;failed equal (zero)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 100`	`>; db $db ; M65C02/M65C02A SToP instruction`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`16dc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`16dd : 14 > db test_num`
	`>`
	`16de : >skip1196`



`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`13ee : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`16de : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`13f0 : 48 [ 3]> pha ;use stack to load status`	`16e0 : 48 [ 3]> pha ;use stack to load status`
`13f1 : 28 [ 4]> plp`	`16e1 : 28 [ 4]> plp`

`13f2 : a0c3 [ 2] ldy #$c3`	`16e2 : a0c3 [ 2] ldy #$c3`
`13f4 : 08 [ 3] php`	`16e4 : 08 [ 3] php`
`13f5 : cc0802 [ 4] cpy abs1 ;test result`	`16e5 : cc0802 [ 4] cpy abs1 ;test result`
`trap_ne`	`trap_ne`
`13f8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`16e8 : f002 [ 3]> beq skip1200`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`16ea : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`16eb : 14 > db test_num`
	`>`
	`16ec : >skip1200`

`13fa : 68 [ 4] pla ;load status`	`16ec : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`13fb : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`16ed : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`13fd : cd0d02 [ 4] cmp fLDx ;test flags`	`16ef : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`1400 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`16f2 : f002 [ 3]> beq skip1203`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`16f4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`16f5 : 14 > db test_num`
	`>`
	`16f6 : >skip1203`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1402 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`16f6 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1404 : 48 [ 3]> pha ;use stack to load status`	`16f8 : 48 [ 3]> pha ;use stack to load status`
`1405 : 28 [ 4]> plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 165`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1406 : a082 [ 2] ldy #$82`	`16f9 : 28 [ 4]> plp`
`1408 : 08 [ 3] php`
`1409 : cc0902 [ 4] cpy abs1+1 ;test result`	`16fa : a082 [ 2] ldy #$82`
	`16fc : 08 [ 3] php`
	`16fd : cc0902 [ 4] cpy abs1+1 ;test result`
`trap_ne`	`trap_ne`
`140c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1700 : f002 [ 3]> beq skip1207`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1702 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1703 : 14 > db test_num`
	`>`
	`1704 : >skip1207`

`140e : 68 [ 4] pla ;load status`	`1704 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`140f : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1705 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1411 : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1707 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`1414 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`170a : f002 [ 3]> beq skip1210`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`170c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`170d : 14 > db test_num`
	`>`
	`170e : >skip1210`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1416 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`170e : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1418 : 48 [ 3]> pha ;use stack to load status`	`1710 : 48 [ 3]> pha ;use stack to load status`
`1419 : 28 [ 4]> plp`	`1711 : 28 [ 4]> plp`

`141a : a041 [ 2] ldy #$41`	`1712 : a041 [ 2] ldy #$41`
`141c : 08 [ 3] php`	`1714 : 08 [ 3] php`
`141d : cc0a02 [ 4] cpy abs1+2 ;test result`	`1715 : cc0a02 [ 4] cpy abs1+2 ;test result`
`trap_ne`	`trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 101`	`1718 : f002 [ 3]> beq skip1214`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`1420 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`171a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`171b : 14 > db test_num`
	`>`
	`171c : >skip1214`

`1422 : 68 [ 4] pla ;load status`	`171c : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1423 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`171d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1425 : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`171f : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`1428 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1722 : f002 [ 3]> beq skip1217`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 166`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1724 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1725 : 14 > db test_num`
	`>`
	`1726 : >skip1217`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`142a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1726 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`142c : 48 [ 3]> pha ;use stack to load status`	`1728 : 48 [ 3]> pha ;use stack to load status`
`142d : 28 [ 4]> plp`	`1729 : 28 [ 4]> plp`

`142e : a000 [ 2] ldy #0`	`172a : a000 [ 2] ldy #0`
`1430 : 08 [ 3] php`	`172c : 08 [ 3] php`
`1431 : cc0b02 [ 4] cpy abs1+3 ;test result`	`172d : cc0b02 [ 4] cpy abs1+3 ;test result`
`trap_ne`	`trap_ne`
`1434 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1730 : f002 [ 3]> beq skip1221`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1732 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1733 : 14 > db test_num`
	`>`
	`1734 : >skip1221`

`1436 : 68 [ 4] pla ;load status`	`1734 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1437 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1735 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1439 : cd1002 [ 4] cmp fLDx+3 ;test flags`	`1737 : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`143c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`173a : f002 [ 3]> beq skip1224`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`173c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`173d : 14 > db test_num`
	`>`
	`173e : >skip1224`


`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`143e : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`173e : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1440 : 48 [ 3]> pha ;use stack to load status`	`1740 : 48 [ 3]> pha ;use stack to load status`
`1441 : 28 [ 4]> plp`	`1741 : 28 [ 4]> plp`

`1442 : a0c3 [ 2] ldy #$c3`	`1742 : a0c3 [ 2] ldy #$c3`
`1444 : 08 [ 3] php`	`1744 : 08 [ 3] php`
`1445 : cc0802 [ 4] cpy abs1 ;test result`	`1745 : cc0802 [ 4] cpy abs1 ;test result`
`trap_ne`	`trap_ne`
`1448 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1748 : f002 [ 3]> beq skip1228`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`174a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 167`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`174b : 14 > db test_num`
	`>`
	`174c : >skip1228`

`144a : 68 [ 4] pla ;load status`	`174c : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`144b : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`174d : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`144d : cd0d02 [ 4] cmp fLDx ;test flags`	`174f : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`1450 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1752 : f002 [ 3]> beq skip1231`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1754 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1755 : 14 > db test_num`
	`>`
	`1756 : >skip1231`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 102`	`1756 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1452 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1454 : 48 [ 3]> pha ;use stack to load status`	`1758 : 48 [ 3]> pha ;use stack to load status`
`1455 : 28 [ 4]> plp`	`1759 : 28 [ 4]> plp`

`1456 : a082 [ 2] ldy #$82`	`175a : a082 [ 2] ldy #$82`
`1458 : 08 [ 3] php`	`175c : 08 [ 3] php`
`1459 : cc0902 [ 4] cpy abs1+1 ;test result`	`175d : cc0902 [ 4] cpy abs1+1 ;test result`
`trap_ne`	`trap_ne`
`145c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1760 : f002 [ 3]> beq skip1235`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1762 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1763 : 14 > db test_num`
	`>`
	`1764 : >skip1235`

`145e : 68 [ 4] pla ;load status`	`1764 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`145f : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1765 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1461 : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1767 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`1464 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`176a : f002 [ 3]> beq skip1238`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`176c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`176d : 14 > db test_num`
	`>`
	`176e : >skip1238`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`1466 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`176e : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1468 : 48 [ 3]> pha ;use stack to load status`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 168`
`1469 : 28 [ 4]> plp`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`146a : a041 [ 2] ldy #$41`	`1770 : 48 [ 3]> pha ;use stack to load status`
`146c : 08 [ 3] php`	`1771 : 28 [ 4]> plp`
`146d : cc0a02 [ 4] cpy abs1+2 ;test result`
`trap_ne`	`1772 : a041 [ 2] ldy #$41`
`1470 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1774 : 08 [ 3] php`
	`1775 : cc0a02 [ 4] cpy abs1+2 ;test result`
	`trap_ne`
	`1778 : f002 [ 3]> beq skip1242`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`177a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`177b : 14 > db test_num`
	`>`
	`177c : >skip1242`

`1472 : 68 [ 4] pla ;load status`	`177c : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1473 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`177d : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1475 : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`177f : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`1478 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1782 : f002 [ 3]> beq skip1245`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1784 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1785 : 14 > db test_num`
	`>`
	`1786 : >skip1245`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`147a : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1786 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`147c : 48 [ 3]> pha ;use stack to load status`	`1788 : 48 [ 3]> pha ;use stack to load status`
`147d : 28 [ 4]> plp`	`1789 : 28 [ 4]> plp`

`147e : a000 [ 2] ldy #0`	`178a : a000 [ 2] ldy #0`
`1480 : 08 [ 3] php`	`178c : 08 [ 3] php`
`1481 : cc0b02 [ 4] cpy abs1+3 ;test result`	`178d : cc0b02 [ 4] cpy abs1+3 ;test result`
`trap_ne`	`trap_ne`
`1484 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1790 : f002 [ 3]> beq skip1249`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1792 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1793 : 14 > db test_num`
	`>`
	`1794 : >skip1249`

`1486 : 68 [ 4] pla ;load status`	`1794 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 103`	`1795 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1487 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1797 : cd1002 [ 4] cmp fLDx+3 ;test flags`

`1489 : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`148c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`179a : f002 [ 3]> beq skip1252`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 169`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`179c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`179d : 14 > db test_num`
	`>`
	`179e : >skip1252`

`148e : a000 [ 2] ldy #0`
`1490 : a50c [ 3] lda zpt`
`1492 : 49c3 [ 2] eor #$c3`
`1494 : c513 [ 3] cmp zp1`
`trap_ne ;store to zp data`
`1496 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`1498 : 840c [ 3] sty zpt ;clear`	`179e : a000 [ 2] ldy #0`
`149a : ad0302 [ 4] lda abst`	`17a0 : a5b2 [ 3] lda zpt`
`149d : 49c3 [ 2] eor #$c3`	`17a2 : 49c3 [ 2] eor #$c3`
`149f : cd0802 [ 4] cmp abs1`	`17a4 : c5b9 [ 3] cmp zp1`
	`trap_ne ;store to zp data`
	`17a6 : f002 [ 3]> beq skip1254`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`17a8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`17a9 : 14 > db test_num`
	`>`
	`17aa : >skip1254`

	`17aa : 84b2 [ 3] sty zpt ;clear`
	`17ac : ad0302 [ 4] lda abst`
	`17af : 49c3 [ 2] eor #$c3`
	`17b1 : cd0802 [ 4] cmp abs1`
`trap_ne ;store to abs data`	`trap_ne ;store to abs data`
`14a2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`17b4 : f002 [ 3]> beq skip1256`
	`> trap ;failed equal (zero)`
`14a4 : 8c0302 [ 4] sty abst ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`14a7 : a50d [ 3] lda zpt+1`	`17b6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`14a9 : 49c3 [ 2] eor #$c3`	`17b7 : 14 > db test_num`
`14ab : c514 [ 3] cmp zp1+1`	`>`
	`17b8 : >skip1256`

	`17b8 : 8c0302 [ 4] sty abst ;clear`
	`17bb : a5b3 [ 3] lda zpt+1`
	`17bd : 49c3 [ 2] eor #$c3`
	`17bf : c5ba [ 3] cmp zp1+1`
`trap_ne ;store to zp+1 data`	`trap_ne ;store to zp+1 data`
`14ad : d0fe [ 3]> bne * ;failed not equal (non zero)`	`17c1 : f002 [ 3]> beq skip1258`
	`> trap ;failed equal (zero)`
`14af : 840d [ 3] sty zpt+1 ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`14b1 : ad0402 [ 4] lda abst+1`	`17c3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`14b4 : 49c3 [ 2] eor #$c3`	`17c4 : 14 > db test_num`
`14b6 : cd0902 [ 4] cmp abs1+1`	`>`
	`17c5 : >skip1258`

	`17c5 : 84b3 [ 3] sty zpt+1 ;clear`
	`17c7 : ad0402 [ 4] lda abst+1`
	`17ca : 49c3 [ 2] eor #$c3`
	`17cc : cd0902 [ 4] cmp abs1+1`
`trap_ne ;store to abs+1 data`	`trap_ne ;store to abs+1 data`
`14b9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`17cf : f002 [ 3]> beq skip1260`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 170`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`17d1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`17d2 : 14 > db test_num`
	`>`
	`17d3 : >skip1260`

`14bb : 8c0402 [ 4] sty abst+1 ;clear`	`17d3 : 8c0402 [ 4] sty abst+1 ;clear`
`14be : a50e [ 3] lda zpt+2`	`17d6 : a5b4 [ 3] lda zpt+2`
`14c0 : 49c3 [ 2] eor #$c3`	`17d8 : 49c3 [ 2] eor #$c3`
`14c2 : c515 [ 3] cmp zp1+2`	`17da : c5bb [ 3] cmp zp1+2`
`trap_ne ;store to zp+2 data`	`trap_ne ;store to zp+2 data`
`14c4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`17dc : f002 [ 3]> beq skip1262`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`17de : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`17df : 14 > db test_num`
	`>`
	`17e0 : >skip1262`

`14c6 : 840e [ 3] sty zpt+2 ;clear`	`17e0 : 84b4 [ 3] sty zpt+2 ;clear`
`14c8 : ad0502 [ 4] lda abst+2`	`17e2 : ad0502 [ 4] lda abst+2`
`14cb : 49c3 [ 2] eor #$c3`	`17e5 : 49c3 [ 2] eor #$c3`
`14cd : cd0a02 [ 4] cmp abs1+2`	`17e7 : cd0a02 [ 4] cmp abs1+2`
`trap_ne ;store to abs+2 data`	`trap_ne ;store to abs+2 data`
`14d0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`17ea : f002 [ 3]> beq skip1264`
	`> trap ;failed equal (zero)`
`14d2 : 8c0502 [ 4] sty abst+2 ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`14d5 : a50f [ 3] lda zpt+3`	`17ec : 00 [ 7]> brk ; Use BRK to return to the monitor`
`14d7 : 49c3 [ 2] eor #$c3`	`17ed : 14 > db test_num`
`14d9 : c516 [ 3] cmp zp1+3`	`>`
	`17ee : >skip1264`

	`17ee : 8c0502 [ 4] sty abst+2 ;clear`
	`17f1 : a5b5 [ 3] lda zpt+3`
	`17f3 : 49c3 [ 2] eor #$c3`
	`17f5 : c5bc [ 3] cmp zp1+3`
`trap_ne ;store to zp+3 data`	`trap_ne ;store to zp+3 data`
`14db : d0fe [ 3]> bne * ;failed not equal (non zero)`	`17f7 : f002 [ 3]> beq skip1266`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 104`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`17f9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`17fa : 14 > db test_num`
	`>`
	`17fb : >skip1266`

	`17fb : 84b5 [ 3] sty zpt+3 ;clear`
	`17fd : ad0602 [ 4] lda abst+3`
	`1800 : 49c3 [ 2] eor #$c3`
	`1802 : cd0b02 [ 4] cmp abs1+3`
	`trap_ne ;store to abs+3 data`
	`1805 : f002 [ 3]> beq skip1268`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1807 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1808 : 14 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 171`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1809 : >skip1268`

`14dd : 840f [ 3] sty zpt+3 ;clear`	`1809 : 8c0602 [ 4] sty abst+3 ;clear`
`14df : ad0602 [ 4] lda abst+3`
`14e2 : 49c3 [ 2] eor #$c3`
`14e4 : cd0b02 [ 4] cmp abs1+3`
`trap_ne ;store to abs+3 data`
`14e7 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`14e9 : 8c0602 [ 4] sty abst+3 ;clear`
`next_test`	`next_test`
`14ec : ad0002 [ 4]> lda test_case ;previous test`	`180c : ad0002 [ 4]> lda test_case ;previous test`
`14ef : c914 [ 2]> cmp #test_num`	`180f : c914 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`14f1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1811 : f002 [ 3]> beq skip1271`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1813 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1814 : 14 > db test_num`
	`>`
	`1815 : >skip1271`
`>`	`>`
`0015 = >test_num = test_num + 1`	`0015 = >test_num = test_num + 1`
`14f3 : a915 [ 2]> lda #test_num ;*** this tests' number`	`1815 : a915 [ 2]> lda #test_num ;*** this tests' number`
`14f5 : 8d0002 [ 4]> sta test_case`	`1817 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; testing load / store accumulator LDA / STA all addressing modes`	`; testing load / store accumulator LDA / STA all addressing modes`
`; LDA / STA - zp,x / abs,x`	`; LDA / STA - zp,x / abs,x`
`14f8 : a203 [ 2] ldx #3`
`14fa : tldax`	`181a : a203 [ 2] ldx #3`
	`181c : tldax`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`14fa : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`181c : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`14fc : 48 [ 3]> pha ;use stack to load status`	`181e : 48 [ 3]> pha ;use stack to load status`
`14fd : 28 [ 4]> plp`	`181f : 28 [ 4]> plp`

`14fe : b513 [ 4] lda zp1,x`	`1820 : b5b9 [ 4] lda zp1,x`
`1500 : 08 [ 3] php ;test stores do not alter flags`	`1822 : 08 [ 3] php ;test stores do not alter flags`
`1501 : 49c3 [ 2] eor #$c3`	`1823 : 49c3 [ 2] eor #$c3`
`1503 : 28 [ 4] plp`	`1825 : 28 [ 4] plp`
`1504 : 9d0302 [ 5] sta abst,x`	`1826 : 9d0302 [ 5] sta abst,x`
`1507 : 08 [ 3] php ;flags after load/store sequence`	`1829 : 08 [ 3] php ;flags after load/store sequence`
`1508 : 49c3 [ 2] eor #$c3`	`182a : 49c3 [ 2] eor #$c3`
`150a : dd0802 [ 4] cmp abs1,x ;test result`	`182c : dd0802 [ 4] cmp abs1,x ;test result`
`trap_ne`	`trap_ne`
`150d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`182f : f002 [ 3]> beq skip1275`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1831 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1832 : 15 > db test_num`
	`>`
	`1833 : >skip1275`

`150f : 68 [ 4] pla ;load status`	`1833 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1510 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1834 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1512 : dd0d02 [ 4] cmp fLDx,x ;test flags`	`1836 : dd0d02 [ 4] cmp fLDx,x ;test flags`
`trap_ne`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 172`
`1515 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1517 : ca [ 2] dex`	`trap_ne`
`1518 : 10e0 [ 4] bpl tldax`	`1839 : f002 [ 3]> beq skip1278`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`183b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`183c : 15 > db test_num`
	`>`
	`183d : >skip1278`

`151a : a203 [ 2] ldx #3`	`183d : ca [ 2] dex`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 105`	`183e : 10dc [ 3] bpl tldax`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`151c : tldax1`	`1840 : a203 [ 2] ldx #3`
	`1842 : tldax1`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`151c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1842 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`151e : 48 [ 3]> pha ;use stack to load status`	`1844 : 48 [ 3]> pha ;use stack to load status`
`151f : 28 [ 4]> plp`	`1845 : 28 [ 4]> plp`

`1520 : b513 [ 4] lda zp1,x`	`1846 : b5b9 [ 4] lda zp1,x`
`1522 : 08 [ 3] php ;test stores do not alter flags`	`1848 : 08 [ 3] php ;test stores do not alter flags`
`1523 : 49c3 [ 2] eor #$c3`	`1849 : 49c3 [ 2] eor #$c3`
`1525 : 28 [ 4] plp`	`184b : 28 [ 4] plp`
`1526 : 9d0302 [ 5] sta abst,x`	`184c : 9d0302 [ 5] sta abst,x`
`1529 : 08 [ 3] php ;flags after load/store sequence`	`184f : 08 [ 3] php ;flags after load/store sequence`
`152a : 49c3 [ 2] eor #$c3`	`1850 : 49c3 [ 2] eor #$c3`
`152c : dd0802 [ 4] cmp abs1,x ;test result`	`1852 : dd0802 [ 4] cmp abs1,x ;test result`
`trap_ne`	`trap_ne`
`152f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1855 : f002 [ 3]> beq skip1282`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1857 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1858 : 15 > db test_num`
	`>`
	`1859 : >skip1282`

`1531 : 68 [ 4] pla ;load status`	`1859 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1532 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`185a : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1534 : dd0d02 [ 4] cmp fLDx,x ;test flags`	`185c : dd0d02 [ 4] cmp fLDx,x ;test flags`
`trap_ne`	`trap_ne`
`1537 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`185f : f002 [ 3]> beq skip1285`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1861 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1862 : 15 > db test_num`
	`>`
	`1863 : >skip1285`

`1539 : ca [ 2] dex`	`1863 : ca [ 2] dex`
`153a : 10e0 [ 3] bpl tldax1`	`1864 : 10dc [ 3] bpl tldax1`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 173`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`153c : a203 [ 2] ldx #3`	`1866 : a203 [ 2] ldx #3`
`153e : tldax2`	`1868 : tldax2`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`153e : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1868 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1540 : 48 [ 3]> pha ;use stack to load status`	`186a : 48 [ 3]> pha ;use stack to load status`
`1541 : 28 [ 4]> plp`	`186b : 28 [ 4]> plp`

`1542 : bd0802 [ 4] lda abs1,x`	`186c : bd0802 [ 4] lda abs1,x`
`1545 : 08 [ 3] php ;test stores do not alter flags`	`186f : 08 [ 3] php ;test stores do not alter flags`
`1546 : 49c3 [ 2] eor #$c3`	`1870 : 49c3 [ 2] eor #$c3`
`1548 : 28 [ 4] plp`	`1872 : 28 [ 4] plp`
`1549 : 950c [ 4] sta zpt,x`	`1873 : 95b2 [ 4] sta zpt,x`
`154b : 08 [ 3] php ;flags after load/store sequence`	`1875 : 08 [ 3] php ;flags after load/store sequence`
`154c : 49c3 [ 2] eor #$c3`	`1876 : 49c3 [ 2] eor #$c3`
`154e : d513 [ 4] cmp zp1,x ;test result`	`1878 : d5b9 [ 4] cmp zp1,x ;test result`
`trap_ne`	`trap_ne`
`1550 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`187a : f002 [ 3]> beq skip1289`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`187c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`187d : 15 > db test_num`
	`>`
	`187e : >skip1289`

`1552 : 68 [ 4] pla ;load status`	`187e : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1553 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`187f : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1555 : dd0d02 [ 4] cmp fLDx,x ;test flags`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 106`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1881 : dd0d02 [ 4] cmp fLDx,x ;test flags`
`trap_ne`	`trap_ne`
`1558 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1884 : f002 [ 3]> beq skip1292`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1886 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1887 : 15 > db test_num`
	`>`
	`1888 : >skip1292`

`155a : ca [ 2] dex`	`1888 : ca [ 2] dex`
`155b : 10e1 [ 3] bpl tldax2`	`1889 : 10dd [ 3] bpl tldax2`

`155d : a203 [ 2] ldx #3`	`188b : a203 [ 2] ldx #3`
`155f : tldax3`	`188d : tldax3`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`155f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`188d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1561 : 48 [ 3]> pha ;use stack to load status`	`188f : 48 [ 3]> pha ;use stack to load status`
`1562 : 28 [ 4]> plp`	`1890 : 28 [ 4]> plp`

`1563 : bd0802 [ 4] lda abs1,x`	`1891 : bd0802 [ 4] lda abs1,x`
`1566 : 08 [ 3] php ;test stores do not alter flags`	`1894 : 08 [ 3] php ;test stores do not alter flags`
`1567 : 49c3 [ 2] eor #$c3`	`1895 : 49c3 [ 2] eor #$c3`
`1569 : 28 [ 4] plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 174`
`156a : 950c [ 4] sta zpt,x`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`156c : 08 [ 3] php ;flags after load/store sequence`
`156d : 49c3 [ 2] eor #$c3`
`156f : d513 [ 4] cmp zp1,x ;test result`
`trap_ne`
`1571 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`1573 : 68 [ 4] pla ;load status`	`1897 : 28 [ 4] plp`
	`1898 : 95b2 [ 4] sta zpt,x`
	`189a : 08 [ 3] php ;flags after load/store sequence`
	`189b : 49c3 [ 2] eor #$c3`
	`189d : d5b9 [ 4] cmp zp1,x ;test result`
	`trap_ne`
	`189f : f002 [ 3]> beq skip1296`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`18a1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`18a2 : 15 > db test_num`
	`>`
	`18a3 : >skip1296`

	`18a3 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1574 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`18a4 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1576 : dd0d02 [ 4] cmp fLDx,x ;test flags`	`18a6 : dd0d02 [ 4] cmp fLDx,x ;test flags`
`trap_ne`	`trap_ne`
`1579 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`18a9 : f002 [ 3]> beq skip1299`
	`> trap ;failed equal (zero)`
`157b : ca [ 2] dex`	`>; db $db ; M65C02/M65C02A SToP instruction`
`157c : 10e1 [ 3] bpl tldax3`	`18ab : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`18ac : 15 > db test_num`
`157e : a203 [ 2] ldx #3 ;testing store result`	`>`
`1580 : a000 [ 2] ldy #0`	`18ad : >skip1299`
`1582 : b50c [ 4] tstax lda zpt,x`
`1584 : 49c3 [ 2] eor #$c3`	`18ad : ca [ 2] dex`
`1586 : d513 [ 4] cmp zp1,x`	`18ae : 10dd [ 3] bpl tldax3`

	`18b0 : a203 [ 2] ldx #3 ;testing store result`
	`18b2 : a000 [ 2] ldy #0`
	`18b4 : b5b2 [ 4] tstax lda zpt,x`
	`18b6 : 49c3 [ 2] eor #$c3`
	`18b8 : d5b9 [ 4] cmp zp1,x`
`trap_ne ;store to zp,x data`	`trap_ne ;store to zp,x data`
`1588 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`18ba : f002 [ 3]> beq skip1301`
	`> trap ;failed equal (zero)`
`158a : 940c [ 4] sty zpt,x ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`158c : bd0302 [ 4] lda abst,x`	`18bc : 00 [ 7]> brk ; Use BRK to return to the monitor`
`158f : 49c3 [ 2] eor #$c3`	`18bd : 15 > db test_num`
`1591 : dd0802 [ 4] cmp abs1,x`	`>`
	`18be : >skip1301`

	`18be : 94b2 [ 4] sty zpt,x ;clear`
	`18c0 : bd0302 [ 4] lda abst,x`
	`18c3 : 49c3 [ 2] eor #$c3`
	`18c5 : dd0802 [ 4] cmp abs1,x`
`trap_ne ;store to abs,x data`	`trap_ne ;store to abs,x data`
`1594 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`18c8 : f002 [ 3]> beq skip1303`
	`> trap ;failed equal (zero)`
`1596 : 8a [ 2] txa`	`>; db $db ; M65C02/M65C02A SToP instruction`
`1597 : 9d0302 [ 5] sta abst,x ;clear`	`18ca : 00 [ 7]> brk ; Use BRK to return to the monitor`
`159a : ca [ 2] dex`	`18cb : 15 > db test_num`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 107`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 175`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`159b : 10e5 [ 3] bpl tstax`	`>`
	`18cc : >skip1303`

	`18cc : 8a [ 2] txa`
	`18cd : 9d0302 [ 5] sta abst,x ;clear`
	`18d0 : ca [ 2] dex`
	`18d1 : 10e1 [ 3] bpl tstax`
`next_test`	`next_test`
`159d : ad0002 [ 4]> lda test_case ;previous test`	`18d3 : ad0002 [ 4]> lda test_case ;previous test`
`15a0 : c915 [ 2]> cmp #test_num`	`18d6 : c915 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`15a2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`18d8 : f002 [ 3]> beq skip1306`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`18da : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`18db : 15 > db test_num`
	`>`
	`18dc : >skip1306`
`>`	`>`
`0016 = >test_num = test_num + 1`	`0016 = >test_num = test_num + 1`
`15a4 : a916 [ 2]> lda #test_num ;*** this tests' number`	`18dc : a916 [ 2]> lda #test_num ;*** this tests' number`
`15a6 : 8d0002 [ 4]> sta test_case`	`18de : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; LDA / STA - (zp),y / abs,y / (zp,x)`	`; LDA / STA - (zp),y / abs,y / (zp,x)`
`15a9 : a003 [ 2] ldy #3`
`15ab : tlday`	`18e1 : a003 [ 2] ldy #3`
	`18e3 : tlday`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`15ab : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`18e3 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`15ad : 48 [ 3]> pha ;use stack to load status`	`18e5 : 48 [ 3]> pha ;use stack to load status`
`15ae : 28 [ 4]> plp`	`18e6 : 28 [ 4]> plp`

`15af : b124 [ 5] lda (ind1),y`	`18e7 : b1ca [ 5] lda (ind1),y`
`15b1 : 08 [ 3] php ;test stores do not alter flags`	`18e9 : 08 [ 3] php ;test stores do not alter flags`
`15b2 : 49c3 [ 2] eor #$c3`	`18ea : 49c3 [ 2] eor #$c3`
`15b4 : 28 [ 4] plp`	`18ec : 28 [ 4] plp`
`15b5 : 990302 [ 5] sta abst,y`	`18ed : 990302 [ 5] sta abst,y`
`15b8 : 08 [ 3] php ;flags after load/store sequence`	`18f0 : 08 [ 3] php ;flags after load/store sequence`
`15b9 : 49c3 [ 2] eor #$c3`	`18f1 : 49c3 [ 2] eor #$c3`
`15bb : d90802 [ 4] cmp abs1,y ;test result`	`18f3 : d90802 [ 4] cmp abs1,y ;test result`
`trap_ne`	`trap_ne`
`15be : d0fe [ 3]> bne * ;failed not equal (non zero)`	`18f6 : f002 [ 3]> beq skip1310`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`18f8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`18f9 : 16 > db test_num`
	`>`
	`18fa : >skip1310`

`15c0 : 68 [ 4] pla ;load status`	`18fa : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`15c1 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 176`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`15c3 : d90d02 [ 4] cmp fLDx,y ;test flags`	`18fb : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

	`18fd : d90d02 [ 4] cmp fLDx,y ;test flags`
`trap_ne`	`trap_ne`
`15c6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1900 : f002 [ 3]> beq skip1313`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1902 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1903 : 16 > db test_num`
	`>`
	`1904 : >skip1313`

`15c8 : 88 [ 2] dey`	`1904 : 88 [ 2] dey`
`15c9 : 10e0 [ 3] bpl tlday`	`1905 : 10dc [ 4] bpl tlday`

`15cb : a003 [ 2] ldy #3`	`1907 : a003 [ 2] ldy #3`
`15cd : tlday1`	`1909 : tlday1`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`15cd : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1909 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`15cf : 48 [ 3]> pha ;use stack to load status`	`190b : 48 [ 3]> pha ;use stack to load status`
`15d0 : 28 [ 4]> plp`	`190c : 28 [ 4]> plp`

`15d1 : b124 [ 5] lda (ind1),y`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 108`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`15d3 : 08 [ 3] php ;test stores do not alter flags`	`190d : b1ca [ 5] lda (ind1),y`
`15d4 : 49c3 [ 2] eor #$c3`	`190f : 08 [ 3] php ;test stores do not alter flags`
`15d6 : 28 [ 4] plp`	`1910 : 49c3 [ 2] eor #$c3`
`15d7 : 990302 [ 5] sta abst,y`	`1912 : 28 [ 4] plp`
`15da : 08 [ 3] php ;flags after load/store sequence`	`1913 : 990302 [ 5] sta abst,y`
`15db : 49c3 [ 2] eor #$c3`	`1916 : 08 [ 3] php ;flags after load/store sequence`
`15dd : d90802 [ 4] cmp abs1,y ;test result`	`1917 : 49c3 [ 2] eor #$c3`
`trap_ne`	`1919 : d90802 [ 4] cmp abs1,y ;test result`
`15e0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`trap_ne`
	`191c : f002 [ 3]> beq skip1317`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`191e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`191f : 16 > db test_num`
	`>`
	`1920 : >skip1317`

`15e2 : 68 [ 4] pla ;load status`	`1920 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`15e3 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1921 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`15e5 : d90d02 [ 4] cmp fLDx,y ;test flags`	`1923 : d90d02 [ 4] cmp fLDx,y ;test flags`
`trap_ne`	`trap_ne`
`15e8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1926 : f002 [ 3]> beq skip1320`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1928 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1929 : 16 > db test_num`
	`>`
	`192a : >skip1320`

`15ea : 88 [ 2] dey`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 177`
`15eb : 10e0 [ 3] bpl tlday1`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`15ed : a003 [ 2] ldy #3 ;testing store result`	`192a : 88 [ 2] dey`
`15ef : a200 [ 2] ldx #0`	`192b : 10dc [ 3] bpl tlday1`
`15f1 : b90302 [ 4] tstay lda abst,y`
`15f4 : 49c3 [ 2] eor #$c3`
`15f6 : d90802 [ 4] cmp abs1,y`
`trap_ne ;store to abs data`
`15f9 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`15fb : 8a [ 2] txa`	`192d : a003 [ 2] ldy #3 ;testing store result`
`15fc : 990302 [ 5] sta abst,y ;clear`	`192f : a200 [ 2] ldx #0`
`15ff : 88 [ 2] dey`	`1931 : b90302 [ 4] tstay lda abst,y`
`1600 : 10ef [ 4] bpl tstay`	`1934 : 49c3 [ 2] eor #$c3`
	`1936 : d90802 [ 4] cmp abs1,y`
	`trap_ne ;store to abs data`
	`1939 : f002 [ 3]> beq skip1322`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`193b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`193c : 16 > db test_num`
	`>`
	`193d : >skip1322`

	`193d : 8a [ 2] txa`
	`193e : 990302 [ 5] sta abst,y ;clear`
	`1941 : 88 [ 2] dey`
	`1942 : 10ed [ 3] bpl tstay`

`1602 : a003 [ 2] ldy #3`	`1944 : a003 [ 2] ldy #3`
`1604 : tlday2`	`1946 : tlday2`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1604 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1946 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1606 : 48 [ 3]> pha ;use stack to load status`	`1948 : 48 [ 3]> pha ;use stack to load status`
`1607 : 28 [ 4]> plp`	`1949 : 28 [ 4]> plp`

`1608 : b90802 [ 4] lda abs1,y`	`194a : b90802 [ 4] lda abs1,y`
`160b : 08 [ 3] php ;test stores do not alter flags`	`194d : 08 [ 3] php ;test stores do not alter flags`
`160c : 49c3 [ 2] eor #$c3`	`194e : 49c3 [ 2] eor #$c3`
`160e : 28 [ 4] plp`	`1950 : 28 [ 4] plp`
`160f : 9130 [ 5] sta (indt),y`	`1951 : 91d6 [ 5] sta (indt),y`
`1611 : 08 [ 3] php ;flags after load/store sequence`	`1953 : 08 [ 3] php ;flags after load/store sequence`
`1612 : 49c3 [ 2] eor #$c3`	`1954 : 49c3 [ 2] eor #$c3`
`1614 : d124 [ 5] cmp (ind1),y ;test result`	`1956 : d1ca [ 5] cmp (ind1),y ;test result`
`trap_ne`	`trap_ne`
`1616 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1958 : f002 [ 3]> beq skip1326`
	`> trap ;failed equal (zero)`
`1618 : 68 [ 4] pla ;load status`	`>; db $db ; M65C02/M65C02A SToP instruction`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 109`	`195a : 00 [ 7]> brk ; Use BRK to return to the monitor`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`195b : 16 > db test_num`
	`>`
	`195c : >skip1326`

	`195c : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1619 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`195d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`161b : d90d02 [ 4] cmp fLDx,y ;test flags`	`195f : d90d02 [ 4] cmp fLDx,y ;test flags`
`trap_ne`	`trap_ne`
`161e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1962 : f002 [ 3]> beq skip1329`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 178`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1964 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1965 : 16 > db test_num`
	`>`
	`1966 : >skip1329`

`1620 : 88 [ 2] dey`	`1966 : 88 [ 2] dey`
`1621 : 10e1 [ 3] bpl tlday2`	`1967 : 10dd [ 3] bpl tlday2`

`1623 : a003 [ 2] ldy #3`	`1969 : a003 [ 2] ldy #3`
`1625 : tlday3`	`196b : tlday3`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`1625 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`196b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1627 : 48 [ 3]> pha ;use stack to load status`	`196d : 48 [ 3]> pha ;use stack to load status`
`1628 : 28 [ 4]> plp`	`196e : 28 [ 4]> plp`

`1629 : b90802 [ 4] lda abs1,y`	`196f : b90802 [ 4] lda abs1,y`
`162c : 08 [ 3] php ;test stores do not alter flags`	`1972 : 08 [ 3] php ;test stores do not alter flags`
`162d : 49c3 [ 2] eor #$c3`	`1973 : 49c3 [ 2] eor #$c3`
`162f : 28 [ 4] plp`	`1975 : 28 [ 4] plp`
`1630 : 9130 [ 5] sta (indt),y`	`1976 : 91d6 [ 5] sta (indt),y`
`1632 : 08 [ 3] php ;flags after load/store sequence`	`1978 : 08 [ 3] php ;flags after load/store sequence`
`1633 : 49c3 [ 2] eor #$c3`	`1979 : 49c3 [ 2] eor #$c3`
`1635 : d124 [ 5] cmp (ind1),y ;test result`	`197b : d1ca [ 5] cmp (ind1),y ;test result`
`trap_ne`	`trap_ne`
`1637 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`197d : f002 [ 3]> beq skip1333`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`197f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1980 : 16 > db test_num`
	`>`
	`1981 : >skip1333`

`1639 : 68 [ 4] pla ;load status`	`1981 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`163a : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1982 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`163c : d90d02 [ 4] cmp fLDx,y ;test flags`	`1984 : d90d02 [ 4] cmp fLDx,y ;test flags`
`trap_ne`	`trap_ne`
`163f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1987 : f002 [ 3]> beq skip1336`
	`> trap ;failed equal (zero)`
`1641 : 88 [ 2] dey`	`>; db $db ; M65C02/M65C02A SToP instruction`
`1642 : 10e1 [ 3] bpl tlday3`	`1989 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`198a : 16 > db test_num`
`1644 : a003 [ 2] ldy #3 ;testing store result`	`>`
`1646 : a200 [ 2] ldx #0`	`198b : >skip1336`
`1648 : b90302 [ 4] tstay1 lda abst,y`
`164b : 49c3 [ 2] eor #$c3`
`164d : d90802 [ 4] cmp abs1,y`
`trap_ne ;store to abs data`
`1650 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`1652 : 8a [ 2] txa`	`198b : 88 [ 2] dey`
`1653 : 990302 [ 5] sta abst,y ;clear`	`198c : 10dd [ 3] bpl tlday3`
`1656 : 88 [ 2] dey`
`1657 : 10ef [ 3] bpl tstay1`

`1659 : a206 [ 2] ldx #6`	`198e : a003 [ 2] ldy #3 ;testing store result`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 110`	`1990 : a200 [ 2] ldx #0`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 179`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`165b : a003 [ 2] ldy #3`	`1992 : b90302 [ 4] tstay1 lda abst,y`
`165d : tldax4`	`1995 : 49c3 [ 2] eor #$c3`
	`1997 : d90802 [ 4] cmp abs1,y`
	`trap_ne ;store to abs data`
	`199a : f002 [ 3]> beq skip1338`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`199c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`199d : 16 > db test_num`
	`>`
	`199e : >skip1338`

	`199e : 8a [ 2] txa`
	`199f : 990302 [ 5] sta abst,y ;clear`
	`19a2 : 88 [ 2] dey`
	`19a3 : 10ed [ 3] bpl tstay1`

	`19a5 : a206 [ 2] ldx #6`
	`19a7 : a003 [ 2] ldy #3`
	`19a9 : tldax4`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`165d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`19a9 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`165f : 48 [ 3]> pha ;use stack to load status`	`19ab : 48 [ 3]> pha ;use stack to load status`
`1660 : 28 [ 4]> plp`	`19ac : 28 [ 4]> plp`

`1661 : a124 [ 6] lda (ind1,x)`	`19ad : a1ca [ 6] lda (ind1,x)`
`1663 : 08 [ 3] php ;test stores do not alter flags`	`19af : 08 [ 3] php ;test stores do not alter flags`
`1664 : 49c3 [ 2] eor #$c3`	`19b0 : 49c3 [ 2] eor #$c3`
`1666 : 28 [ 4] plp`	`19b2 : 28 [ 4] plp`
`1667 : 8130 [ 6] sta (indt,x)`	`19b3 : 81d6 [ 6] sta (indt,x)`
`1669 : 08 [ 3] php ;flags after load/store sequence`	`19b5 : 08 [ 3] php ;flags after load/store sequence`
`166a : 49c3 [ 2] eor #$c3`	`19b6 : 49c3 [ 2] eor #$c3`
`166c : d90802 [ 4] cmp abs1,y ;test result`	`19b8 : d90802 [ 4] cmp abs1,y ;test result`
`trap_ne`	`trap_ne`
`166f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`19bb : f002 [ 3]> beq skip1342`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`19bd : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`19be : 16 > db test_num`
	`>`
	`19bf : >skip1342`

`1671 : 68 [ 4] pla ;load status`	`19bf : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1672 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`19c0 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1674 : d90d02 [ 4] cmp fLDx,y ;test flags`	`19c2 : d90d02 [ 4] cmp fLDx,y ;test flags`
`trap_ne`	`trap_ne`
`1677 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`19c5 : f002 [ 3]> beq skip1345`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`19c7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`19c8 : 16 > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 180`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1679 : ca [ 2] dex`	`>`
`167a : ca [ 2] dex`	`19c9 : >skip1345`
`167b : 88 [ 2] dey`
`167c : 10df [ 3] bpl tldax4`

`167e : a206 [ 2] ldx #6`	`19c9 : ca [ 2] dex`
`1680 : a003 [ 2] ldy #3`	`19ca : ca [ 2] dex`
`1682 : tldax5`	`19cb : 88 [ 2] dey`
	`19cc : 10db [ 3] bpl tldax4`

	`19ce : a206 [ 2] ldx #6`
	`19d0 : a003 [ 2] ldy #3`
	`19d2 : tldax5`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`1682 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`19d2 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1684 : 48 [ 3]> pha ;use stack to load status`	`19d4 : 48 [ 3]> pha ;use stack to load status`
`1685 : 28 [ 4]> plp`	`19d5 : 28 [ 4]> plp`

`1686 : a124 [ 6] lda (ind1,x)`	`19d6 : a1ca [ 6] lda (ind1,x)`
`1688 : 08 [ 3] php ;test stores do not alter flags`	`19d8 : 08 [ 3] php ;test stores do not alter flags`
`1689 : 49c3 [ 2] eor #$c3`	`19d9 : 49c3 [ 2] eor #$c3`
`168b : 28 [ 4] plp`	`19db : 28 [ 4] plp`
`168c : 8130 [ 6] sta (indt,x)`	`19dc : 81d6 [ 6] sta (indt,x)`
`168e : 08 [ 3] php ;flags after load/store sequence`	`19de : 08 [ 3] php ;flags after load/store sequence`
`168f : 49c3 [ 2] eor #$c3`	`19df : 49c3 [ 2] eor #$c3`
`1691 : d90802 [ 4] cmp abs1,y ;test result`	`19e1 : d90802 [ 4] cmp abs1,y ;test result`
`trap_ne`	`trap_ne`
`1694 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`19e4 : f002 [ 3]> beq skip1349`
	`> trap ;failed equal (zero)`
`1696 : 68 [ 4] pla ;load status`	`>; db $db ; M65C02/M65C02A SToP instruction`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 111`	`19e6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`19e7 : 16 > db test_num`
	`>`
	`19e8 : >skip1349`

	`19e8 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1697 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`19e9 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1699 : d90d02 [ 4] cmp fLDx,y ;test flags`	`19eb : d90d02 [ 4] cmp fLDx,y ;test flags`
`trap_ne`	`trap_ne`
`169c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`19ee : f002 [ 3]> beq skip1352`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`19f0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`19f1 : 16 > db test_num`
	`>`
	`19f2 : >skip1352`

`169e : ca [ 2] dex`	`19f2 : ca [ 2] dex`
`169f : ca [ 2] dex`	`19f3 : ca [ 2] dex`
`16a0 : 88 [ 2] dey`	`19f4 : 88 [ 2] dey`
`16a1 : 10df [ 3] bpl tldax5`	`19f5 : 10db [ 3] bpl tldax5`

`16a3 : a003 [ 2] ldy #3 ;testing store result`	`19f7 : a003 [ 2] ldy #3 ;testing store result`
`16a5 : a200 [ 2] ldx #0`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 181`
`16a7 : b90302 [ 4] tstay2 lda abst,y`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`16aa : 49c3 [ 2] eor #$c3`
`16ac : d90802 [ 4] cmp abs1,y`
`trap_ne ;store to abs data`
`16af : d0fe [ 3]> bne * ;failed not equal (non zero)`

`16b1 : 8a [ 2] txa`	`19f9 : a200 [ 2] ldx #0`
`16b2 : 990302 [ 5] sta abst,y ;clear`	`19fb : b90302 [ 4] tstay2 lda abst,y`
`16b5 : 88 [ 2] dey`	`19fe : 49c3 [ 2] eor #$c3`
`16b6 : 10ef [ 3] bpl tstay2`	`1a00 : d90802 [ 4] cmp abs1,y`
	`trap_ne ;store to abs data`
	`1a03 : f002 [ 3]> beq skip1354`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1a05 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1a06 : 16 > db test_num`
	`>`
	`1a07 : >skip1354`

	`1a07 : 8a [ 2] txa`
	`1a08 : 990302 [ 5] sta abst,y ;clear`
	`1a0b : 88 [ 2] dey`
	`1a0c : 10ed [ 4] bpl tstay2`
`next_test`	`next_test`
`16b8 : ad0002 [ 4]> lda test_case ;previous test`	`1a0e : ad0002 [ 4]> lda test_case ;previous test`
`16bb : c916 [ 2]> cmp #test_num`	`1a11 : c916 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`16bd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1a13 : f002 [ 3]> beq skip1357`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1a15 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1a16 : 16 > db test_num`
	`>`
	`1a17 : >skip1357`
`>`	`>`
`0017 = >test_num = test_num + 1`	`0017 = >test_num = test_num + 1`
`16bf : a917 [ 2]> lda #test_num ;*** this tests' number`	`1a17 : a917 [ 2]> lda #test_num ;*** this tests' number`
`16c1 : 8d0002 [ 4]> sta test_case`	`1a19 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; indexed wraparound test (only zp should wrap)`	`; indexed wraparound test (only zp should wrap)`
`16c4 : a2fd [ 2] ldx #3+$fa`
`16c6 : b519 [ 4] tldax6 lda zp1-$fa&$ff,x ;wrap on indexed zp`	`1a1c : a2fd [ 2] ldx #3+$fa`
`16c8 : 9d0901 [ 5] sta abst-$fa,x ;no STX abs,x!`	`1a1e : b5bf [ 4] tldax6 lda zp1-$fa&$ff,x ;wrap on indexed zp`
`16cb : ca [ 2] dex`	`1a20 : 9d0901 [ 5] sta abst-$fa,x ;no STX abs,x!`
`16cc : e0fa [ 2] cpx #$fa`	`1a23 : ca [ 2] dex`
`16ce : b0f6 [ 3] bcs tldax6`	`1a24 : e0fa [ 2] cpx #$fa`
`16d0 : a2fd [ 2] ldx #3+$fa`	`1a26 : b0f6 [ 3] bcs tldax6`
`16d2 : bd0e01 [ 4] tldax7 lda abs1-$fa,x ;no wrap on indexed abs`	`1a28 : a2fd [ 2] ldx #3+$fa`
`16d5 : 9512 [ 4] sta zpt-$fa&$ff,x`	`1a2a : bd0e01 [ 4] tldax7 lda abs1-$fa,x ;no wrap on indexed abs`
`16d7 : ca [ 2] dex`	`1a2d : 95b8 [ 4] sta zpt-$fa&$ff,x`
`16d8 : e0fa [ 2] cpx #$fa`	`1a2f : ca [ 2] dex`
`16da : b0f6 [ 3] bcs tldax7`	`1a30 : e0fa [ 2] cpx #$fa`
	`1a32 : b0f6 [ 3] bcs tldax7`
`16dc : a203 [ 2] ldx #3 ;testing wraparound result`
`16de : a000 [ 2] ldy #0`	`1a34 : a203 [ 2] ldx #3 ;testing wraparound result`
`16e0 : b50c [ 4] tstax1 lda zpt,x`	`1a36 : a000 [ 2] ldy #0`
`16e2 : d513 [ 4] cmp zp1,x`	`1a38 : b5b2 [ 4] tstax1 lda zpt,x`
	`1a3a : d5b9 [ 4] cmp zp1,x`
`trap_ne ;store to zp,x data`	`trap_ne ;store to zp,x data`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 112`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 182`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`16e4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1a3c : f002 [ 3]> beq skip1359`
	`> trap ;failed equal (zero)`
`16e6 : 940c [ 4] sty zpt,x ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`16e8 : bd0302 [ 4] lda abst,x`	`1a3e : 00 [ 7]> brk ; Use BRK to return to the monitor`
`16eb : dd0802 [ 4] cmp abs1,x`	`1a3f : 17 > db test_num`
	`>`
	`1a40 : >skip1359`

	`1a40 : 94b2 [ 4] sty zpt,x ;clear`
	`1a42 : bd0302 [ 4] lda abst,x`
	`1a45 : dd0802 [ 4] cmp abs1,x`
`trap_ne ;store to abs,x data`	`trap_ne ;store to abs,x data`
`16ee : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1a48 : f002 [ 3]> beq skip1361`
	`> trap ;failed equal (zero)`
`16f0 : 8a [ 2] txa`	`>; db $db ; M65C02/M65C02A SToP instruction`
`16f1 : 9d0302 [ 5] sta abst,x ;clear`	`1a4a : 00 [ 7]> brk ; Use BRK to return to the monitor`
`16f4 : ca [ 2] dex`	`1a4b : 17 > db test_num`
`16f5 : 10e9 [ 3] bpl tstax1`	`>`
	`1a4c : >skip1361`
`16f7 : a0fb [ 2] ldy #3+$f8`
`16f9 : a2fe [ 2] ldx #6+$f8`	`1a4c : 8a [ 2] txa`
`16fb : a12c [ 6] tlday4 lda (ind1-$f8&$ff,x) ;wrap on indexed zp indirect`	`1a4d : 9d0302 [ 5] sta abst,x ;clear`
`16fd : 990b01 [ 5] sta abst-$f8,y`	`1a50 : ca [ 2] dex`
`1700 : ca [ 2] dex`	`1a51 : 10e5 [ 3] bpl tstax1`
`1701 : ca [ 2] dex`
`1702 : 88 [ 2] dey`	`1a53 : a0fb [ 2] ldy #3+$f8`
`1703 : c0f8 [ 2] cpy #$f8`	`1a55 : a2fe [ 2] ldx #6+$f8`
`1705 : b0f4 [ 4] bcs tlday4`	`1a57 : a1d2 [ 6] tlday4 lda (ind1-$f8&$ff,x) ;wrap on indexed zp indirect`
`1707 : a003 [ 2] ldy #3 ;testing wraparound result`	`1a59 : 990b01 [ 5] sta abst-$f8,y`
`1709 : a200 [ 2] ldx #0`	`1a5c : ca [ 2] dex`
`170b : b90302 [ 4] tstay4 lda abst,y`	`1a5d : ca [ 2] dex`
`170e : d90802 [ 4] cmp abs1,y`	`1a5e : 88 [ 2] dey`
`trap_ne ;store to abs data`	`1a5f : c0f8 [ 2] cpy #$f8`
`1711 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1a61 : b0f4 [ 3] bcs tlday4`
	`1a63 : a003 [ 2] ldy #3 ;testing wraparound result`
`1713 : 8a [ 2] txa`	`1a65 : a200 [ 2] ldx #0`
`1714 : 990302 [ 5] sta abst,y ;clear`	`1a67 : b90302 [ 4] tstay4 lda abst,y`
`1717 : 88 [ 2] dey`	`1a6a : d90802 [ 4] cmp abs1,y`
`1718 : 10f1 [ 3] bpl tstay4`

`171a : a0fb [ 2] ldy #3+$f8`
`171c : b91001 [ 4] tlday5 lda abs1-$f8,y ;no wrap on indexed abs`
`171f : 9138 [ 5] sta (inwt),y`
`1721 : 88 [ 2] dey`
`1722 : c0f8 [ 2] cpy #$f8`
`1724 : b0f6 [ 3] bcs tlday5`
`1726 : a003 [ 2] ldy #3 ;testing wraparound result`
`1728 : a200 [ 2] ldx #0`
`172a : b90302 [ 4] tstay5 lda abst,y`
`172d : d90802 [ 4] cmp abs1,y`
`trap_ne ;store to abs data`	`trap_ne ;store to abs data`
`1730 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1a6d : f002 [ 3]> beq skip1363`
	`> trap ;failed equal (zero)`
`1732 : 8a [ 2] txa`	`>; db $db ; M65C02/M65C02A SToP instruction`
`1733 : 990302 [ 5] sta abst,y ;clear`	`1a6f : 00 [ 7]> brk ; Use BRK to return to the monitor`
`1736 : 88 [ 2] dey`	`1a70 : 17 > db test_num`
`1737 : 10f1 [ 3] bpl tstay5`	`>`
	`1a71 : >skip1363`
`1739 : a0fb [ 2] ldy #3+$f8`
`173b : a2fe [ 2] ldx #6+$f8`	`1a71 : 8a [ 2] txa`
`173d : b12e [ 5] tlday6 lda (inw1),y ;no wrap on zp indirect indexed`	`1a72 : 990302 [ 5] sta abst,y ;clear`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 113`	`1a75 : 88 [ 2] dey`
	`1a76 : 10ef [ 3] bpl tstay4`

	`1a78 : a0fb [ 2] ldy #3+$f8`
	`1a7a : b91001 [ 4] tlday5 lda abs1-$f8,y ;no wrap on indexed abs`
	`1a7d : 91de [ 5] sta (inwt),y`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 183`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`173f : 8138 [ 6] sta (indt-$f8&$ff,x)`	`1a7f : 88 [ 2] dey`
`1741 : ca [ 2] dex`	`1a80 : c0f8 [ 2] cpy #$f8`
`1742 : ca [ 2] dex`	`1a82 : b0f6 [ 3] bcs tlday5`
`1743 : 88 [ 2] dey`	`1a84 : a003 [ 2] ldy #3 ;testing wraparound result`
`1744 : c0f8 [ 2] cpy #$f8`	`1a86 : a200 [ 2] ldx #0`
`1746 : b0f5 [ 3] bcs tlday6`	`1a88 : b90302 [ 4] tstay5 lda abst,y`
`1748 : a003 [ 2] ldy #3 ;testing wraparound result`	`1a8b : d90802 [ 4] cmp abs1,y`
`174a : a200 [ 2] ldx #0`
`174c : b90302 [ 4] tstay6 lda abst,y`
`174f : d90802 [ 4] cmp abs1,y`
`trap_ne ;store to abs data`	`trap_ne ;store to abs data`
`1752 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1a8e : f002 [ 3]> beq skip1365`
	`> trap ;failed equal (zero)`
`1754 : 8a [ 2] txa`	`>; db $db ; M65C02/M65C02A SToP instruction`
`1755 : 990302 [ 5] sta abst,y ;clear`	`1a90 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`1758 : 88 [ 2] dey`	`1a91 : 17 > db test_num`
`1759 : 10f1 [ 3] bpl tstay6`	`>`
	`1a92 : >skip1365`

	`1a92 : 8a [ 2] txa`
	`1a93 : 990302 [ 5] sta abst,y ;clear`
	`1a96 : 88 [ 2] dey`
	`1a97 : 10ef [ 3] bpl tstay5`

	`1a99 : a0fb [ 2] ldy #3+$f8`
	`1a9b : a2fe [ 2] ldx #6+$f8`
	`1a9d : b1d4 [ 5] tlday6 lda (inw1),y ;no wrap on zp indirect indexed`
	`1a9f : 81de [ 6] sta (indt-$f8&$ff,x)`
	`1aa1 : ca [ 2] dex`
	`1aa2 : ca [ 2] dex`
	`1aa3 : 88 [ 2] dey`
	`1aa4 : c0f8 [ 2] cpy #$f8`
	`1aa6 : b0f5 [ 3] bcs tlday6`
	`1aa8 : a003 [ 2] ldy #3 ;testing wraparound result`
	`1aaa : a200 [ 2] ldx #0`
	`1aac : b90302 [ 4] tstay6 lda abst,y`
	`1aaf : d90802 [ 4] cmp abs1,y`
	`trap_ne ;store to abs data`
	`1ab2 : f002 [ 3]> beq skip1367`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ab4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ab5 : 17 > db test_num`
	`>`
	`1ab6 : >skip1367`

	`1ab6 : 8a [ 2] txa`
	`1ab7 : 990302 [ 5] sta abst,y ;clear`
	`1aba : 88 [ 2] dey`
	`1abb : 10ef [ 3] bpl tstay6`
`next_test`	`next_test`
`175b : ad0002 [ 4]> lda test_case ;previous test`	`1abd : ad0002 [ 4]> lda test_case ;previous test`
`175e : c917 [ 2]> cmp #test_num`	`1ac0 : c917 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`1760 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1ac2 : f002 [ 3]> beq skip1370`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ac4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 184`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1ac5 : 17 > db test_num`
	`>`
	`1ac6 : >skip1370`
`>`	`>`
`0018 = >test_num = test_num + 1`	`0018 = >test_num = test_num + 1`
`1762 : a918 [ 2]> lda #test_num ;*** this tests' number`	`1ac6 : a918 [ 2]> lda #test_num ;*** this tests' number`
`1764 : 8d0002 [ 4]> sta test_case`	`1ac8 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; LDA / STA - zp / abs / #`	`; LDA / STA - zp / abs / #`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1767 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1acb : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1769 : 48 [ 3]> pha ;use stack to load status`	`1acd : 48 [ 3]> pha ;use stack to load status`
`176a : 28 [ 4]> plp`	`1ace : 28 [ 4]> plp`

`176b : a513 [ 3] lda zp1`	`1acf : a5b9 [ 3] lda zp1`
`176d : 08 [ 3] php ;test stores do not alter flags`	`1ad1 : 08 [ 3] php ;test stores do not alter flags`
`176e : 49c3 [ 2] eor #$c3`	`1ad2 : 49c3 [ 2] eor #$c3`
`1770 : 28 [ 4] plp`	`1ad4 : 28 [ 4] plp`
`1771 : 8d0302 [ 4] sta abst`	`1ad5 : 8d0302 [ 4] sta abst`
`1774 : 08 [ 3] php ;flags after load/store sequence`	`1ad8 : 08 [ 3] php ;flags after load/store sequence`
`1775 : 49c3 [ 2] eor #$c3`	`1ad9 : 49c3 [ 2] eor #$c3`
`1777 : c9c3 [ 2] cmp #$c3 ;test result`	`1adb : c9c3 [ 2] cmp #$c3 ;test result`
`trap_ne`	`trap_ne`
`1779 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1add : f002 [ 3]> beq skip1374`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1adf : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ae0 : 18 > db test_num`
	`>`
	`1ae1 : >skip1374`

`177b : 68 [ 4] pla ;load status`	`1ae1 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`177c : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1ae2 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`177e : cd0d02 [ 4] cmp fLDx ;test flags`	`1ae4 : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`1781 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1ae7 : f002 [ 3]> beq skip1377`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 114`	`> trap ;failed equal (zero)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ae9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1aea : 18 > db test_num`
	`>`
	`1aeb : >skip1377`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1783 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1aeb : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1785 : 48 [ 3]> pha ;use stack to load status`	`1aed : 48 [ 3]> pha ;use stack to load status`
`1786 : 28 [ 4]> plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 185`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1787 : a514 [ 3] lda zp1+1`	`1aee : 28 [ 4]> plp`
`1789 : 08 [ 3] php ;test stores do not alter flags`
`178a : 49c3 [ 2] eor #$c3`	`1aef : a5ba [ 3] lda zp1+1`
`178c : 28 [ 4] plp`	`1af1 : 08 [ 3] php ;test stores do not alter flags`
`178d : 8d0402 [ 4] sta abst+1`	`1af2 : 49c3 [ 2] eor #$c3`
`1790 : 08 [ 3] php ;flags after load/store sequence`	`1af4 : 28 [ 4] plp`
`1791 : 49c3 [ 2] eor #$c3`	`1af5 : 8d0402 [ 4] sta abst+1`
`1793 : c982 [ 2] cmp #$82 ;test result`	`1af8 : 08 [ 3] php ;flags after load/store sequence`
`trap_ne`	`1af9 : 49c3 [ 2] eor #$c3`
`1795 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1afb : c982 [ 2] cmp #$82 ;test result`
	`trap_ne`
	`1afd : f002 [ 4]> beq skip1381`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1aff : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1b00 : 18 > db test_num`
	`>`
	`1b01 : >skip1381`

`1797 : 68 [ 4] pla ;load status`	`1b01 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1798 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1b02 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`179a : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1b04 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`179d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1b07 : f002 [ 3]> beq skip1384`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1b09 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1b0a : 18 > db test_num`
	`>`
	`1b0b : >skip1384`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`179f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1b0b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`17a1 : 48 [ 3]> pha ;use stack to load status`	`1b0d : 48 [ 3]> pha ;use stack to load status`
`17a2 : 28 [ 4]> plp`	`1b0e : 28 [ 4]> plp`

`17a3 : a515 [ 3] lda zp1+2`	`1b0f : a5bb [ 3] lda zp1+2`
`17a5 : 08 [ 3] php ;test stores do not alter flags`	`1b11 : 08 [ 3] php ;test stores do not alter flags`
`17a6 : 49c3 [ 2] eor #$c3`	`1b12 : 49c3 [ 2] eor #$c3`
`17a8 : 28 [ 4] plp`	`1b14 : 28 [ 4] plp`
`17a9 : 8d0502 [ 4] sta abst+2`	`1b15 : 8d0502 [ 4] sta abst+2`
`17ac : 08 [ 3] php ;flags after load/store sequence`	`1b18 : 08 [ 3] php ;flags after load/store sequence`
`17ad : 49c3 [ 2] eor #$c3`	`1b19 : 49c3 [ 2] eor #$c3`
`17af : c941 [ 2] cmp #$41 ;test result`	`1b1b : c941 [ 2] cmp #$41 ;test result`
`trap_ne`	`trap_ne`
`17b1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1b1d : f002 [ 3]> beq skip1388`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1b1f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1b20 : 18 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 186`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1b21 : >skip1388`

`17b3 : 68 [ 4] pla ;load status`	`1b21 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`17b4 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1b22 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`17b6 : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`1b24 : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`17b9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1b27 : f002 [ 3]> beq skip1391`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1b29 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1b2a : 18 > db test_num`
	`>`
	`1b2b : >skip1391`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 115`	`1b2b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`17bb : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`17bd : 48 [ 3]> pha ;use stack to load status`	`1b2d : 48 [ 3]> pha ;use stack to load status`
`17be : 28 [ 4]> plp`	`1b2e : 28 [ 4]> plp`

`17bf : a516 [ 3] lda zp1+3`	`1b2f : a5bc [ 3] lda zp1+3`
`17c1 : 08 [ 3] php ;test stores do not alter flags`	`1b31 : 08 [ 3] php ;test stores do not alter flags`
`17c2 : 49c3 [ 2] eor #$c3`	`1b32 : 49c3 [ 2] eor #$c3`
`17c4 : 28 [ 4] plp`	`1b34 : 28 [ 4] plp`
`17c5 : 8d0602 [ 4] sta abst+3`	`1b35 : 8d0602 [ 4] sta abst+3`
`17c8 : 08 [ 3] php ;flags after load/store sequence`	`1b38 : 08 [ 3] php ;flags after load/store sequence`
`17c9 : 49c3 [ 2] eor #$c3`	`1b39 : 49c3 [ 2] eor #$c3`
`17cb : c900 [ 2] cmp #0 ;test result`	`1b3b : c900 [ 2] cmp #0 ;test result`
`trap_ne`	`trap_ne`
`17cd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1b3d : f002 [ 3]> beq skip1395`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1b3f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1b40 : 18 > db test_num`
	`>`
	`1b41 : >skip1395`

`17cf : 68 [ 4] pla ;load status`	`1b41 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`17d0 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1b42 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`17d2 : cd1002 [ 4] cmp fLDx+3 ;test flags`	`1b44 : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`17d5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1b47 : f002 [ 3]> beq skip1398`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1b49 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1b4a : 18 > db test_num`
	`>`
	`1b4b : >skip1398`

`set_stat $ff`	`set_stat $ff`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 187`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag $ff`	`> load_flag $ff`
`17d7 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1b4b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`17d9 : 48 [ 3]> pha ;use stack to load status`	`1b4d : 48 [ 3]> pha ;use stack to load status`
`17da : 28 [ 4]> plp`	`1b4e : 28 [ 4]> plp`

`17db : a513 [ 3] lda zp1`	`1b4f : a5b9 [ 3] lda zp1`
`17dd : 08 [ 3] php ;test stores do not alter flags`	`1b51 : 08 [ 3] php ;test stores do not alter flags`
`17de : 49c3 [ 2] eor #$c3`	`1b52 : 49c3 [ 2] eor #$c3`
`17e0 : 28 [ 4] plp`	`1b54 : 28 [ 4] plp`
`17e1 : 8d0302 [ 4] sta abst`	`1b55 : 8d0302 [ 4] sta abst`
`17e4 : 08 [ 3] php ;flags after load/store sequence`	`1b58 : 08 [ 3] php ;flags after load/store sequence`
`17e5 : 49c3 [ 2] eor #$c3`	`1b59 : 49c3 [ 2] eor #$c3`
`17e7 : c9c3 [ 2] cmp #$c3 ;test result`	`1b5b : c9c3 [ 2] cmp #$c3 ;test result`
`trap_ne`	`trap_ne`
`17e9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1b5d : f002 [ 3]> beq skip1402`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1b5f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1b60 : 18 > db test_num`
	`>`
	`1b61 : >skip1402`

`17eb : 68 [ 4] pla ;load status`	`1b61 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`17ec : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1b62 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`17ee : cd0d02 [ 4] cmp fLDx ;test flags`	`1b64 : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`17f1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1b67 : f002 [ 3]> beq skip1405`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1b69 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1b6a : 18 > db test_num`
	`>`
	`1b6b : >skip1405`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`17f3 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1b6b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`17f5 : 48 [ 3]> pha ;use stack to load status`	`1b6d : 48 [ 3]> pha ;use stack to load status`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 116`	`1b6e : 28 [ 4]> plp`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`17f6 : 28 [ 4]> plp`	`1b6f : a5ba [ 3] lda zp1+1`
	`1b71 : 08 [ 3] php ;test stores do not alter flags`
`17f7 : a514 [ 3] lda zp1+1`	`1b72 : 49c3 [ 2] eor #$c3`
`17f9 : 08 [ 3] php ;test stores do not alter flags`	`1b74 : 28 [ 4] plp`
`17fa : 49c3 [ 2] eor #$c3`	`1b75 : 8d0402 [ 4] sta abst+1`
`17fc : 28 [ 4] plp`	`1b78 : 08 [ 3] php ;flags after load/store sequence`
`17fd : 8d0402 [ 4] sta abst+1`	`1b79 : 49c3 [ 2] eor #$c3`
`1800 : 08 [ 3] php ;flags after load/store sequence`	`1b7b : c982 [ 2] cmp #$82 ;test result`
`1801 : 49c3 [ 2] eor #$c3`
`1803 : c982 [ 2] cmp #$82 ;test result`
`trap_ne`	`trap_ne`
`1805 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1b7d : f002 [ 3]> beq skip1409`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 188`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1b7f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1b80 : 18 > db test_num`
	`>`
	`1b81 : >skip1409`

`1807 : 68 [ 4] pla ;load status`	`1b81 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1808 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1b82 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`180a : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1b84 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`180d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1b87 : f002 [ 3]> beq skip1412`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1b89 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1b8a : 18 > db test_num`
	`>`
	`1b8b : >skip1412`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`180f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1b8b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1811 : 48 [ 3]> pha ;use stack to load status`	`1b8d : 48 [ 3]> pha ;use stack to load status`
`1812 : 28 [ 4]> plp`	`1b8e : 28 [ 4]> plp`

`1813 : a515 [ 3] lda zp1+2`	`1b8f : a5bb [ 3] lda zp1+2`
`1815 : 08 [ 3] php ;test stores do not alter flags`	`1b91 : 08 [ 3] php ;test stores do not alter flags`
`1816 : 49c3 [ 2] eor #$c3`	`1b92 : 49c3 [ 2] eor #$c3`
`1818 : 28 [ 4] plp`	`1b94 : 28 [ 4] plp`
`1819 : 8d0502 [ 4] sta abst+2`	`1b95 : 8d0502 [ 4] sta abst+2`
`181c : 08 [ 3] php ;flags after load/store sequence`	`1b98 : 08 [ 3] php ;flags after load/store sequence`
`181d : 49c3 [ 2] eor #$c3`	`1b99 : 49c3 [ 2] eor #$c3`
`181f : c941 [ 2] cmp #$41 ;test result`	`1b9b : c941 [ 2] cmp #$41 ;test result`
`trap_ne`	`trap_ne`
`1821 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1b9d : f002 [ 3]> beq skip1416`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1b9f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ba0 : 18 > db test_num`
	`>`
	`1ba1 : >skip1416`

`1823 : 68 [ 4] pla ;load status`	`1ba1 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1824 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1ba2 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1826 : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`1ba4 : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`1829 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1ba7 : f002 [ 3]> beq skip1419`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ba9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1baa : 18 > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 189`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>`
	`1bab : >skip1419`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`182b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1bab : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`182d : 48 [ 3]> pha ;use stack to load status`	`1bad : 48 [ 3]> pha ;use stack to load status`
`182e : 28 [ 4]> plp`	`1bae : 28 [ 4]> plp`

`182f : a516 [ 3] lda zp1+3`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 117`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1831 : 08 [ 3] php ;test stores do not alter flags`	`1baf : a5bc [ 3] lda zp1+3`
`1832 : 49c3 [ 2] eor #$c3`	`1bb1 : 08 [ 3] php ;test stores do not alter flags`
`1834 : 28 [ 4] plp`	`1bb2 : 49c3 [ 2] eor #$c3`
`1835 : 8d0602 [ 4] sta abst+3`	`1bb4 : 28 [ 4] plp`
`1838 : 08 [ 3] php ;flags after load/store sequence`	`1bb5 : 8d0602 [ 4] sta abst+3`
`1839 : 49c3 [ 2] eor #$c3`	`1bb8 : 08 [ 3] php ;flags after load/store sequence`
`183b : c900 [ 2] cmp #0 ;test result`	`1bb9 : 49c3 [ 2] eor #$c3`
`trap_ne`	`1bbb : c900 [ 2] cmp #0 ;test result`
`183d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`trap_ne`
	`1bbd : f002 [ 3]> beq skip1423`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1bbf : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1bc0 : 18 > db test_num`
	`>`
	`1bc1 : >skip1423`

`183f : 68 [ 4] pla ;load status`	`1bc1 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1840 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1bc2 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1842 : cd1002 [ 4] cmp fLDx+3 ;test flags`	`1bc4 : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`1845 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1bc7 : f002 [ 3]> beq skip1426`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1bc9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1bca : 18 > db test_num`
	`>`
	`1bcb : >skip1426`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1847 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1bcb : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1849 : 48 [ 3]> pha ;use stack to load status`	`1bcd : 48 [ 3]> pha ;use stack to load status`
`184a : 28 [ 4]> plp`	`1bce : 28 [ 4]> plp`

`184b : ad0802 [ 4] lda abs1`	`1bcf : ad0802 [ 4] lda abs1`
`184e : 08 [ 3] php ;test stores do not alter flags`	`1bd2 : 08 [ 3] php ;test stores do not alter flags`
`184f : 49c3 [ 2] eor #$c3`	`1bd3 : 49c3 [ 2] eor #$c3`
`1851 : 28 [ 4] plp`	`1bd5 : 28 [ 4] plp`
`1852 : 850c [ 3] sta zpt`	`1bd6 : 85b2 [ 3] sta zpt`
`1854 : 08 [ 3] php ;flags after load/store sequence`	`1bd8 : 08 [ 3] php ;flags after load/store sequence`
`1855 : 49c3 [ 2] eor #$c3`	`1bd9 : 49c3 [ 2] eor #$c3`
`1857 : c513 [ 3] cmp zp1 ;test result`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 190`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1bdb : c5b9 [ 3] cmp zp1 ;test result`
`trap_ne`	`trap_ne`
`1859 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1bdd : f002 [ 3]> beq skip1430`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1bdf : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1be0 : 18 > db test_num`
	`>`
	`1be1 : >skip1430`

`185b : 68 [ 4] pla ;load status`	`1be1 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`185c : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1be2 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`185e : cd0d02 [ 4] cmp fLDx ;test flags`	`1be4 : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`1861 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1be7 : f002 [ 3]> beq skip1433`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1be9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1bea : 18 > db test_num`
	`>`
	`1beb : >skip1433`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1863 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1beb : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1865 : 48 [ 3]> pha ;use stack to load status`	`1bed : 48 [ 3]> pha ;use stack to load status`
`1866 : 28 [ 4]> plp`	`1bee : 28 [ 4]> plp`

`1867 : ad0902 [ 4] lda abs1+1`
`186a : 08 [ 3] php ;test stores do not alter flags`
`186b : 49c3 [ 2] eor #$c3`
`186d : 28 [ 4] plp`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 118`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`186e : 850d [ 3] sta zpt+1`	`1bef : ad0902 [ 4] lda abs1+1`
`1870 : 08 [ 3] php ;flags after load/store sequence`	`1bf2 : 08 [ 3] php ;test stores do not alter flags`
`1871 : 49c3 [ 2] eor #$c3`	`1bf3 : 49c3 [ 2] eor #$c3`
`1873 : c514 [ 3] cmp zp1+1 ;test result`	`1bf5 : 28 [ 4] plp`
`trap_ne`	`1bf6 : 85b3 [ 3] sta zpt+1`
`1875 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1bf8 : 08 [ 3] php ;flags after load/store sequence`
	`1bf9 : 49c3 [ 2] eor #$c3`
	`1bfb : c5ba [ 3] cmp zp1+1 ;test result`
	`trap_ne`
	`1bfd : f002 [ 4]> beq skip1437`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1bff : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1c00 : 18 > db test_num`
	`>`
	`1c01 : >skip1437`

`1877 : 68 [ 4] pla ;load status`	`1c01 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1878 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1c02 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`187a : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1c04 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`187d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1c07 : f002 [ 3]> beq skip1440`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 191`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1c09 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1c0a : 18 > db test_num`
	`>`
	`1c0b : >skip1440`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`187f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1c0b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1881 : 48 [ 3]> pha ;use stack to load status`	`1c0d : 48 [ 3]> pha ;use stack to load status`
`1882 : 28 [ 4]> plp`	`1c0e : 28 [ 4]> plp`

`1883 : ad0a02 [ 4] lda abs1+2`	`1c0f : ad0a02 [ 4] lda abs1+2`
`1886 : 08 [ 3] php ;test stores do not alter flags`	`1c12 : 08 [ 3] php ;test stores do not alter flags`
`1887 : 49c3 [ 2] eor #$c3`	`1c13 : 49c3 [ 2] eor #$c3`
`1889 : 28 [ 4] plp`	`1c15 : 28 [ 4] plp`
`188a : 850e [ 3] sta zpt+2`	`1c16 : 85b4 [ 3] sta zpt+2`
`188c : 08 [ 3] php ;flags after load/store sequence`	`1c18 : 08 [ 3] php ;flags after load/store sequence`
`188d : 49c3 [ 2] eor #$c3`	`1c19 : 49c3 [ 2] eor #$c3`
`188f : c515 [ 3] cmp zp1+2 ;test result`	`1c1b : c5bb [ 3] cmp zp1+2 ;test result`
`trap_ne`	`trap_ne`
`1891 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1c1d : f002 [ 3]> beq skip1444`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1c1f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1c20 : 18 > db test_num`
	`>`
	`1c21 : >skip1444`

`1893 : 68 [ 4] pla ;load status`	`1c21 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1894 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1c22 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1896 : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`1c24 : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`1899 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1c27 : f002 [ 3]> beq skip1447`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1c29 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1c2a : 18 > db test_num`
	`>`
	`1c2b : >skip1447`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`189b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1c2b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`189d : 48 [ 3]> pha ;use stack to load status`	`1c2d : 48 [ 3]> pha ;use stack to load status`
`189e : 28 [ 4]> plp`	`1c2e : 28 [ 4]> plp`

`189f : ad0b02 [ 4] lda abs1+3`	`1c2f : ad0b02 [ 4] lda abs1+3`
`18a2 : 08 [ 3] php ;test stores do not alter flags`	`1c32 : 08 [ 3] php ;test stores do not alter flags`
`18a3 : 49c3 [ 2] eor #$c3`	`1c33 : 49c3 [ 2] eor #$c3`
`18a5 : 28 [ 4] plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 192`
`18a6 : 850f [ 3] sta zpt+3`
`18a8 : 08 [ 3] php ;flags after load/store sequence`
`18a9 : 49c3 [ 2] eor #$c3`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 119`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`18ab : c516 [ 3] cmp zp1+3 ;test result`	`1c35 : 28 [ 4] plp`
`trap_ne`	`1c36 : 85b5 [ 3] sta zpt+3`
`18ad : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1c38 : 08 [ 3] php ;flags after load/store sequence`
	`1c39 : 49c3 [ 2] eor #$c3`
	`1c3b : c5bc [ 3] cmp zp1+3 ;test result`
	`trap_ne`
	`1c3d : f002 [ 3]> beq skip1451`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1c3f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1c40 : 18 > db test_num`
	`>`
	`1c41 : >skip1451`

`18af : 68 [ 4] pla ;load status`	`1c41 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`18b0 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1c42 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`18b2 : cd1002 [ 4] cmp fLDx+3 ;test flags`	`1c44 : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`18b5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1c47 : f002 [ 3]> beq skip1454`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1c49 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1c4a : 18 > db test_num`
	`>`
	`1c4b : >skip1454`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`18b7 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1c4b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`18b9 : 48 [ 3]> pha ;use stack to load status`	`1c4d : 48 [ 3]> pha ;use stack to load status`
`18ba : 28 [ 4]> plp`	`1c4e : 28 [ 4]> plp`

`18bb : ad0802 [ 4] lda abs1`	`1c4f : ad0802 [ 4] lda abs1`
`18be : 08 [ 3] php ;test stores do not alter flags`	`1c52 : 08 [ 3] php ;test stores do not alter flags`
`18bf : 49c3 [ 2] eor #$c3`	`1c53 : 49c3 [ 2] eor #$c3`
`18c1 : 28 [ 4] plp`	`1c55 : 28 [ 4] plp`
`18c2 : 850c [ 3] sta zpt`	`1c56 : 85b2 [ 3] sta zpt`
`18c4 : 08 [ 3] php ;flags after load/store sequence`	`1c58 : 08 [ 3] php ;flags after load/store sequence`
`18c5 : 49c3 [ 2] eor #$c3`	`1c59 : 49c3 [ 2] eor #$c3`
`18c7 : c513 [ 3] cmp zp1 ;test result`	`1c5b : c5b9 [ 3] cmp zp1 ;test result`
`trap_ne`	`trap_ne`
`18c9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1c5d : f002 [ 3]> beq skip1458`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1c5f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1c60 : 18 > db test_num`
	`>`
	`1c61 : >skip1458`

`18cb : 68 [ 4] pla ;load status`	`1c61 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`18cc : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1c62 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 193`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`18ce : cd0d02 [ 4] cmp fLDx ;test flags`
	`1c64 : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`18d1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1c67 : f002 [ 3]> beq skip1461`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1c69 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1c6a : 18 > db test_num`
	`>`
	`1c6b : >skip1461`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`18d3 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1c6b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`18d5 : 48 [ 3]> pha ;use stack to load status`	`1c6d : 48 [ 3]> pha ;use stack to load status`
`18d6 : 28 [ 4]> plp`	`1c6e : 28 [ 4]> plp`

`18d7 : ad0902 [ 4] lda abs1+1`
`18da : 08 [ 3] php ;test stores do not alter flags`
`18db : 49c3 [ 2] eor #$c3`
`18dd : 28 [ 4] plp`
`18de : 850d [ 3] sta zpt+1`
`18e0 : 08 [ 3] php ;flags after load/store sequence`
`18e1 : 49c3 [ 2] eor #$c3`
`18e3 : c514 [ 3] cmp zp1+1 ;test result`
`trap_ne`
`18e5 : d0fe [ 3]> bne * ;failed not equal (non zero)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 120`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1c6f : ad0902 [ 4] lda abs1+1`
	`1c72 : 08 [ 3] php ;test stores do not alter flags`
	`1c73 : 49c3 [ 2] eor #$c3`
	`1c75 : 28 [ 4] plp`
	`1c76 : 85b3 [ 3] sta zpt+1`
	`1c78 : 08 [ 3] php ;flags after load/store sequence`
	`1c79 : 49c3 [ 2] eor #$c3`
	`1c7b : c5ba [ 3] cmp zp1+1 ;test result`
	`trap_ne`
	`1c7d : f002 [ 3]> beq skip1465`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1c7f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1c80 : 18 > db test_num`
	`>`
	`1c81 : >skip1465`

`18e7 : 68 [ 4] pla ;load status`	`1c81 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`18e8 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1c82 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`18ea : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1c84 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`18ed : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1c87 : f002 [ 3]> beq skip1468`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1c89 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1c8a : 18 > db test_num`
	`>`
	`1c8b : >skip1468`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`18ef : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1c8b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`18f1 : 48 [ 3]> pha ;use stack to load status`	`1c8d : 48 [ 3]> pha ;use stack to load status`
`18f2 : 28 [ 4]> plp`	`1c8e : 28 [ 4]> plp`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 194`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`18f3 : ad0a02 [ 4] lda abs1+2`
`18f6 : 08 [ 3] php ;test stores do not alter flags`
`18f7 : 49c3 [ 2] eor #$c3`
`18f9 : 28 [ 4] plp`
`18fa : 850e [ 3] sta zpt+2`
`18fc : 08 [ 3] php ;flags after load/store sequence`
`18fd : 49c3 [ 2] eor #$c3`
`18ff : c515 [ 3] cmp zp1+2 ;test result`
`trap_ne`
`1901 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`1903 : 68 [ 4] pla ;load status`	`1c8f : ad0a02 [ 4] lda abs1+2`
	`1c92 : 08 [ 3] php ;test stores do not alter flags`
	`1c93 : 49c3 [ 2] eor #$c3`
	`1c95 : 28 [ 4] plp`
	`1c96 : 85b4 [ 3] sta zpt+2`
	`1c98 : 08 [ 3] php ;flags after load/store sequence`
	`1c99 : 49c3 [ 2] eor #$c3`
	`1c9b : c5bb [ 3] cmp zp1+2 ;test result`
	`trap_ne`
	`1c9d : f002 [ 3]> beq skip1472`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1c9f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ca0 : 18 > db test_num`
	`>`
	`1ca1 : >skip1472`

	`1ca1 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1904 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1ca2 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1906 : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`1ca4 : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`1909 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1ca7 : f002 [ 3]> beq skip1475`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ca9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1caa : 18 > db test_num`
	`>`
	`1cab : >skip1475`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`190b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1cab : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`190d : 48 [ 3]> pha ;use stack to load status`	`1cad : 48 [ 3]> pha ;use stack to load status`
`190e : 28 [ 4]> plp`	`1cae : 28 [ 4]> plp`

`190f : ad0b02 [ 4] lda abs1+3`	`1caf : ad0b02 [ 4] lda abs1+3`
`1912 : 08 [ 3] php ;test stores do not alter flags`	`1cb2 : 08 [ 3] php ;test stores do not alter flags`
`1913 : 49c3 [ 2] eor #$c3`	`1cb3 : 49c3 [ 2] eor #$c3`
`1915 : 28 [ 4] plp`	`1cb5 : 28 [ 4] plp`
`1916 : 850f [ 3] sta zpt+3`	`1cb6 : 85b5 [ 3] sta zpt+3`
`1918 : 08 [ 3] php ;flags after load/store sequence`	`1cb8 : 08 [ 3] php ;flags after load/store sequence`
`1919 : 49c3 [ 2] eor #$c3`	`1cb9 : 49c3 [ 2] eor #$c3`
`191b : c516 [ 3] cmp zp1+3 ;test result`	`1cbb : c5bc [ 3] cmp zp1+3 ;test result`
`trap_ne`	`trap_ne`
`191d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1cbd : f002 [ 3]> beq skip1479`
	`> trap ;failed equal (zero)`
`191f : 68 [ 4] pla ;load status`	`>; db $db ; M65C02/M65C02A SToP instruction`
`eor_flag lo~fnz ;mask bits not altered`	`1cbf : 00 [ 7]> brk ; Use BRK to return to the monitor`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 121`	`1cc0 : 18 > db test_num`
	`>`
	`1cc1 : >skip1479`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 195`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1920 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1922 : cd1002 [ 4] cmp fLDx+3 ;test flags`	`1cc1 : 68 [ 4] pla ;load status`
	`eor_flag lo~fnz ;mask bits not altered`
	`1cc2 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

	`1cc4 : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`1925 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1cc7 : f002 [ 3]> beq skip1482`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1cc9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1cca : 18 > db test_num`
	`>`
	`1ccb : >skip1482`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1927 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1ccb : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1929 : 48 [ 3]> pha ;use stack to load status`	`1ccd : 48 [ 3]> pha ;use stack to load status`
`192a : 28 [ 4]> plp`	`1cce : 28 [ 4]> plp`

`192b : a9c3 [ 2] lda #$c3`	`1ccf : a9c3 [ 2] lda #$c3`
`192d : 08 [ 3] php`	`1cd1 : 08 [ 3] php`
`192e : cd0802 [ 4] cmp abs1 ;test result`	`1cd2 : cd0802 [ 4] cmp abs1 ;test result`
`trap_ne`	`trap_ne`
`1931 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1cd5 : f002 [ 3]> beq skip1486`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1cd7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1cd8 : 18 > db test_num`
	`>`
	`1cd9 : >skip1486`

`1933 : 68 [ 4] pla ;load status`	`1cd9 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1934 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1cda : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1936 : cd0d02 [ 4] cmp fLDx ;test flags`	`1cdc : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`1939 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1cdf : f002 [ 3]> beq skip1489`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ce1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ce2 : 18 > db test_num`
	`>`
	`1ce3 : >skip1489`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`193b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1ce3 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`193d : 48 [ 3]> pha ;use stack to load status`	`1ce5 : 48 [ 3]> pha ;use stack to load status`
`193e : 28 [ 4]> plp`	`1ce6 : 28 [ 4]> plp`

`193f : a982 [ 2] lda #$82`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 196`
`1941 : 08 [ 3] php`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`1942 : cd0902 [ 4] cmp abs1+1 ;test result`
`trap_ne`	`1ce7 : a982 [ 2] lda #$82`
`1945 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1ce9 : 08 [ 3] php`
	`1cea : cd0902 [ 4] cmp abs1+1 ;test result`
	`trap_ne`
	`1ced : f002 [ 3]> beq skip1493`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1cef : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1cf0 : 18 > db test_num`
	`>`
	`1cf1 : >skip1493`

`1947 : 68 [ 4] pla ;load status`	`1cf1 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1948 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1cf2 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`194a : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1cf4 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`194d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1cf7 : f002 [ 3]> beq skip1496`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1cf9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1cfa : 18 > db test_num`
	`>`
	`1cfb : >skip1496`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`194f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1cfb : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1951 : 48 [ 3]> pha ;use stack to load status`	`1cfd : 48 [ 3]> pha ;use stack to load status`
`1952 : 28 [ 4]> plp`	`1cfe : 28 [ 4]> plp`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 122`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1953 : a941 [ 2] lda #$41`	`1cff : a941 [ 2] lda #$41`
`1955 : 08 [ 3] php`	`1d01 : 08 [ 3] php`
`1956 : cd0a02 [ 4] cmp abs1+2 ;test result`	`1d02 : cd0a02 [ 4] cmp abs1+2 ;test result`
`trap_ne`	`trap_ne`
`1959 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1d05 : f002 [ 3]> beq skip1500`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1d07 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1d08 : 18 > db test_num`
	`>`
	`1d09 : >skip1500`

`195b : 68 [ 4] pla ;load status`	`1d09 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`195c : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1d0a : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`195e : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`1d0c : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`1961 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1d0f : f002 [ 3]> beq skip1503`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1d11 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 197`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1d12 : 18 > db test_num`
	`>`
	`1d13 : >skip1503`

`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`1963 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1d13 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1965 : 48 [ 3]> pha ;use stack to load status`	`1d15 : 48 [ 3]> pha ;use stack to load status`
`1966 : 28 [ 4]> plp`	`1d16 : 28 [ 4]> plp`

`1967 : a900 [ 2] lda #0`	`1d17 : a900 [ 2] lda #0`
`1969 : 08 [ 3] php`	`1d19 : 08 [ 3] php`
`196a : cd0b02 [ 4] cmp abs1+3 ;test result`	`1d1a : cd0b02 [ 4] cmp abs1+3 ;test result`
`trap_ne`	`trap_ne`
`196d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1d1d : f002 [ 3]> beq skip1507`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1d1f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1d20 : 18 > db test_num`
	`>`
	`1d21 : >skip1507`

`196f : 68 [ 4] pla ;load status`	`1d21 : 68 [ 4] pla ;load status`
`eor_flag 0`	`eor_flag 0`
`1970 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`1d22 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`

`1972 : cd1002 [ 4] cmp fLDx+3 ;test flags`	`1d24 : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`1975 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1d27 : f002 [ 3]> beq skip1510`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1d29 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1d2a : 18 > db test_num`
	`>`
	`1d2b : >skip1510`


`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`1977 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1d2b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1979 : 48 [ 3]> pha ;use stack to load status`	`1d2d : 48 [ 3]> pha ;use stack to load status`
`197a : 28 [ 4]> plp`	`1d2e : 28 [ 4]> plp`

`197b : a9c3 [ 2] lda #$c3`	`1d2f : a9c3 [ 2] lda #$c3`
`197d : 08 [ 3] php`	`1d31 : 08 [ 3] php`
`197e : cd0802 [ 4] cmp abs1 ;test result`	`1d32 : cd0802 [ 4] cmp abs1 ;test result`
`trap_ne`	`trap_ne`
`1981 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1d35 : f002 [ 3]> beq skip1514`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1d37 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1d38 : 18 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 198`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1d39 : >skip1514`

`1983 : 68 [ 4] pla ;load status`	`1d39 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1984 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1d3a : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`1986 : cd0d02 [ 4] cmp fLDx ;test flags`	`1d3c : cd0d02 [ 4] cmp fLDx ;test flags`
`trap_ne`	`trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 123`	`1d3f : f002 [ 3]> beq skip1517`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`1989 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1d41 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1d42 : 18 > db test_num`
	`>`
	`1d43 : >skip1517`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`198b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1d43 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`198d : 48 [ 3]> pha ;use stack to load status`	`1d45 : 48 [ 3]> pha ;use stack to load status`
`198e : 28 [ 4]> plp`	`1d46 : 28 [ 4]> plp`

`198f : a982 [ 2] lda #$82`	`1d47 : a982 [ 2] lda #$82`
`1991 : 08 [ 3] php`	`1d49 : 08 [ 3] php`
`1992 : cd0902 [ 4] cmp abs1+1 ;test result`	`1d4a : cd0902 [ 4] cmp abs1+1 ;test result`
`trap_ne`	`trap_ne`
`1995 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1d4d : f002 [ 3]> beq skip1521`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1d4f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1d50 : 18 > db test_num`
	`>`
	`1d51 : >skip1521`

`1997 : 68 [ 4] pla ;load status`	`1d51 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`1998 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1d52 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`199a : cd0e02 [ 4] cmp fLDx+1 ;test flags`	`1d54 : cd0e02 [ 4] cmp fLDx+1 ;test flags`
`trap_ne`	`trap_ne`
`199d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1d57 : f002 [ 3]> beq skip1524`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1d59 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1d5a : 18 > db test_num`
	`>`
	`1d5b : >skip1524`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`199f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1d5b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`19a1 : 48 [ 3]> pha ;use stack to load status`	`1d5d : 48 [ 3]> pha ;use stack to load status`
`19a2 : 28 [ 4]> plp`	`1d5e : 28 [ 4]> plp`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 199`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`19a3 : a941 [ 2] lda #$41`
`19a5 : 08 [ 3] php`
`19a6 : cd0a02 [ 4] cmp abs1+2 ;test result`
`trap_ne`
`19a9 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`19ab : 68 [ 4] pla ;load status`	`1d5f : a941 [ 2] lda #$41`
	`1d61 : 08 [ 3] php`
	`1d62 : cd0a02 [ 4] cmp abs1+2 ;test result`
	`trap_ne`
	`1d65 : f002 [ 3]> beq skip1528`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1d67 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1d68 : 18 > db test_num`
	`>`
	`1d69 : >skip1528`

	`1d69 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`19ac : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1d6a : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`19ae : cd0f02 [ 4] cmp fLDx+2 ;test flags`	`1d6c : cd0f02 [ 4] cmp fLDx+2 ;test flags`
`trap_ne`	`trap_ne`
`19b1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1d6f : f002 [ 3]> beq skip1531`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1d71 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1d72 : 18 > db test_num`
	`>`
	`1d73 : >skip1531`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`19b3 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1d73 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`19b5 : 48 [ 3]> pha ;use stack to load status`	`1d75 : 48 [ 3]> pha ;use stack to load status`
`19b6 : 28 [ 4]> plp`	`1d76 : 28 [ 4]> plp`

`19b7 : a900 [ 2] lda #0`	`1d77 : a900 [ 2] lda #0`
`19b9 : 08 [ 3] php`	`1d79 : 08 [ 3] php`
`19ba : cd0b02 [ 4] cmp abs1+3 ;test result`	`1d7a : cd0b02 [ 4] cmp abs1+3 ;test result`
`trap_ne`	`trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 124`	`1d7d : f002 [ 3]> beq skip1535`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`19bd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1d7f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1d80 : 18 > db test_num`
	`>`
	`1d81 : >skip1535`

`19bf : 68 [ 4] pla ;load status`	`1d81 : 68 [ 4] pla ;load status`
`eor_flag lo~fnz ;mask bits not altered`	`eor_flag lo~fnz ;mask bits not altered`
`19c0 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`	`1d82 : 497d [ 2]> eor #lo~fnz \|fao ;invert expected flags + always on bits`

`19c2 : cd1002 [ 4] cmp fLDx+3 ;test flags`	`1d84 : cd1002 [ 4] cmp fLDx+3 ;test flags`
`trap_ne`	`trap_ne`
`19c5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1d87 : f002 [ 3]> beq skip1538`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 200`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`19c7 : a200 [ 2] ldx #0`	`1d89 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`19c9 : a50c [ 3] lda zpt`	`1d8a : 18 > db test_num`
`19cb : 49c3 [ 2] eor #$c3`	`>`
`19cd : c513 [ 3] cmp zp1`	`1d8b : >skip1538`
`trap_ne ;store to zp data`
`19cf : d0fe [ 3]> bne * ;failed not equal (non zero)`

`19d1 : 860c [ 3] stx zpt ;clear`
`19d3 : ad0302 [ 4] lda abst`
`19d6 : 49c3 [ 2] eor #$c3`
`19d8 : cd0802 [ 4] cmp abs1`
`trap_ne ;store to abs data`
`19db : d0fe [ 3]> bne * ;failed not equal (non zero)`

`19dd : 8e0302 [ 4] stx abst ;clear`	`1d8b : a200 [ 2] ldx #0`
`19e0 : a50d [ 3] lda zpt+1`	`1d8d : a5b2 [ 3] lda zpt`
`19e2 : 49c3 [ 2] eor #$c3`	`1d8f : 49c3 [ 2] eor #$c3`
`19e4 : c514 [ 3] cmp zp1+1`	`1d91 : c5b9 [ 3] cmp zp1`
`trap_ne ;store to zp data`	`trap_ne ;store to zp data`
`19e6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1d93 : f002 [ 3]> beq skip1540`
	`> trap ;failed equal (zero)`
`19e8 : 860d [ 3] stx zpt+1 ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`19ea : ad0402 [ 4] lda abst+1`	`1d95 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`19ed : 49c3 [ 2] eor #$c3`	`1d96 : 18 > db test_num`
`19ef : cd0902 [ 4] cmp abs1+1`	`>`
	`1d97 : >skip1540`

	`1d97 : 86b2 [ 3] stx zpt ;clear`
	`1d99 : ad0302 [ 4] lda abst`
	`1d9c : 49c3 [ 2] eor #$c3`
	`1d9e : cd0802 [ 4] cmp abs1`
`trap_ne ;store to abs data`	`trap_ne ;store to abs data`
`19f2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1da1 : f002 [ 3]> beq skip1542`
	`> trap ;failed equal (zero)`
`19f4 : 8e0402 [ 4] stx abst+1 ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`19f7 : a50e [ 3] lda zpt+2`	`1da3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`19f9 : 49c3 [ 2] eor #$c3`	`1da4 : 18 > db test_num`
`19fb : c515 [ 3] cmp zp1+2`	`>`
	`1da5 : >skip1542`

	`1da5 : 8e0302 [ 4] stx abst ;clear`
	`1da8 : a5b3 [ 3] lda zpt+1`
	`1daa : 49c3 [ 2] eor #$c3`
	`1dac : c5ba [ 3] cmp zp1+1`
`trap_ne ;store to zp data`	`trap_ne ;store to zp data`
`19fd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1dae : f002 [ 3]> beq skip1544`
	`> trap ;failed equal (zero)`
`19ff : 860e [ 3] stx zpt+2 ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`1a01 : ad0502 [ 4] lda abst+2`	`1db0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`1a04 : 49c3 [ 2] eor #$c3`	`1db1 : 18 > db test_num`
`1a06 : cd0a02 [ 4] cmp abs1+2`	`>`
	`1db2 : >skip1544`

	`1db2 : 86b3 [ 3] stx zpt+1 ;clear`
	`1db4 : ad0402 [ 4] lda abst+1`
	`1db7 : 49c3 [ 2] eor #$c3`
	`1db9 : cd0902 [ 4] cmp abs1+1`
`trap_ne ;store to abs data`	`trap_ne ;store to abs data`
`1a09 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1dbc : f002 [ 3]> beq skip1546`
	`> trap ;failed equal (zero)`
`1a0b : 8e0502 [ 4] stx abst+2 ;clear`	`>; db $db ; M65C02/M65C02A SToP instruction`
`1a0e : a50f [ 3] lda zpt+3`	`1dbe : 00 [ 7]> brk ; Use BRK to return to the monitor`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 125`	`1dbf : 18 > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 201`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1a10 : 49c3 [ 2] eor #$c3`	`>`
`1a12 : c516 [ 3] cmp zp1+3`	`1dc0 : >skip1546`
`trap_ne ;store to zp data`
`1a14 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`1a16 : 860f [ 3] stx zpt+3 ;clear`	`1dc0 : 8e0402 [ 4] stx abst+1 ;clear`
`1a18 : ad0602 [ 4] lda abst+3`	`1dc3 : a5b4 [ 3] lda zpt+2`
`1a1b : 49c3 [ 2] eor #$c3`	`1dc5 : 49c3 [ 2] eor #$c3`
`1a1d : cd0b02 [ 4] cmp abs1+3`	`1dc7 : c5bb [ 3] cmp zp1+2`
	`trap_ne ;store to zp data`
	`1dc9 : f002 [ 3]> beq skip1548`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1dcb : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1dcc : 18 > db test_num`
	`>`
	`1dcd : >skip1548`

	`1dcd : 86b4 [ 3] stx zpt+2 ;clear`
	`1dcf : ad0502 [ 4] lda abst+2`
	`1dd2 : 49c3 [ 2] eor #$c3`
	`1dd4 : cd0a02 [ 4] cmp abs1+2`
	`trap_ne ;store to abs data`
	`1dd7 : f002 [ 3]> beq skip1550`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1dd9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1dda : 18 > db test_num`
	`>`
	`1ddb : >skip1550`

	`1ddb : 8e0502 [ 4] stx abst+2 ;clear`
	`1dde : a5b5 [ 3] lda zpt+3`
	`1de0 : 49c3 [ 2] eor #$c3`
	`1de2 : c5bc [ 3] cmp zp1+3`
	`trap_ne ;store to zp data`
	`1de4 : f002 [ 3]> beq skip1552`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1de6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1de7 : 18 > db test_num`
	`>`
	`1de8 : >skip1552`

	`1de8 : 86b5 [ 3] stx zpt+3 ;clear`
	`1dea : ad0602 [ 4] lda abst+3`
	`1ded : 49c3 [ 2] eor #$c3`
	`1def : cd0b02 [ 4] cmp abs1+3`
`trap_ne ;store to abs data`	`trap_ne ;store to abs data`
`1a20 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1df2 : f002 [ 3]> beq skip1554`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1df4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1df5 : 18 > db test_num`
	`>`
	`1df6 : >skip1554`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 202`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1a22 : 8e0602 [ 4] stx abst+3 ;clear`	`1df6 : 8e0602 [ 4] stx abst+3 ;clear`
`next_test`	`next_test`
`1a25 : ad0002 [ 4]> lda test_case ;previous test`	`1df9 : ad0002 [ 4]> lda test_case ;previous test`
`1a28 : c918 [ 2]> cmp #test_num`	`1dfc : c918 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`1a2a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1dfe : f002 [ 4]> beq skip1557`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e00 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e01 : 18 > db test_num`
	`>`
	`1e02 : >skip1557`
`>`	`>`
`0019 = >test_num = test_num + 1`	`0019 = >test_num = test_num + 1`
`1a2c : a919 [ 2]> lda #test_num ;*** this tests' number`	`1e02 : a919 [ 2]> lda #test_num ;*** this tests' number`
`1a2e : 8d0002 [ 4]> sta test_case`	`1e04 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; testing bit test & compares BIT CPX CPY CMP all addressing modes`	`; testing bit test & compares BIT CPX CPY CMP all addressing modes`
`; BIT - zp / abs`	`; BIT - zp / abs`

`set_a $ff,0`	`set_a $ff,0`
`> load_flag 0`	`> load_flag 0`
`1a31 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1e07 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1a33 : 48 [ 3]> pha ;use stack to load status`	`1e09 : 48 [ 3]> pha ;use stack to load status`
`1a34 : a9ff [ 2]> lda #$ff ;precharge accu`	`1e0a : a9ff [ 2]> lda #$ff ;precharge accu`
`1a36 : 28 [ 4]> plp`	`1e0c : 28 [ 4]> plp`

`1a37 : 2416 [ 3] bit zp1+3 ;00 - should set Z / clear NV`	`1e0d : 24bc [ 3] bit zp1+3 ;00 - should set Z / clear NV`
`tst_a $ff,fz`	`tst_a $ff,fz`
`1a39 : 08 [ 3]> php ;save flags`	`1e0f : 08 [ 3]> php ;save flags`
`1a3a : 08 [ 3]> php`	`1e10 : 08 [ 3]> php`
`1a3b : c9ff [ 2]> cmp #$ff ;test result`	`1e11 : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`> trap_ne`
`1a3d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1e13 : f002 [ 3]> beq skip1562`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e15 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e16 : 19 > db test_num`
	`>`
	`1e17 : >skip1562`
`>`	`>`
`1a3f : 68 [ 4]> pla ;load status`	`1e17 : 68 [ 4]> pla ;load status`
`> cmp_flag fz`	`> cmp_flag fz`
`1a40 : c932 [ 2]> cmp #(fz \|fao)&m8 ;expected flags + always on bits`	`1e18 : c932 [ 2]> cmp #(fz \|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1a42 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1e1a : f002 [ 3]> beq skip1565`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e1c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e1d : 19 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 203`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1e1e : >skip1565`
`>`	`>`
`1a44 : 28 [ 4]> plp ;restore status`	`1e1e : 28 [ 4]> plp ;restore status`

`set_a 1,0`	`set_a 1,0`
`> load_flag 0`	`> load_flag 0`
`1a45 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1e1f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 126`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`1a47 : 48 [ 3]> pha ;use stack to load status`	`1e21 : 48 [ 3]> pha ;use stack to load status`
`1a48 : a901 [ 2]> lda #1 ;precharge accu`	`1e22 : a901 [ 2]> lda #1 ;precharge accu`
`1a4a : 28 [ 4]> plp`	`1e24 : 28 [ 4]> plp`

`1a4b : 2415 [ 3] bit zp1+2 ;41 - should set V (M6) / clear NZ`	`1e25 : 24bb [ 3] bit zp1+2 ;41 - should set V (M6) / clear NZ`
`tst_a 1,fv`	`tst_a 1,fv`
`1a4d : 08 [ 3]> php ;save flags`	`1e27 : 08 [ 3]> php ;save flags`
`1a4e : 08 [ 3]> php`	`1e28 : 08 [ 3]> php`
`1a4f : c901 [ 2]> cmp #1 ;test result`	`1e29 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`1a51 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1e2b : f002 [ 3]> beq skip1570`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e2d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e2e : 19 > db test_num`
`>`	`>`
`1a53 : 68 [ 4]> pla ;load status`	`1e2f : >skip1570`
	`>`
	`1e2f : 68 [ 4]> pla ;load status`
`> cmp_flag fv`	`> cmp_flag fv`
`1a54 : c970 [ 2]> cmp #(fv\|fao)&m8 ;expected flags + always on bits`	`1e30 : c970 [ 2]> cmp #(fv\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1a56 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1e32 : f002 [ 3]> beq skip1573`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e34 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e35 : 19 > db test_num`
	`>`
	`1e36 : >skip1573`
`>`	`>`
`1a58 : 28 [ 4]> plp ;restore status`	`1e36 : 28 [ 4]> plp ;restore status`

`set_a 1,0`	`set_a 1,0`
`> load_flag 0`	`> load_flag 0`
`1a59 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1e37 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1a5b : 48 [ 3]> pha ;use stack to load status`	`1e39 : 48 [ 3]> pha ;use stack to load status`
`1a5c : a901 [ 2]> lda #1 ;precharge accu`	`1e3a : a901 [ 2]> lda #1 ;precharge accu`
`1a5e : 28 [ 4]> plp`	`1e3c : 28 [ 4]> plp`

`1a5f : 2414 [ 3] bit zp1+1 ;82 - should set N (M7) & Z / clear V`	`1e3d : 24ba [ 3] bit zp1+1 ;82 - should set N (M7) & Z / clear V`
`tst_a 1,fnz`	`tst_a 1,fnz`
`1a61 : 08 [ 3]> php ;save flags`	`1e3f : 08 [ 3]> php ;save flags`
`1a62 : 08 [ 3]> php`	`1e40 : 08 [ 3]> php`
`1a63 : c901 [ 2]> cmp #1 ;test result`	`1e41 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`1a65 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 204`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1e43 : f002 [ 3]> beq skip1578`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e45 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e46 : 19 > db test_num`
	`>`
	`1e47 : >skip1578`
`>`	`>`
`1a67 : 68 [ 4]> pla ;load status`	`1e47 : 68 [ 4]> pla ;load status`
`> cmp_flag fnz`	`> cmp_flag fnz`
`1a68 : c9b2 [ 2]> cmp #(fnz\|fao)&m8 ;expected flags + always on bits`	`1e48 : c9b2 [ 2]> cmp #(fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1a6a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1e4a : f002 [ 3]> beq skip1581`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e4c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e4d : 19 > db test_num`
`>`	`>`
`1a6c : 28 [ 4]> plp ;restore status`	`1e4e : >skip1581`
	`>`
	`1e4e : 28 [ 4]> plp ;restore status`

`set_a 1,0`	`set_a 1,0`
`> load_flag 0`	`> load_flag 0`
`1a6d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1e4f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1a6f : 48 [ 3]> pha ;use stack to load status`	`1e51 : 48 [ 3]> pha ;use stack to load status`
`1a70 : a901 [ 2]> lda #1 ;precharge accu`	`1e52 : a901 [ 2]> lda #1 ;precharge accu`
`1a72 : 28 [ 4]> plp`	`1e54 : 28 [ 4]> plp`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 127`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1a73 : 2413 [ 3] bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z`	`1e55 : 24b9 [ 3] bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z`
`tst_a 1,fnv`	`tst_a 1,fnv`
`1a75 : 08 [ 3]> php ;save flags`	`1e57 : 08 [ 3]> php ;save flags`
`1a76 : 08 [ 3]> php`	`1e58 : 08 [ 3]> php`
`1a77 : c901 [ 2]> cmp #1 ;test result`	`1e59 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`1a79 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1e5b : f002 [ 3]> beq skip1586`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e5d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e5e : 19 > db test_num`
	`>`
	`1e5f : >skip1586`
`>`	`>`
`1a7b : 68 [ 4]> pla ;load status`	`1e5f : 68 [ 4]> pla ;load status`
`> cmp_flag fnv`	`> cmp_flag fnv`
`1a7c : c9f0 [ 2]> cmp #(fnv\|fao)&m8 ;expected flags + always on bits`	`1e60 : c9f0 [ 2]> cmp #(fnv\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1a7e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1e62 : f002 [ 3]> beq skip1589`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e64 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e65 : 19 > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 205`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>`
	`1e66 : >skip1589`
`>`	`>`
`1a80 : 28 [ 4]> plp ;restore status`	`1e66 : 28 [ 4]> plp ;restore status`


`set_a $ff,$ff`	`set_a $ff,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1a81 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1e67 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1a83 : 48 [ 3]> pha ;use stack to load status`	`1e69 : 48 [ 3]> pha ;use stack to load status`
`1a84 : a9ff [ 2]> lda #$ff ;precharge accu`	`1e6a : a9ff [ 2]> lda #$ff ;precharge accu`
`1a86 : 28 [ 4]> plp`	`1e6c : 28 [ 4]> plp`

`1a87 : 2416 [ 3] bit zp1+3 ;00 - should set Z / clear NV`	`1e6d : 24bc [ 3] bit zp1+3 ;00 - should set Z / clear NV`
`tst_a $ff,~fnv`	`tst_a $ff,~fnv`
`1a89 : 08 [ 3]> php ;save flags`	`1e6f : 08 [ 3]> php ;save flags`
`1a8a : 08 [ 3]> php`	`1e70 : 08 [ 3]> php`
`1a8b : c9ff [ 2]> cmp #$ff ;test result`	`1e71 : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`> trap_ne`
`1a8d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1e73 : f002 [ 3]> beq skip1594`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e75 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e76 : 19 > db test_num`
	`>`
	`1e77 : >skip1594`
`>`	`>`
`1a8f : 68 [ 4]> pla ;load status`	`1e77 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fnv`	`> cmp_flag ~fnv`
`1a90 : c93f [ 2]> cmp #(~fnv \|fao)&m8 ;expected flags + always on bits`	`1e78 : c93f [ 2]> cmp #(~fnv \|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1a92 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1e7a : f002 [ 3]> beq skip1597`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e7c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e7d : 19 > db test_num`
`>`	`>`
`1a94 : 28 [ 4]> plp ;restore status`	`1e7e : >skip1597`
	`>`
	`1e7e : 28 [ 4]> plp ;restore status`

`set_a 1,$ff`	`set_a 1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1a95 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1e7f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1a97 : 48 [ 3]> pha ;use stack to load status`	`1e81 : 48 [ 3]> pha ;use stack to load status`
`1a98 : a901 [ 2]> lda #1 ;precharge accu`	`1e82 : a901 [ 2]> lda #1 ;precharge accu`
`1a9a : 28 [ 4]> plp`	`1e84 : 28 [ 4]> plp`

`1a9b : 2415 [ 3] bit zp1+2 ;41 - should set V (M6) / clear NZ`	`1e85 : 24bb [ 3] bit zp1+2 ;41 - should set V (M6) / clear NZ`
`tst_a 1,~fnz`	`tst_a 1,~fnz`
`1a9d : 08 [ 3]> php ;save flags`	`1e87 : 08 [ 3]> php ;save flags`
`1a9e : 08 [ 3]> php`	`1e88 : 08 [ 3]> php`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 128`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 206`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1a9f : c901 [ 2]> cmp #1 ;test result`	`1e89 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`1aa1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1e8b : f002 [ 3]> beq skip1602`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e8d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e8e : 19 > db test_num`
	`>`
	`1e8f : >skip1602`
`>`	`>`
`1aa3 : 68 [ 4]> pla ;load status`	`1e8f : 68 [ 4]> pla ;load status`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1aa4 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`1e90 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1aa6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1e92 : f002 [ 3]> beq skip1605`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1e94 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1e95 : 19 > db test_num`
`>`	`>`
`1aa8 : 28 [ 4]> plp ;restore status`	`1e96 : >skip1605`
	`>`
	`1e96 : 28 [ 4]> plp ;restore status`

`set_a 1,$ff`	`set_a 1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1aa9 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1e97 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1aab : 48 [ 3]> pha ;use stack to load status`	`1e99 : 48 [ 3]> pha ;use stack to load status`
`1aac : a901 [ 2]> lda #1 ;precharge accu`	`1e9a : a901 [ 2]> lda #1 ;precharge accu`
`1aae : 28 [ 4]> plp`	`1e9c : 28 [ 4]> plp`

`1aaf : 2414 [ 3] bit zp1+1 ;82 - should set N (M7) & Z / clear V`	`1e9d : 24ba [ 3] bit zp1+1 ;82 - should set N (M7) & Z / clear V`
`tst_a 1,~fv`	`tst_a 1,~fv`
`1ab1 : 08 [ 3]> php ;save flags`	`1e9f : 08 [ 3]> php ;save flags`
`1ab2 : 08 [ 3]> php`	`1ea0 : 08 [ 3]> php`
`1ab3 : c901 [ 2]> cmp #1 ;test result`	`1ea1 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`1ab5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1ea3 : f002 [ 3]> beq skip1610`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ea5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ea6 : 19 > db test_num`
`>`	`>`
`1ab7 : 68 [ 4]> pla ;load status`	`1ea7 : >skip1610`
	`>`
	`1ea7 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fv`	`> cmp_flag ~fv`
`1ab8 : c9bf [ 2]> cmp #(~fv\|fao)&m8 ;expected flags + always on bits`	`1ea8 : c9bf [ 2]> cmp #(~fv\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1aba : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1eaa : f002 [ 3]> beq skip1613`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 207`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1eac : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ead : 19 > db test_num`
`>`	`>`
`1abc : 28 [ 4]> plp ;restore status`	`1eae : >skip1613`
	`>`
	`1eae : 28 [ 4]> plp ;restore status`

`set_a 1,$ff`	`set_a 1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1abd : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1eaf : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1abf : 48 [ 3]> pha ;use stack to load status`	`1eb1 : 48 [ 3]> pha ;use stack to load status`
`1ac0 : a901 [ 2]> lda #1 ;precharge accu`	`1eb2 : a901 [ 2]> lda #1 ;precharge accu`
`1ac2 : 28 [ 4]> plp`	`1eb4 : 28 [ 4]> plp`

`1ac3 : 2413 [ 3] bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z`	`1eb5 : 24b9 [ 3] bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z`
`tst_a 1,~fz`	`tst_a 1,~fz`
`1ac5 : 08 [ 3]> php ;save flags`	`1eb7 : 08 [ 3]> php ;save flags`
`1ac6 : 08 [ 3]> php`	`1eb8 : 08 [ 3]> php`
`1ac7 : c901 [ 2]> cmp #1 ;test result`	`1eb9 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`1ac9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1ebb : f002 [ 3]> beq skip1618`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ebd : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ebe : 19 > db test_num`
`>`	`>`
`1acb : 68 [ 4]> pla ;load status`	`1ebf : >skip1618`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 129`	`>`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`1ebf : 68 [ 4]> pla ;load status`

`> cmp_flag ~fz`	`> cmp_flag ~fz`
`1acc : c9fd [ 2]> cmp #(~fz\|fao)&m8 ;expected flags + always on bits`	`1ec0 : c9fd [ 2]> cmp #(~fz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1ace : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1ec2 : f002 [ 3]> beq skip1621`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ec4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ec5 : 19 > db test_num`
`>`	`>`
`1ad0 : 28 [ 4]> plp ;restore status`	`1ec6 : >skip1621`
	`>`
	`1ec6 : 28 [ 4]> plp ;restore status`


`set_a $ff,0`	`set_a $ff,0`
`> load_flag 0`	`> load_flag 0`
`1ad1 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1ec7 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1ad3 : 48 [ 3]> pha ;use stack to load status`	`1ec9 : 48 [ 3]> pha ;use stack to load status`
`1ad4 : a9ff [ 2]> lda #$ff ;precharge accu`	`1eca : a9ff [ 2]> lda #$ff ;precharge accu`
`1ad6 : 28 [ 4]> plp`	`1ecc : 28 [ 4]> plp`

`1ad7 : 2c0b02 [ 4] bit abs1+3 ;00 - should set Z / clear NV`	`1ecd : 2c0b02 [ 4] bit abs1+3 ;00 - should set Z / clear NV`
`tst_a $ff,fz`	`tst_a $ff,fz`
`1ada : 08 [ 3]> php ;save flags`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 208`
`1adb : 08 [ 3]> php`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`1adc : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`1ed0 : 08 [ 3]> php ;save flags`
`1ade : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1ed1 : 08 [ 3]> php`
	`1ed2 : c9ff [ 2]> cmp #$ff ;test result`
	`> trap_ne`
	`1ed4 : f002 [ 3]> beq skip1626`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ed6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ed7 : 19 > db test_num`
	`>`
	`1ed8 : >skip1626`
`>`	`>`
`1ae0 : 68 [ 4]> pla ;load status`	`1ed8 : 68 [ 4]> pla ;load status`
`> cmp_flag fz`	`> cmp_flag fz`
`1ae1 : c932 [ 2]> cmp #(fz \|fao)&m8 ;expected flags + always on bits`	`1ed9 : c932 [ 2]> cmp #(fz \|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1ae3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1edb : f002 [ 3]> beq skip1629`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1edd : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ede : 19 > db test_num`
`>`	`>`
`1ae5 : 28 [ 4]> plp ;restore status`	`1edf : >skip1629`
	`>`
	`1edf : 28 [ 4]> plp ;restore status`

`set_a 1,0`	`set_a 1,0`
`> load_flag 0`	`> load_flag 0`
`1ae6 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1ee0 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1ae8 : 48 [ 3]> pha ;use stack to load status`	`1ee2 : 48 [ 3]> pha ;use stack to load status`
`1ae9 : a901 [ 2]> lda #1 ;precharge accu`	`1ee3 : a901 [ 2]> lda #1 ;precharge accu`
`1aeb : 28 [ 4]> plp`	`1ee5 : 28 [ 4]> plp`

`1aec : 2c0a02 [ 4] bit abs1+2 ;41 - should set V (M6) / clear NZ`	`1ee6 : 2c0a02 [ 4] bit abs1+2 ;41 - should set V (M6) / clear NZ`
`tst_a 1,fv`	`tst_a 1,fv`
`1aef : 08 [ 3]> php ;save flags`	`1ee9 : 08 [ 3]> php ;save flags`
`1af0 : 08 [ 3]> php`	`1eea : 08 [ 3]> php`
`1af1 : c901 [ 2]> cmp #1 ;test result`	`1eeb : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`1af3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1eed : f002 [ 3]> beq skip1634`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1eef : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ef0 : 19 > db test_num`
`>`	`>`
`1af5 : 68 [ 4]> pla ;load status`	`1ef1 : >skip1634`
	`>`
	`1ef1 : 68 [ 4]> pla ;load status`
`> cmp_flag fv`	`> cmp_flag fv`
`1af6 : c970 [ 2]> cmp #(fv\|fao)&m8 ;expected flags + always on bits`	`1ef2 : c970 [ 2]> cmp #(fv\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 130`	`1ef4 : f002 [ 3]> beq skip1637`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 209`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1af8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ef6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ef7 : 19 > db test_num`
	`>`
	`1ef8 : >skip1637`
`>`	`>`
`1afa : 28 [ 4]> plp ;restore status`	`1ef8 : 28 [ 4]> plp ;restore status`

`set_a 1,0`	`set_a 1,0`
`> load_flag 0`	`> load_flag 0`
`1afb : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1ef9 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1afd : 48 [ 3]> pha ;use stack to load status`	`1efb : 48 [ 3]> pha ;use stack to load status`
`1afe : a901 [ 2]> lda #1 ;precharge accu`	`1efc : a901 [ 2]> lda #1 ;precharge accu`
`1b00 : 28 [ 4]> plp`	`1efe : 28 [ 4]> plp`

`1b01 : 2c0902 [ 4] bit abs1+1 ;82 - should set N (M7) & Z / clear V`	`1eff : 2c0902 [ 4] bit abs1+1 ;82 - should set N (M7) & Z / clear V`
`tst_a 1,fnz`	`tst_a 1,fnz`
`1b04 : 08 [ 3]> php ;save flags`	`1f02 : 08 [ 3]> php ;save flags`
`1b05 : 08 [ 3]> php`	`1f03 : 08 [ 3]> php`
`1b06 : c901 [ 2]> cmp #1 ;test result`	`1f04 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`1b08 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f06 : f002 [ 3]> beq skip1642`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f08 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f09 : 19 > db test_num`
	`>`
	`1f0a : >skip1642`
`>`	`>`
`1b0a : 68 [ 4]> pla ;load status`	`1f0a : 68 [ 4]> pla ;load status`
`> cmp_flag fnz`	`> cmp_flag fnz`
`1b0b : c9b2 [ 2]> cmp #(fnz\|fao)&m8 ;expected flags + always on bits`	`1f0b : c9b2 [ 2]> cmp #(fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1b0d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f0d : f002 [ 3]> beq skip1645`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f0f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f10 : 19 > db test_num`
`>`	`>`
`1b0f : 28 [ 4]> plp ;restore status`	`1f11 : >skip1645`
	`>`
	`1f11 : 28 [ 4]> plp ;restore status`

`set_a 1,0`	`set_a 1,0`
`> load_flag 0`	`> load_flag 0`
`1b10 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1f12 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1b12 : 48 [ 3]> pha ;use stack to load status`	`1f14 : 48 [ 3]> pha ;use stack to load status`
`1b13 : a901 [ 2]> lda #1 ;precharge accu`	`1f15 : a901 [ 2]> lda #1 ;precharge accu`
`1b15 : 28 [ 4]> plp`	`1f17 : 28 [ 4]> plp`

	`1f18 : 2c0802 [ 4] bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 210`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1b16 : 2c0802 [ 4] bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z`
`tst_a 1,fnv`	`tst_a 1,fnv`
`1b19 : 08 [ 3]> php ;save flags`	`1f1b : 08 [ 3]> php ;save flags`
`1b1a : 08 [ 3]> php`	`1f1c : 08 [ 3]> php`
`1b1b : c901 [ 2]> cmp #1 ;test result`	`1f1d : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`1b1d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f1f : f002 [ 3]> beq skip1650`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f21 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f22 : 19 > db test_num`
	`>`
	`1f23 : >skip1650`
`>`	`>`
`1b1f : 68 [ 4]> pla ;load status`	`1f23 : 68 [ 4]> pla ;load status`
`> cmp_flag fnv`	`> cmp_flag fnv`
`1b20 : c9f0 [ 2]> cmp #(fnv\|fao)&m8 ;expected flags + always on bits`	`1f24 : c9f0 [ 2]> cmp #(fnv\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1b22 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f26 : f002 [ 3]> beq skip1653`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f28 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f29 : 19 > db test_num`
`>`	`>`
`1b24 : 28 [ 4]> plp ;restore status`	`1f2a : >skip1653`
	`>`
	`1f2a : 28 [ 4]> plp ;restore status`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 131`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`set_a $ff,$ff`	`set_a $ff,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1b25 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1f2b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1b27 : 48 [ 3]> pha ;use stack to load status`	`1f2d : 48 [ 3]> pha ;use stack to load status`
`1b28 : a9ff [ 2]> lda #$ff ;precharge accu`	`1f2e : a9ff [ 2]> lda #$ff ;precharge accu`
`1b2a : 28 [ 4]> plp`	`1f30 : 28 [ 4]> plp`

`1b2b : 2c0b02 [ 4] bit abs1+3 ;00 - should set Z / clear NV`	`1f31 : 2c0b02 [ 4] bit abs1+3 ;00 - should set Z / clear NV`
`tst_a $ff,~fnv`	`tst_a $ff,~fnv`
`1b2e : 08 [ 3]> php ;save flags`	`1f34 : 08 [ 3]> php ;save flags`
`1b2f : 08 [ 3]> php`	`1f35 : 08 [ 3]> php`
`1b30 : c9ff [ 2]> cmp #$ff ;test result`	`1f36 : c9ff [ 2]> cmp #$ff ;test result`
`> trap_ne`	`> trap_ne`
`1b32 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f38 : f002 [ 3]> beq skip1658`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f3a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f3b : 19 > db test_num`
	`>`
	`1f3c : >skip1658`
`>`	`>`
`1b34 : 68 [ 4]> pla ;load status`	`1f3c : 68 [ 4]> pla ;load status`
`> cmp_flag ~fnv`	`> cmp_flag ~fnv`
`1b35 : c93f [ 2]> cmp #(~fnv \|fao)&m8 ;expected flags + always on bits`	`1f3d : c93f [ 2]> cmp #(~fnv \|fao)&m8 ;expected flags + always on bits`
`>`	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 211`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> trap_ne`	`> trap_ne`
`1b37 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f3f : f002 [ 3]> beq skip1661`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f41 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f42 : 19 > db test_num`
	`>`
	`1f43 : >skip1661`
`>`	`>`
`1b39 : 28 [ 4]> plp ;restore status`	`1f43 : 28 [ 4]> plp ;restore status`

`set_a 1,$ff`	`set_a 1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1b3a : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1f44 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1b3c : 48 [ 3]> pha ;use stack to load status`	`1f46 : 48 [ 3]> pha ;use stack to load status`
`1b3d : a901 [ 2]> lda #1 ;precharge accu`	`1f47 : a901 [ 2]> lda #1 ;precharge accu`
`1b3f : 28 [ 4]> plp`	`1f49 : 28 [ 4]> plp`

`1b40 : 2c0a02 [ 4] bit abs1+2 ;41 - should set V (M6) / clear NZ`	`1f4a : 2c0a02 [ 4] bit abs1+2 ;41 - should set V (M6) / clear NZ`
`tst_a 1,~fnz`	`tst_a 1,~fnz`
`1b43 : 08 [ 3]> php ;save flags`	`1f4d : 08 [ 3]> php ;save flags`
`1b44 : 08 [ 3]> php`	`1f4e : 08 [ 3]> php`
`1b45 : c901 [ 2]> cmp #1 ;test result`	`1f4f : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`1b47 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f51 : f002 [ 3]> beq skip1666`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f53 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f54 : 19 > db test_num`
	`>`
	`1f55 : >skip1666`
`>`	`>`
`1b49 : 68 [ 4]> pla ;load status`	`1f55 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1b4a : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`1f56 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1b4c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f58 : f002 [ 3]> beq skip1669`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f5a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f5b : 19 > db test_num`
`>`	`>`
`1b4e : 28 [ 4]> plp ;restore status`	`1f5c : >skip1669`
	`>`
	`1f5c : 28 [ 4]> plp ;restore status`

`set_a 1,$ff`	`set_a 1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1b4f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1f5d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1b51 : 48 [ 3]> pha ;use stack to load status`	`1f5f : 48 [ 3]> pha ;use stack to load status`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 132`	`1f60 : a901 [ 2]> lda #1 ;precharge accu`
	`1f62 : 28 [ 4]> plp`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 212`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1b52 : a901 [ 2]> lda #1 ;precharge accu`
`1b54 : 28 [ 4]> plp`

`1b55 : 2c0902 [ 4] bit abs1+1 ;82 - should set N (M7) & Z / clear V`	`1f63 : 2c0902 [ 4] bit abs1+1 ;82 - should set N (M7) & Z / clear V`
`tst_a 1,~fv`	`tst_a 1,~fv`
`1b58 : 08 [ 3]> php ;save flags`	`1f66 : 08 [ 3]> php ;save flags`
`1b59 : 08 [ 3]> php`	`1f67 : 08 [ 3]> php`
`1b5a : c901 [ 2]> cmp #1 ;test result`	`1f68 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`1b5c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f6a : f002 [ 3]> beq skip1674`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f6c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f6d : 19 > db test_num`
`>`	`>`
`1b5e : 68 [ 4]> pla ;load status`	`1f6e : >skip1674`
	`>`
	`1f6e : 68 [ 4]> pla ;load status`
`> cmp_flag ~fv`	`> cmp_flag ~fv`
`1b5f : c9bf [ 2]> cmp #(~fv\|fao)&m8 ;expected flags + always on bits`	`1f6f : c9bf [ 2]> cmp #(~fv\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1b61 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f71 : f002 [ 3]> beq skip1677`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f73 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f74 : 19 > db test_num`
	`>`
	`1f75 : >skip1677`
`>`	`>`
`1b63 : 28 [ 4]> plp ;restore status`	`1f75 : 28 [ 4]> plp ;restore status`

`set_a 1,$ff`	`set_a 1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1b64 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1f76 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1b66 : 48 [ 3]> pha ;use stack to load status`	`1f78 : 48 [ 3]> pha ;use stack to load status`
`1b67 : a901 [ 2]> lda #1 ;precharge accu`	`1f79 : a901 [ 2]> lda #1 ;precharge accu`
`1b69 : 28 [ 4]> plp`	`1f7b : 28 [ 4]> plp`

`1b6a : 2c0802 [ 4] bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z`	`1f7c : 2c0802 [ 4] bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z`
`tst_a 1,~fz`	`tst_a 1,~fz`
`1b6d : 08 [ 3]> php ;save flags`	`1f7f : 08 [ 3]> php ;save flags`
`1b6e : 08 [ 3]> php`	`1f80 : 08 [ 3]> php`
`1b6f : c901 [ 2]> cmp #1 ;test result`	`1f81 : c901 [ 2]> cmp #1 ;test result`
`> trap_ne`	`> trap_ne`
`1b71 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f83 : f002 [ 3]> beq skip1682`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f85 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f86 : 19 > db test_num`
	`>`
	`1f87 : >skip1682`
`>`	`>`
`1b73 : 68 [ 4]> pla ;load status`	`1f87 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fz`	`> cmp_flag ~fz`
`1b74 : c9fd [ 2]> cmp #(~fz\|fao)&m8 ;expected flags + always on bits`	`1f88 : c9fd [ 2]> cmp #(~fz\|fao)&m8 ;expected flags + always on bits`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 213`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`> trap_ne`	`> trap_ne`
`1b76 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f8a : f002 [ 3]> beq skip1685`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f8c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f8d : 19 > db test_num`
	`>`
	`1f8e : >skip1685`
`>`	`>`
`1b78 : 28 [ 4]> plp ;restore status`	`1f8e : 28 [ 4]> plp ;restore status`

`next_test`	`next_test`
`1b79 : ad0002 [ 4]> lda test_case ;previous test`	`1f8f : ad0002 [ 4]> lda test_case ;previous test`
`1b7c : c919 [ 2]> cmp #test_num`	`1f92 : c919 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`1b7e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1f94 : f002 [ 3]> beq skip1688`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1f96 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1f97 : 19 > db test_num`
	`>`
	`1f98 : >skip1688`
`>`	`>`
`001a = >test_num = test_num + 1`	`001a = >test_num = test_num + 1`
`1b80 : a91a [ 2]> lda #test_num ;*** this tests' number`	`1f98 : a91a [ 2]> lda #test_num ;*** this tests' number`
`1b82 : 8d0002 [ 4]> sta test_case`	`1f9a : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 133`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`



`; CPX - zp / abs / #`	`; CPX - zp / abs / #`

`set_x $80,0`	`set_x $80,0`
`> load_flag 0`	`> load_flag 0`
`1b85 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`1f9d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1b87 : 48 [ 3]> pha ;use stack to load status`	`1f9f : 48 [ 3]> pha ;use stack to load status`
`1b88 : a280 [ 2]> ldx #$80 ;precharge index x`	`1fa0 : a280 [ 2]> ldx #$80 ;precharge index x`
`1b8a : 28 [ 4]> plp`	`1fa2 : 28 [ 4]> plp`

`1b8b : e417 [ 3] cpx zp7f`	`1fa3 : e4bd [ 3] cpx zp7f`
`tst_stat fc`	`tst_stat fc`
`1b8d : 08 [ 3]> php ;save status`	`1fa5 : 08 [ 3]> php ;save status`
`1b8e : 08 [ 3]> php ;use stack to retrieve status`	`1fa6 : 08 [ 3]> php ;use stack to retrieve status`
`1b8f : 68 [ 4]> pla`	`1fa7 : 68 [ 4]> pla`
`> cmp_flag fc`	`> cmp_flag fc`
`1b90 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`1fa8 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1b92 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1faa : f002 [ 3]> beq skip1694`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1fac : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1fad : 1a > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 214`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`1fae : >skip1694`
`>`	`>`
`1b94 : 28 [ 4]> plp ;restore status`	`1fae : 28 [ 4]> plp ;restore status`

`1b95 : ca [ 2] dex`	`1faf : ca [ 2] dex`
`1b96 : e417 [ 3] cpx zp7f`	`1fb0 : e4bd [ 3] cpx zp7f`
`tst_stat fzc`	`tst_stat fzc`
`1b98 : 08 [ 3]> php ;save status`	`1fb2 : 08 [ 3]> php ;save status`
`1b99 : 08 [ 3]> php ;use stack to retrieve status`	`1fb3 : 08 [ 3]> php ;use stack to retrieve status`
`1b9a : 68 [ 4]> pla`	`1fb4 : 68 [ 4]> pla`
`> cmp_flag fzc`	`> cmp_flag fzc`
`1b9b : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`1fb5 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1b9d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1fb7 : f002 [ 3]> beq skip1698`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1fb9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1fba : 1a > db test_num`
	`>`
	`1fbb : >skip1698`
`>`	`>`
`1b9f : 28 [ 4]> plp ;restore status`	`1fbb : 28 [ 4]> plp ;restore status`

`1ba0 : ca [ 2] dex`	`1fbc : ca [ 2] dex`
`1ba1 : e417 [ 3] cpx zp7f`	`1fbd : e4bd [ 3] cpx zp7f`
`tst_x $7e,fn`	`tst_x $7e,fn`
`1ba3 : 08 [ 3]> php ;save flags`	`1fbf : 08 [ 3]> php ;save flags`
`1ba4 : 08 [ 3]> php`	`1fc0 : 08 [ 3]> php`
`1ba5 : e07e [ 2]> cpx #$7e ;test result`	`1fc1 : e07e [ 2]> cpx #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1ba7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1fc3 : f002 [ 3]> beq skip1701`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1fc5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1fc6 : 1a > db test_num`
	`>`
	`1fc7 : >skip1701`
`>`	`>`
`1ba9 : 68 [ 4]> pla ;load status`	`1fc7 : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`1baa : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`1fc8 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1bac : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1fca : f002 [ 3]> beq skip1704`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1fcc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1fcd : 1a > db test_num`
`>`	`>`
`1bae : 28 [ 4]> plp ;restore status`	`1fce : >skip1704`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 134`	`>`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`1fce : 28 [ 4]> plp ;restore status`


`set_x $80,$ff`	`set_x $80,$ff`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 215`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag $ff`	`> load_flag $ff`
`1baf : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`1fcf : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1bb1 : 48 [ 3]> pha ;use stack to load status`	`1fd1 : 48 [ 3]> pha ;use stack to load status`
`1bb2 : a280 [ 2]> ldx #$80 ;precharge index x`	`1fd2 : a280 [ 2]> ldx #$80 ;precharge index x`
`1bb4 : 28 [ 4]> plp`	`1fd4 : 28 [ 4]> plp`

`1bb5 : e417 [ 3] cpx zp7f`	`1fd5 : e4bd [ 3] cpx zp7f`
`tst_stat ~fnz`	`tst_stat ~fnz`
`1bb7 : 08 [ 3]> php ;save status`	`1fd7 : 08 [ 3]> php ;save status`
`1bb8 : 08 [ 3]> php ;use stack to retrieve status`	`1fd8 : 08 [ 3]> php ;use stack to retrieve status`
`1bb9 : 68 [ 4]> pla`	`1fd9 : 68 [ 4]> pla`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1bba : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`1fda : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1bbc : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1fdc : f002 [ 3]> beq skip1710`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1fde : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1fdf : 1a > db test_num`
	`>`
	`1fe0 : >skip1710`
`>`	`>`
`1bbe : 28 [ 4]> plp ;restore status`	`1fe0 : 28 [ 4]> plp ;restore status`

`1bbf : ca [ 2] dex`	`1fe1 : ca [ 2] dex`
`1bc0 : e417 [ 3] cpx zp7f`	`1fe2 : e4bd [ 3] cpx zp7f`
`tst_stat ~fn`	`tst_stat ~fn`
`1bc2 : 08 [ 3]> php ;save status`	`1fe4 : 08 [ 3]> php ;save status`
`1bc3 : 08 [ 3]> php ;use stack to retrieve status`	`1fe5 : 08 [ 3]> php ;use stack to retrieve status`
`1bc4 : 68 [ 4]> pla`	`1fe6 : 68 [ 4]> pla`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`1bc5 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`1fe7 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1bc7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1fe9 : f002 [ 3]> beq skip1714`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1feb : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1fec : 1a > db test_num`
`>`	`>`
`1bc9 : 28 [ 4]> plp ;restore status`	`1fed : >skip1714`
	`>`
	`1fed : 28 [ 4]> plp ;restore status`

`1bca : ca [ 2] dex`	`1fee : ca [ 2] dex`
`1bcb : e417 [ 3] cpx zp7f`	`1fef : e4bd [ 3] cpx zp7f`
`tst_x $7e,~fzc`	`tst_x $7e,~fzc`
`1bcd : 08 [ 3]> php ;save flags`	`1ff1 : 08 [ 3]> php ;save flags`
`1bce : 08 [ 3]> php`	`1ff2 : 08 [ 3]> php`
`1bcf : e07e [ 2]> cpx #$7e ;test result`	`1ff3 : e07e [ 2]> cpx #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1bd1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1ff5 : f002 [ 3]> beq skip1717`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 216`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ff7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1ff8 : 1a > db test_num`
`>`	`>`
`1bd3 : 68 [ 4]> pla ;load status`	`1ff9 : >skip1717`
	`>`
	`1ff9 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`1bd4 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`1ffa : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1bd6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`1ffc : f002 [ 4]> beq skip1720`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`1ffe : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`1fff : 1a > db test_num`
`>`	`>`
`1bd8 : 28 [ 4]> plp ;restore status`	`2000 : >skip1720`
	`>`
	`2000 : 28 [ 4]> plp ;restore status`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 135`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`set_x $80,0`	`set_x $80,0`
`> load_flag 0`	`> load_flag 0`
`1bd9 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2001 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1bdb : 48 [ 3]> pha ;use stack to load status`	`2003 : 48 [ 3]> pha ;use stack to load status`
`1bdc : a280 [ 2]> ldx #$80 ;precharge index x`	`2004 : a280 [ 2]> ldx #$80 ;precharge index x`
`1bde : 28 [ 4]> plp`	`2006 : 28 [ 4]> plp`

`1bdf : ec0c02 [ 4] cpx abs7f`	`2007 : ec0c02 [ 4] cpx abs7f`
`tst_stat fc`	`tst_stat fc`
`1be2 : 08 [ 3]> php ;save status`	`200a : 08 [ 3]> php ;save status`
`1be3 : 08 [ 3]> php ;use stack to retrieve status`	`200b : 08 [ 3]> php ;use stack to retrieve status`
`1be4 : 68 [ 4]> pla`	`200c : 68 [ 4]> pla`
`> cmp_flag fc`	`> cmp_flag fc`
`1be5 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`200d : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1be7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`200f : f002 [ 3]> beq skip1726`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2011 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2012 : 1a > db test_num`
	`>`
	`2013 : >skip1726`
`>`	`>`
`1be9 : 28 [ 4]> plp ;restore status`	`2013 : 28 [ 4]> plp ;restore status`

`1bea : ca [ 2] dex`	`2014 : ca [ 2] dex`
`1beb : ec0c02 [ 4] cpx abs7f`	`2015 : ec0c02 [ 4] cpx abs7f`
`tst_stat fzc`	`tst_stat fzc`
`1bee : 08 [ 3]> php ;save status`	`2018 : 08 [ 3]> php ;save status`
`1bef : 08 [ 3]> php ;use stack to retrieve status`	`2019 : 08 [ 3]> php ;use stack to retrieve status`
`1bf0 : 68 [ 4]> pla`	`201a : 68 [ 4]> pla`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 217`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> cmp_flag fzc`	`> cmp_flag fzc`
`1bf1 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`201b : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1bf3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`201d : f002 [ 3]> beq skip1730`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`201f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2020 : 1a > db test_num`
	`>`
	`2021 : >skip1730`
`>`	`>`
`1bf5 : 28 [ 4]> plp ;restore status`	`2021 : 28 [ 4]> plp ;restore status`

`1bf6 : ca [ 2] dex`	`2022 : ca [ 2] dex`
`1bf7 : ec0c02 [ 4] cpx abs7f`	`2023 : ec0c02 [ 4] cpx abs7f`
`tst_x $7e,fn`	`tst_x $7e,fn`
`1bfa : 08 [ 3]> php ;save flags`	`2026 : 08 [ 3]> php ;save flags`
`1bfb : 08 [ 3]> php`	`2027 : 08 [ 3]> php`
`1bfc : e07e [ 2]> cpx #$7e ;test result`	`2028 : e07e [ 2]> cpx #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1bfe : d0fe [ 3]> bne * ;failed not equal (non zero)`	`202a : f002 [ 3]> beq skip1733`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`202c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`202d : 1a > db test_num`
	`>`
	`202e : >skip1733`
`>`	`>`
`1c00 : 68 [ 4]> pla ;load status`	`202e : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`1c01 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`202f : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1c03 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2031 : f002 [ 3]> beq skip1736`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2033 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2034 : 1a > db test_num`
`>`	`>`
`1c05 : 28 [ 4]> plp ;restore status`	`2035 : >skip1736`
	`>`
	`2035 : 28 [ 4]> plp ;restore status`

`set_x $80,$ff`	`set_x $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 136`	`2036 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1c06 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1c08 : 48 [ 3]> pha ;use stack to load status`	`2038 : 48 [ 3]> pha ;use stack to load status`
`1c09 : a280 [ 2]> ldx #$80 ;precharge index x`	`2039 : a280 [ 2]> ldx #$80 ;precharge index x`
`1c0b : 28 [ 4]> plp`	`203b : 28 [ 4]> plp`

`1c0c : ec0c02 [ 4] cpx abs7f`	`203c : ec0c02 [ 4] cpx abs7f`
`tst_stat ~fnz`	`tst_stat ~fnz`
`1c0f : 08 [ 3]> php ;save status`	`203f : 08 [ 3]> php ;save status`
`1c10 : 08 [ 3]> php ;use stack to retrieve status`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 218`
`1c11 : 68 [ 4]> pla`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2040 : 08 [ 3]> php ;use stack to retrieve status`
	`2041 : 68 [ 4]> pla`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1c12 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`2042 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1c14 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2044 : f002 [ 3]> beq skip1742`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2046 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2047 : 1a > db test_num`
	`>`
	`2048 : >skip1742`
`>`	`>`
`1c16 : 28 [ 4]> plp ;restore status`	`2048 : 28 [ 4]> plp ;restore status`

`1c17 : ca [ 2] dex`	`2049 : ca [ 2] dex`
`1c18 : ec0c02 [ 4] cpx abs7f`	`204a : ec0c02 [ 4] cpx abs7f`
`tst_stat ~fn`	`tst_stat ~fn`
`1c1b : 08 [ 3]> php ;save status`	`204d : 08 [ 3]> php ;save status`
`1c1c : 08 [ 3]> php ;use stack to retrieve status`	`204e : 08 [ 3]> php ;use stack to retrieve status`
`1c1d : 68 [ 4]> pla`	`204f : 68 [ 4]> pla`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`1c1e : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`2050 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1c20 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2052 : f002 [ 3]> beq skip1746`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2054 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2055 : 1a > db test_num`
`>`	`>`
`1c22 : 28 [ 4]> plp ;restore status`	`2056 : >skip1746`
	`>`
	`2056 : 28 [ 4]> plp ;restore status`

`1c23 : ca [ 2] dex`	`2057 : ca [ 2] dex`
`1c24 : ec0c02 [ 4] cpx abs7f`	`2058 : ec0c02 [ 4] cpx abs7f`
`tst_x $7e,~fzc`	`tst_x $7e,~fzc`
`1c27 : 08 [ 3]> php ;save flags`	`205b : 08 [ 3]> php ;save flags`
`1c28 : 08 [ 3]> php`	`205c : 08 [ 3]> php`
`1c29 : e07e [ 2]> cpx #$7e ;test result`	`205d : e07e [ 2]> cpx #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1c2b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`205f : f002 [ 3]> beq skip1749`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2061 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2062 : 1a > db test_num`
`>`	`>`
`1c2d : 68 [ 4]> pla ;load status`	`2063 : >skip1749`
	`>`
	`2063 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`1c2e : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`2064 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 219`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> trap_ne`	`> trap_ne`
`1c30 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2066 : f002 [ 3]> beq skip1752`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2068 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2069 : 1a > db test_num`
`>`	`>`
`1c32 : 28 [ 4]> plp ;restore status`	`206a : >skip1752`
	`>`
	`206a : 28 [ 4]> plp ;restore status`


`set_x $80,0`	`set_x $80,0`
`> load_flag 0`	`> load_flag 0`
`1c33 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`206b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 137`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`1c35 : 48 [ 3]> pha ;use stack to load status`	`206d : 48 [ 3]> pha ;use stack to load status`
`1c36 : a280 [ 2]> ldx #$80 ;precharge index x`	`206e : a280 [ 2]> ldx #$80 ;precharge index x`
`1c38 : 28 [ 4]> plp`	`2070 : 28 [ 4]> plp`

`1c39 : e07f [ 2] cpx #$7f`	`2071 : e07f [ 2] cpx #$7f`
`tst_stat fc`	`tst_stat fc`
`1c3b : 08 [ 3]> php ;save status`	`2073 : 08 [ 3]> php ;save status`
`1c3c : 08 [ 3]> php ;use stack to retrieve status`	`2074 : 08 [ 3]> php ;use stack to retrieve status`
`1c3d : 68 [ 4]> pla`	`2075 : 68 [ 4]> pla`
`> cmp_flag fc`	`> cmp_flag fc`
`1c3e : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`2076 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1c40 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2078 : f002 [ 3]> beq skip1758`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`207a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`207b : 1a > db test_num`
`>`	`>`
`1c42 : 28 [ 4]> plp ;restore status`	`207c : >skip1758`
	`>`
	`207c : 28 [ 4]> plp ;restore status`

`1c43 : ca [ 2] dex`	`207d : ca [ 2] dex`
`1c44 : e07f [ 2] cpx #$7f`	`207e : e07f [ 2] cpx #$7f`
`tst_stat fzc`	`tst_stat fzc`
`1c46 : 08 [ 3]> php ;save status`	`2080 : 08 [ 3]> php ;save status`
`1c47 : 08 [ 3]> php ;use stack to retrieve status`	`2081 : 08 [ 3]> php ;use stack to retrieve status`
`1c48 : 68 [ 4]> pla`	`2082 : 68 [ 4]> pla`
`> cmp_flag fzc`	`> cmp_flag fzc`
`1c49 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`2083 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1c4b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2085 : f002 [ 3]> beq skip1762`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2087 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2088 : 1a > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 220`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2089 : >skip1762`
`>`	`>`
`1c4d : 28 [ 4]> plp ;restore status`	`2089 : 28 [ 4]> plp ;restore status`

`1c4e : ca [ 2] dex`	`208a : ca [ 2] dex`
`1c4f : e07f [ 2] cpx #$7f`	`208b : e07f [ 2] cpx #$7f`
`tst_x $7e,fn`	`tst_x $7e,fn`
`1c51 : 08 [ 3]> php ;save flags`	`208d : 08 [ 3]> php ;save flags`
`1c52 : 08 [ 3]> php`	`208e : 08 [ 3]> php`
`1c53 : e07e [ 2]> cpx #$7e ;test result`	`208f : e07e [ 2]> cpx #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1c55 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2091 : f002 [ 3]> beq skip1765`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2093 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2094 : 1a > db test_num`
`>`	`>`
`1c57 : 68 [ 4]> pla ;load status`	`2095 : >skip1765`
	`>`
	`2095 : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`1c58 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`2096 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1c5a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2098 : f002 [ 3]> beq skip1768`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`209a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`209b : 1a > db test_num`
	`>`
	`209c : >skip1768`
`>`	`>`
`1c5c : 28 [ 4]> plp ;restore status`	`209c : 28 [ 4]> plp ;restore status`

`set_x $80,$ff`	`set_x $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1c5d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`209d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1c5f : 48 [ 3]> pha ;use stack to load status`	`209f : 48 [ 3]> pha ;use stack to load status`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 138`	`20a0 : a280 [ 2]> ldx #$80 ;precharge index x`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`20a2 : 28 [ 4]> plp`

`1c60 : a280 [ 2]> ldx #$80 ;precharge index x`
`1c62 : 28 [ 4]> plp`

`1c63 : e07f [ 2] cpx #$7f`	`20a3 : e07f [ 2] cpx #$7f`
`tst_stat ~fnz`	`tst_stat ~fnz`
`1c65 : 08 [ 3]> php ;save status`	`20a5 : 08 [ 3]> php ;save status`
`1c66 : 08 [ 3]> php ;use stack to retrieve status`	`20a6 : 08 [ 3]> php ;use stack to retrieve status`
`1c67 : 68 [ 4]> pla`	`20a7 : 68 [ 4]> pla`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1c68 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`20a8 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1c6a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`20aa : f002 [ 3]> beq skip1774`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`20ac : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 221`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`20ad : 1a > db test_num`
	`>`
	`20ae : >skip1774`
`>`	`>`
`1c6c : 28 [ 4]> plp ;restore status`	`20ae : 28 [ 4]> plp ;restore status`

`1c6d : ca [ 2] dex`	`20af : ca [ 2] dex`
`1c6e : e07f [ 2] cpx #$7f`	`20b0 : e07f [ 2] cpx #$7f`
`tst_stat ~fn`	`tst_stat ~fn`
`1c70 : 08 [ 3]> php ;save status`	`20b2 : 08 [ 3]> php ;save status`
`1c71 : 08 [ 3]> php ;use stack to retrieve status`	`20b3 : 08 [ 3]> php ;use stack to retrieve status`
`1c72 : 68 [ 4]> pla`	`20b4 : 68 [ 4]> pla`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`1c73 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`20b5 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1c75 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`20b7 : f002 [ 3]> beq skip1778`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`20b9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`20ba : 1a > db test_num`
`>`	`>`
`1c77 : 28 [ 4]> plp ;restore status`	`20bb : >skip1778`
	`>`
	`20bb : 28 [ 4]> plp ;restore status`

`1c78 : ca [ 2] dex`	`20bc : ca [ 2] dex`
`1c79 : e07f [ 2] cpx #$7f`	`20bd : e07f [ 2] cpx #$7f`
`tst_x $7e,~fzc`	`tst_x $7e,~fzc`
`1c7b : 08 [ 3]> php ;save flags`	`20bf : 08 [ 3]> php ;save flags`
`1c7c : 08 [ 3]> php`	`20c0 : 08 [ 3]> php`
`1c7d : e07e [ 2]> cpx #$7e ;test result`	`20c1 : e07e [ 2]> cpx #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1c7f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`20c3 : f002 [ 3]> beq skip1781`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`20c5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`20c6 : 1a > db test_num`
`>`	`>`
`1c81 : 68 [ 4]> pla ;load status`	`20c7 : >skip1781`
	`>`
	`20c7 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`1c82 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`20c8 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1c84 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`20ca : f002 [ 3]> beq skip1784`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`20cc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`20cd : 1a > db test_num`
	`>`
	`20ce : >skip1784`
`>`	`>`
`1c86 : 28 [ 4]> plp ;restore status`	`20ce : 28 [ 4]> plp ;restore status`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 222`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`next_test`	`next_test`
`1c87 : ad0002 [ 4]> lda test_case ;previous test`	`20cf : ad0002 [ 4]> lda test_case ;previous test`
`1c8a : c91a [ 2]> cmp #test_num`	`20d2 : c91a [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`1c8c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`20d4 : f002 [ 3]> beq skip1787`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`20d6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`20d7 : 1a > db test_num`
	`>`
	`20d8 : >skip1787`
`>`	`>`
`001b = >test_num = test_num + 1`	`001b = >test_num = test_num + 1`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 139`	`20d8 : a91b [ 2]> lda #test_num ;*** this tests' number`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`20da : 8d0002 [ 4]> sta test_case`

`1c8e : a91b [ 2]> lda #test_num ;*** this tests' number`
`1c90 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; CPY - zp / abs / #`	`; CPY - zp / abs / #`

`set_y $80,0`	`set_y $80,0`
`> load_flag 0`	`> load_flag 0`
`1c93 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`20dd : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1c95 : 48 [ 3]> pha ;use stack to load status`	`20df : 48 [ 3]> pha ;use stack to load status`
`1c96 : a080 [ 2]> ldy #$80 ;precharge index y`	`20e0 : a080 [ 2]> ldy #$80 ;precharge index y`
`1c98 : 28 [ 4]> plp`	`20e2 : 28 [ 4]> plp`

`1c99 : c417 [ 3] cpy zp7f`	`20e3 : c4bd [ 3] cpy zp7f`
`tst_stat fc`	`tst_stat fc`
`1c9b : 08 [ 3]> php ;save status`	`20e5 : 08 [ 3]> php ;save status`
`1c9c : 08 [ 3]> php ;use stack to retrieve status`	`20e6 : 08 [ 3]> php ;use stack to retrieve status`
`1c9d : 68 [ 4]> pla`	`20e7 : 68 [ 4]> pla`
`> cmp_flag fc`	`> cmp_flag fc`
`1c9e : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`20e8 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1ca0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`20ea : f002 [ 3]> beq skip1793`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`20ec : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`20ed : 1b > db test_num`
`>`	`>`
`1ca2 : 28 [ 4]> plp ;restore status`	`20ee : >skip1793`
	`>`
	`20ee : 28 [ 4]> plp ;restore status`

`1ca3 : 88 [ 2] dey`	`20ef : 88 [ 2] dey`
`1ca4 : c417 [ 3] cpy zp7f`	`20f0 : c4bd [ 3] cpy zp7f`
`tst_stat fzc`	`tst_stat fzc`
`1ca6 : 08 [ 3]> php ;save status`	`20f2 : 08 [ 3]> php ;save status`
`1ca7 : 08 [ 3]> php ;use stack to retrieve status`	`20f3 : 08 [ 3]> php ;use stack to retrieve status`
`1ca8 : 68 [ 4]> pla`	`20f4 : 68 [ 4]> pla`
`> cmp_flag fzc`	`> cmp_flag fzc`
`1ca9 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 223`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`20f5 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1cab : d0fe [ 3]> bne * ;failed not equal (non zero)`	`20f7 : f002 [ 3]> beq skip1797`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`20f9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`20fa : 1b > db test_num`
`>`	`>`
`1cad : 28 [ 4]> plp ;restore status`	`20fb : >skip1797`
	`>`
	`20fb : 28 [ 4]> plp ;restore status`

`1cae : 88 [ 2] dey`	`20fc : 88 [ 2] dey`
`1caf : c417 [ 3] cpy zp7f`	`20fd : c4bd [ 3] cpy zp7f`
`tst_y $7e,fn`	`tst_y $7e,fn`
`1cb1 : 08 [ 3]> php ;save flags`	`20ff : 08 [ 3]> php ;save flags`
`1cb2 : 08 [ 3]> php`	`2100 : 08 [ 3]> php`
`1cb3 : c07e [ 2]> cpy #$7e ;test result`	`2101 : c07e [ 2]> cpy #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1cb5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2103 : f002 [ 3]> beq skip1800`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2105 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2106 : 1b > db test_num`
`>`	`>`
`1cb7 : 68 [ 4]> pla ;load status`	`2107 : >skip1800`
	`>`
	`2107 : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`1cb8 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`2108 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 140`	`210a : f002 [ 3]> beq skip1803`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`1cba : d0fe [ 3]> bne * ;failed not equal (non zero)`	`210c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`210d : 1b > db test_num`
`>`	`>`
`1cbc : 28 [ 4]> plp ;restore status`	`210e : >skip1803`
	`>`
	`210e : 28 [ 4]> plp ;restore status`

`set_y $80,$ff`	`set_y $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1cbd : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`210f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1cbf : 48 [ 3]> pha ;use stack to load status`	`2111 : 48 [ 3]> pha ;use stack to load status`
`1cc0 : a080 [ 2]> ldy #$80 ;precharge index y`	`2112 : a080 [ 2]> ldy #$80 ;precharge index y`
`1cc2 : 28 [ 4]> plp`	`2114 : 28 [ 4]> plp`

`1cc3 : c417 [ 3] cpy zp7f`	`2115 : c4bd [ 3] cpy zp7f`
`tst_stat ~fnz`	`tst_stat ~fnz`
`1cc5 : 08 [ 3]> php ;save status`	`2117 : 08 [ 3]> php ;save status`
`1cc6 : 08 [ 3]> php ;use stack to retrieve status`	`2118 : 08 [ 3]> php ;use stack to retrieve status`
`1cc7 : 68 [ 4]> pla`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 224`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2119 : 68 [ 4]> pla`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1cc8 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`211a : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1cca : d0fe [ 3]> bne * ;failed not equal (non zero)`	`211c : f002 [ 3]> beq skip1809`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`211e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`211f : 1b > db test_num`
`>`	`>`
`1ccc : 28 [ 4]> plp ;restore status`	`2120 : >skip1809`
	`>`
	`2120 : 28 [ 4]> plp ;restore status`

`1ccd : 88 [ 2] dey`	`2121 : 88 [ 2] dey`
`1cce : c417 [ 3] cpy zp7f`	`2122 : c4bd [ 3] cpy zp7f`
`tst_stat ~fn`	`tst_stat ~fn`
`1cd0 : 08 [ 3]> php ;save status`	`2124 : 08 [ 3]> php ;save status`
`1cd1 : 08 [ 3]> php ;use stack to retrieve status`	`2125 : 08 [ 3]> php ;use stack to retrieve status`
`1cd2 : 68 [ 4]> pla`	`2126 : 68 [ 4]> pla`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`1cd3 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`2127 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1cd5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2129 : f002 [ 3]> beq skip1813`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`212b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`212c : 1b > db test_num`
	`>`
	`212d : >skip1813`
`>`	`>`
`1cd7 : 28 [ 4]> plp ;restore status`	`212d : 28 [ 4]> plp ;restore status`

`1cd8 : 88 [ 2] dey`	`212e : 88 [ 2] dey`
`1cd9 : c417 [ 3] cpy zp7f`	`212f : c4bd [ 3] cpy zp7f`
`tst_y $7e,~fzc`	`tst_y $7e,~fzc`
`1cdb : 08 [ 3]> php ;save flags`	`2131 : 08 [ 3]> php ;save flags`
`1cdc : 08 [ 3]> php`	`2132 : 08 [ 3]> php`
`1cdd : c07e [ 2]> cpy #$7e ;test result`	`2133 : c07e [ 2]> cpy #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1cdf : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2135 : f002 [ 3]> beq skip1816`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2137 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2138 : 1b > db test_num`
`>`	`>`
`1ce1 : 68 [ 4]> pla ;load status`	`2139 : >skip1816`
	`>`
	`2139 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`1ce2 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`213a : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1ce4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 225`
`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 141`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1ce6 : 28 [ 4]> plp ;restore status`	`213c : f002 [ 3]> beq skip1819`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`213e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`213f : 1b > db test_num`
	`>`
	`2140 : >skip1819`
	`>`
	`2140 : 28 [ 4]> plp ;restore status`


`set_y $80,0`	`set_y $80,0`
`> load_flag 0`	`> load_flag 0`
`1ce7 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2141 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1ce9 : 48 [ 3]> pha ;use stack to load status`	`2143 : 48 [ 3]> pha ;use stack to load status`
`1cea : a080 [ 2]> ldy #$80 ;precharge index y`	`2144 : a080 [ 2]> ldy #$80 ;precharge index y`
`1cec : 28 [ 4]> plp`	`2146 : 28 [ 4]> plp`

`1ced : cc0c02 [ 4] cpy abs7f`	`2147 : cc0c02 [ 4] cpy abs7f`
`tst_stat fc`	`tst_stat fc`
`1cf0 : 08 [ 3]> php ;save status`	`214a : 08 [ 3]> php ;save status`
`1cf1 : 08 [ 3]> php ;use stack to retrieve status`	`214b : 08 [ 3]> php ;use stack to retrieve status`
`1cf2 : 68 [ 4]> pla`	`214c : 68 [ 4]> pla`
`> cmp_flag fc`	`> cmp_flag fc`
`1cf3 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`214d : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1cf5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`214f : f002 [ 3]> beq skip1825`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2151 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2152 : 1b > db test_num`
`>`	`>`
`1cf7 : 28 [ 4]> plp ;restore status`	`2153 : >skip1825`
	`>`
	`2153 : 28 [ 4]> plp ;restore status`

`1cf8 : 88 [ 2] dey`	`2154 : 88 [ 2] dey`
`1cf9 : cc0c02 [ 4] cpy abs7f`	`2155 : cc0c02 [ 4] cpy abs7f`
`tst_stat fzc`	`tst_stat fzc`
`1cfc : 08 [ 3]> php ;save status`	`2158 : 08 [ 3]> php ;save status`
`1cfd : 08 [ 3]> php ;use stack to retrieve status`	`2159 : 08 [ 3]> php ;use stack to retrieve status`
`1cfe : 68 [ 4]> pla`	`215a : 68 [ 4]> pla`
`> cmp_flag fzc`	`> cmp_flag fzc`
`1cff : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`215b : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1d01 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`215d : f002 [ 3]> beq skip1829`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`215f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2160 : 1b > db test_num`
	`>`
	`2161 : >skip1829`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 226`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`1d03 : 28 [ 4]> plp ;restore status`	`2161 : 28 [ 4]> plp ;restore status`

`1d04 : 88 [ 2] dey`	`2162 : 88 [ 2] dey`
`1d05 : cc0c02 [ 4] cpy abs7f`	`2163 : cc0c02 [ 4] cpy abs7f`
`tst_y $7e,fn`	`tst_y $7e,fn`
`1d08 : 08 [ 3]> php ;save flags`	`2166 : 08 [ 3]> php ;save flags`
`1d09 : 08 [ 3]> php`	`2167 : 08 [ 3]> php`
`1d0a : c07e [ 2]> cpy #$7e ;test result`	`2168 : c07e [ 2]> cpy #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1d0c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`216a : f002 [ 3]> beq skip1832`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`216c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`216d : 1b > db test_num`
`>`	`>`
`1d0e : 68 [ 4]> pla ;load status`	`216e : >skip1832`
	`>`
	`216e : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`1d0f : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`216f : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1d11 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2171 : f002 [ 3]> beq skip1835`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2173 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2174 : 1b > db test_num`
`>`	`>`
`1d13 : 28 [ 4]> plp ;restore status`	`2175 : >skip1835`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 142`	`>`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`2175 : 28 [ 4]> plp ;restore status`


`set_y $80,$ff`	`set_y $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1d14 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2176 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1d16 : 48 [ 3]> pha ;use stack to load status`	`2178 : 48 [ 3]> pha ;use stack to load status`
`1d17 : a080 [ 2]> ldy #$80 ;precharge index y`	`2179 : a080 [ 2]> ldy #$80 ;precharge index y`
`1d19 : 28 [ 4]> plp`	`217b : 28 [ 4]> plp`

`1d1a : cc0c02 [ 4] cpy abs7f`	`217c : cc0c02 [ 4] cpy abs7f`
`tst_stat ~fnz`	`tst_stat ~fnz`
`1d1d : 08 [ 3]> php ;save status`	`217f : 08 [ 3]> php ;save status`
`1d1e : 08 [ 3]> php ;use stack to retrieve status`	`2180 : 08 [ 3]> php ;use stack to retrieve status`
`1d1f : 68 [ 4]> pla`	`2181 : 68 [ 4]> pla`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1d20 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`2182 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1d22 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2184 : f002 [ 3]> beq skip1841`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2186 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2187 : 1b > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 227`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`1d24 : 28 [ 4]> plp ;restore status`	`2188 : >skip1841`
	`>`
	`2188 : 28 [ 4]> plp ;restore status`

`1d25 : 88 [ 2] dey`	`2189 : 88 [ 2] dey`
`1d26 : cc0c02 [ 4] cpy abs7f`	`218a : cc0c02 [ 4] cpy abs7f`
`tst_stat ~fn`	`tst_stat ~fn`
`1d29 : 08 [ 3]> php ;save status`	`218d : 08 [ 3]> php ;save status`
`1d2a : 08 [ 3]> php ;use stack to retrieve status`	`218e : 08 [ 3]> php ;use stack to retrieve status`
`1d2b : 68 [ 4]> pla`	`218f : 68 [ 4]> pla`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`1d2c : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`2190 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1d2e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2192 : f002 [ 3]> beq skip1845`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2194 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2195 : 1b > db test_num`
	`>`
	`2196 : >skip1845`
`>`	`>`
`1d30 : 28 [ 4]> plp ;restore status`	`2196 : 28 [ 4]> plp ;restore status`

`1d31 : 88 [ 2] dey`	`2197 : 88 [ 2] dey`
`1d32 : cc0c02 [ 4] cpy abs7f`	`2198 : cc0c02 [ 4] cpy abs7f`
`tst_y $7e,~fzc`	`tst_y $7e,~fzc`
`1d35 : 08 [ 3]> php ;save flags`	`219b : 08 [ 3]> php ;save flags`
`1d36 : 08 [ 3]> php`	`219c : 08 [ 3]> php`
`1d37 : c07e [ 2]> cpy #$7e ;test result`	`219d : c07e [ 2]> cpy #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1d39 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`219f : f002 [ 3]> beq skip1848`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`21a1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`21a2 : 1b > db test_num`
	`>`
	`21a3 : >skip1848`
`>`	`>`
`1d3b : 68 [ 4]> pla ;load status`	`21a3 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`1d3c : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`21a4 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1d3e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`21a6 : f002 [ 3]> beq skip1851`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`21a8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`21a9 : 1b > db test_num`
`>`	`>`
`1d40 : 28 [ 4]> plp ;restore status`	`21aa : >skip1851`
	`>`
	`21aa : 28 [ 4]> plp ;restore status`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 143`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 228`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`set_y $80,0`	`set_y $80,0`
`> load_flag 0`	`> load_flag 0`
`1d41 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`21ab : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1d43 : 48 [ 3]> pha ;use stack to load status`	`21ad : 48 [ 3]> pha ;use stack to load status`
`1d44 : a080 [ 2]> ldy #$80 ;precharge index y`	`21ae : a080 [ 2]> ldy #$80 ;precharge index y`
`1d46 : 28 [ 4]> plp`	`21b0 : 28 [ 4]> plp`

`1d47 : c07f [ 2] cpy #$7f`	`21b1 : c07f [ 2] cpy #$7f`
`tst_stat fc`	`tst_stat fc`
`1d49 : 08 [ 3]> php ;save status`	`21b3 : 08 [ 3]> php ;save status`
`1d4a : 08 [ 3]> php ;use stack to retrieve status`	`21b4 : 08 [ 3]> php ;use stack to retrieve status`
`1d4b : 68 [ 4]> pla`	`21b5 : 68 [ 4]> pla`
`> cmp_flag fc`	`> cmp_flag fc`
`1d4c : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`21b6 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1d4e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`21b8 : f002 [ 3]> beq skip1857`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`21ba : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`21bb : 1b > db test_num`
`>`	`>`
`1d50 : 28 [ 4]> plp ;restore status`	`21bc : >skip1857`
	`>`
	`21bc : 28 [ 4]> plp ;restore status`

`1d51 : 88 [ 2] dey`	`21bd : 88 [ 2] dey`
`1d52 : c07f [ 2] cpy #$7f`	`21be : c07f [ 2] cpy #$7f`
`tst_stat fzc`	`tst_stat fzc`
`1d54 : 08 [ 3]> php ;save status`	`21c0 : 08 [ 3]> php ;save status`
`1d55 : 08 [ 3]> php ;use stack to retrieve status`	`21c1 : 08 [ 3]> php ;use stack to retrieve status`
`1d56 : 68 [ 4]> pla`	`21c2 : 68 [ 4]> pla`
`> cmp_flag fzc`	`> cmp_flag fzc`
`1d57 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`21c3 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1d59 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`21c5 : f002 [ 3]> beq skip1861`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`21c7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`21c8 : 1b > db test_num`
	`>`
	`21c9 : >skip1861`
`>`	`>`
`1d5b : 28 [ 4]> plp ;restore status`	`21c9 : 28 [ 4]> plp ;restore status`

`1d5c : 88 [ 2] dey`	`21ca : 88 [ 2] dey`
`1d5d : c07f [ 2] cpy #$7f`	`21cb : c07f [ 2] cpy #$7f`
`tst_y $7e,fn`	`tst_y $7e,fn`
`1d5f : 08 [ 3]> php ;save flags`	`21cd : 08 [ 3]> php ;save flags`
`1d60 : 08 [ 3]> php`	`21ce : 08 [ 3]> php`
`1d61 : c07e [ 2]> cpy #$7e ;test result`	`21cf : c07e [ 2]> cpy #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1d63 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 229`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`21d1 : f002 [ 3]> beq skip1864`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`21d3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`21d4 : 1b > db test_num`
	`>`
	`21d5 : >skip1864`
`>`	`>`
`1d65 : 68 [ 4]> pla ;load status`	`21d5 : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`1d66 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`21d6 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1d68 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`21d8 : f002 [ 3]> beq skip1867`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`21da : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`21db : 1b > db test_num`
`>`	`>`
`1d6a : 28 [ 4]> plp ;restore status`	`21dc : >skip1867`
	`>`
	`21dc : 28 [ 4]> plp ;restore status`

`set_y $80,$ff`	`set_y $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 144`	`21dd : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1d6b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1d6d : 48 [ 3]> pha ;use stack to load status`	`21df : 48 [ 3]> pha ;use stack to load status`
`1d6e : a080 [ 2]> ldy #$80 ;precharge index y`	`21e0 : a080 [ 2]> ldy #$80 ;precharge index y`
`1d70 : 28 [ 4]> plp`	`21e2 : 28 [ 4]> plp`

`1d71 : c07f [ 2] cpy #$7f`	`21e3 : c07f [ 2] cpy #$7f`
`tst_stat ~fnz`	`tst_stat ~fnz`
`1d73 : 08 [ 3]> php ;save status`	`21e5 : 08 [ 3]> php ;save status`
`1d74 : 08 [ 3]> php ;use stack to retrieve status`	`21e6 : 08 [ 3]> php ;use stack to retrieve status`
`1d75 : 68 [ 4]> pla`	`21e7 : 68 [ 4]> pla`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1d76 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`21e8 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1d78 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`21ea : f002 [ 3]> beq skip1873`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`21ec : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`21ed : 1b > db test_num`
`>`	`>`
`1d7a : 28 [ 4]> plp ;restore status`	`21ee : >skip1873`
	`>`
	`21ee : 28 [ 4]> plp ;restore status`

`1d7b : 88 [ 2] dey`	`21ef : 88 [ 2] dey`
`1d7c : c07f [ 2] cpy #$7f`	`21f0 : c07f [ 2] cpy #$7f`
`tst_stat ~fn`	`tst_stat ~fn`
`1d7e : 08 [ 3]> php ;save status`	`21f2 : 08 [ 3]> php ;save status`
`1d7f : 08 [ 3]> php ;use stack to retrieve status`	`21f3 : 08 [ 3]> php ;use stack to retrieve status`
`1d80 : 68 [ 4]> pla`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 230`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`21f4 : 68 [ 4]> pla`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`1d81 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`21f5 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1d83 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`21f7 : f002 [ 3]> beq skip1877`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`21f9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`21fa : 1b > db test_num`
`>`	`>`
`1d85 : 28 [ 4]> plp ;restore status`	`21fb : >skip1877`
	`>`
	`21fb : 28 [ 4]> plp ;restore status`

`1d86 : 88 [ 2] dey`	`21fc : 88 [ 2] dey`
`1d87 : c07f [ 2] cpy #$7f`	`21fd : c07f [ 2] cpy #$7f`
`tst_y $7e,~fzc`	`tst_y $7e,~fzc`
`1d89 : 08 [ 3]> php ;save flags`	`21ff : 08 [ 3]> php ;save flags`
`1d8a : 08 [ 3]> php`	`2200 : 08 [ 3]> php`
`1d8b : c07e [ 2]> cpy #$7e ;test result`	`2201 : c07e [ 2]> cpy #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1d8d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2203 : f002 [ 3]> beq skip1880`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2205 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2206 : 1b > db test_num`
`>`	`>`
`1d8f : 68 [ 4]> pla ;load status`	`2207 : >skip1880`
	`>`
	`2207 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`1d90 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`2208 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1d92 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`220a : f002 [ 3]> beq skip1883`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`220c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`220d : 1b > db test_num`
	`>`
	`220e : >skip1883`
`>`	`>`
`1d94 : 28 [ 4]> plp ;restore status`	`220e : 28 [ 4]> plp ;restore status`

`next_test`	`next_test`
`1d95 : ad0002 [ 4]> lda test_case ;previous test`	`220f : ad0002 [ 4]> lda test_case ;previous test`
`1d98 : c91b [ 2]> cmp #test_num`	`2212 : c91b [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 145`	`2214 : f002 [ 3]> beq skip1886`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2216 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2217 : 1b > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 231`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1d9a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2218 : >skip1886`
`>`	`>`
`001c = >test_num = test_num + 1`	`001c = >test_num = test_num + 1`
`1d9c : a91c [ 2]> lda #test_num ;*** this tests' number`	`2218 : a91c [ 2]> lda #test_num ;*** this tests' number`
`1d9e : 8d0002 [ 4]> sta test_case`	`221a : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; CMP - zp / abs / #`	`; CMP - zp / abs / #`

`set_a $80,0`	`set_a $80,0`
`> load_flag 0`	`> load_flag 0`
`1da1 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`221d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1da3 : 48 [ 3]> pha ;use stack to load status`	`221f : 48 [ 3]> pha ;use stack to load status`
`1da4 : a980 [ 2]> lda #$80 ;precharge accu`	`2220 : a980 [ 2]> lda #$80 ;precharge accu`
`1da6 : 28 [ 4]> plp`	`2222 : 28 [ 4]> plp`

`1da7 : c517 [ 3] cmp zp7f`	`2223 : c5bd [ 3] cmp zp7f`
`tst_a $80,fc`	`tst_a $80,fc`
`1da9 : 08 [ 3]> php ;save flags`	`2225 : 08 [ 3]> php ;save flags`
`1daa : 08 [ 3]> php`	`2226 : 08 [ 3]> php`
`1dab : c980 [ 2]> cmp #$80 ;test result`	`2227 : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`1dad : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2229 : f002 [ 3]> beq skip1891`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`222b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`222c : 1c > db test_num`
	`>`
	`222d : >skip1891`
`>`	`>`
`1daf : 68 [ 4]> pla ;load status`	`222d : 68 [ 4]> pla ;load status`
`> cmp_flag fc`	`> cmp_flag fc`
`1db0 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`222e : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1db2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2230 : f002 [ 3]> beq skip1894`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2232 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2233 : 1c > db test_num`
`>`	`>`
`1db4 : 28 [ 4]> plp ;restore status`	`2234 : >skip1894`
	`>`
	`2234 : 28 [ 4]> plp ;restore status`

`set_a $7f,0`	`set_a $7f,0`
`> load_flag 0`	`> load_flag 0`
`1db5 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2235 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1db7 : 48 [ 3]> pha ;use stack to load status`	`2237 : 48 [ 3]> pha ;use stack to load status`
`1db8 : a97f [ 2]> lda #$7f ;precharge accu`	`2238 : a97f [ 2]> lda #$7f ;precharge accu`
`1dba : 28 [ 4]> plp`	`223a : 28 [ 4]> plp`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 232`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1dbb : c517 [ 3] cmp zp7f`	`223b : c5bd [ 3] cmp zp7f`
`tst_a $7f,fzc`	`tst_a $7f,fzc`
`1dbd : 08 [ 3]> php ;save flags`	`223d : 08 [ 3]> php ;save flags`
`1dbe : 08 [ 3]> php`	`223e : 08 [ 3]> php`
`1dbf : c97f [ 2]> cmp #$7f ;test result`	`223f : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`1dc1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2241 : f002 [ 3]> beq skip1899`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2243 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2244 : 1c > db test_num`
	`>`
	`2245 : >skip1899`
`>`	`>`
`1dc3 : 68 [ 4]> pla ;load status`	`2245 : 68 [ 4]> pla ;load status`
`> cmp_flag fzc`	`> cmp_flag fzc`
`1dc4 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`2246 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 146`	`2248 : f002 [ 3]> beq skip1902`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`1dc6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`224a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`224b : 1c > db test_num`
	`>`
	`224c : >skip1902`
`>`	`>`
`1dc8 : 28 [ 4]> plp ;restore status`	`224c : 28 [ 4]> plp ;restore status`

`set_a $7e,0`	`set_a $7e,0`
`> load_flag 0`	`> load_flag 0`
`1dc9 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`224d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1dcb : 48 [ 3]> pha ;use stack to load status`	`224f : 48 [ 3]> pha ;use stack to load status`
`1dcc : a97e [ 2]> lda #$7e ;precharge accu`	`2250 : a97e [ 2]> lda #$7e ;precharge accu`
`1dce : 28 [ 4]> plp`	`2252 : 28 [ 4]> plp`

`1dcf : c517 [ 3] cmp zp7f`	`2253 : c5bd [ 3] cmp zp7f`
`tst_a $7e,fn`	`tst_a $7e,fn`
`1dd1 : 08 [ 3]> php ;save flags`	`2255 : 08 [ 3]> php ;save flags`
`1dd2 : 08 [ 3]> php`	`2256 : 08 [ 3]> php`
`1dd3 : c97e [ 2]> cmp #$7e ;test result`	`2257 : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1dd5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2259 : f002 [ 3]> beq skip1907`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`225b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`225c : 1c > db test_num`
	`>`
	`225d : >skip1907`
`>`	`>`
`1dd7 : 68 [ 4]> pla ;load status`	`225d : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`1dd8 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`225e : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 233`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> trap_ne`	`> trap_ne`
`1dda : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2260 : f002 [ 3]> beq skip1910`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2262 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2263 : 1c > db test_num`
	`>`
	`2264 : >skip1910`
`>`	`>`
`1ddc : 28 [ 4]> plp ;restore status`	`2264 : 28 [ 4]> plp ;restore status`

`set_a $80,$ff`	`set_a $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1ddd : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2265 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1ddf : 48 [ 3]> pha ;use stack to load status`	`2267 : 48 [ 3]> pha ;use stack to load status`
`1de0 : a980 [ 2]> lda #$80 ;precharge accu`	`2268 : a980 [ 2]> lda #$80 ;precharge accu`
`1de2 : 28 [ 4]> plp`	`226a : 28 [ 4]> plp`

`1de3 : c517 [ 3] cmp zp7f`	`226b : c5bd [ 3] cmp zp7f`
`tst_a $80,~fnz`	`tst_a $80,~fnz`
`1de5 : 08 [ 3]> php ;save flags`	`226d : 08 [ 3]> php ;save flags`
`1de6 : 08 [ 3]> php`	`226e : 08 [ 3]> php`
`1de7 : c980 [ 2]> cmp #$80 ;test result`	`226f : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`1de9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2271 : f002 [ 3]> beq skip1915`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2273 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2274 : 1c > db test_num`
	`>`
	`2275 : >skip1915`
`>`	`>`
`1deb : 68 [ 4]> pla ;load status`	`2275 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1dec : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`2276 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1dee : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2278 : f002 [ 3]> beq skip1918`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`227a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`227b : 1c > db test_num`
`>`	`>`
`1df0 : 28 [ 4]> plp ;restore status`	`227c : >skip1918`
	`>`
	`227c : 28 [ 4]> plp ;restore status`

`set_a $7f,$ff`	`set_a $7f,$ff`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 147`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag $ff`	`> load_flag $ff`
`1df1 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`227d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1df3 : 48 [ 3]> pha ;use stack to load status`	`227f : 48 [ 3]> pha ;use stack to load status`
`1df4 : a97f [ 2]> lda #$7f ;precharge accu`	`2280 : a97f [ 2]> lda #$7f ;precharge accu`
`1df6 : 28 [ 4]> plp`	`2282 : 28 [ 4]> plp`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 234`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1df7 : c517 [ 3] cmp zp7f`
	`2283 : c5bd [ 3] cmp zp7f`
`tst_a $7f,~fn`	`tst_a $7f,~fn`
`1df9 : 08 [ 3]> php ;save flags`	`2285 : 08 [ 3]> php ;save flags`
`1dfa : 08 [ 3]> php`	`2286 : 08 [ 3]> php`
`1dfb : c97f [ 2]> cmp #$7f ;test result`	`2287 : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`1dfd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2289 : f002 [ 3]> beq skip1923`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`228b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`228c : 1c > db test_num`
`>`	`>`
`1dff : 68 [ 4]> pla ;load status`	`228d : >skip1923`
	`>`
	`228d : 68 [ 4]> pla ;load status`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`1e00 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`228e : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1e02 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2290 : f002 [ 3]> beq skip1926`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2292 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2293 : 1c > db test_num`
	`>`
	`2294 : >skip1926`
`>`	`>`
`1e04 : 28 [ 4]> plp ;restore status`	`2294 : 28 [ 4]> plp ;restore status`

`set_a $7e,$ff`	`set_a $7e,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1e05 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2295 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1e07 : 48 [ 3]> pha ;use stack to load status`	`2297 : 48 [ 3]> pha ;use stack to load status`
`1e08 : a97e [ 2]> lda #$7e ;precharge accu`	`2298 : a97e [ 2]> lda #$7e ;precharge accu`
`1e0a : 28 [ 4]> plp`	`229a : 28 [ 4]> plp`

`1e0b : c517 [ 3] cmp zp7f`	`229b : c5bd [ 3] cmp zp7f`
`tst_a $7e,~fzc`	`tst_a $7e,~fzc`
`1e0d : 08 [ 3]> php ;save flags`	`229d : 08 [ 3]> php ;save flags`
`1e0e : 08 [ 3]> php`	`229e : 08 [ 3]> php`
`1e0f : c97e [ 2]> cmp #$7e ;test result`	`229f : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1e11 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`22a1 : f002 [ 3]> beq skip1931`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`22a3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`22a4 : 1c > db test_num`
	`>`
	`22a5 : >skip1931`
`>`	`>`
`1e13 : 68 [ 4]> pla ;load status`	`22a5 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`1e14 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`22a6 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 235`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`> trap_ne`	`> trap_ne`
`1e16 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`22a8 : f002 [ 3]> beq skip1934`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`22aa : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`22ab : 1c > db test_num`
	`>`
	`22ac : >skip1934`
`>`	`>`
`1e18 : 28 [ 4]> plp ;restore status`	`22ac : 28 [ 4]> plp ;restore status`


`set_a $80,0`	`set_a $80,0`
`> load_flag 0`	`> load_flag 0`
`1e19 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`22ad : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1e1b : 48 [ 3]> pha ;use stack to load status`	`22af : 48 [ 3]> pha ;use stack to load status`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 148`	`22b0 : a980 [ 2]> lda #$80 ;precharge accu`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`22b2 : 28 [ 4]> plp`

`1e1c : a980 [ 2]> lda #$80 ;precharge accu`	`22b3 : cd0c02 [ 4] cmp abs7f`
`1e1e : 28 [ 4]> plp`

`1e1f : cd0c02 [ 4] cmp abs7f`
`tst_a $80,fc`	`tst_a $80,fc`
`1e22 : 08 [ 3]> php ;save flags`	`22b6 : 08 [ 3]> php ;save flags`
`1e23 : 08 [ 3]> php`	`22b7 : 08 [ 3]> php`
`1e24 : c980 [ 2]> cmp #$80 ;test result`	`22b8 : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`1e26 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`22ba : f002 [ 3]> beq skip1939`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`22bc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`22bd : 1c > db test_num`
`>`	`>`
`1e28 : 68 [ 4]> pla ;load status`	`22be : >skip1939`
	`>`
	`22be : 68 [ 4]> pla ;load status`
`> cmp_flag fc`	`> cmp_flag fc`
`1e29 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`22bf : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1e2b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`22c1 : f002 [ 3]> beq skip1942`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`22c3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`22c4 : 1c > db test_num`
	`>`
	`22c5 : >skip1942`
`>`	`>`
`1e2d : 28 [ 4]> plp ;restore status`	`22c5 : 28 [ 4]> plp ;restore status`

`set_a $7f,0`	`set_a $7f,0`
`> load_flag 0`	`> load_flag 0`
`1e2e : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`22c6 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1e30 : 48 [ 3]> pha ;use stack to load status`	`22c8 : 48 [ 3]> pha ;use stack to load status`
`1e31 : a97f [ 2]> lda #$7f ;precharge accu`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 236`
`1e33 : 28 [ 4]> plp`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1e34 : cd0c02 [ 4] cmp abs7f`	`22c9 : a97f [ 2]> lda #$7f ;precharge accu`
	`22cb : 28 [ 4]> plp`

	`22cc : cd0c02 [ 4] cmp abs7f`
`tst_a $7f,fzc`	`tst_a $7f,fzc`
`1e37 : 08 [ 3]> php ;save flags`	`22cf : 08 [ 3]> php ;save flags`
`1e38 : 08 [ 3]> php`	`22d0 : 08 [ 3]> php`
`1e39 : c97f [ 2]> cmp #$7f ;test result`	`22d1 : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`1e3b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`22d3 : f002 [ 3]> beq skip1947`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`22d5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`22d6 : 1c > db test_num`
`>`	`>`
`1e3d : 68 [ 4]> pla ;load status`	`22d7 : >skip1947`
	`>`
	`22d7 : 68 [ 4]> pla ;load status`
`> cmp_flag fzc`	`> cmp_flag fzc`
`1e3e : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`22d8 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1e40 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`22da : f002 [ 3]> beq skip1950`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`22dc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`22dd : 1c > db test_num`
	`>`
	`22de : >skip1950`
`>`	`>`
`1e42 : 28 [ 4]> plp ;restore status`	`22de : 28 [ 4]> plp ;restore status`

`set_a $7e,0`	`set_a $7e,0`
`> load_flag 0`	`> load_flag 0`
`1e43 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`22df : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1e45 : 48 [ 3]> pha ;use stack to load status`	`22e1 : 48 [ 3]> pha ;use stack to load status`
`1e46 : a97e [ 2]> lda #$7e ;precharge accu`	`22e2 : a97e [ 2]> lda #$7e ;precharge accu`
`1e48 : 28 [ 4]> plp`	`22e4 : 28 [ 4]> plp`

`1e49 : cd0c02 [ 4] cmp abs7f`	`22e5 : cd0c02 [ 4] cmp abs7f`
`tst_a $7e,fn`	`tst_a $7e,fn`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 149`	`22e8 : 08 [ 3]> php ;save flags`
	`22e9 : 08 [ 3]> php`
	`22ea : c97e [ 2]> cmp #$7e ;test result`
	`> trap_ne`
	`22ec : f002 [ 3]> beq skip1955`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`22ee : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`22ef : 1c > db test_num`
	`>`
	`22f0 : >skip1955`
	`>`
	`22f0 : 68 [ 4]> pla ;load status`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 237`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`1e4c : 08 [ 3]> php ;save flags`
`1e4d : 08 [ 3]> php`
`1e4e : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`
`1e50 : d0fe [ 3]> bne * ;failed not equal (non zero)`
`>`
`1e52 : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`1e53 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`22f1 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1e55 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`22f3 : f002 [ 3]> beq skip1958`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`22f5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`22f6 : 1c > db test_num`
`>`	`>`
`1e57 : 28 [ 4]> plp ;restore status`	`22f7 : >skip1958`
	`>`
	`22f7 : 28 [ 4]> plp ;restore status`

`set_a $80,$ff`	`set_a $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1e58 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`22f8 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1e5a : 48 [ 3]> pha ;use stack to load status`	`22fa : 48 [ 3]> pha ;use stack to load status`
`1e5b : a980 [ 2]> lda #$80 ;precharge accu`	`22fb : a980 [ 2]> lda #$80 ;precharge accu`
`1e5d : 28 [ 4]> plp`	`22fd : 28 [ 4]> plp`

`1e5e : cd0c02 [ 4] cmp abs7f`	`22fe : cd0c02 [ 4] cmp abs7f`
`tst_a $80,~fnz`	`tst_a $80,~fnz`
`1e61 : 08 [ 3]> php ;save flags`	`2301 : 08 [ 3]> php ;save flags`
`1e62 : 08 [ 3]> php`	`2302 : 08 [ 3]> php`
`1e63 : c980 [ 2]> cmp #$80 ;test result`	`2303 : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`1e65 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2305 : f002 [ 3]> beq skip1963`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2307 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2308 : 1c > db test_num`
`>`	`>`
`1e67 : 68 [ 4]> pla ;load status`	`2309 : >skip1963`
	`>`
	`2309 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1e68 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`230a : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1e6a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`230c : f002 [ 3]> beq skip1966`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`230e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`230f : 1c > db test_num`
	`>`
	`2310 : >skip1966`
`>`	`>`
`1e6c : 28 [ 4]> plp ;restore status`	`2310 : 28 [ 4]> plp ;restore status`

`set_a $7f,$ff`	`set_a $7f,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1e6d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2311 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1e6f : 48 [ 3]> pha ;use stack to load status`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 238`
`1e70 : a97f [ 2]> lda #$7f ;precharge accu`
`1e72 : 28 [ 4]> plp`

`1e73 : cd0c02 [ 4] cmp abs7f`
`tst_a $7f,~fn`
`1e76 : 08 [ 3]> php ;save flags`
`1e77 : 08 [ 3]> php`
`1e78 : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`
`1e7a : d0fe [ 3]> bne * ;failed not equal (non zero)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 150`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2313 : 48 [ 3]> pha ;use stack to load status`
	`2314 : a97f [ 2]> lda #$7f ;precharge accu`
	`2316 : 28 [ 4]> plp`

	`2317 : cd0c02 [ 4] cmp abs7f`
	`tst_a $7f,~fn`
	`231a : 08 [ 3]> php ;save flags`
	`231b : 08 [ 3]> php`
	`231c : c97f [ 2]> cmp #$7f ;test result`
	`> trap_ne`
	`231e : f002 [ 3]> beq skip1971`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2320 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2321 : 1c > db test_num`
	`>`
	`2322 : >skip1971`
`>`	`>`
`1e7c : 68 [ 4]> pla ;load status`	`2322 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`1e7d : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`2323 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1e7f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2325 : f002 [ 3]> beq skip1974`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2327 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2328 : 1c > db test_num`
`>`	`>`
`1e81 : 28 [ 4]> plp ;restore status`	`2329 : >skip1974`
	`>`
	`2329 : 28 [ 4]> plp ;restore status`

`set_a $7e,$ff`	`set_a $7e,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1e82 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`232a : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1e84 : 48 [ 3]> pha ;use stack to load status`	`232c : 48 [ 3]> pha ;use stack to load status`
`1e85 : a97e [ 2]> lda #$7e ;precharge accu`	`232d : a97e [ 2]> lda #$7e ;precharge accu`
`1e87 : 28 [ 4]> plp`	`232f : 28 [ 4]> plp`

`1e88 : cd0c02 [ 4] cmp abs7f`	`2330 : cd0c02 [ 4] cmp abs7f`
`tst_a $7e,~fzc`	`tst_a $7e,~fzc`
`1e8b : 08 [ 3]> php ;save flags`	`2333 : 08 [ 3]> php ;save flags`
`1e8c : 08 [ 3]> php`	`2334 : 08 [ 3]> php`
`1e8d : c97e [ 2]> cmp #$7e ;test result`	`2335 : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1e8f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2337 : f002 [ 3]> beq skip1979`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2339 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`233a : 1c > db test_num`
	`>`
	`233b : >skip1979`
`>`	`>`
`1e91 : 68 [ 4]> pla ;load status`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 239`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`233b : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`1e92 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`233c : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1e94 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`233e : f002 [ 3]> beq skip1982`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2340 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2341 : 1c > db test_num`
`>`	`>`
`1e96 : 28 [ 4]> plp ;restore status`	`2342 : >skip1982`
	`>`
	`2342 : 28 [ 4]> plp ;restore status`


`set_a $80,0`	`set_a $80,0`
`> load_flag 0`	`> load_flag 0`
`1e97 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2343 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1e99 : 48 [ 3]> pha ;use stack to load status`	`2345 : 48 [ 3]> pha ;use stack to load status`
`1e9a : a980 [ 2]> lda #$80 ;precharge accu`	`2346 : a980 [ 2]> lda #$80 ;precharge accu`
`1e9c : 28 [ 4]> plp`	`2348 : 28 [ 4]> plp`

`1e9d : c97f [ 2] cmp #$7f`	`2349 : c97f [ 2] cmp #$7f`
`tst_a $80,fc`	`tst_a $80,fc`
`1e9f : 08 [ 3]> php ;save flags`	`234b : 08 [ 3]> php ;save flags`
`1ea0 : 08 [ 3]> php`	`234c : 08 [ 3]> php`
`1ea1 : c980 [ 2]> cmp #$80 ;test result`	`234d : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`1ea3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`234f : f002 [ 3]> beq skip1987`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2351 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2352 : 1c > db test_num`
`>`	`>`
`1ea5 : 68 [ 4]> pla ;load status`	`2353 : >skip1987`
	`>`
	`2353 : 68 [ 4]> pla ;load status`
`> cmp_flag fc`	`> cmp_flag fc`
`1ea6 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`2354 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 151`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`> trap_ne`	`> trap_ne`
`1ea8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2356 : f002 [ 3]> beq skip1990`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2358 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2359 : 1c > db test_num`
`>`	`>`
`1eaa : 28 [ 4]> plp ;restore status`	`235a : >skip1990`
	`>`
	`235a : 28 [ 4]> plp ;restore status`

`set_a $7f,0`	`set_a $7f,0`
`> load_flag 0`	`> load_flag 0`
`1eab : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 240`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`235b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1ead : 48 [ 3]> pha ;use stack to load status`	`235d : 48 [ 3]> pha ;use stack to load status`
`1eae : a97f [ 2]> lda #$7f ;precharge accu`	`235e : a97f [ 2]> lda #$7f ;precharge accu`
`1eb0 : 28 [ 4]> plp`	`2360 : 28 [ 4]> plp`

`1eb1 : c97f [ 2] cmp #$7f`	`2361 : c97f [ 2] cmp #$7f`
`tst_a $7f,fzc`	`tst_a $7f,fzc`
`1eb3 : 08 [ 3]> php ;save flags`	`2363 : 08 [ 3]> php ;save flags`
`1eb4 : 08 [ 3]> php`	`2364 : 08 [ 3]> php`
`1eb5 : c97f [ 2]> cmp #$7f ;test result`	`2365 : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`1eb7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2367 : f002 [ 3]> beq skip1995`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2369 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`236a : 1c > db test_num`
	`>`
	`236b : >skip1995`
`>`	`>`
`1eb9 : 68 [ 4]> pla ;load status`	`236b : 68 [ 4]> pla ;load status`
`> cmp_flag fzc`	`> cmp_flag fzc`
`1eba : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`236c : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1ebc : d0fe [ 3]> bne * ;failed not equal (non zero)`	`236e : f002 [ 3]> beq skip1998`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2370 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2371 : 1c > db test_num`
`>`	`>`
`1ebe : 28 [ 4]> plp ;restore status`	`2372 : >skip1998`
	`>`
	`2372 : 28 [ 4]> plp ;restore status`

`set_a $7e,0`	`set_a $7e,0`
`> load_flag 0`	`> load_flag 0`
`1ebf : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2373 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1ec1 : 48 [ 3]> pha ;use stack to load status`	`2375 : 48 [ 3]> pha ;use stack to load status`
`1ec2 : a97e [ 2]> lda #$7e ;precharge accu`	`2376 : a97e [ 2]> lda #$7e ;precharge accu`
`1ec4 : 28 [ 4]> plp`	`2378 : 28 [ 4]> plp`

`1ec5 : c97f [ 2] cmp #$7f`	`2379 : c97f [ 2] cmp #$7f`
`tst_a $7e,fn`	`tst_a $7e,fn`
`1ec7 : 08 [ 3]> php ;save flags`	`237b : 08 [ 3]> php ;save flags`
`1ec8 : 08 [ 3]> php`	`237c : 08 [ 3]> php`
`1ec9 : c97e [ 2]> cmp #$7e ;test result`	`237d : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1ecb : d0fe [ 3]> bne * ;failed not equal (non zero)`	`237f : f002 [ 3]> beq skip2003`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2381 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2382 : 1c > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 241`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2383 : >skip2003`
`>`	`>`
`1ecd : 68 [ 4]> pla ;load status`	`2383 : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`1ece : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`2384 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1ed0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2386 : f002 [ 3]> beq skip2006`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2388 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2389 : 1c > db test_num`
`>`	`>`
`1ed2 : 28 [ 4]> plp ;restore status`	`238a : >skip2006`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 152`	`>`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`238a : 28 [ 4]> plp ;restore status`


`set_a $80,$ff`	`set_a $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1ed3 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`238b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1ed5 : 48 [ 3]> pha ;use stack to load status`	`238d : 48 [ 3]> pha ;use stack to load status`
`1ed6 : a980 [ 2]> lda #$80 ;precharge accu`	`238e : a980 [ 2]> lda #$80 ;precharge accu`
`1ed8 : 28 [ 4]> plp`	`2390 : 28 [ 4]> plp`

`1ed9 : c97f [ 2] cmp #$7f`	`2391 : c97f [ 2] cmp #$7f`
`tst_a $80,~fnz`	`tst_a $80,~fnz`
`1edb : 08 [ 3]> php ;save flags`	`2393 : 08 [ 3]> php ;save flags`
`1edc : 08 [ 3]> php`	`2394 : 08 [ 3]> php`
`1edd : c980 [ 2]> cmp #$80 ;test result`	`2395 : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`1edf : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2397 : f002 [ 3]> beq skip2011`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2399 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`239a : 1c > db test_num`
	`>`
	`239b : >skip2011`
`>`	`>`
`1ee1 : 68 [ 4]> pla ;load status`	`239b : 68 [ 4]> pla ;load status`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1ee2 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`239c : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1ee4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`239e : f002 [ 3]> beq skip2014`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`23a0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`23a1 : 1c > db test_num`
`>`	`>`
`1ee6 : 28 [ 4]> plp ;restore status`	`23a2 : >skip2014`
	`>`
	`23a2 : 28 [ 4]> plp ;restore status`

`set_a $7f,$ff`	`set_a $7f,$ff`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 242`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag $ff`	`> load_flag $ff`
`1ee7 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`23a3 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1ee9 : 48 [ 3]> pha ;use stack to load status`	`23a5 : 48 [ 3]> pha ;use stack to load status`
`1eea : a97f [ 2]> lda #$7f ;precharge accu`	`23a6 : a97f [ 2]> lda #$7f ;precharge accu`
`1eec : 28 [ 4]> plp`	`23a8 : 28 [ 4]> plp`

`1eed : c97f [ 2] cmp #$7f`	`23a9 : c97f [ 2] cmp #$7f`
`tst_a $7f,~fn`	`tst_a $7f,~fn`
`1eef : 08 [ 3]> php ;save flags`	`23ab : 08 [ 3]> php ;save flags`
`1ef0 : 08 [ 3]> php`	`23ac : 08 [ 3]> php`
`1ef1 : c97f [ 2]> cmp #$7f ;test result`	`23ad : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`1ef3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`23af : f002 [ 3]> beq skip2019`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`23b1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`23b2 : 1c > db test_num`
	`>`
	`23b3 : >skip2019`
`>`	`>`
`1ef5 : 68 [ 4]> pla ;load status`	`23b3 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`1ef6 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`23b4 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1ef8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`23b6 : f002 [ 3]> beq skip2022`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`23b8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`23b9 : 1c > db test_num`
`>`	`>`
`1efa : 28 [ 4]> plp ;restore status`	`23ba : >skip2022`
	`>`
	`23ba : 28 [ 4]> plp ;restore status`

`set_a $7e,$ff`	`set_a $7e,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1efb : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`23bb : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 153`	`23bd : 48 [ 3]> pha ;use stack to load status`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`23be : a97e [ 2]> lda #$7e ;precharge accu`
	`23c0 : 28 [ 4]> plp`
`1efd : 48 [ 3]> pha ;use stack to load status`
`1efe : a97e [ 2]> lda #$7e ;precharge accu`
`1f00 : 28 [ 4]> plp`

`1f01 : c97f [ 2] cmp #$7f`	`23c1 : c97f [ 2] cmp #$7f`
`tst_a $7e,~fzc`	`tst_a $7e,~fzc`
`1f03 : 08 [ 3]> php ;save flags`	`23c3 : 08 [ 3]> php ;save flags`
`1f04 : 08 [ 3]> php`	`23c4 : 08 [ 3]> php`
`1f05 : c97e [ 2]> cmp #$7e ;test result`	`23c5 : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1f07 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`23c7 : f002 [ 3]> beq skip2027`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`23c9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`23ca : 1c > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 243`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`1f09 : 68 [ 4]> pla ;load status`	`23cb : >skip2027`
	`>`
	`23cb : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`1f0a : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`23cc : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1f0c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`23ce : f002 [ 3]> beq skip2030`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`23d0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`23d1 : 1c > db test_num`
	`>`
	`23d2 : >skip2030`
`>`	`>`
`1f0e : 28 [ 4]> plp ;restore status`	`23d2 : 28 [ 4]> plp ;restore status`


`1f0f : a204 [ 2] ldx #4 ;with indexing by X`	`23d3 : a204 [ 2] ldx #4 ;with indexing by X`
`set_a $80,0`	`set_a $80,0`
`> load_flag 0`	`> load_flag 0`
`1f11 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`23d5 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1f13 : 48 [ 3]> pha ;use stack to load status`	`23d7 : 48 [ 3]> pha ;use stack to load status`
`1f14 : a980 [ 2]> lda #$80 ;precharge accu`	`23d8 : a980 [ 2]> lda #$80 ;precharge accu`
`1f16 : 28 [ 4]> plp`	`23da : 28 [ 4]> plp`

`1f17 : d513 [ 4] cmp zp1,x`	`23db : d5b9 [ 4] cmp zp1,x`
`tst_a $80,fc`	`tst_a $80,fc`
`1f19 : 08 [ 3]> php ;save flags`	`23dd : 08 [ 3]> php ;save flags`
`1f1a : 08 [ 3]> php`	`23de : 08 [ 3]> php`
`1f1b : c980 [ 2]> cmp #$80 ;test result`	`23df : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`1f1d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`23e1 : f002 [ 3]> beq skip2035`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`23e3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`23e4 : 1c > db test_num`
	`>`
	`23e5 : >skip2035`
`>`	`>`
`1f1f : 68 [ 4]> pla ;load status`	`23e5 : 68 [ 4]> pla ;load status`
`> cmp_flag fc`	`> cmp_flag fc`
`1f20 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`23e6 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1f22 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`23e8 : f002 [ 3]> beq skip2038`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`23ea : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`23eb : 1c > db test_num`
`>`	`>`
`1f24 : 28 [ 4]> plp ;restore status`	`23ec : >skip2038`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 244`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`23ec : 28 [ 4]> plp ;restore status`

`set_a $7f,0`	`set_a $7f,0`
`> load_flag 0`	`> load_flag 0`
`1f25 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`23ed : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1f27 : 48 [ 3]> pha ;use stack to load status`	`23ef : 48 [ 3]> pha ;use stack to load status`
`1f28 : a97f [ 2]> lda #$7f ;precharge accu`	`23f0 : a97f [ 2]> lda #$7f ;precharge accu`
`1f2a : 28 [ 4]> plp`	`23f2 : 28 [ 4]> plp`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 154`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`23f3 : d5b9 [ 4] cmp zp1,x`
`1f2b : d513 [ 4] cmp zp1,x`
`tst_a $7f,fzc`	`tst_a $7f,fzc`
`1f2d : 08 [ 3]> php ;save flags`	`23f5 : 08 [ 3]> php ;save flags`
`1f2e : 08 [ 3]> php`	`23f6 : 08 [ 3]> php`
`1f2f : c97f [ 2]> cmp #$7f ;test result`	`23f7 : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`1f31 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`23f9 : f002 [ 3]> beq skip2043`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`23fb : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`23fc : 1c > db test_num`
`>`	`>`
`1f33 : 68 [ 4]> pla ;load status`	`23fd : >skip2043`
	`>`
	`23fd : 68 [ 4]> pla ;load status`
`> cmp_flag fzc`	`> cmp_flag fzc`
`1f34 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`23fe : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1f36 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2400 : f002 [ 3]> beq skip2046`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2402 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2403 : 1c > db test_num`
	`>`
	`2404 : >skip2046`
`>`	`>`
`1f38 : 28 [ 4]> plp ;restore status`	`2404 : 28 [ 4]> plp ;restore status`

`set_a $7e,0`	`set_a $7e,0`
`> load_flag 0`	`> load_flag 0`
`1f39 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2405 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1f3b : 48 [ 3]> pha ;use stack to load status`	`2407 : 48 [ 3]> pha ;use stack to load status`
`1f3c : a97e [ 2]> lda #$7e ;precharge accu`	`2408 : a97e [ 2]> lda #$7e ;precharge accu`
`1f3e : 28 [ 4]> plp`	`240a : 28 [ 4]> plp`

`1f3f : d513 [ 4] cmp zp1,x`	`240b : d5b9 [ 4] cmp zp1,x`
`tst_a $7e,fn`	`tst_a $7e,fn`
`1f41 : 08 [ 3]> php ;save flags`	`240d : 08 [ 3]> php ;save flags`
`1f42 : 08 [ 3]> php`	`240e : 08 [ 3]> php`
`1f43 : c97e [ 2]> cmp #$7e ;test result`	`240f : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1f45 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2411 : f002 [ 3]> beq skip2051`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 245`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2413 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2414 : 1c > db test_num`
	`>`
	`2415 : >skip2051`
`>`	`>`
`1f47 : 68 [ 4]> pla ;load status`	`2415 : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`1f48 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`2416 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1f4a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2418 : f002 [ 3]> beq skip2054`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`241a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`241b : 1c > db test_num`
`>`	`>`
`1f4c : 28 [ 4]> plp ;restore status`	`241c : >skip2054`
	`>`
	`241c : 28 [ 4]> plp ;restore status`

`set_a $80,$ff`	`set_a $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1f4d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`241d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1f4f : 48 [ 3]> pha ;use stack to load status`	`241f : 48 [ 3]> pha ;use stack to load status`
`1f50 : a980 [ 2]> lda #$80 ;precharge accu`	`2420 : a980 [ 2]> lda #$80 ;precharge accu`
`1f52 : 28 [ 4]> plp`	`2422 : 28 [ 4]> plp`

`1f53 : d513 [ 4] cmp zp1,x`	`2423 : d5b9 [ 4] cmp zp1,x`
`tst_a $80,~fnz`	`tst_a $80,~fnz`
`1f55 : 08 [ 3]> php ;save flags`	`2425 : 08 [ 3]> php ;save flags`
`1f56 : 08 [ 3]> php`	`2426 : 08 [ 3]> php`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 155`	`2427 : c980 [ 2]> cmp #$80 ;test result`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap_ne`
	`2429 : f002 [ 3]> beq skip2059`
`1f57 : c980 [ 2]> cmp #$80 ;test result`	`> trap ;failed equal (zero)`
`> trap_ne`	`>; db $db ; M65C02/M65C02A SToP instruction`
`1f59 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`242b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`242c : 1c > db test_num`
	`>`
	`242d : >skip2059`
`>`	`>`
`1f5b : 68 [ 4]> pla ;load status`	`242d : 68 [ 4]> pla ;load status`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1f5c : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`242e : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1f5e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2430 : f002 [ 3]> beq skip2062`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2432 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2433 : 1c > db test_num`
	`>`
	`2434 : >skip2062`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 246`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`1f60 : 28 [ 4]> plp ;restore status`	`2434 : 28 [ 4]> plp ;restore status`

`set_a $7f,$ff`	`set_a $7f,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1f61 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2435 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1f63 : 48 [ 3]> pha ;use stack to load status`	`2437 : 48 [ 3]> pha ;use stack to load status`
`1f64 : a97f [ 2]> lda #$7f ;precharge accu`	`2438 : a97f [ 2]> lda #$7f ;precharge accu`
`1f66 : 28 [ 4]> plp`	`243a : 28 [ 4]> plp`

`1f67 : d513 [ 4] cmp zp1,x`	`243b : d5b9 [ 4] cmp zp1,x`
`tst_a $7f,~fn`	`tst_a $7f,~fn`
`1f69 : 08 [ 3]> php ;save flags`	`243d : 08 [ 3]> php ;save flags`
`1f6a : 08 [ 3]> php`	`243e : 08 [ 3]> php`
`1f6b : c97f [ 2]> cmp #$7f ;test result`	`243f : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`1f6d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2441 : f002 [ 3]> beq skip2067`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2443 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2444 : 1c > db test_num`
	`>`
	`2445 : >skip2067`
`>`	`>`
`1f6f : 68 [ 4]> pla ;load status`	`2445 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`1f70 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`2446 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1f72 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2448 : f002 [ 3]> beq skip2070`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`244a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`244b : 1c > db test_num`
`>`	`>`
`1f74 : 28 [ 4]> plp ;restore status`	`244c : >skip2070`
	`>`
	`244c : 28 [ 4]> plp ;restore status`

`set_a $7e,$ff`	`set_a $7e,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1f75 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`244d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1f77 : 48 [ 3]> pha ;use stack to load status`	`244f : 48 [ 3]> pha ;use stack to load status`
`1f78 : a97e [ 2]> lda #$7e ;precharge accu`	`2450 : a97e [ 2]> lda #$7e ;precharge accu`
`1f7a : 28 [ 4]> plp`	`2452 : 28 [ 4]> plp`

`1f7b : d513 [ 4] cmp zp1,x`	`2453 : d5b9 [ 4] cmp zp1,x`
`tst_a $7e,~fzc`	`tst_a $7e,~fzc`
`1f7d : 08 [ 3]> php ;save flags`	`2455 : 08 [ 3]> php ;save flags`
`1f7e : 08 [ 3]> php`	`2456 : 08 [ 3]> php`
`1f7f : c97e [ 2]> cmp #$7e ;test result`	`2457 : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1f81 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2459 : f002 [ 3]> beq skip2075`
`>`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 247`
`1f83 : 68 [ 4]> pla ;load status`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 156`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`245b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`245c : 1c > db test_num`
	`>`
	`245d : >skip2075`
	`>`
	`245d : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`1f84 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`245e : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1f86 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2460 : f002 [ 3]> beq skip2078`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2462 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2463 : 1c > db test_num`
`>`	`>`
`1f88 : 28 [ 4]> plp ;restore status`	`2464 : >skip2078`
	`>`
	`2464 : 28 [ 4]> plp ;restore status`


`set_a $80,0`	`set_a $80,0`
`> load_flag 0`	`> load_flag 0`
`1f89 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2465 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1f8b : 48 [ 3]> pha ;use stack to load status`	`2467 : 48 [ 3]> pha ;use stack to load status`
`1f8c : a980 [ 2]> lda #$80 ;precharge accu`	`2468 : a980 [ 2]> lda #$80 ;precharge accu`
`1f8e : 28 [ 4]> plp`	`246a : 28 [ 4]> plp`

`1f8f : dd0802 [ 4] cmp abs1,x`	`246b : dd0802 [ 4] cmp abs1,x`
`tst_a $80,fc`	`tst_a $80,fc`
`1f92 : 08 [ 3]> php ;save flags`	`246e : 08 [ 3]> php ;save flags`
`1f93 : 08 [ 3]> php`	`246f : 08 [ 3]> php`
`1f94 : c980 [ 2]> cmp #$80 ;test result`	`2470 : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`1f96 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2472 : f002 [ 3]> beq skip2083`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2474 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2475 : 1c > db test_num`
`>`	`>`
`1f98 : 68 [ 4]> pla ;load status`	`2476 : >skip2083`
	`>`
	`2476 : 68 [ 4]> pla ;load status`
`> cmp_flag fc`	`> cmp_flag fc`
`1f99 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`2477 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1f9b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2479 : f002 [ 3]> beq skip2086`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`247b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`247c : 1c > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 248`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`1f9d : 28 [ 4]> plp ;restore status`	`247d : >skip2086`
	`>`
	`247d : 28 [ 4]> plp ;restore status`

`set_a $7f,0`	`set_a $7f,0`
`> load_flag 0`	`> load_flag 0`
`1f9e : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`247e : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1fa0 : 48 [ 3]> pha ;use stack to load status`	`2480 : 48 [ 3]> pha ;use stack to load status`
`1fa1 : a97f [ 2]> lda #$7f ;precharge accu`	`2481 : a97f [ 2]> lda #$7f ;precharge accu`
`1fa3 : 28 [ 4]> plp`	`2483 : 28 [ 4]> plp`

`1fa4 : dd0802 [ 4] cmp abs1,x`	`2484 : dd0802 [ 4] cmp abs1,x`
`tst_a $7f,fzc`	`tst_a $7f,fzc`
`1fa7 : 08 [ 3]> php ;save flags`	`2487 : 08 [ 3]> php ;save flags`
`1fa8 : 08 [ 3]> php`	`2488 : 08 [ 3]> php`
`1fa9 : c97f [ 2]> cmp #$7f ;test result`	`2489 : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`1fab : d0fe [ 3]> bne * ;failed not equal (non zero)`	`248b : f002 [ 3]> beq skip2091`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`248d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`248e : 1c > db test_num`
`>`	`>`
`1fad : 68 [ 4]> pla ;load status`	`248f : >skip2091`
	`>`
	`248f : 68 [ 4]> pla ;load status`
`> cmp_flag fzc`	`> cmp_flag fzc`
`1fae : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`2490 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 157`	`2492 : f002 [ 3]> beq skip2094`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`1fb0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2494 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2495 : 1c > db test_num`
`>`	`>`
`1fb2 : 28 [ 4]> plp ;restore status`	`2496 : >skip2094`
	`>`
	`2496 : 28 [ 4]> plp ;restore status`

`set_a $7e,0`	`set_a $7e,0`
`> load_flag 0`	`> load_flag 0`
`1fb3 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2497 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`1fb5 : 48 [ 3]> pha ;use stack to load status`	`2499 : 48 [ 3]> pha ;use stack to load status`
`1fb6 : a97e [ 2]> lda #$7e ;precharge accu`	`249a : a97e [ 2]> lda #$7e ;precharge accu`
`1fb8 : 28 [ 4]> plp`	`249c : 28 [ 4]> plp`

`1fb9 : dd0802 [ 4] cmp abs1,x`	`249d : dd0802 [ 4] cmp abs1,x`
`tst_a $7e,fn`	`tst_a $7e,fn`
`1fbc : 08 [ 3]> php ;save flags`	`24a0 : 08 [ 3]> php ;save flags`
`1fbd : 08 [ 3]> php`	`24a1 : 08 [ 3]> php`
`1fbe : c97e [ 2]> cmp #$7e ;test result`	`24a2 : c97e [ 2]> cmp #$7e ;test result`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 249`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> trap_ne`	`> trap_ne`
`1fc0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`24a4 : f002 [ 3]> beq skip2099`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`24a6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`24a7 : 1c > db test_num`
`>`	`>`
`1fc2 : 68 [ 4]> pla ;load status`	`24a8 : >skip2099`
	`>`
	`24a8 : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`1fc3 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`24a9 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1fc5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`24ab : f002 [ 3]> beq skip2102`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`24ad : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`24ae : 1c > db test_num`
	`>`
	`24af : >skip2102`
`>`	`>`
`1fc7 : 28 [ 4]> plp ;restore status`	`24af : 28 [ 4]> plp ;restore status`

`set_a $80,$ff`	`set_a $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1fc8 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`24b0 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1fca : 48 [ 3]> pha ;use stack to load status`	`24b2 : 48 [ 3]> pha ;use stack to load status`
`1fcb : a980 [ 2]> lda #$80 ;precharge accu`	`24b3 : a980 [ 2]> lda #$80 ;precharge accu`
`1fcd : 28 [ 4]> plp`	`24b5 : 28 [ 4]> plp`

`1fce : dd0802 [ 4] cmp abs1,x`	`24b6 : dd0802 [ 4] cmp abs1,x`
`tst_a $80,~fnz`	`tst_a $80,~fnz`
`1fd1 : 08 [ 3]> php ;save flags`	`24b9 : 08 [ 3]> php ;save flags`
`1fd2 : 08 [ 3]> php`	`24ba : 08 [ 3]> php`
`1fd3 : c980 [ 2]> cmp #$80 ;test result`	`24bb : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`1fd5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`24bd : f002 [ 3]> beq skip2107`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`24bf : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`24c0 : 1c > db test_num`
	`>`
	`24c1 : >skip2107`
`>`	`>`
`1fd7 : 68 [ 4]> pla ;load status`	`24c1 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`1fd8 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`24c2 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1fda : d0fe [ 3]> bne * ;failed not equal (non zero)`	`24c4 : f002 [ 3]> beq skip2110`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`24c6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 250`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`24c7 : 1c > db test_num`
	`>`
	`24c8 : >skip2110`
`>`	`>`
`1fdc : 28 [ 4]> plp ;restore status`	`24c8 : 28 [ 4]> plp ;restore status`

`set_a $7f,$ff`	`set_a $7f,$ff`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 158`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag $ff`	`> load_flag $ff`
`1fdd : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`24c9 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1fdf : 48 [ 3]> pha ;use stack to load status`	`24cb : 48 [ 3]> pha ;use stack to load status`
`1fe0 : a97f [ 2]> lda #$7f ;precharge accu`	`24cc : a97f [ 2]> lda #$7f ;precharge accu`
`1fe2 : 28 [ 4]> plp`	`24ce : 28 [ 4]> plp`

`1fe3 : dd0802 [ 4] cmp abs1,x`	`24cf : dd0802 [ 4] cmp abs1,x`
`tst_a $7f,~fn`	`tst_a $7f,~fn`
`1fe6 : 08 [ 3]> php ;save flags`	`24d2 : 08 [ 3]> php ;save flags`
`1fe7 : 08 [ 3]> php`	`24d3 : 08 [ 3]> php`
`1fe8 : c97f [ 2]> cmp #$7f ;test result`	`24d4 : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`1fea : d0fe [ 3]> bne * ;failed not equal (non zero)`	`24d6 : f002 [ 3]> beq skip2115`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`24d8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`24d9 : 1c > db test_num`
`>`	`>`
`1fec : 68 [ 4]> pla ;load status`	`24da : >skip2115`
	`>`
	`24da : 68 [ 4]> pla ;load status`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`1fed : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`24db : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`1fef : d0fe [ 3]> bne * ;failed not equal (non zero)`	`24dd : f002 [ 3]> beq skip2118`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`24df : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`24e0 : 1c > db test_num`
	`>`
	`24e1 : >skip2118`
`>`	`>`
`1ff1 : 28 [ 4]> plp ;restore status`	`24e1 : 28 [ 4]> plp ;restore status`

`set_a $7e,$ff`	`set_a $7e,$ff`
`> load_flag $ff`	`> load_flag $ff`
`1ff2 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`24e2 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`1ff4 : 48 [ 3]> pha ;use stack to load status`	`24e4 : 48 [ 3]> pha ;use stack to load status`
`1ff5 : a97e [ 2]> lda #$7e ;precharge accu`	`24e5 : a97e [ 2]> lda #$7e ;precharge accu`
`1ff7 : 28 [ 4]> plp`	`24e7 : 28 [ 4]> plp`

`1ff8 : dd0802 [ 4] cmp abs1,x`	`24e8 : dd0802 [ 4] cmp abs1,x`
`tst_a $7e,~fzc`	`tst_a $7e,~fzc`
`1ffb : 08 [ 3]> php ;save flags`	`24eb : 08 [ 3]> php ;save flags`
`1ffc : 08 [ 3]> php`	`24ec : 08 [ 3]> php`
`1ffd : c97e [ 2]> cmp #$7e ;test result`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 251`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`24ed : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`1fff : d0fe [ 3]> bne * ;failed not equal (non zero)`	`24ef : f002 [ 3]> beq skip2123`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`24f1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`24f2 : 1c > db test_num`
	`>`
	`24f3 : >skip2123`
`>`	`>`
`2001 : 68 [ 4]> pla ;load status`	`24f3 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`2002 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`24f4 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`2004 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`24f6 : f002 [ 3]> beq skip2126`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`24f8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`24f9 : 1c > db test_num`
`>`	`>`
`2006 : 28 [ 4]> plp ;restore status`	`24fa : >skip2126`
	`>`
	`24fa : 28 [ 4]> plp ;restore status`


`2007 : a004 [ 2] ldy #4 ;with indexing by Y`	`24fb : a004 [ 2] ldy #4 ;with indexing by Y`
`2009 : a208 [ 2] ldx #8 ;with indexed indirect`	`24fd : a208 [ 2] ldx #8 ;with indexed indirect`
`set_a $80,0`	`set_a $80,0`
`> load_flag 0`	`> load_flag 0`
`200b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`24ff : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 159`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`200d : 48 [ 3]> pha ;use stack to load status`	`2501 : 48 [ 3]> pha ;use stack to load status`
`200e : a980 [ 2]> lda #$80 ;precharge accu`	`2502 : a980 [ 2]> lda #$80 ;precharge accu`
`2010 : 28 [ 4]> plp`	`2504 : 28 [ 4]> plp`

`2011 : d90802 [ 4] cmp abs1,y`	`2505 : d90802 [ 4] cmp abs1,y`
`tst_a $80,fc`	`tst_a $80,fc`
`2014 : 08 [ 3]> php ;save flags`	`2508 : 08 [ 3]> php ;save flags`
`2015 : 08 [ 3]> php`	`2509 : 08 [ 3]> php`
`2016 : c980 [ 2]> cmp #$80 ;test result`	`250a : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`2018 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`250c : f002 [ 3]> beq skip2131`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`250e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`250f : 1c > db test_num`
	`>`
	`2510 : >skip2131`
`>`	`>`
`201a : 68 [ 4]> pla ;load status`	`2510 : 68 [ 4]> pla ;load status`
`> cmp_flag fc`	`> cmp_flag fc`
`201b : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`2511 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`201d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 252`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2513 : f002 [ 3]> beq skip2134`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2515 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2516 : 1c > db test_num`
	`>`
	`2517 : >skip2134`
`>`	`>`
`201f : 28 [ 4]> plp ;restore status`	`2517 : 28 [ 4]> plp ;restore status`

`set_a $7f,0`	`set_a $7f,0`
`> load_flag 0`	`> load_flag 0`
`2020 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2518 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2022 : 48 [ 3]> pha ;use stack to load status`	`251a : 48 [ 3]> pha ;use stack to load status`
`2023 : a97f [ 2]> lda #$7f ;precharge accu`	`251b : a97f [ 2]> lda #$7f ;precharge accu`
`2025 : 28 [ 4]> plp`	`251d : 28 [ 4]> plp`

`2026 : d90802 [ 4] cmp abs1,y`	`251e : d90802 [ 4] cmp abs1,y`
`tst_a $7f,fzc`	`tst_a $7f,fzc`
`2029 : 08 [ 3]> php ;save flags`	`2521 : 08 [ 3]> php ;save flags`
`202a : 08 [ 3]> php`	`2522 : 08 [ 3]> php`
`202b : c97f [ 2]> cmp #$7f ;test result`	`2523 : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`202d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2525 : f002 [ 3]> beq skip2139`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2527 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2528 : 1c > db test_num`
	`>`
	`2529 : >skip2139`
`>`	`>`
`202f : 68 [ 4]> pla ;load status`	`2529 : 68 [ 4]> pla ;load status`
`> cmp_flag fzc`	`> cmp_flag fzc`
`2030 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`252a : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`2032 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`252c : f002 [ 3]> beq skip2142`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`252e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`252f : 1c > db test_num`
`>`	`>`
`2034 : 28 [ 4]> plp ;restore status`	`2530 : >skip2142`
	`>`
	`2530 : 28 [ 4]> plp ;restore status`

`set_a $7e,0`	`set_a $7e,0`
`> load_flag 0`	`> load_flag 0`
`2035 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2531 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2037 : 48 [ 3]> pha ;use stack to load status`	`2533 : 48 [ 3]> pha ;use stack to load status`
`2038 : a97e [ 2]> lda #$7e ;precharge accu`	`2534 : a97e [ 2]> lda #$7e ;precharge accu`
`203a : 28 [ 4]> plp`	`2536 : 28 [ 4]> plp`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 160`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 253`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`203b : d90802 [ 4] cmp abs1,y`	`2537 : d90802 [ 4] cmp abs1,y`
`tst_a $7e,fn`	`tst_a $7e,fn`
`203e : 08 [ 3]> php ;save flags`	`253a : 08 [ 3]> php ;save flags`
`203f : 08 [ 3]> php`	`253b : 08 [ 3]> php`
`2040 : c97e [ 2]> cmp #$7e ;test result`	`253c : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`2042 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`253e : f002 [ 3]> beq skip2147`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2540 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2541 : 1c > db test_num`
`>`	`>`
`2044 : 68 [ 4]> pla ;load status`	`2542 : >skip2147`
	`>`
	`2542 : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`2045 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`2543 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`2047 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2545 : f002 [ 3]> beq skip2150`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2547 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2548 : 1c > db test_num`
	`>`
	`2549 : >skip2150`
`>`	`>`
`2049 : 28 [ 4]> plp ;restore status`	`2549 : 28 [ 4]> plp ;restore status`

`set_a $80,$ff`	`set_a $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`204a : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`254a : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`204c : 48 [ 3]> pha ;use stack to load status`	`254c : 48 [ 3]> pha ;use stack to load status`
`204d : a980 [ 2]> lda #$80 ;precharge accu`	`254d : a980 [ 2]> lda #$80 ;precharge accu`
`204f : 28 [ 4]> plp`	`254f : 28 [ 4]> plp`

`2050 : d90802 [ 4] cmp abs1,y`	`2550 : d90802 [ 4] cmp abs1,y`
`tst_a $80,~fnz`	`tst_a $80,~fnz`
`2053 : 08 [ 3]> php ;save flags`	`2553 : 08 [ 3]> php ;save flags`
`2054 : 08 [ 3]> php`	`2554 : 08 [ 3]> php`
`2055 : c980 [ 2]> cmp #$80 ;test result`	`2555 : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`2057 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2557 : f002 [ 3]> beq skip2155`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2559 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`255a : 1c > db test_num`
	`>`
	`255b : >skip2155`
`>`	`>`
`2059 : 68 [ 4]> pla ;load status`	`255b : 68 [ 4]> pla ;load status`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`205a : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`255c : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 254`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> trap_ne`	`> trap_ne`
`205c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`255e : f002 [ 3]> beq skip2158`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2560 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2561 : 1c > db test_num`
	`>`
	`2562 : >skip2158`
`>`	`>`
`205e : 28 [ 4]> plp ;restore status`	`2562 : 28 [ 4]> plp ;restore status`

`set_a $7f,$ff`	`set_a $7f,$ff`
`> load_flag $ff`	`> load_flag $ff`
`205f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2563 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2061 : 48 [ 3]> pha ;use stack to load status`	`2565 : 48 [ 3]> pha ;use stack to load status`
`2062 : a97f [ 2]> lda #$7f ;precharge accu`	`2566 : a97f [ 2]> lda #$7f ;precharge accu`
`2064 : 28 [ 4]> plp`	`2568 : 28 [ 4]> plp`

`2065 : d90802 [ 4] cmp abs1,y`	`2569 : d90802 [ 4] cmp abs1,y`
`tst_a $7f,~fn`	`tst_a $7f,~fn`
`2068 : 08 [ 3]> php ;save flags`	`256c : 08 [ 3]> php ;save flags`
`2069 : 08 [ 3]> php`	`256d : 08 [ 3]> php`
`206a : c97f [ 2]> cmp #$7f ;test result`	`256e : c97f [ 2]> cmp #$7f ;test result`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 161`	`> trap_ne`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`2570 : f002 [ 3]> beq skip2163`
	`> trap ;failed equal (zero)`
`> trap_ne`	`>; db $db ; M65C02/M65C02A SToP instruction`
`206c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2572 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2573 : 1c > db test_num`
`>`	`>`
`206e : 68 [ 4]> pla ;load status`	`2574 : >skip2163`
	`>`
	`2574 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`206f : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`2575 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`2071 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2577 : f002 [ 3]> beq skip2166`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2579 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`257a : 1c > db test_num`
	`>`
	`257b : >skip2166`
`>`	`>`
`2073 : 28 [ 4]> plp ;restore status`	`257b : 28 [ 4]> plp ;restore status`

`set_a $7e,$ff`	`set_a $7e,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2074 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`257c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2076 : 48 [ 3]> pha ;use stack to load status`	`257e : 48 [ 3]> pha ;use stack to load status`
`2077 : a97e [ 2]> lda #$7e ;precharge accu`	`257f : a97e [ 2]> lda #$7e ;precharge accu`
`2079 : 28 [ 4]> plp`	`2581 : 28 [ 4]> plp`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 255`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`207a : d90802 [ 4] cmp abs1,y`
	`2582 : d90802 [ 4] cmp abs1,y`
`tst_a $7e,~fzc`	`tst_a $7e,~fzc`
`207d : 08 [ 3]> php ;save flags`	`2585 : 08 [ 3]> php ;save flags`
`207e : 08 [ 3]> php`	`2586 : 08 [ 3]> php`
`207f : c97e [ 2]> cmp #$7e ;test result`	`2587 : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`2081 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2589 : f002 [ 3]> beq skip2171`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`258b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`258c : 1c > db test_num`
`>`	`>`
`2083 : 68 [ 4]> pla ;load status`	`258d : >skip2171`
	`>`
	`258d : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`2084 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`258e : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`2086 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2590 : f002 [ 3]> beq skip2174`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2592 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2593 : 1c > db test_num`
	`>`
	`2594 : >skip2174`
`>`	`>`
`2088 : 28 [ 4]> plp ;restore status`	`2594 : 28 [ 4]> plp ;restore status`


`set_a $80,0`	`set_a $80,0`
`> load_flag 0`	`> load_flag 0`
`2089 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2595 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`208b : 48 [ 3]> pha ;use stack to load status`	`2597 : 48 [ 3]> pha ;use stack to load status`
`208c : a980 [ 2]> lda #$80 ;precharge accu`	`2598 : a980 [ 2]> lda #$80 ;precharge accu`
`208e : 28 [ 4]> plp`	`259a : 28 [ 4]> plp`

`208f : c124 [ 6] cmp (ind1,x)`	`259b : c1ca [ 6] cmp (ind1,x)`
`tst_a $80,fc`	`tst_a $80,fc`
`2091 : 08 [ 3]> php ;save flags`	`259d : 08 [ 3]> php ;save flags`
`2092 : 08 [ 3]> php`	`259e : 08 [ 3]> php`
`2093 : c980 [ 2]> cmp #$80 ;test result`	`259f : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`2095 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`25a1 : f002 [ 3]> beq skip2179`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`25a3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`25a4 : 1c > db test_num`
`>`	`>`
`2097 : 68 [ 4]> pla ;load status`	`25a5 : >skip2179`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 162`	`>`
	`25a5 : 68 [ 4]> pla ;load status`
	`> cmp_flag fc`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 256`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> cmp_flag fc`	`25a6 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`2098 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`209a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`25a8 : f002 [ 3]> beq skip2182`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`25aa : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`25ab : 1c > db test_num`
`>`	`>`
`209c : 28 [ 4]> plp ;restore status`	`25ac : >skip2182`
	`>`
	`25ac : 28 [ 4]> plp ;restore status`

`set_a $7f,0`	`set_a $7f,0`
`> load_flag 0`	`> load_flag 0`
`209d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`25ad : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`209f : 48 [ 3]> pha ;use stack to load status`	`25af : 48 [ 3]> pha ;use stack to load status`
`20a0 : a97f [ 2]> lda #$7f ;precharge accu`	`25b0 : a97f [ 2]> lda #$7f ;precharge accu`
`20a2 : 28 [ 4]> plp`	`25b2 : 28 [ 4]> plp`

`20a3 : c124 [ 6] cmp (ind1,x)`	`25b3 : c1ca [ 6] cmp (ind1,x)`
`tst_a $7f,fzc`	`tst_a $7f,fzc`
`20a5 : 08 [ 3]> php ;save flags`	`25b5 : 08 [ 3]> php ;save flags`
`20a6 : 08 [ 3]> php`	`25b6 : 08 [ 3]> php`
`20a7 : c97f [ 2]> cmp #$7f ;test result`	`25b7 : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`20a9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`25b9 : f002 [ 3]> beq skip2187`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`25bb : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`25bc : 1c > db test_num`
	`>`
	`25bd : >skip2187`
`>`	`>`
`20ab : 68 [ 4]> pla ;load status`	`25bd : 68 [ 4]> pla ;load status`
`> cmp_flag fzc`	`> cmp_flag fzc`
`20ac : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`25be : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`20ae : d0fe [ 3]> bne * ;failed not equal (non zero)`	`25c0 : f002 [ 3]> beq skip2190`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`25c2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`25c3 : 1c > db test_num`
`>`	`>`
`20b0 : 28 [ 4]> plp ;restore status`	`25c4 : >skip2190`
	`>`
	`25c4 : 28 [ 4]> plp ;restore status`

`set_a $7e,0`	`set_a $7e,0`
`> load_flag 0`	`> load_flag 0`
`20b1 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`25c5 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`20b3 : 48 [ 3]> pha ;use stack to load status`	`25c7 : 48 [ 3]> pha ;use stack to load status`
`20b4 : a97e [ 2]> lda #$7e ;precharge accu`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 257`
`20b6 : 28 [ 4]> plp`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`25c8 : a97e [ 2]> lda #$7e ;precharge accu`
	`25ca : 28 [ 4]> plp`

`20b7 : c124 [ 6] cmp (ind1,x)`	`25cb : c1ca [ 6] cmp (ind1,x)`
`tst_a $7e,fn`	`tst_a $7e,fn`
`20b9 : 08 [ 3]> php ;save flags`	`25cd : 08 [ 3]> php ;save flags`
`20ba : 08 [ 3]> php`	`25ce : 08 [ 3]> php`
`20bb : c97e [ 2]> cmp #$7e ;test result`	`25cf : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`20bd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`25d1 : f002 [ 3]> beq skip2195`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`25d3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`25d4 : 1c > db test_num`
	`>`
	`25d5 : >skip2195`
`>`	`>`
`20bf : 68 [ 4]> pla ;load status`	`25d5 : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`20c0 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`25d6 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`20c2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`25d8 : f002 [ 3]> beq skip2198`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 163`	`> trap ;failed equal (zero)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`25da : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`25db : 1c > db test_num`
	`>`
	`25dc : >skip2198`
`>`	`>`
`20c4 : 28 [ 4]> plp ;restore status`	`25dc : 28 [ 4]> plp ;restore status`

`set_a $80,$ff`	`set_a $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`20c5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`25dd : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`20c7 : 48 [ 3]> pha ;use stack to load status`	`25df : 48 [ 3]> pha ;use stack to load status`
`20c8 : a980 [ 2]> lda #$80 ;precharge accu`	`25e0 : a980 [ 2]> lda #$80 ;precharge accu`
`20ca : 28 [ 4]> plp`	`25e2 : 28 [ 4]> plp`

`20cb : c124 [ 6] cmp (ind1,x)`	`25e3 : c1ca [ 6] cmp (ind1,x)`
`tst_a $80,~fnz`	`tst_a $80,~fnz`
`20cd : 08 [ 3]> php ;save flags`	`25e5 : 08 [ 3]> php ;save flags`
`20ce : 08 [ 3]> php`	`25e6 : 08 [ 3]> php`
`20cf : c980 [ 2]> cmp #$80 ;test result`	`25e7 : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`20d1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`25e9 : f002 [ 3]> beq skip2203`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`25eb : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`25ec : 1c > db test_num`
	`>`
	`25ed : >skip2203`
`>`	`>`
`20d3 : 68 [ 4]> pla ;load status`	`25ed : 68 [ 4]> pla ;load status`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 258`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`20d4 : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`25ee : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`20d6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`25f0 : f002 [ 3]> beq skip2206`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`25f2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`25f3 : 1c > db test_num`
	`>`
	`25f4 : >skip2206`
`>`	`>`
`20d8 : 28 [ 4]> plp ;restore status`	`25f4 : 28 [ 4]> plp ;restore status`

`set_a $7f,$ff`	`set_a $7f,$ff`
`> load_flag $ff`	`> load_flag $ff`
`20d9 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`25f5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`20db : 48 [ 3]> pha ;use stack to load status`	`25f7 : 48 [ 3]> pha ;use stack to load status`
`20dc : a97f [ 2]> lda #$7f ;precharge accu`	`25f8 : a97f [ 2]> lda #$7f ;precharge accu`
`20de : 28 [ 4]> plp`	`25fa : 28 [ 4]> plp`

`20df : c124 [ 6] cmp (ind1,x)`	`25fb : c1ca [ 6] cmp (ind1,x)`
`tst_a $7f,~fn`	`tst_a $7f,~fn`
`20e1 : 08 [ 3]> php ;save flags`	`25fd : 08 [ 3]> php ;save flags`
`20e2 : 08 [ 3]> php`	`25fe : 08 [ 3]> php`
`20e3 : c97f [ 2]> cmp #$7f ;test result`	`25ff : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`20e5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2601 : f002 [ 3]> beq skip2211`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2603 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2604 : 1c > db test_num`
	`>`
	`2605 : >skip2211`
`>`	`>`
`20e7 : 68 [ 4]> pla ;load status`	`2605 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`20e8 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`2606 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`20ea : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2608 : f002 [ 3]> beq skip2214`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`260a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`260b : 1c > db test_num`
`>`	`>`
`20ec : 28 [ 4]> plp ;restore status`	`260c : >skip2214`
	`>`
	`260c : 28 [ 4]> plp ;restore status`

`set_a $7e,$ff`	`set_a $7e,$ff`
`> load_flag $ff`	`> load_flag $ff`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 164`	`260d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 259`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`20ed : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`260f : 48 [ 3]> pha ;use stack to load status`
`>`	`2610 : a97e [ 2]> lda #$7e ;precharge accu`
`20ef : 48 [ 3]> pha ;use stack to load status`	`2612 : 28 [ 4]> plp`
`20f0 : a97e [ 2]> lda #$7e ;precharge accu`
`20f2 : 28 [ 4]> plp`

`20f3 : c124 [ 6] cmp (ind1,x)`	`2613 : c1ca [ 6] cmp (ind1,x)`
`tst_a $7e,~fzc`	`tst_a $7e,~fzc`
`20f5 : 08 [ 3]> php ;save flags`	`2615 : 08 [ 3]> php ;save flags`
`20f6 : 08 [ 3]> php`	`2616 : 08 [ 3]> php`
`20f7 : c97e [ 2]> cmp #$7e ;test result`	`2617 : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`20f9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2619 : f002 [ 3]> beq skip2219`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`261b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`261c : 1c > db test_num`
	`>`
	`261d : >skip2219`
`>`	`>`
`20fb : 68 [ 4]> pla ;load status`	`261d : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`20fc : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`261e : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`20fe : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2620 : f002 [ 3]> beq skip2222`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2622 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2623 : 1c > db test_num`
`>`	`>`
`2100 : 28 [ 4]> plp ;restore status`	`2624 : >skip2222`
	`>`
	`2624 : 28 [ 4]> plp ;restore status`


`set_a $80,0`	`set_a $80,0`
`> load_flag 0`	`> load_flag 0`
`2101 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2625 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2103 : 48 [ 3]> pha ;use stack to load status`	`2627 : 48 [ 3]> pha ;use stack to load status`
`2104 : a980 [ 2]> lda #$80 ;precharge accu`	`2628 : a980 [ 2]> lda #$80 ;precharge accu`
`2106 : 28 [ 4]> plp`	`262a : 28 [ 4]> plp`

`2107 : d124 [ 5] cmp (ind1),y`	`262b : d1ca [ 5] cmp (ind1),y`
`tst_a $80,fc`	`tst_a $80,fc`
`2109 : 08 [ 3]> php ;save flags`	`262d : 08 [ 3]> php ;save flags`
`210a : 08 [ 3]> php`	`262e : 08 [ 3]> php`
`210b : c980 [ 2]> cmp #$80 ;test result`	`262f : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`	`> trap_ne`
`210d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2631 : f002 [ 3]> beq skip2227`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2633 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2634 : 1c > db test_num`
	`>`
	`2635 : >skip2227`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 260`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`210f : 68 [ 4]> pla ;load status`	`2635 : 68 [ 4]> pla ;load status`
`> cmp_flag fc`	`> cmp_flag fc`
`2110 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`	`2636 : c931 [ 2]> cmp #(fc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`2112 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2638 : f002 [ 3]> beq skip2230`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`263a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`263b : 1c > db test_num`
`>`	`>`
`2114 : 28 [ 4]> plp ;restore status`	`263c : >skip2230`
	`>`
	`263c : 28 [ 4]> plp ;restore status`

`set_a $7f,0`	`set_a $7f,0`
`> load_flag 0`	`> load_flag 0`
`2115 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`263d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2117 : 48 [ 3]> pha ;use stack to load status`	`263f : 48 [ 3]> pha ;use stack to load status`
`2118 : a97f [ 2]> lda #$7f ;precharge accu`	`2640 : a97f [ 2]> lda #$7f ;precharge accu`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 165`	`2642 : 28 [ 4]> plp`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`211a : 28 [ 4]> plp`

`211b : d124 [ 5] cmp (ind1),y`	`2643 : d1ca [ 5] cmp (ind1),y`
`tst_a $7f,fzc`	`tst_a $7f,fzc`
`211d : 08 [ 3]> php ;save flags`	`2645 : 08 [ 3]> php ;save flags`
`211e : 08 [ 3]> php`	`2646 : 08 [ 3]> php`
`211f : c97f [ 2]> cmp #$7f ;test result`	`2647 : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`2121 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2649 : f002 [ 3]> beq skip2235`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`264b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`264c : 1c > db test_num`
	`>`
	`264d : >skip2235`
`>`	`>`
`2123 : 68 [ 4]> pla ;load status`	`264d : 68 [ 4]> pla ;load status`
`> cmp_flag fzc`	`> cmp_flag fzc`
`2124 : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`	`264e : c933 [ 2]> cmp #(fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`2126 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2650 : f002 [ 3]> beq skip2238`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2652 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2653 : 1c > db test_num`
`>`	`>`
`2128 : 28 [ 4]> plp ;restore status`	`2654 : >skip2238`
	`>`
	`2654 : 28 [ 4]> plp ;restore status`

`set_a $7e,0`	`set_a $7e,0`
`> load_flag 0`	`> load_flag 0`
`2129 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 261`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2655 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`212b : 48 [ 3]> pha ;use stack to load status`	`2657 : 48 [ 3]> pha ;use stack to load status`
`212c : a97e [ 2]> lda #$7e ;precharge accu`	`2658 : a97e [ 2]> lda #$7e ;precharge accu`
`212e : 28 [ 4]> plp`	`265a : 28 [ 4]> plp`

`212f : d124 [ 5] cmp (ind1),y`	`265b : d1ca [ 5] cmp (ind1),y`
`tst_a $7e,fn`	`tst_a $7e,fn`
`2131 : 08 [ 3]> php ;save flags`	`265d : 08 [ 3]> php ;save flags`
`2132 : 08 [ 3]> php`	`265e : 08 [ 3]> php`
`2133 : c97e [ 2]> cmp #$7e ;test result`	`265f : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`2135 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2661 : f002 [ 3]> beq skip2243`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2663 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2664 : 1c > db test_num`
`>`	`>`
`2137 : 68 [ 4]> pla ;load status`	`2665 : >skip2243`
	`>`
	`2665 : 68 [ 4]> pla ;load status`
`> cmp_flag fn`	`> cmp_flag fn`
`2138 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`	`2666 : c9b0 [ 2]> cmp #(fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`213a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2668 : f002 [ 3]> beq skip2246`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`266a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`266b : 1c > db test_num`
	`>`
	`266c : >skip2246`
`>`	`>`
`213c : 28 [ 4]> plp ;restore status`	`266c : 28 [ 4]> plp ;restore status`

`set_a $80,$ff`	`set_a $80,$ff`
`> load_flag $ff`	`> load_flag $ff`
`213d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`266d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`213f : 48 [ 3]> pha ;use stack to load status`	`266f : 48 [ 3]> pha ;use stack to load status`
`2140 : a980 [ 2]> lda #$80 ;precharge accu`	`2670 : a980 [ 2]> lda #$80 ;precharge accu`
`2142 : 28 [ 4]> plp`	`2672 : 28 [ 4]> plp`

`2143 : d124 [ 5] cmp (ind1),y`	`2673 : d1ca [ 5] cmp (ind1),y`
`tst_a $80,~fnz`	`tst_a $80,~fnz`
`2145 : 08 [ 3]> php ;save flags`	`2675 : 08 [ 3]> php ;save flags`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 166`	`2676 : 08 [ 3]> php`
	`2677 : c980 [ 2]> cmp #$80 ;test result`
	`> trap_ne`
	`2679 : f002 [ 3]> beq skip2251`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`267b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`267c : 1c > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 262`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2146 : 08 [ 3]> php`	`267d : >skip2251`
`2147 : c980 [ 2]> cmp #$80 ;test result`
`> trap_ne`
`2149 : d0fe [ 3]> bne * ;failed not equal (non zero)`
`>`	`>`
`214b : 68 [ 4]> pla ;load status`	`267d : 68 [ 4]> pla ;load status`
`> cmp_flag ~fnz`	`> cmp_flag ~fnz`
`214c : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`	`267e : c97d [ 2]> cmp #(~fnz\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`214e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2680 : f002 [ 3]> beq skip2254`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2682 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2683 : 1c > db test_num`
	`>`
	`2684 : >skip2254`
`>`	`>`
`2150 : 28 [ 4]> plp ;restore status`	`2684 : 28 [ 4]> plp ;restore status`

`set_a $7f,$ff`	`set_a $7f,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2151 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2685 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2153 : 48 [ 3]> pha ;use stack to load status`	`2687 : 48 [ 3]> pha ;use stack to load status`
`2154 : a97f [ 2]> lda #$7f ;precharge accu`	`2688 : a97f [ 2]> lda #$7f ;precharge accu`
`2156 : 28 [ 4]> plp`	`268a : 28 [ 4]> plp`

`2157 : d124 [ 5] cmp (ind1),y`	`268b : d1ca [ 5] cmp (ind1),y`
`tst_a $7f,~fn`	`tst_a $7f,~fn`
`2159 : 08 [ 3]> php ;save flags`	`268d : 08 [ 3]> php ;save flags`
`215a : 08 [ 3]> php`	`268e : 08 [ 3]> php`
`215b : c97f [ 2]> cmp #$7f ;test result`	`268f : c97f [ 2]> cmp #$7f ;test result`
`> trap_ne`	`> trap_ne`
`215d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2691 : f002 [ 3]> beq skip2259`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2693 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2694 : 1c > db test_num`
	`>`
	`2695 : >skip2259`
`>`	`>`
`215f : 68 [ 4]> pla ;load status`	`2695 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fn`	`> cmp_flag ~fn`
`2160 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`	`2696 : c97f [ 2]> cmp #(~fn\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`2162 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2698 : f002 [ 3]> beq skip2262`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`269a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`269b : 1c > db test_num`
`>`	`>`
`2164 : 28 [ 4]> plp ;restore status`	`269c : >skip2262`
	`>`
	`269c : 28 [ 4]> plp ;restore status`

`set_a $7e,$ff`	`set_a $7e,$ff`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 263`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag $ff`	`> load_flag $ff`
`2165 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`269d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2167 : 48 [ 3]> pha ;use stack to load status`	`269f : 48 [ 3]> pha ;use stack to load status`
`2168 : a97e [ 2]> lda #$7e ;precharge accu`	`26a0 : a97e [ 2]> lda #$7e ;precharge accu`
`216a : 28 [ 4]> plp`	`26a2 : 28 [ 4]> plp`

`216b : d124 [ 5] cmp (ind1),y`	`26a3 : d1ca [ 5] cmp (ind1),y`
`tst_a $7e,~fzc`	`tst_a $7e,~fzc`
`216d : 08 [ 3]> php ;save flags`	`26a5 : 08 [ 3]> php ;save flags`
`216e : 08 [ 3]> php`	`26a6 : 08 [ 3]> php`
`216f : c97e [ 2]> cmp #$7e ;test result`	`26a7 : c97e [ 2]> cmp #$7e ;test result`
`> trap_ne`	`> trap_ne`
`2171 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`26a9 : f002 [ 3]> beq skip2267`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`26ab : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`26ac : 1c > db test_num`
`>`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 167`	`26ad : >skip2267`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`>`
	`26ad : 68 [ 4]> pla ;load status`
`2173 : 68 [ 4]> pla ;load status`
`> cmp_flag ~fzc`	`> cmp_flag ~fzc`
`2174 : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`	`26ae : c9fc [ 2]> cmp #(~fzc\|fao)&m8 ;expected flags + always on bits`
`>`	`>`
`> trap_ne`	`> trap_ne`
`2176 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`26b0 : f002 [ 3]> beq skip2270`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`26b2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`26b3 : 1c > db test_num`
`>`	`>`
`2178 : 28 [ 4]> plp ;restore status`	`26b4 : >skip2270`
	`>`
	`26b4 : 28 [ 4]> plp ;restore status`

`next_test`	`next_test`
`2179 : ad0002 [ 4]> lda test_case ;previous test`	`26b5 : ad0002 [ 4]> lda test_case ;previous test`
`217c : c91c [ 2]> cmp #test_num`	`26b8 : c91c [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`217e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`26ba : f002 [ 3]> beq skip2273`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`26bc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`26bd : 1c > db test_num`
	`>`
	`26be : >skip2273`
`>`	`>`
`001d = >test_num = test_num + 1`	`001d = >test_num = test_num + 1`
`2180 : a91d [ 2]> lda #test_num ;*** this tests' number`	`26be : a91d [ 2]> lda #test_num ;*** this tests' number`
`2182 : 8d0002 [ 4]> sta test_case`	`26c0 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; testing shifts - ASL LSR ROL ROR all addressing modes`	`; testing shifts - ASL LSR ROL ROR all addressing modes`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 264`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`; shifts - accumulator`	`; shifts - accumulator`
`2185 : a203 [ 2] ldx #3`
`2187 : tasl`	`26c3 : a203 [ 2] ldx #3`
	`26c5 : tasl`
`set_ax zp1,0`	`set_ax zp1,0`
`> load_flag 0`	`> load_flag 0`
`2187 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`26c5 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2189 : 48 [ 3]> pha ;use stack to load status`	`26c7 : 48 [ 3]> pha ;use stack to load status`
`218a : b513 [ 4]> lda zp1,x ;precharge accu`	`26c8 : b5b9 [ 4]> lda zp1,x ;precharge accu`
`218c : 28 [ 4]> plp`	`26ca : 28 [ 4]> plp`

`218d : 0a [ 2] asl a`	`26cb : 0a [ 2] asl a`
`tst_ax rASL,fASL,0`	`tst_ax rASL,fASL,0`
`218e : 08 [ 3]> php ;save flags`	`26cc : 08 [ 3]> php ;save flags`
`218f : dd1102 [ 4]> cmp rASL,x ;test result`	`26cd : dd1102 [ 4]> cmp rASL,x ;test result`
`> trap_ne`	`> trap_ne`
`2192 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`26d0 : f002 [ 3]> beq skip2278`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`26d2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`26d3 : 1d > db test_num`
	`>`
	`26d4 : >skip2278`
`>`	`>`
`2194 : 68 [ 4]> pla ;load status`	`26d4 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2195 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`26d5 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2197 : dd2102 [ 4]> cmp fASL,x ;test flags`	`26d7 : dd2102 [ 4]> cmp fASL,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`219a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`26da : f002 [ 3]> beq skip2281`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`26dc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`26dd : 1d > db test_num`
	`>`
	`26de : >skip2281`
`>`	`>`

`219c : ca [ 2] dex`	`26de : ca [ 2] dex`
`219d : 10e8 [ 3] bpl tasl`	`26df : 10e4 [ 3] bpl tasl`
`219f : a203 [ 2] ldx #3`	`26e1 : a203 [ 2] ldx #3`
`21a1 : tasl1`	`26e3 : tasl1`
`set_ax zp1,$ff`	`set_ax zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 168`	`26e3 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`21a1 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`21a3 : 48 [ 3]> pha ;use stack to load status`	`26e5 : 48 [ 3]> pha ;use stack to load status`
`21a4 : b513 [ 4]> lda zp1,x ;precharge accu`	`26e6 : b5b9 [ 4]> lda zp1,x ;precharge accu`
`21a6 : 28 [ 4]> plp`	`26e8 : 28 [ 4]> plp`

`21a7 : 0a [ 2] asl a`	`26e9 : 0a [ 2] asl a`
`tst_ax rASL,fASL,$ff-fnzc`	`tst_ax rASL,fASL,$ff-fnzc`
`21a8 : 08 [ 3]> php ;save flags`	`26ea : 08 [ 3]> php ;save flags`
`21a9 : dd1102 [ 4]> cmp rASL,x ;test result`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 265`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`26eb : dd1102 [ 4]> cmp rASL,x ;test result`
`> trap_ne`	`> trap_ne`
`21ac : d0fe [ 3]> bne * ;failed not equal (non zero)`	`26ee : f002 [ 3]> beq skip2286`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`26f0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`26f1 : 1d > db test_num`
	`>`
	`26f2 : >skip2286`
`>`	`>`
`21ae : 68 [ 4]> pla ;load status`	`26f2 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`21af : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`26f3 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`21b1 : dd2102 [ 4]> cmp fASL,x ;test flags`	`26f5 : dd2102 [ 4]> cmp fASL,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`21b4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`26f8 : f002 [ 3]> beq skip2289`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`26fa : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`26fb : 1d > db test_num`
	`>`
	`26fc : >skip2289`
`>`	`>`

`21b6 : ca [ 2] dex`	`26fc : ca [ 2] dex`
`21b7 : 10e8 [ 3] bpl tasl1`	`26fd : 10e4 [ 3] bpl tasl1`

`21b9 : a203 [ 2] ldx #3`	`26ff : a203 [ 2] ldx #3`
`21bb : tlsr`	`2701 : tlsr`
`set_ax zp1,0`	`set_ax zp1,0`
`> load_flag 0`	`> load_flag 0`
`21bb : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2701 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`21bd : 48 [ 3]> pha ;use stack to load status`	`2703 : 48 [ 3]> pha ;use stack to load status`
`21be : b513 [ 4]> lda zp1,x ;precharge accu`	`2704 : b5b9 [ 4]> lda zp1,x ;precharge accu`
`21c0 : 28 [ 4]> plp`	`2706 : 28 [ 4]> plp`

`21c1 : 4a [ 2] lsr a`	`2707 : 4a [ 2] lsr a`
`tst_ax rLSR,fLSR,0`	`tst_ax rLSR,fLSR,0`
`21c2 : 08 [ 3]> php ;save flags`	`2708 : 08 [ 3]> php ;save flags`
`21c3 : dd1902 [ 4]> cmp rLSR,x ;test result`	`2709 : dd1902 [ 4]> cmp rLSR,x ;test result`
`> trap_ne`	`> trap_ne`
`21c6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`270c : f002 [ 3]> beq skip2294`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`270e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`270f : 1d > db test_num`
	`>`
	`2710 : >skip2294`
`>`	`>`
`21c8 : 68 [ 4]> pla ;load status`	`2710 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`21c9 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2711 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`21cb : dd2902 [ 4]> cmp fLSR,x ;test flags`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 266`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2713 : dd2902 [ 4]> cmp fLSR,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`21ce : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2716 : f002 [ 3]> beq skip2297`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2718 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2719 : 1d > db test_num`
	`>`
	`271a : >skip2297`
`>`	`>`

`21d0 : ca [ 2] dex`	`271a : ca [ 2] dex`
`21d1 : 10e8 [ 3] bpl tlsr`	`271b : 10e4 [ 3] bpl tlsr`
`21d3 : a203 [ 2] ldx #3`	`271d : a203 [ 2] ldx #3`
`21d5 : tlsr1`	`271f : tlsr1`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 169`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`set_ax zp1,$ff`	`set_ax zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`21d5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`271f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`21d7 : 48 [ 3]> pha ;use stack to load status`	`2721 : 48 [ 3]> pha ;use stack to load status`
`21d8 : b513 [ 4]> lda zp1,x ;precharge accu`	`2722 : b5b9 [ 4]> lda zp1,x ;precharge accu`
`21da : 28 [ 4]> plp`	`2724 : 28 [ 4]> plp`

`21db : 4a [ 2] lsr a`	`2725 : 4a [ 2] lsr a`
`tst_ax rLSR,fLSR,$ff-fnzc`	`tst_ax rLSR,fLSR,$ff-fnzc`
`21dc : 08 [ 3]> php ;save flags`	`2726 : 08 [ 3]> php ;save flags`
`21dd : dd1902 [ 4]> cmp rLSR,x ;test result`	`2727 : dd1902 [ 4]> cmp rLSR,x ;test result`
`> trap_ne`	`> trap_ne`
`21e0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`272a : f002 [ 3]> beq skip2302`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`272c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`272d : 1d > db test_num`
	`>`
	`272e : >skip2302`
`>`	`>`
`21e2 : 68 [ 4]> pla ;load status`	`272e : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`21e3 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`272f : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`21e5 : dd2902 [ 4]> cmp fLSR,x ;test flags`	`2731 : dd2902 [ 4]> cmp fLSR,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`21e8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2734 : f002 [ 3]> beq skip2305`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2736 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2737 : 1d > db test_num`
`>`	`>`
	`2738 : >skip2305`
	`>`

	`2738 : ca [ 2] dex`
	`2739 : 10e4 [ 3] bpl tlsr1`

`21ea : ca [ 2] dex`	`273b : a203 [ 2] ldx #3`
`21eb : 10e8 [ 3] bpl tlsr1`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 267`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`21ed : a203 [ 2] ldx #3`	`273d : trol`
`21ef : trol`
`set_ax zp1,0`	`set_ax zp1,0`
`> load_flag 0`	`> load_flag 0`
`21ef : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`273d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`21f1 : 48 [ 3]> pha ;use stack to load status`	`273f : 48 [ 3]> pha ;use stack to load status`
`21f2 : b513 [ 4]> lda zp1,x ;precharge accu`	`2740 : b5b9 [ 4]> lda zp1,x ;precharge accu`
`21f4 : 28 [ 4]> plp`	`2742 : 28 [ 4]> plp`

`21f5 : 2a [ 2] rol a`	`2743 : 2a [ 2] rol a`
`tst_ax rROL,fROL,0`	`tst_ax rROL,fROL,0`
`21f6 : 08 [ 3]> php ;save flags`	`2744 : 08 [ 3]> php ;save flags`
`21f7 : dd1102 [ 4]> cmp rROL,x ;test result`	`2745 : dd1102 [ 4]> cmp rROL,x ;test result`
`> trap_ne`	`> trap_ne`
`21fa : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2748 : f002 [ 3]> beq skip2310`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`274a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`274b : 1d > db test_num`
	`>`
	`274c : >skip2310`
`>`	`>`
`21fc : 68 [ 4]> pla ;load status`	`274c : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`21fd : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`274d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`21ff : dd2102 [ 4]> cmp fROL,x ;test flags`	`274f : dd2102 [ 4]> cmp fROL,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2202 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2752 : f002 [ 3]> beq skip2313`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2754 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2755 : 1d > db test_num`
	`>`
	`2756 : >skip2313`
`>`	`>`

`2204 : ca [ 2] dex`	`2756 : ca [ 2] dex`
`2205 : 10e8 [ 4] bpl trol`	`2757 : 10e4 [ 3] bpl trol`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 170`	`2759 : a203 [ 2] ldx #3`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`275b : trol1`

`2207 : a203 [ 2] ldx #3`
`2209 : trol1`
`set_ax zp1,$ff-fc`	`set_ax zp1,$ff-fc`
`> load_flag $ff-fc`	`> load_flag $ff-fc`
`2209 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`	`275b : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`
`>`	`>`
`220b : 48 [ 3]> pha ;use stack to load status`	`275d : 48 [ 3]> pha ;use stack to load status`
`220c : b513 [ 4]> lda zp1,x ;precharge accu`	`275e : b5b9 [ 4]> lda zp1,x ;precharge accu`
`220e : 28 [ 4]> plp`	`2760 : 28 [ 4]> plp`

`220f : 2a [ 2] rol a`	`2761 : 2a [ 2] rol a`
`tst_ax rROL,fROL,$ff-fnzc`	`tst_ax rROL,fROL,$ff-fnzc`
`2210 : 08 [ 3]> php ;save flags`	`2762 : 08 [ 3]> php ;save flags`
`2211 : dd1102 [ 4]> cmp rROL,x ;test result`	`2763 : dd1102 [ 4]> cmp rROL,x ;test result`
`> trap_ne`	`> trap_ne`
`2214 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2766 : f002 [ 3]> beq skip2318`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 268`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2768 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2769 : 1d > db test_num`
	`>`
	`276a : >skip2318`
`>`	`>`
`2216 : 68 [ 4]> pla ;load status`	`276a : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`2217 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`276b : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`2219 : dd2102 [ 4]> cmp fROL,x ;test flags`	`276d : dd2102 [ 4]> cmp fROL,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`221c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2770 : f002 [ 3]> beq skip2321`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2772 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2773 : 1d > db test_num`
	`>`
	`2774 : >skip2321`
`>`	`>`

`221e : ca [ 2] dex`	`2774 : ca [ 2] dex`
`221f : 10e8 [ 3] bpl trol1`	`2775 : 10e4 [ 3] bpl trol1`

`2221 : a203 [ 2] ldx #3`	`2777 : a203 [ 2] ldx #3`
`2223 : trolc`	`2779 : trolc`
`set_ax zp1,fc`	`set_ax zp1,fc`
`> load_flag fc`	`> load_flag fc`
`2223 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`	`2779 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`
`>`	`>`
`2225 : 48 [ 3]> pha ;use stack to load status`	`277b : 48 [ 3]> pha ;use stack to load status`
`2226 : b513 [ 4]> lda zp1,x ;precharge accu`	`277c : b5b9 [ 4]> lda zp1,x ;precharge accu`
`2228 : 28 [ 4]> plp`	`277e : 28 [ 4]> plp`

`2229 : 2a [ 2] rol a`	`277f : 2a [ 2] rol a`
`tst_ax rROLc,fROLc,0`	`tst_ax rROLc,fROLc,0`
`222a : 08 [ 3]> php ;save flags`	`2780 : 08 [ 3]> php ;save flags`
`222b : dd1502 [ 4]> cmp rROLc,x ;test result`	`2781 : dd1502 [ 4]> cmp rROLc,x ;test result`
`> trap_ne`	`> trap_ne`
`222e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2784 : f002 [ 3]> beq skip2326`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2786 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2787 : 1d > db test_num`
	`>`
	`2788 : >skip2326`
`>`	`>`
`2230 : 68 [ 4]> pla ;load status`	`2788 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2231 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2789 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2233 : dd2502 [ 4]> cmp fROLc,x ;test flags`	`278b : dd2502 [ 4]> cmp fROLc,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2236 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`278e : f002 [ 3]> beq skip2329`
`>`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 269`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 171`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2238 : ca [ 2] dex`	`> trap ;failed equal (zero)`
`2239 : 10e8 [ 3] bpl trolc`	`>; db $db ; M65C02/M65C02A SToP instruction`
`223b : a203 [ 2] ldx #3`	`2790 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`223d : trolc1`	`2791 : 1d > db test_num`
	`>`
	`2792 : >skip2329`
	`>`

	`2792 : ca [ 2] dex`
	`2793 : 10e4 [ 3] bpl trolc`
	`2795 : a203 [ 2] ldx #3`
	`2797 : trolc1`
`set_ax zp1,$ff`	`set_ax zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`223d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2797 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`223f : 48 [ 3]> pha ;use stack to load status`	`2799 : 48 [ 3]> pha ;use stack to load status`
`2240 : b513 [ 4]> lda zp1,x ;precharge accu`	`279a : b5b9 [ 4]> lda zp1,x ;precharge accu`
`2242 : 28 [ 4]> plp`	`279c : 28 [ 4]> plp`

`2243 : 2a [ 2] rol a`	`279d : 2a [ 2] rol a`
`tst_ax rROLc,fROLc,$ff-fnzc`	`tst_ax rROLc,fROLc,$ff-fnzc`
`2244 : 08 [ 3]> php ;save flags`	`279e : 08 [ 3]> php ;save flags`
`2245 : dd1502 [ 4]> cmp rROLc,x ;test result`	`279f : dd1502 [ 4]> cmp rROLc,x ;test result`
`> trap_ne`	`> trap_ne`
`2248 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`27a2 : f002 [ 3]> beq skip2334`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`27a4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`27a5 : 1d > db test_num`
`>`	`>`
`224a : 68 [ 4]> pla ;load status`	`27a6 : >skip2334`
	`>`
	`27a6 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`224b : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`27a7 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`224d : dd2502 [ 4]> cmp fROLc,x ;test flags`	`27a9 : dd2502 [ 4]> cmp fROLc,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2250 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`27ac : f002 [ 3]> beq skip2337`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`27ae : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`27af : 1d > db test_num`
	`>`
	`27b0 : >skip2337`
`>`	`>`

`2252 : ca [ 2] dex`	`27b0 : ca [ 2] dex`
`2253 : 10e8 [ 3] bpl trolc1`	`27b1 : 10e4 [ 3] bpl trolc1`

`2255 : a203 [ 2] ldx #3`	`27b3 : a203 [ 2] ldx #3`
`2257 : tror`	`27b5 : tror`
`set_ax zp1,0`	`set_ax zp1,0`
`> load_flag 0`	`> load_flag 0`
`2257 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 270`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`27b5 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2259 : 48 [ 3]> pha ;use stack to load status`	`27b7 : 48 [ 3]> pha ;use stack to load status`
`225a : b513 [ 4]> lda zp1,x ;precharge accu`	`27b8 : b5b9 [ 4]> lda zp1,x ;precharge accu`
`225c : 28 [ 4]> plp`	`27ba : 28 [ 4]> plp`

`225d : 6a [ 2] ror a`	`27bb : 6a [ 2] ror a`
`tst_ax rROR,fROR,0`	`tst_ax rROR,fROR,0`
`225e : 08 [ 3]> php ;save flags`	`27bc : 08 [ 3]> php ;save flags`
`225f : dd1902 [ 4]> cmp rROR,x ;test result`	`27bd : dd1902 [ 4]> cmp rROR,x ;test result`
`> trap_ne`	`> trap_ne`
`2262 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`27c0 : f002 [ 3]> beq skip2342`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`27c2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`27c3 : 1d > db test_num`
`>`	`>`
`2264 : 68 [ 4]> pla ;load status`	`27c4 : >skip2342`
	`>`
	`27c4 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2265 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`27c5 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2267 : dd2902 [ 4]> cmp fROR,x ;test flags`	`27c7 : dd2902 [ 4]> cmp fROR,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`226a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`27ca : f002 [ 3]> beq skip2345`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 172`	`> trap ;failed equal (zero)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`27cc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`27cd : 1d > db test_num`
	`>`
	`27ce : >skip2345`
`>`	`>`

`226c : ca [ 2] dex`	`27ce : ca [ 2] dex`
`226d : 10e8 [ 3] bpl tror`	`27cf : 10e4 [ 3] bpl tror`
`226f : a203 [ 2] ldx #3`	`27d1 : a203 [ 2] ldx #3`
`2271 : tror1`	`27d3 : tror1`
`set_ax zp1,$ff-fc`	`set_ax zp1,$ff-fc`
`> load_flag $ff-fc`	`> load_flag $ff-fc`
`2271 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`	`27d3 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`
`>`	`>`
`2273 : 48 [ 3]> pha ;use stack to load status`	`27d5 : 48 [ 3]> pha ;use stack to load status`
`2274 : b513 [ 4]> lda zp1,x ;precharge accu`	`27d6 : b5b9 [ 4]> lda zp1,x ;precharge accu`
`2276 : 28 [ 4]> plp`	`27d8 : 28 [ 4]> plp`

`2277 : 6a [ 2] ror a`	`27d9 : 6a [ 2] ror a`
`tst_ax rROR,fROR,$ff-fnzc`	`tst_ax rROR,fROR,$ff-fnzc`
`2278 : 08 [ 3]> php ;save flags`	`27da : 08 [ 3]> php ;save flags`
`2279 : dd1902 [ 4]> cmp rROR,x ;test result`	`27db : dd1902 [ 4]> cmp rROR,x ;test result`
`> trap_ne`	`> trap_ne`
`227c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`27de : f002 [ 3]> beq skip2350`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`27e0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 271`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`27e1 : 1d > db test_num`
`>`	`>`
`227e : 68 [ 4]> pla ;load status`	`27e2 : >skip2350`
	`>`
	`27e2 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`227f : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`27e3 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`2281 : dd2902 [ 4]> cmp fROR,x ;test flags`	`27e5 : dd2902 [ 4]> cmp fROR,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2284 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`27e8 : f002 [ 3]> beq skip2353`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`27ea : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`27eb : 1d > db test_num`
	`>`
	`27ec : >skip2353`
`>`	`>`

`2286 : ca [ 2] dex`	`27ec : ca [ 2] dex`
`2287 : 10e8 [ 3] bpl tror1`	`27ed : 10e4 [ 3] bpl tror1`

`2289 : a203 [ 2] ldx #3`	`27ef : a203 [ 2] ldx #3`
`228b : trorc`	`27f1 : trorc`
`set_ax zp1,fc`	`set_ax zp1,fc`
`> load_flag fc`	`> load_flag fc`
`228b : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`	`27f1 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`
`>`	`>`
`228d : 48 [ 3]> pha ;use stack to load status`	`27f3 : 48 [ 3]> pha ;use stack to load status`
`228e : b513 [ 4]> lda zp1,x ;precharge accu`	`27f4 : b5b9 [ 4]> lda zp1,x ;precharge accu`
`2290 : 28 [ 4]> plp`	`27f6 : 28 [ 4]> plp`

`2291 : 6a [ 2] ror a`	`27f7 : 6a [ 2] ror a`
`tst_ax rRORc,fRORc,0`	`tst_ax rRORc,fRORc,0`
`2292 : 08 [ 3]> php ;save flags`	`27f8 : 08 [ 3]> php ;save flags`
`2293 : dd1d02 [ 4]> cmp rRORc,x ;test result`	`27f9 : dd1d02 [ 4]> cmp rRORc,x ;test result`
`> trap_ne`	`> trap_ne`
`2296 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`27fc : f002 [ 4]> beq skip2358`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`27fe : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`27ff : 1d > db test_num`
`>`	`>`
`2298 : 68 [ 4]> pla ;load status`	`2800 : >skip2358`
	`>`
	`2800 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2299 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2801 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`229b : dd2d02 [ 4]> cmp fRORc,x ;test flags`	`2803 : dd2d02 [ 4]> cmp fRORc,x ;test flags`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 173`	`> trap_ne ;`
	`2806 : f002 [ 3]> beq skip2361`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2808 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 272`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> trap_ne ;`	`2809 : 1d > db test_num`
`229e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`>`
	`280a : >skip2361`
`>`	`>`

`22a0 : ca [ 2] dex`	`280a : ca [ 2] dex`
`22a1 : 10e8 [ 3] bpl trorc`	`280b : 10e4 [ 4] bpl trorc`
`22a3 : a203 [ 2] ldx #3`	`280d : a203 [ 2] ldx #3`
`22a5 : trorc1`	`280f : trorc1`
`set_ax zp1,$ff`	`set_ax zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`22a5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`280f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`22a7 : 48 [ 3]> pha ;use stack to load status`	`2811 : 48 [ 3]> pha ;use stack to load status`
`22a8 : b513 [ 4]> lda zp1,x ;precharge accu`	`2812 : b5b9 [ 4]> lda zp1,x ;precharge accu`
`22aa : 28 [ 4]> plp`	`2814 : 28 [ 4]> plp`

`22ab : 6a [ 2] ror a`	`2815 : 6a [ 2] ror a`
`tst_ax rRORc,fRORc,$ff-fnzc`	`tst_ax rRORc,fRORc,$ff-fnzc`
`22ac : 08 [ 3]> php ;save flags`	`2816 : 08 [ 3]> php ;save flags`
`22ad : dd1d02 [ 4]> cmp rRORc,x ;test result`	`2817 : dd1d02 [ 4]> cmp rRORc,x ;test result`
`> trap_ne`	`> trap_ne`
`22b0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`281a : f002 [ 3]> beq skip2366`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`281c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`281d : 1d > db test_num`
	`>`
	`281e : >skip2366`
`>`	`>`
`22b2 : 68 [ 4]> pla ;load status`	`281e : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`22b3 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`281f : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`22b5 : dd2d02 [ 4]> cmp fRORc,x ;test flags`	`2821 : dd2d02 [ 4]> cmp fRORc,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`22b8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2824 : f002 [ 3]> beq skip2369`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2826 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2827 : 1d > db test_num`
	`>`
	`2828 : >skip2369`
`>`	`>`

`22ba : ca [ 2] dex`	`2828 : ca [ 2] dex`
`22bb : 10e8 [ 3] bpl trorc1`	`2829 : 10e4 [ 3] bpl trorc1`
`next_test`	`next_test`
`22bd : ad0002 [ 4]> lda test_case ;previous test`	`282b : ad0002 [ 4]> lda test_case ;previous test`
`22c0 : c91d [ 2]> cmp #test_num`	`282e : c91d [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`22c2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2830 : f002 [ 3]> beq skip2372`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2832 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 273`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2833 : 1d > db test_num`
	`>`
	`2834 : >skip2372`
`>`	`>`
`001e = >test_num = test_num + 1`	`001e = >test_num = test_num + 1`
`22c4 : a91e [ 2]> lda #test_num ;*** this tests' number`	`2834 : a91e [ 2]> lda #test_num ;*** this tests' number`
`22c6 : 8d0002 [ 4]> sta test_case`	`2836 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; shifts - zeropage`	`; shifts - zeropage`
`22c9 : a203 [ 2] ldx #3`
`22cb : tasl2`	`2839 : a203 [ 2] ldx #3`
	`283b : tasl2`
`set_z zp1,0`	`set_z zp1,0`
`> load_flag 0`	`> load_flag 0`
`22cb : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`283b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`22cd : 48 [ 3]> pha ;use stack to load status`	`283d : 48 [ 3]> pha ;use stack to load status`
`22ce : b513 [ 4]> lda zp1,x ;load to zeropage`	`283e : b5b9 [ 4]> lda zp1,x ;load to zeropage`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 174`	`2840 : 85b2 [ 3]> sta zpt`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`2842 : 28 [ 4]> plp`

`22d0 : 850c [ 3]> sta zpt`
`22d2 : 28 [ 4]> plp`

`22d3 : 060c [ 5] asl zpt`	`2843 : 06b2 [ 5] asl zpt`
`tst_z rASL,fASL,0`	`tst_z rASL,fASL,0`
`22d5 : 08 [ 3]> php ;save flags`	`2845 : 08 [ 3]> php ;save flags`
`22d6 : a50c [ 3]> lda zpt`	`2846 : a5b2 [ 3]> lda zpt`
`22d8 : dd1102 [ 4]> cmp rASL,x ;test result`	`2848 : dd1102 [ 4]> cmp rASL,x ;test result`
`> trap_ne`	`> trap_ne`
`22db : d0fe [ 3]> bne * ;failed not equal (non zero)`	`284b : f002 [ 3]> beq skip2377`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`284d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`284e : 1e > db test_num`
	`>`
	`284f : >skip2377`
`>`	`>`
`22dd : 68 [ 4]> pla ;load status`	`284f : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`22de : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2850 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`22e0 : dd2102 [ 4]> cmp fASL,x ;test flags`	`2852 : dd2102 [ 4]> cmp fASL,x ;test flags`
`> trap_ne`	`> trap_ne`
`22e3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2855 : f002 [ 3]> beq skip2380`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2857 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2858 : 1e > db test_num`
`>`	`>`
	`2859 : >skip2380`
	`>`

	`2859 : ca [ 2] dex`
	`285a : 10df [ 3] bpl tasl2`
	`285c : a203 [ 2] ldx #3`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 274`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`22e5 : ca [ 2] dex`	`285e : tasl3`
`22e6 : 10e3 [ 3] bpl tasl2`
`22e8 : a203 [ 2] ldx #3`
`22ea : tasl3`
`set_z zp1,$ff`	`set_z zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`22ea : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`285e : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`22ec : 48 [ 3]> pha ;use stack to load status`	`2860 : 48 [ 3]> pha ;use stack to load status`
`22ed : b513 [ 4]> lda zp1,x ;load to zeropage`	`2861 : b5b9 [ 4]> lda zp1,x ;load to zeropage`
`22ef : 850c [ 3]> sta zpt`	`2863 : 85b2 [ 3]> sta zpt`
`22f1 : 28 [ 4]> plp`	`2865 : 28 [ 4]> plp`

`22f2 : 060c [ 5] asl zpt`	`2866 : 06b2 [ 5] asl zpt`
`tst_z rASL,fASL,$ff-fnzc`	`tst_z rASL,fASL,$ff-fnzc`
`22f4 : 08 [ 3]> php ;save flags`	`2868 : 08 [ 3]> php ;save flags`
`22f5 : a50c [ 3]> lda zpt`	`2869 : a5b2 [ 3]> lda zpt`
`22f7 : dd1102 [ 4]> cmp rASL,x ;test result`	`286b : dd1102 [ 4]> cmp rASL,x ;test result`
`> trap_ne`	`> trap_ne`
`22fa : d0fe [ 3]> bne * ;failed not equal (non zero)`	`286e : f002 [ 3]> beq skip2385`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2870 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2871 : 1e > db test_num`
	`>`
	`2872 : >skip2385`
`>`	`>`
`22fc : 68 [ 4]> pla ;load status`	`2872 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`22fd : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2873 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`22ff : dd2102 [ 4]> cmp fASL,x ;test flags`	`2875 : dd2102 [ 4]> cmp fASL,x ;test flags`
`> trap_ne`	`> trap_ne`
`2302 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2878 : f002 [ 3]> beq skip2388`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`287a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`287b : 1e > db test_num`
	`>`
	`287c : >skip2388`
`>`	`>`

`2304 : ca [ 2] dex`	`287c : ca [ 2] dex`
`2305 : 10e3 [ 4] bpl tasl3`	`287d : 10df [ 3] bpl tasl3`

`2307 : a203 [ 2] ldx #3`
`2309 : tlsr2`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 175`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`287f : a203 [ 2] ldx #3`
	`2881 : tlsr2`
`set_z zp1,0`	`set_z zp1,0`
`> load_flag 0`	`> load_flag 0`
`2309 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2881 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`230b : 48 [ 3]> pha ;use stack to load status`	`2883 : 48 [ 3]> pha ;use stack to load status`
`230c : b513 [ 4]> lda zp1,x ;load to zeropage`	`2884 : b5b9 [ 4]> lda zp1,x ;load to zeropage`
`230e : 850c [ 3]> sta zpt`	`2886 : 85b2 [ 3]> sta zpt`
`2310 : 28 [ 4]> plp`	`2888 : 28 [ 4]> plp`

`2311 : 460c [ 5] lsr zpt`	`2889 : 46b2 [ 5] lsr zpt`
`tst_z rLSR,fLSR,0`	`tst_z rLSR,fLSR,0`
`2313 : 08 [ 3]> php ;save flags`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 275`
`2314 : a50c [ 3]> lda zpt`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`2316 : dd1902 [ 4]> cmp rLSR,x ;test result`
	`288b : 08 [ 3]> php ;save flags`
	`288c : a5b2 [ 3]> lda zpt`
	`288e : dd1902 [ 4]> cmp rLSR,x ;test result`
`> trap_ne`	`> trap_ne`
`2319 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2891 : f002 [ 3]> beq skip2393`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2893 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2894 : 1e > db test_num`
	`>`
	`2895 : >skip2393`
`>`	`>`
`231b : 68 [ 4]> pla ;load status`	`2895 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`231c : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2896 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`231e : dd2902 [ 4]> cmp fLSR,x ;test flags`	`2898 : dd2902 [ 4]> cmp fLSR,x ;test flags`
`> trap_ne`	`> trap_ne`
`2321 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`289b : f002 [ 3]> beq skip2396`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`289d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`289e : 1e > db test_num`
	`>`
	`289f : >skip2396`
`>`	`>`

`2323 : ca [ 2] dex`	`289f : ca [ 2] dex`
`2324 : 10e3 [ 3] bpl tlsr2`	`28a0 : 10df [ 3] bpl tlsr2`
`2326 : a203 [ 2] ldx #3`	`28a2 : a203 [ 2] ldx #3`
`2328 : tlsr3`	`28a4 : tlsr3`
`set_z zp1,$ff`	`set_z zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2328 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`28a4 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`232a : 48 [ 3]> pha ;use stack to load status`	`28a6 : 48 [ 3]> pha ;use stack to load status`
`232b : b513 [ 4]> lda zp1,x ;load to zeropage`	`28a7 : b5b9 [ 4]> lda zp1,x ;load to zeropage`
`232d : 850c [ 3]> sta zpt`	`28a9 : 85b2 [ 3]> sta zpt`
`232f : 28 [ 4]> plp`	`28ab : 28 [ 4]> plp`

`2330 : 460c [ 5] lsr zpt`	`28ac : 46b2 [ 5] lsr zpt`
`tst_z rLSR,fLSR,$ff-fnzc`	`tst_z rLSR,fLSR,$ff-fnzc`
`2332 : 08 [ 3]> php ;save flags`	`28ae : 08 [ 3]> php ;save flags`
`2333 : a50c [ 3]> lda zpt`	`28af : a5b2 [ 3]> lda zpt`
`2335 : dd1902 [ 4]> cmp rLSR,x ;test result`	`28b1 : dd1902 [ 4]> cmp rLSR,x ;test result`
`> trap_ne`	`> trap_ne`
`2338 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`28b4 : f002 [ 3]> beq skip2401`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`28b6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`28b7 : 1e > db test_num`
	`>`
	`28b8 : >skip2401`
`>`	`>`
`233a : 68 [ 4]> pla ;load status`	`28b8 : 68 [ 4]> pla ;load status`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 276`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`233b : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`28b9 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`233d : dd2902 [ 4]> cmp fLSR,x ;test flags`	`28bb : dd2902 [ 4]> cmp fLSR,x ;test flags`
`> trap_ne`	`> trap_ne`
`2340 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`28be : f002 [ 3]> beq skip2404`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`28c0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`28c1 : 1e > db test_num`
	`>`
	`28c2 : >skip2404`
`>`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 176`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`2342 : ca [ 2] dex`	`28c2 : ca [ 2] dex`
`2343 : 10e3 [ 3] bpl tlsr3`	`28c3 : 10df [ 3] bpl tlsr3`

`2345 : a203 [ 2] ldx #3`	`28c5 : a203 [ 2] ldx #3`
`2347 : trol2`	`28c7 : trol2`
`set_z zp1,0`	`set_z zp1,0`
`> load_flag 0`	`> load_flag 0`
`2347 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`28c7 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2349 : 48 [ 3]> pha ;use stack to load status`	`28c9 : 48 [ 3]> pha ;use stack to load status`
`234a : b513 [ 4]> lda zp1,x ;load to zeropage`	`28ca : b5b9 [ 4]> lda zp1,x ;load to zeropage`
`234c : 850c [ 3]> sta zpt`	`28cc : 85b2 [ 3]> sta zpt`
`234e : 28 [ 4]> plp`	`28ce : 28 [ 4]> plp`

`234f : 260c [ 5] rol zpt`	`28cf : 26b2 [ 5] rol zpt`
`tst_z rROL,fROL,0`	`tst_z rROL,fROL,0`
`2351 : 08 [ 3]> php ;save flags`	`28d1 : 08 [ 3]> php ;save flags`
`2352 : a50c [ 3]> lda zpt`	`28d2 : a5b2 [ 3]> lda zpt`
`2354 : dd1102 [ 4]> cmp rROL,x ;test result`	`28d4 : dd1102 [ 4]> cmp rROL,x ;test result`
`> trap_ne`	`> trap_ne`
`2357 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`28d7 : f002 [ 3]> beq skip2409`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`28d9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`28da : 1e > db test_num`
	`>`
	`28db : >skip2409`
`>`	`>`
`2359 : 68 [ 4]> pla ;load status`	`28db : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`235a : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`28dc : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`235c : dd2102 [ 4]> cmp fROL,x ;test flags`	`28de : dd2102 [ 4]> cmp fROL,x ;test flags`
`> trap_ne`	`> trap_ne`
`235f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`28e1 : f002 [ 3]> beq skip2412`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`28e3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`28e4 : 1e > db test_num`
	`>`
	`28e5 : >skip2412`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 277`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`

`2361 : ca [ 2] dex`	`28e5 : ca [ 2] dex`
`2362 : 10e3 [ 3] bpl trol2`	`28e6 : 10df [ 3] bpl trol2`
`2364 : a203 [ 2] ldx #3`	`28e8 : a203 [ 2] ldx #3`
`2366 : trol3`	`28ea : trol3`
`set_z zp1,$ff-fc`	`set_z zp1,$ff-fc`
`> load_flag $ff-fc`	`> load_flag $ff-fc`
`2366 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`	`28ea : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`
`>`	`>`
`2368 : 48 [ 3]> pha ;use stack to load status`	`28ec : 48 [ 3]> pha ;use stack to load status`
`2369 : b513 [ 4]> lda zp1,x ;load to zeropage`	`28ed : b5b9 [ 4]> lda zp1,x ;load to zeropage`
`236b : 850c [ 3]> sta zpt`	`28ef : 85b2 [ 3]> sta zpt`
`236d : 28 [ 4]> plp`	`28f1 : 28 [ 4]> plp`

`236e : 260c [ 5] rol zpt`	`28f2 : 26b2 [ 5] rol zpt`
`tst_z rROL,fROL,$ff-fnzc`	`tst_z rROL,fROL,$ff-fnzc`
`2370 : 08 [ 3]> php ;save flags`	`28f4 : 08 [ 3]> php ;save flags`
`2371 : a50c [ 3]> lda zpt`	`28f5 : a5b2 [ 3]> lda zpt`
`2373 : dd1102 [ 4]> cmp rROL,x ;test result`	`28f7 : dd1102 [ 4]> cmp rROL,x ;test result`
`> trap_ne`	`> trap_ne`
`2376 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`28fa : f002 [ 3]> beq skip2417`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`28fc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`28fd : 1e > db test_num`
`>`	`>`
`2378 : 68 [ 4]> pla ;load status`	`28fe : >skip2417`
	`>`
	`28fe : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 177`	`28ff : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2379 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`237b : dd2102 [ 4]> cmp fROL,x ;test flags`	`2901 : dd2102 [ 4]> cmp fROL,x ;test flags`
`> trap_ne`	`> trap_ne`
`237e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2904 : f002 [ 3]> beq skip2420`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2906 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2907 : 1e > db test_num`
	`>`
	`2908 : >skip2420`
`>`	`>`

`2380 : ca [ 2] dex`	`2908 : ca [ 2] dex`
`2381 : 10e3 [ 3] bpl trol3`	`2909 : 10df [ 4] bpl trol3`

`2383 : a203 [ 2] ldx #3`	`290b : a203 [ 2] ldx #3`
`2385 : trolc2`	`290d : trolc2`
`set_z zp1,fc`	`set_z zp1,fc`
`> load_flag fc`	`> load_flag fc`
`2385 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`	`290d : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`
`>`	`>`
`2387 : 48 [ 3]> pha ;use stack to load status`	`290f : 48 [ 3]> pha ;use stack to load status`
`2388 : b513 [ 4]> lda zp1,x ;load to zeropage`	`2910 : b5b9 [ 4]> lda zp1,x ;load to zeropage`
`238a : 850c [ 3]> sta zpt`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 278`
`238c : 28 [ 4]> plp`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`238d : 260c [ 5] rol zpt`	`2912 : 85b2 [ 3]> sta zpt`
	`2914 : 28 [ 4]> plp`

	`2915 : 26b2 [ 5] rol zpt`
`tst_z rROLc,fROLc,0`	`tst_z rROLc,fROLc,0`
`238f : 08 [ 3]> php ;save flags`	`2917 : 08 [ 3]> php ;save flags`
`2390 : a50c [ 3]> lda zpt`	`2918 : a5b2 [ 3]> lda zpt`
`2392 : dd1502 [ 4]> cmp rROLc,x ;test result`	`291a : dd1502 [ 4]> cmp rROLc,x ;test result`
`> trap_ne`	`> trap_ne`
`2395 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`291d : f002 [ 3]> beq skip2425`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`291f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2920 : 1e > db test_num`
`>`	`>`
`2397 : 68 [ 4]> pla ;load status`	`2921 : >skip2425`
	`>`
	`2921 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2398 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2922 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`239a : dd2502 [ 4]> cmp fROLc,x ;test flags`	`2924 : dd2502 [ 4]> cmp fROLc,x ;test flags`
`> trap_ne`	`> trap_ne`
`239d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2927 : f002 [ 3]> beq skip2428`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2929 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`292a : 1e > db test_num`
	`>`
	`292b : >skip2428`
`>`	`>`

`239f : ca [ 2] dex`	`292b : ca [ 2] dex`
`23a0 : 10e3 [ 3] bpl trolc2`	`292c : 10df [ 3] bpl trolc2`
`23a2 : a203 [ 2] ldx #3`	`292e : a203 [ 2] ldx #3`
`23a4 : trolc3`	`2930 : trolc3`
`set_z zp1,$ff`	`set_z zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`23a4 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2930 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`23a6 : 48 [ 3]> pha ;use stack to load status`	`2932 : 48 [ 3]> pha ;use stack to load status`
`23a7 : b513 [ 4]> lda zp1,x ;load to zeropage`	`2933 : b5b9 [ 4]> lda zp1,x ;load to zeropage`
`23a9 : 850c [ 3]> sta zpt`	`2935 : 85b2 [ 3]> sta zpt`
`23ab : 28 [ 4]> plp`	`2937 : 28 [ 4]> plp`

`23ac : 260c [ 5] rol zpt`	`2938 : 26b2 [ 5] rol zpt`
`tst_z rROLc,fROLc,$ff-fnzc`	`tst_z rROLc,fROLc,$ff-fnzc`
`23ae : 08 [ 3]> php ;save flags`	`293a : 08 [ 3]> php ;save flags`
`23af : a50c [ 3]> lda zpt`	`293b : a5b2 [ 3]> lda zpt`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 178`	`293d : dd1502 [ 4]> cmp rROLc,x ;test result`
	`> trap_ne`
	`2940 : f002 [ 3]> beq skip2433`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2942 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 279`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`23b1 : dd1502 [ 4]> cmp rROLc,x ;test result`	`2943 : 1e > db test_num`
`> trap_ne`	`>`
`23b4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2944 : >skip2433`
`>`	`>`
`23b6 : 68 [ 4]> pla ;load status`	`2944 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`23b7 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2945 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`23b9 : dd2502 [ 4]> cmp fROLc,x ;test flags`	`2947 : dd2502 [ 4]> cmp fROLc,x ;test flags`
`> trap_ne`	`> trap_ne`
`23bc : d0fe [ 3]> bne * ;failed not equal (non zero)`	`294a : f002 [ 3]> beq skip2436`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`294c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`294d : 1e > db test_num`
	`>`
	`294e : >skip2436`
`>`	`>`

`23be : ca [ 2] dex`	`294e : ca [ 2] dex`
`23bf : 10e3 [ 3] bpl trolc3`	`294f : 10df [ 3] bpl trolc3`

`23c1 : a203 [ 2] ldx #3`	`2951 : a203 [ 2] ldx #3`
`23c3 : tror2`	`2953 : tror2`
`set_z zp1,0`	`set_z zp1,0`
`> load_flag 0`	`> load_flag 0`
`23c3 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2953 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`23c5 : 48 [ 3]> pha ;use stack to load status`	`2955 : 48 [ 3]> pha ;use stack to load status`
`23c6 : b513 [ 4]> lda zp1,x ;load to zeropage`	`2956 : b5b9 [ 4]> lda zp1,x ;load to zeropage`
`23c8 : 850c [ 3]> sta zpt`	`2958 : 85b2 [ 3]> sta zpt`
`23ca : 28 [ 4]> plp`	`295a : 28 [ 4]> plp`

`23cb : 660c [ 5] ror zpt`	`295b : 66b2 [ 5] ror zpt`
`tst_z rROR,fROR,0`	`tst_z rROR,fROR,0`
`23cd : 08 [ 3]> php ;save flags`	`295d : 08 [ 3]> php ;save flags`
`23ce : a50c [ 3]> lda zpt`	`295e : a5b2 [ 3]> lda zpt`
`23d0 : dd1902 [ 4]> cmp rROR,x ;test result`	`2960 : dd1902 [ 4]> cmp rROR,x ;test result`
`> trap_ne`	`> trap_ne`
`23d3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2963 : f002 [ 3]> beq skip2441`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2965 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2966 : 1e > db test_num`
`>`	`>`
`23d5 : 68 [ 4]> pla ;load status`	`2967 : >skip2441`
	`>`
	`2967 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`23d6 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2968 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`23d8 : dd2902 [ 4]> cmp fROR,x ;test flags`	`296a : dd2902 [ 4]> cmp fROR,x ;test flags`
`> trap_ne`	`> trap_ne`
`23db : d0fe [ 3]> bne * ;failed not equal (non zero)`	`296d : f002 [ 3]> beq skip2444`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 280`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>; db $db ; M65C02/M65C02A SToP instruction`
	`296f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2970 : 1e > db test_num`
	`>`
	`2971 : >skip2444`
`>`	`>`

`23dd : ca [ 2] dex`	`2971 : ca [ 2] dex`
`23de : 10e3 [ 3] bpl tror2`	`2972 : 10df [ 3] bpl tror2`
`23e0 : a203 [ 2] ldx #3`	`2974 : a203 [ 2] ldx #3`
`23e2 : tror3`	`2976 : tror3`
`set_z zp1,$ff-fc`	`set_z zp1,$ff-fc`
`> load_flag $ff-fc`	`> load_flag $ff-fc`
`23e2 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`	`2976 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`
`>`	`>`
`23e4 : 48 [ 3]> pha ;use stack to load status`	`2978 : 48 [ 3]> pha ;use stack to load status`
`23e5 : b513 [ 4]> lda zp1,x ;load to zeropage`	`2979 : b5b9 [ 4]> lda zp1,x ;load to zeropage`
`23e7 : 850c [ 3]> sta zpt`	`297b : 85b2 [ 3]> sta zpt`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 179`	`297d : 28 [ 4]> plp`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`23e9 : 28 [ 4]> plp`	`297e : 66b2 [ 5] ror zpt`

`23ea : 660c [ 5] ror zpt`
`tst_z rROR,fROR,$ff-fnzc`	`tst_z rROR,fROR,$ff-fnzc`
`23ec : 08 [ 3]> php ;save flags`	`2980 : 08 [ 3]> php ;save flags`
`23ed : a50c [ 3]> lda zpt`	`2981 : a5b2 [ 3]> lda zpt`
`23ef : dd1902 [ 4]> cmp rROR,x ;test result`	`2983 : dd1902 [ 4]> cmp rROR,x ;test result`
`> trap_ne`	`> trap_ne`
`23f2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2986 : f002 [ 3]> beq skip2449`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2988 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2989 : 1e > db test_num`
`>`	`>`
`23f4 : 68 [ 4]> pla ;load status`	`298a : >skip2449`
	`>`
	`298a : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`23f5 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`298b : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`23f7 : dd2902 [ 4]> cmp fROR,x ;test flags`	`298d : dd2902 [ 4]> cmp fROR,x ;test flags`
`> trap_ne`	`> trap_ne`
`23fa : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2990 : f002 [ 3]> beq skip2452`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2992 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2993 : 1e > db test_num`
	`>`
	`2994 : >skip2452`
`>`	`>`

`23fc : ca [ 2] dex`	`2994 : ca [ 2] dex`
`23fd : 10e3 [ 3] bpl tror3`	`2995 : 10df [ 3] bpl tror3`

`23ff : a203 [ 2] ldx #3`	`2997 : a203 [ 2] ldx #3`
`2401 : trorc2`	`2999 : trorc2`
`set_z zp1,fc`	`set_z zp1,fc`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 281`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag fc`	`> load_flag fc`
`2401 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`	`2999 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`
`>`	`>`
`2403 : 48 [ 3]> pha ;use stack to load status`	`299b : 48 [ 3]> pha ;use stack to load status`
`2404 : b513 [ 4]> lda zp1,x ;load to zeropage`	`299c : b5b9 [ 4]> lda zp1,x ;load to zeropage`
`2406 : 850c [ 3]> sta zpt`	`299e : 85b2 [ 3]> sta zpt`
`2408 : 28 [ 4]> plp`	`29a0 : 28 [ 4]> plp`

`2409 : 660c [ 5] ror zpt`	`29a1 : 66b2 [ 5] ror zpt`
`tst_z rRORc,fRORc,0`	`tst_z rRORc,fRORc,0`
`240b : 08 [ 3]> php ;save flags`	`29a3 : 08 [ 3]> php ;save flags`
`240c : a50c [ 3]> lda zpt`	`29a4 : a5b2 [ 3]> lda zpt`
`240e : dd1d02 [ 4]> cmp rRORc,x ;test result`	`29a6 : dd1d02 [ 4]> cmp rRORc,x ;test result`
`> trap_ne`	`> trap_ne`
`2411 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`29a9 : f002 [ 3]> beq skip2457`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`29ab : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`29ac : 1e > db test_num`
	`>`
	`29ad : >skip2457`
`>`	`>`
`2413 : 68 [ 4]> pla ;load status`	`29ad : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2414 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`29ae : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2416 : dd2d02 [ 4]> cmp fRORc,x ;test flags`	`29b0 : dd2d02 [ 4]> cmp fRORc,x ;test flags`
`> trap_ne`	`> trap_ne`
`2419 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`29b3 : f002 [ 3]> beq skip2460`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`29b5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`29b6 : 1e > db test_num`
	`>`
	`29b7 : >skip2460`
`>`	`>`

`241b : ca [ 2] dex`	`29b7 : ca [ 2] dex`
`241c : 10e3 [ 3] bpl trorc2`	`29b8 : 10df [ 3] bpl trorc2`
`241e : a203 [ 2] ldx #3`	`29ba : a203 [ 2] ldx #3`
`2420 : trorc3`	`29bc : trorc3`
`set_z zp1,$ff`	`set_z zp1,$ff`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 180`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag $ff`	`> load_flag $ff`
`2420 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`29bc : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2422 : 48 [ 3]> pha ;use stack to load status`	`29be : 48 [ 3]> pha ;use stack to load status`
`2423 : b513 [ 4]> lda zp1,x ;load to zeropage`	`29bf : b5b9 [ 4]> lda zp1,x ;load to zeropage`
`2425 : 850c [ 3]> sta zpt`	`29c1 : 85b2 [ 3]> sta zpt`
`2427 : 28 [ 4]> plp`	`29c3 : 28 [ 4]> plp`

`2428 : 660c [ 5] ror zpt`	`29c4 : 66b2 [ 5] ror zpt`
`tst_z rRORc,fRORc,$ff-fnzc`	`tst_z rRORc,fRORc,$ff-fnzc`
`242a : 08 [ 3]> php ;save flags`	`29c6 : 08 [ 3]> php ;save flags`
`242b : a50c [ 3]> lda zpt`	`29c7 : a5b2 [ 3]> lda zpt`
`242d : dd1d02 [ 4]> cmp rRORc,x ;test result`	`29c9 : dd1d02 [ 4]> cmp rRORc,x ;test result`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 282`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> trap_ne`	`> trap_ne`
`2430 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`29cc : f002 [ 3]> beq skip2465`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`29ce : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`29cf : 1e > db test_num`
`>`	`>`
`2432 : 68 [ 4]> pla ;load status`	`29d0 : >skip2465`
	`>`
	`29d0 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`2433 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`29d1 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`2435 : dd2d02 [ 4]> cmp fRORc,x ;test flags`	`29d3 : dd2d02 [ 4]> cmp fRORc,x ;test flags`
`> trap_ne`	`> trap_ne`
`2438 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`29d6 : f002 [ 3]> beq skip2468`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`29d8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`29d9 : 1e > db test_num`
	`>`
	`29da : >skip2468`
`>`	`>`

`243a : ca [ 2] dex`	`29da : ca [ 2] dex`
`243b : 10e3 [ 3] bpl trorc3`	`29db : 10df [ 3] bpl trorc3`
`next_test`	`next_test`
`243d : ad0002 [ 4]> lda test_case ;previous test`	`29dd : ad0002 [ 4]> lda test_case ;previous test`
`2440 : c91e [ 2]> cmp #test_num`	`29e0 : c91e [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`2442 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`29e2 : f002 [ 3]> beq skip2471`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`29e4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`29e5 : 1e > db test_num`
	`>`
	`29e6 : >skip2471`
`>`	`>`
`001f = >test_num = test_num + 1`	`001f = >test_num = test_num + 1`
`2444 : a91f [ 2]> lda #test_num ;*** this tests' number`	`29e6 : a91f [ 2]> lda #test_num ;*** this tests' number`
`2446 : 8d0002 [ 4]> sta test_case`	`29e8 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; shifts - absolute`	`; shifts - absolute`
`2449 : a203 [ 2] ldx #3`
`244b : tasl4`	`29eb : a203 [ 2] ldx #3`
	`29ed : tasl4`
`set_abs zp1,0`	`set_abs zp1,0`
`> load_flag 0`	`> load_flag 0`
`244b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`29ed : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`244d : 48 [ 3]> pha ;use stack to load status`	`29ef : 48 [ 3]> pha ;use stack to load status`
`244e : b513 [ 4]> lda zp1,x ;load to memory`	`29f0 : b5b9 [ 4]> lda zp1,x ;load to memory`
`2450 : 8d0302 [ 4]> sta abst`	`29f2 : 8d0302 [ 4]> sta abst`
`2453 : 28 [ 4]> plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 283`

`2454 : 0e0302 [ 6] asl abst`
`tst_abs rASL,fASL,0`
`2457 : 08 [ 3]> php ;save flags`
`2458 : ad0302 [ 4]> lda abst`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 181`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`245b : dd1102 [ 4]> cmp rASL,x ;test result`	`29f5 : 28 [ 4]> plp`
`> trap_ne`
`245e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`29f6 : 0e0302 [ 6] asl abst`
	`tst_abs rASL,fASL,0`
	`29f9 : 08 [ 3]> php ;save flags`
	`29fa : ad0302 [ 4]> lda abst`
	`29fd : dd1102 [ 4]> cmp rASL,x ;test result`
	`> trap_ne`
	`2a00 : f002 [ 3]> beq skip2476`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2a02 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2a03 : 1f > db test_num`
`>`	`>`
`2460 : 68 [ 4]> pla ;load status`	`2a04 : >skip2476`
	`>`
	`2a04 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2461 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2a05 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2463 : dd2102 [ 4]> cmp fASL,x ;test flags`	`2a07 : dd2102 [ 4]> cmp fASL,x ;test flags`
`> trap_ne`	`> trap_ne`
`2466 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2a0a : f002 [ 3]> beq skip2479`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2a0c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2a0d : 1f > db test_num`
	`>`
	`2a0e : >skip2479`
`>`	`>`

`2468 : ca [ 2] dex`	`2a0e : ca [ 2] dex`
`2469 : 10e0 [ 3] bpl tasl4`	`2a0f : 10dc [ 4] bpl tasl4`
`246b : a203 [ 2] ldx #3`	`2a11 : a203 [ 2] ldx #3`
`246d : tasl5`	`2a13 : tasl5`
`set_abs zp1,$ff`	`set_abs zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`246d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2a13 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`246f : 48 [ 3]> pha ;use stack to load status`	`2a15 : 48 [ 3]> pha ;use stack to load status`
`2470 : b513 [ 4]> lda zp1,x ;load to memory`	`2a16 : b5b9 [ 4]> lda zp1,x ;load to memory`
`2472 : 8d0302 [ 4]> sta abst`	`2a18 : 8d0302 [ 4]> sta abst`
`2475 : 28 [ 4]> plp`	`2a1b : 28 [ 4]> plp`

`2476 : 0e0302 [ 6] asl abst`	`2a1c : 0e0302 [ 6] asl abst`
`tst_abs rASL,fASL,$ff-fnzc`	`tst_abs rASL,fASL,$ff-fnzc`
`2479 : 08 [ 3]> php ;save flags`	`2a1f : 08 [ 3]> php ;save flags`
`247a : ad0302 [ 4]> lda abst`	`2a20 : ad0302 [ 4]> lda abst`
`247d : dd1102 [ 4]> cmp rASL,x ;test result`	`2a23 : dd1102 [ 4]> cmp rASL,x ;test result`
`> trap_ne`	`> trap_ne`
`2480 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2a26 : f002 [ 3]> beq skip2484`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2a28 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2a29 : 1f > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 284`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`2482 : 68 [ 4]> pla ;load status`	`2a2a : >skip2484`
	`>`
	`2a2a : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`2483 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2a2b : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`2485 : dd2102 [ 4]> cmp fASL,x ;test flags`	`2a2d : dd2102 [ 4]> cmp fASL,x ;test flags`
`> trap_ne`	`> trap_ne`
`2488 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2a30 : f002 [ 3]> beq skip2487`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2a32 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2a33 : 1f > db test_num`
	`>`
	`2a34 : >skip2487`
`>`	`>`

`248a : ca [ 2] dex`	`2a34 : ca [ 2] dex`
`248b : 10e0 [ 3] bpl tasl5`	`2a35 : 10dc [ 3] bpl tasl5`

`248d : a203 [ 2] ldx #3`	`2a37 : a203 [ 2] ldx #3`
`248f : tlsr4`	`2a39 : tlsr4`
`set_abs zp1,0`	`set_abs zp1,0`
`> load_flag 0`	`> load_flag 0`
`248f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2a39 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2491 : 48 [ 3]> pha ;use stack to load status`	`2a3b : 48 [ 3]> pha ;use stack to load status`
`2492 : b513 [ 4]> lda zp1,x ;load to memory`	`2a3c : b5b9 [ 4]> lda zp1,x ;load to memory`
`2494 : 8d0302 [ 4]> sta abst`	`2a3e : 8d0302 [ 4]> sta abst`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 182`	`2a41 : 28 [ 4]> plp`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2497 : 28 [ 4]> plp`	`2a42 : 4e0302 [ 6] lsr abst`

`2498 : 4e0302 [ 6] lsr abst`
`tst_abs rLSR,fLSR,0`	`tst_abs rLSR,fLSR,0`
`249b : 08 [ 3]> php ;save flags`	`2a45 : 08 [ 3]> php ;save flags`
`249c : ad0302 [ 4]> lda abst`	`2a46 : ad0302 [ 4]> lda abst`
`249f : dd1902 [ 4]> cmp rLSR,x ;test result`	`2a49 : dd1902 [ 4]> cmp rLSR,x ;test result`
`> trap_ne`	`> trap_ne`
`24a2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2a4c : f002 [ 3]> beq skip2492`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2a4e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2a4f : 1f > db test_num`
`>`	`>`
`24a4 : 68 [ 4]> pla ;load status`	`2a50 : >skip2492`
	`>`
	`2a50 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`24a5 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2a51 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`24a7 : dd2902 [ 4]> cmp fLSR,x ;test flags`	`2a53 : dd2902 [ 4]> cmp fLSR,x ;test flags`
`> trap_ne`	`> trap_ne`
`24aa : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2a56 : f002 [ 3]> beq skip2495`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 285`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2a58 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2a59 : 1f > db test_num`
	`>`
	`2a5a : >skip2495`
`>`	`>`

`24ac : ca [ 2] dex`	`2a5a : ca [ 2] dex`
`24ad : 10e0 [ 3] bpl tlsr4`	`2a5b : 10dc [ 3] bpl tlsr4`
`24af : a203 [ 2] ldx #3`	`2a5d : a203 [ 2] ldx #3`
`24b1 : tlsr5`	`2a5f : tlsr5`
`set_abs zp1,$ff`	`set_abs zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`24b1 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2a5f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`24b3 : 48 [ 3]> pha ;use stack to load status`	`2a61 : 48 [ 3]> pha ;use stack to load status`
`24b4 : b513 [ 4]> lda zp1,x ;load to memory`	`2a62 : b5b9 [ 4]> lda zp1,x ;load to memory`
`24b6 : 8d0302 [ 4]> sta abst`	`2a64 : 8d0302 [ 4]> sta abst`
`24b9 : 28 [ 4]> plp`	`2a67 : 28 [ 4]> plp`

`24ba : 4e0302 [ 6] lsr abst`	`2a68 : 4e0302 [ 6] lsr abst`
`tst_abs rLSR,fLSR,$ff-fnzc`	`tst_abs rLSR,fLSR,$ff-fnzc`
`24bd : 08 [ 3]> php ;save flags`	`2a6b : 08 [ 3]> php ;save flags`
`24be : ad0302 [ 4]> lda abst`	`2a6c : ad0302 [ 4]> lda abst`
`24c1 : dd1902 [ 4]> cmp rLSR,x ;test result`	`2a6f : dd1902 [ 4]> cmp rLSR,x ;test result`
`> trap_ne`	`> trap_ne`
`24c4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2a72 : f002 [ 3]> beq skip2500`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2a74 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2a75 : 1f > db test_num`
	`>`
	`2a76 : >skip2500`
`>`	`>`
`24c6 : 68 [ 4]> pla ;load status`	`2a76 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`24c7 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2a77 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`24c9 : dd2902 [ 4]> cmp fLSR,x ;test flags`	`2a79 : dd2902 [ 4]> cmp fLSR,x ;test flags`
`> trap_ne`	`> trap_ne`
`24cc : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2a7c : f002 [ 3]> beq skip2503`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2a7e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2a7f : 1f > db test_num`
	`>`
	`2a80 : >skip2503`
`>`	`>`

`24ce : ca [ 2] dex`	`2a80 : ca [ 2] dex`
`24cf : 10e0 [ 3] bpl tlsr5`	`2a81 : 10dc [ 3] bpl tlsr5`

`24d1 : a203 [ 2] ldx #3`	`2a83 : a203 [ 2] ldx #3`
`24d3 : trol4`	`2a85 : trol4`
`set_abs zp1,0`	`set_abs zp1,0`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 183`	`> load_flag 0`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 286`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag 0`	`2a85 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`24d3 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`24d5 : 48 [ 3]> pha ;use stack to load status`	`2a87 : 48 [ 3]> pha ;use stack to load status`
`24d6 : b513 [ 4]> lda zp1,x ;load to memory`	`2a88 : b5b9 [ 4]> lda zp1,x ;load to memory`
`24d8 : 8d0302 [ 4]> sta abst`	`2a8a : 8d0302 [ 4]> sta abst`
`24db : 28 [ 4]> plp`	`2a8d : 28 [ 4]> plp`

`24dc : 2e0302 [ 6] rol abst`	`2a8e : 2e0302 [ 6] rol abst`
`tst_abs rROL,fROL,0`	`tst_abs rROL,fROL,0`
`24df : 08 [ 3]> php ;save flags`	`2a91 : 08 [ 3]> php ;save flags`
`24e0 : ad0302 [ 4]> lda abst`	`2a92 : ad0302 [ 4]> lda abst`
`24e3 : dd1102 [ 4]> cmp rROL,x ;test result`	`2a95 : dd1102 [ 4]> cmp rROL,x ;test result`
`> trap_ne`	`> trap_ne`
`24e6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2a98 : f002 [ 3]> beq skip2508`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2a9a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2a9b : 1f > db test_num`
	`>`
	`2a9c : >skip2508`
`>`	`>`
`24e8 : 68 [ 4]> pla ;load status`	`2a9c : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`24e9 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2a9d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`24eb : dd2102 [ 4]> cmp fROL,x ;test flags`	`2a9f : dd2102 [ 4]> cmp fROL,x ;test flags`
`> trap_ne`	`> trap_ne`
`24ee : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2aa2 : f002 [ 3]> beq skip2511`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2aa4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2aa5 : 1f > db test_num`
	`>`
	`2aa6 : >skip2511`
`>`	`>`

`24f0 : ca [ 2] dex`	`2aa6 : ca [ 2] dex`
`24f1 : 10e0 [ 3] bpl trol4`	`2aa7 : 10dc [ 3] bpl trol4`
`24f3 : a203 [ 2] ldx #3`	`2aa9 : a203 [ 2] ldx #3`
`24f5 : trol5`	`2aab : trol5`
`set_abs zp1,$ff-fc`	`set_abs zp1,$ff-fc`
`> load_flag $ff-fc`	`> load_flag $ff-fc`
`24f5 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`	`2aab : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`
`>`	`>`
`24f7 : 48 [ 3]> pha ;use stack to load status`	`2aad : 48 [ 3]> pha ;use stack to load status`
`24f8 : b513 [ 4]> lda zp1,x ;load to memory`	`2aae : b5b9 [ 4]> lda zp1,x ;load to memory`
`24fa : 8d0302 [ 4]> sta abst`	`2ab0 : 8d0302 [ 4]> sta abst`
`24fd : 28 [ 4]> plp`	`2ab3 : 28 [ 4]> plp`

`24fe : 2e0302 [ 6] rol abst`	`2ab4 : 2e0302 [ 6] rol abst`
`tst_abs rROL,fROL,$ff-fnzc`	`tst_abs rROL,fROL,$ff-fnzc`
`2501 : 08 [ 3]> php ;save flags`	`2ab7 : 08 [ 3]> php ;save flags`
`2502 : ad0302 [ 4]> lda abst`	`2ab8 : ad0302 [ 4]> lda abst`
`2505 : dd1102 [ 4]> cmp rROL,x ;test result`	`2abb : dd1102 [ 4]> cmp rROL,x ;test result`
`> trap_ne`	`> trap_ne`
`2508 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 287`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2abe : f002 [ 3]> beq skip2516`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2ac0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2ac1 : 1f > db test_num`
	`>`
	`2ac2 : >skip2516`
`>`	`>`
`250a : 68 [ 4]> pla ;load status`	`2ac2 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`250b : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2ac3 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`250d : dd2102 [ 4]> cmp fROL,x ;test flags`	`2ac5 : dd2102 [ 4]> cmp fROL,x ;test flags`
`> trap_ne`	`> trap_ne`
`2510 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2ac8 : f002 [ 3]> beq skip2519`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2aca : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2acb : 1f > db test_num`
	`>`
	`2acc : >skip2519`
`>`	`>`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 184`	`2acc : ca [ 2] dex`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`2acd : 10dc [ 3] bpl trol5`

`2512 : ca [ 2] dex`
`2513 : 10e0 [ 4] bpl trol5`

`2515 : a203 [ 2] ldx #3`	`2acf : a203 [ 2] ldx #3`
`2517 : trolc4`	`2ad1 : trolc4`
`set_abs zp1,fc`	`set_abs zp1,fc`
`> load_flag fc`	`> load_flag fc`
`2517 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`	`2ad1 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`
`>`	`>`
`2519 : 48 [ 3]> pha ;use stack to load status`	`2ad3 : 48 [ 3]> pha ;use stack to load status`
`251a : b513 [ 4]> lda zp1,x ;load to memory`	`2ad4 : b5b9 [ 4]> lda zp1,x ;load to memory`
`251c : 8d0302 [ 4]> sta abst`	`2ad6 : 8d0302 [ 4]> sta abst`
`251f : 28 [ 4]> plp`	`2ad9 : 28 [ 4]> plp`

`2520 : 2e0302 [ 6] rol abst`	`2ada : 2e0302 [ 6] rol abst`
`tst_abs rROLc,fROLc,0`	`tst_abs rROLc,fROLc,0`
`2523 : 08 [ 3]> php ;save flags`	`2add : 08 [ 3]> php ;save flags`
`2524 : ad0302 [ 4]> lda abst`	`2ade : ad0302 [ 4]> lda abst`
`2527 : dd1502 [ 4]> cmp rROLc,x ;test result`	`2ae1 : dd1502 [ 4]> cmp rROLc,x ;test result`
`> trap_ne`	`> trap_ne`
`252a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2ae4 : f002 [ 3]> beq skip2524`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2ae6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2ae7 : 1f > db test_num`
	`>`
	`2ae8 : >skip2524`
`>`	`>`
`252c : 68 [ 4]> pla ;load status`	`2ae8 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`252d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2ae9 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`252f : dd2502 [ 4]> cmp fROLc,x ;test flags`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 288`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2aeb : dd2502 [ 4]> cmp fROLc,x ;test flags`
`> trap_ne`	`> trap_ne`
`2532 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2aee : f002 [ 3]> beq skip2527`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2af0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2af1 : 1f > db test_num`
	`>`
	`2af2 : >skip2527`
`>`	`>`

`2534 : ca [ 2] dex`	`2af2 : ca [ 2] dex`
`2535 : 10e0 [ 3] bpl trolc4`	`2af3 : 10dc [ 3] bpl trolc4`
`2537 : a203 [ 2] ldx #3`	`2af5 : a203 [ 2] ldx #3`
`2539 : trolc5`	`2af7 : trolc5`
`set_abs zp1,$ff`	`set_abs zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2539 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2af7 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`253b : 48 [ 3]> pha ;use stack to load status`	`2af9 : 48 [ 3]> pha ;use stack to load status`
`253c : b513 [ 4]> lda zp1,x ;load to memory`	`2afa : b5b9 [ 4]> lda zp1,x ;load to memory`
`253e : 8d0302 [ 4]> sta abst`	`2afc : 8d0302 [ 4]> sta abst`
`2541 : 28 [ 4]> plp`	`2aff : 28 [ 4]> plp`

`2542 : 2e0302 [ 6] rol abst`	`2b00 : 2e0302 [ 6] rol abst`
`tst_abs rROLc,fROLc,$ff-fnzc`	`tst_abs rROLc,fROLc,$ff-fnzc`
`2545 : 08 [ 3]> php ;save flags`	`2b03 : 08 [ 3]> php ;save flags`
`2546 : ad0302 [ 4]> lda abst`	`2b04 : ad0302 [ 4]> lda abst`
`2549 : dd1502 [ 4]> cmp rROLc,x ;test result`	`2b07 : dd1502 [ 4]> cmp rROLc,x ;test result`
`> trap_ne`	`> trap_ne`
`254c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2b0a : f002 [ 3]> beq skip2532`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2b0c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2b0d : 1f > db test_num`
`>`	`>`
`254e : 68 [ 4]> pla ;load status`	`2b0e : >skip2532`
	`>`
	`2b0e : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`254f : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2b0f : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 185`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`2551 : dd2502 [ 4]> cmp fROLc,x ;test flags`	`2b11 : dd2502 [ 4]> cmp fROLc,x ;test flags`
`> trap_ne`	`> trap_ne`
`2554 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2b14 : f002 [ 3]> beq skip2535`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2b16 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2b17 : 1f > db test_num`
`>`	`>`
	`2b18 : >skip2535`
	`>`

	`2b18 : ca [ 2] dex`
	`2b19 : 10dc [ 4] bpl trolc5`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 289`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2556 : ca [ 2] dex`
`2557 : 10e0 [ 3] bpl trolc5`

`2559 : a203 [ 2] ldx #3`	`2b1b : a203 [ 2] ldx #3`
`255b : tror4`	`2b1d : tror4`
`set_abs zp1,0`	`set_abs zp1,0`
`> load_flag 0`	`> load_flag 0`
`255b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2b1d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`255d : 48 [ 3]> pha ;use stack to load status`	`2b1f : 48 [ 3]> pha ;use stack to load status`
`255e : b513 [ 4]> lda zp1,x ;load to memory`	`2b20 : b5b9 [ 4]> lda zp1,x ;load to memory`
`2560 : 8d0302 [ 4]> sta abst`	`2b22 : 8d0302 [ 4]> sta abst`
`2563 : 28 [ 4]> plp`	`2b25 : 28 [ 4]> plp`

`2564 : 6e0302 [ 6] ror abst`	`2b26 : 6e0302 [ 6] ror abst`
`tst_abs rROR,fROR,0`	`tst_abs rROR,fROR,0`
`2567 : 08 [ 3]> php ;save flags`	`2b29 : 08 [ 3]> php ;save flags`
`2568 : ad0302 [ 4]> lda abst`	`2b2a : ad0302 [ 4]> lda abst`
`256b : dd1902 [ 4]> cmp rROR,x ;test result`	`2b2d : dd1902 [ 4]> cmp rROR,x ;test result`
`> trap_ne`	`> trap_ne`
`256e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2b30 : f002 [ 3]> beq skip2540`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2b32 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2b33 : 1f > db test_num`
`>`	`>`
`2570 : 68 [ 4]> pla ;load status`	`2b34 : >skip2540`
	`>`
	`2b34 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2571 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2b35 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2573 : dd2902 [ 4]> cmp fROR,x ;test flags`	`2b37 : dd2902 [ 4]> cmp fROR,x ;test flags`
`> trap_ne`	`> trap_ne`
`2576 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2b3a : f002 [ 3]> beq skip2543`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2b3c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2b3d : 1f > db test_num`
	`>`
	`2b3e : >skip2543`
`>`	`>`

`2578 : ca [ 2] dex`	`2b3e : ca [ 2] dex`
`2579 : 10e0 [ 3] bpl tror4`	`2b3f : 10dc [ 3] bpl tror4`
`257b : a203 [ 2] ldx #3`	`2b41 : a203 [ 2] ldx #3`
`257d : tror5`	`2b43 : tror5`
`set_abs zp1,$ff-fc`	`set_abs zp1,$ff-fc`
`> load_flag $ff-fc`	`> load_flag $ff-fc`
`257d : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`	`2b43 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`
`>`	`>`
`257f : 48 [ 3]> pha ;use stack to load status`	`2b45 : 48 [ 3]> pha ;use stack to load status`
`2580 : b513 [ 4]> lda zp1,x ;load to memory`	`2b46 : b5b9 [ 4]> lda zp1,x ;load to memory`
`2582 : 8d0302 [ 4]> sta abst`	`2b48 : 8d0302 [ 4]> sta abst`
`2585 : 28 [ 4]> plp`	`2b4b : 28 [ 4]> plp`

`2586 : 6e0302 [ 6] ror abst`	`2b4c : 6e0302 [ 6] ror abst`
`tst_abs rROR,fROR,$ff-fnzc`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 290`
`2589 : 08 [ 3]> php ;save flags`
`258a : ad0302 [ 4]> lda abst`
`258d : dd1902 [ 4]> cmp rROR,x ;test result`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 186`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> trap_ne`	`tst_abs rROR,fROR,$ff-fnzc`
`2590 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2b4f : 08 [ 3]> php ;save flags`
	`2b50 : ad0302 [ 4]> lda abst`
	`2b53 : dd1902 [ 4]> cmp rROR,x ;test result`
	`> trap_ne`
	`2b56 : f002 [ 3]> beq skip2548`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2b58 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2b59 : 1f > db test_num`
`>`	`>`
`2592 : 68 [ 4]> pla ;load status`	`2b5a : >skip2548`
	`>`
	`2b5a : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`2593 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2b5b : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`2595 : dd2902 [ 4]> cmp fROR,x ;test flags`	`2b5d : dd2902 [ 4]> cmp fROR,x ;test flags`
`> trap_ne`	`> trap_ne`
`2598 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2b60 : f002 [ 3]> beq skip2551`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2b62 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2b63 : 1f > db test_num`
	`>`
	`2b64 : >skip2551`
`>`	`>`

`259a : ca [ 2] dex`	`2b64 : ca [ 2] dex`
`259b : 10e0 [ 3] bpl tror5`	`2b65 : 10dc [ 3] bpl tror5`

`259d : a203 [ 2] ldx #3`	`2b67 : a203 [ 2] ldx #3`
`259f : trorc4`	`2b69 : trorc4`
`set_abs zp1,fc`	`set_abs zp1,fc`
`> load_flag fc`	`> load_flag fc`
`259f : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`	`2b69 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`
`>`	`>`
`25a1 : 48 [ 3]> pha ;use stack to load status`	`2b6b : 48 [ 3]> pha ;use stack to load status`
`25a2 : b513 [ 4]> lda zp1,x ;load to memory`	`2b6c : b5b9 [ 4]> lda zp1,x ;load to memory`
`25a4 : 8d0302 [ 4]> sta abst`	`2b6e : 8d0302 [ 4]> sta abst`
`25a7 : 28 [ 4]> plp`	`2b71 : 28 [ 4]> plp`

`25a8 : 6e0302 [ 6] ror abst`	`2b72 : 6e0302 [ 6] ror abst`
`tst_abs rRORc,fRORc,0`	`tst_abs rRORc,fRORc,0`
`25ab : 08 [ 3]> php ;save flags`	`2b75 : 08 [ 3]> php ;save flags`
`25ac : ad0302 [ 4]> lda abst`	`2b76 : ad0302 [ 4]> lda abst`
`25af : dd1d02 [ 4]> cmp rRORc,x ;test result`	`2b79 : dd1d02 [ 4]> cmp rRORc,x ;test result`
`> trap_ne`	`> trap_ne`
`25b2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2b7c : f002 [ 3]> beq skip2556`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2b7e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2b7f : 1f > db test_num`
	`>`
	`2b80 : >skip2556`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 291`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`25b4 : 68 [ 4]> pla ;load status`	`2b80 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`25b5 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2b81 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`25b7 : dd2d02 [ 4]> cmp fRORc,x ;test flags`	`2b83 : dd2d02 [ 4]> cmp fRORc,x ;test flags`
`> trap_ne`	`> trap_ne`
`25ba : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2b86 : f002 [ 3]> beq skip2559`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2b88 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2b89 : 1f > db test_num`
	`>`
	`2b8a : >skip2559`
`>`	`>`

`25bc : ca [ 2] dex`	`2b8a : ca [ 2] dex`
`25bd : 10e0 [ 3] bpl trorc4`	`2b8b : 10dc [ 3] bpl trorc4`
`25bf : a203 [ 2] ldx #3`	`2b8d : a203 [ 2] ldx #3`
`25c1 : trorc5`	`2b8f : trorc5`
`set_abs zp1,$ff`	`set_abs zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`25c1 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2b8f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`25c3 : 48 [ 3]> pha ;use stack to load status`	`2b91 : 48 [ 3]> pha ;use stack to load status`
`25c4 : b513 [ 4]> lda zp1,x ;load to memory`	`2b92 : b5b9 [ 4]> lda zp1,x ;load to memory`
`25c6 : 8d0302 [ 4]> sta abst`	`2b94 : 8d0302 [ 4]> sta abst`
`25c9 : 28 [ 4]> plp`	`2b97 : 28 [ 4]> plp`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 187`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2b98 : 6e0302 [ 6] ror abst`
`25ca : 6e0302 [ 6] ror abst`
`tst_abs rRORc,fRORc,$ff-fnzc`	`tst_abs rRORc,fRORc,$ff-fnzc`
`25cd : 08 [ 3]> php ;save flags`	`2b9b : 08 [ 3]> php ;save flags`
`25ce : ad0302 [ 4]> lda abst`	`2b9c : ad0302 [ 4]> lda abst`
`25d1 : dd1d02 [ 4]> cmp rRORc,x ;test result`	`2b9f : dd1d02 [ 4]> cmp rRORc,x ;test result`
`> trap_ne`	`> trap_ne`
`25d4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2ba2 : f002 [ 3]> beq skip2564`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2ba4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2ba5 : 1f > db test_num`
	`>`
	`2ba6 : >skip2564`
`>`	`>`
`25d6 : 68 [ 4]> pla ;load status`	`2ba6 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`25d7 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2ba7 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`25d9 : dd2d02 [ 4]> cmp fRORc,x ;test flags`	`2ba9 : dd2d02 [ 4]> cmp fRORc,x ;test flags`
`> trap_ne`	`> trap_ne`
`25dc : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2bac : f002 [ 3]> beq skip2567`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2bae : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2baf : 1f > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 292`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2bb0 : >skip2567`
`>`	`>`

`25de : ca [ 2] dex`	`2bb0 : ca [ 2] dex`
`25df : 10e0 [ 3] bpl trorc5`	`2bb1 : 10dc [ 3] bpl trorc5`
`next_test`	`next_test`
`25e1 : ad0002 [ 4]> lda test_case ;previous test`	`2bb3 : ad0002 [ 4]> lda test_case ;previous test`
`25e4 : c91f [ 2]> cmp #test_num`	`2bb6 : c91f [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`25e6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2bb8 : f002 [ 3]> beq skip2570`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2bba : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2bbb : 1f > db test_num`
	`>`
	`2bbc : >skip2570`
`>`	`>`
`0020 = >test_num = test_num + 1`	`0020 = >test_num = test_num + 1`
`25e8 : a920 [ 2]> lda #test_num ;*** this tests' number`	`2bbc : a920 [ 2]> lda #test_num ;*** this tests' number`
`25ea : 8d0002 [ 4]> sta test_case`	`2bbe : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; shifts - zp indexed`	`; shifts - zp indexed`
`25ed : a203 [ 2] ldx #3`
`25ef : tasl6`	`2bc1 : a203 [ 2] ldx #3`
	`2bc3 : tasl6`
`set_zx zp1,0`	`set_zx zp1,0`
`> load_flag 0`	`> load_flag 0`
`25ef : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2bc3 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`25f1 : 48 [ 3]> pha ;use stack to load status`	`2bc5 : 48 [ 3]> pha ;use stack to load status`
`25f2 : b513 [ 4]> lda zp1,x ;load to indexed zeropage`	`2bc6 : b5b9 [ 4]> lda zp1,x ;load to indexed zeropage`
`25f4 : 950c [ 4]> sta zpt,x`	`2bc8 : 95b2 [ 4]> sta zpt,x`
`25f6 : 28 [ 4]> plp`	`2bca : 28 [ 4]> plp`

`25f7 : 160c [ 6] asl zpt,x`	`2bcb : 16b2 [ 6] asl zpt,x`
`tst_zx rASL,fASL,0`	`tst_zx rASL,fASL,0`
`25f9 : 08 [ 3]> php ;save flags`	`2bcd : 08 [ 3]> php ;save flags`
`25fa : b50c [ 4]> lda zpt,x`	`2bce : b5b2 [ 4]> lda zpt,x`
`25fc : dd1102 [ 4]> cmp rASL,x ;test result`	`2bd0 : dd1102 [ 4]> cmp rASL,x ;test result`
`> trap_ne`	`> trap_ne`
`25ff : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2bd3 : f002 [ 3]> beq skip2575`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2bd5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2bd6 : 20 > db test_num`
`>`	`>`
`2601 : 68 [ 4]> pla ;load status`	`2bd7 : >skip2575`
	`>`
	`2bd7 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2602 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2bd8 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 188`	`>`
	`2bda : dd2102 [ 4]> cmp fASL,x ;test flags`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 293`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`
`2604 : dd2102 [ 4]> cmp fASL,x ;test flags`
`> trap_ne`	`> trap_ne`
`2607 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2bdd : f002 [ 3]> beq skip2578`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2bdf : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2be0 : 20 > db test_num`
	`>`
	`2be1 : >skip2578`
`>`	`>`

`2609 : ca [ 2] dex`	`2be1 : ca [ 2] dex`
`260a : 10e3 [ 4] bpl tasl6`	`2be2 : 10df [ 3] bpl tasl6`
`260c : a203 [ 2] ldx #3`	`2be4 : a203 [ 2] ldx #3`
`260e : tasl7`	`2be6 : tasl7`
`set_zx zp1,$ff`	`set_zx zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`260e : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2be6 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2610 : 48 [ 3]> pha ;use stack to load status`	`2be8 : 48 [ 3]> pha ;use stack to load status`
`2611 : b513 [ 4]> lda zp1,x ;load to indexed zeropage`	`2be9 : b5b9 [ 4]> lda zp1,x ;load to indexed zeropage`
`2613 : 950c [ 4]> sta zpt,x`	`2beb : 95b2 [ 4]> sta zpt,x`
`2615 : 28 [ 4]> plp`	`2bed : 28 [ 4]> plp`

`2616 : 160c [ 6] asl zpt,x`	`2bee : 16b2 [ 6] asl zpt,x`
`tst_zx rASL,fASL,$ff-fnzc`	`tst_zx rASL,fASL,$ff-fnzc`
`2618 : 08 [ 3]> php ;save flags`	`2bf0 : 08 [ 3]> php ;save flags`
`2619 : b50c [ 4]> lda zpt,x`	`2bf1 : b5b2 [ 4]> lda zpt,x`
`261b : dd1102 [ 4]> cmp rASL,x ;test result`	`2bf3 : dd1102 [ 4]> cmp rASL,x ;test result`
`> trap_ne`	`> trap_ne`
`261e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2bf6 : f002 [ 3]> beq skip2583`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2bf8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2bf9 : 20 > db test_num`
`>`	`>`
`2620 : 68 [ 4]> pla ;load status`	`2bfa : >skip2583`
	`>`
	`2bfa : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`2621 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2bfb : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`2623 : dd2102 [ 4]> cmp fASL,x ;test flags`	`2bfd : dd2102 [ 4]> cmp fASL,x ;test flags`
`> trap_ne`	`> trap_ne`
`2626 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2c00 : f002 [ 3]> beq skip2586`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2c02 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2c03 : 20 > db test_num`
	`>`
	`2c04 : >skip2586`
`>`	`>`

`2628 : ca [ 2] dex`	`2c04 : ca [ 2] dex`
`2629 : 10e3 [ 3] bpl tasl7`	`2c05 : 10df [ 4] bpl tasl7`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 294`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`262b : a203 [ 2] ldx #3`	`2c07 : a203 [ 2] ldx #3`
`262d : tlsr6`	`2c09 : tlsr6`
`set_zx zp1,0`	`set_zx zp1,0`
`> load_flag 0`	`> load_flag 0`
`262d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2c09 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`262f : 48 [ 3]> pha ;use stack to load status`	`2c0b : 48 [ 3]> pha ;use stack to load status`
`2630 : b513 [ 4]> lda zp1,x ;load to indexed zeropage`	`2c0c : b5b9 [ 4]> lda zp1,x ;load to indexed zeropage`
`2632 : 950c [ 4]> sta zpt,x`	`2c0e : 95b2 [ 4]> sta zpt,x`
`2634 : 28 [ 4]> plp`	`2c10 : 28 [ 4]> plp`

`2635 : 560c [ 6] lsr zpt,x`	`2c11 : 56b2 [ 6] lsr zpt,x`
`tst_zx rLSR,fLSR,0`	`tst_zx rLSR,fLSR,0`
`2637 : 08 [ 3]> php ;save flags`	`2c13 : 08 [ 3]> php ;save flags`
`2638 : b50c [ 4]> lda zpt,x`	`2c14 : b5b2 [ 4]> lda zpt,x`
`263a : dd1902 [ 4]> cmp rLSR,x ;test result`	`2c16 : dd1902 [ 4]> cmp rLSR,x ;test result`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 189`	`> trap_ne`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`2c19 : f002 [ 3]> beq skip2591`
	`> trap ;failed equal (zero)`
`> trap_ne`	`>; db $db ; M65C02/M65C02A SToP instruction`
`263d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2c1b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2c1c : 20 > db test_num`
	`>`
	`2c1d : >skip2591`
`>`	`>`
`263f : 68 [ 4]> pla ;load status`	`2c1d : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2640 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2c1e : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2642 : dd2902 [ 4]> cmp fLSR,x ;test flags`	`2c20 : dd2902 [ 4]> cmp fLSR,x ;test flags`
`> trap_ne`	`> trap_ne`
`2645 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2c23 : f002 [ 3]> beq skip2594`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2c25 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2c26 : 20 > db test_num`
	`>`
	`2c27 : >skip2594`
`>`	`>`

`2647 : ca [ 2] dex`	`2c27 : ca [ 2] dex`
`2648 : 10e3 [ 3] bpl tlsr6`	`2c28 : 10df [ 3] bpl tlsr6`
`264a : a203 [ 2] ldx #3`	`2c2a : a203 [ 2] ldx #3`
`264c : tlsr7`	`2c2c : tlsr7`
`set_zx zp1,$ff`	`set_zx zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`264c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2c2c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`264e : 48 [ 3]> pha ;use stack to load status`	`2c2e : 48 [ 3]> pha ;use stack to load status`
`264f : b513 [ 4]> lda zp1,x ;load to indexed zeropage`	`2c2f : b5b9 [ 4]> lda zp1,x ;load to indexed zeropage`
`2651 : 950c [ 4]> sta zpt,x`	`2c31 : 95b2 [ 4]> sta zpt,x`
`2653 : 28 [ 4]> plp`	`2c33 : 28 [ 4]> plp`

`2654 : 560c [ 6] lsr zpt,x`	`2c34 : 56b2 [ 6] lsr zpt,x`
`tst_zx rLSR,fLSR,$ff-fnzc`	`tst_zx rLSR,fLSR,$ff-fnzc`
`2656 : 08 [ 3]> php ;save flags`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 295`
`2657 : b50c [ 4]> lda zpt,x`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`2659 : dd1902 [ 4]> cmp rLSR,x ;test result`
	`2c36 : 08 [ 3]> php ;save flags`
	`2c37 : b5b2 [ 4]> lda zpt,x`
	`2c39 : dd1902 [ 4]> cmp rLSR,x ;test result`
`> trap_ne`	`> trap_ne`
`265c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2c3c : f002 [ 3]> beq skip2599`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2c3e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2c3f : 20 > db test_num`
	`>`
	`2c40 : >skip2599`
`>`	`>`
`265e : 68 [ 4]> pla ;load status`	`2c40 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`265f : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2c41 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`2661 : dd2902 [ 4]> cmp fLSR,x ;test flags`	`2c43 : dd2902 [ 4]> cmp fLSR,x ;test flags`
`> trap_ne`	`> trap_ne`
`2664 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2c46 : f002 [ 3]> beq skip2602`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2c48 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2c49 : 20 > db test_num`
	`>`
	`2c4a : >skip2602`
`>`	`>`

`2666 : ca [ 2] dex`	`2c4a : ca [ 2] dex`
`2667 : 10e3 [ 3] bpl tlsr7`	`2c4b : 10df [ 3] bpl tlsr7`

`2669 : a203 [ 2] ldx #3`	`2c4d : a203 [ 2] ldx #3`
`266b : trol6`	`2c4f : trol6`
`set_zx zp1,0`	`set_zx zp1,0`
`> load_flag 0`	`> load_flag 0`
`266b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2c4f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`266d : 48 [ 3]> pha ;use stack to load status`	`2c51 : 48 [ 3]> pha ;use stack to load status`
`266e : b513 [ 4]> lda zp1,x ;load to indexed zeropage`	`2c52 : b5b9 [ 4]> lda zp1,x ;load to indexed zeropage`
`2670 : 950c [ 4]> sta zpt,x`	`2c54 : 95b2 [ 4]> sta zpt,x`
`2672 : 28 [ 4]> plp`	`2c56 : 28 [ 4]> plp`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 190`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2c57 : 36b2 [ 6] rol zpt,x`
`2673 : 360c [ 6] rol zpt,x`
`tst_zx rROL,fROL,0`	`tst_zx rROL,fROL,0`
`2675 : 08 [ 3]> php ;save flags`	`2c59 : 08 [ 3]> php ;save flags`
`2676 : b50c [ 4]> lda zpt,x`	`2c5a : b5b2 [ 4]> lda zpt,x`
`2678 : dd1102 [ 4]> cmp rROL,x ;test result`	`2c5c : dd1102 [ 4]> cmp rROL,x ;test result`
`> trap_ne`	`> trap_ne`
`267b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2c5f : f002 [ 3]> beq skip2607`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2c61 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2c62 : 20 > db test_num`
`>`	`>`
`267d : 68 [ 4]> pla ;load status`	`2c63 : >skip2607`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 296`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2c63 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`267e : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2c64 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2680 : dd2102 [ 4]> cmp fROL,x ;test flags`	`2c66 : dd2102 [ 4]> cmp fROL,x ;test flags`
`> trap_ne`	`> trap_ne`
`2683 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2c69 : f002 [ 3]> beq skip2610`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2c6b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2c6c : 20 > db test_num`
	`>`
	`2c6d : >skip2610`
`>`	`>`

`2685 : ca [ 2] dex`	`2c6d : ca [ 2] dex`
`2686 : 10e3 [ 3] bpl trol6`	`2c6e : 10df [ 3] bpl trol6`
`2688 : a203 [ 2] ldx #3`	`2c70 : a203 [ 2] ldx #3`
`268a : trol7`	`2c72 : trol7`
`set_zx zp1,$ff-fc`	`set_zx zp1,$ff-fc`
`> load_flag $ff-fc`	`> load_flag $ff-fc`
`268a : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`	`2c72 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`
`>`	`>`
`268c : 48 [ 3]> pha ;use stack to load status`	`2c74 : 48 [ 3]> pha ;use stack to load status`
`268d : b513 [ 4]> lda zp1,x ;load to indexed zeropage`	`2c75 : b5b9 [ 4]> lda zp1,x ;load to indexed zeropage`
`268f : 950c [ 4]> sta zpt,x`	`2c77 : 95b2 [ 4]> sta zpt,x`
`2691 : 28 [ 4]> plp`	`2c79 : 28 [ 4]> plp`

`2692 : 360c [ 6] rol zpt,x`	`2c7a : 36b2 [ 6] rol zpt,x`
`tst_zx rROL,fROL,$ff-fnzc`	`tst_zx rROL,fROL,$ff-fnzc`
`2694 : 08 [ 3]> php ;save flags`	`2c7c : 08 [ 3]> php ;save flags`
`2695 : b50c [ 4]> lda zpt,x`	`2c7d : b5b2 [ 4]> lda zpt,x`
`2697 : dd1102 [ 4]> cmp rROL,x ;test result`	`2c7f : dd1102 [ 4]> cmp rROL,x ;test result`
`> trap_ne`	`> trap_ne`
`269a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2c82 : f002 [ 3]> beq skip2615`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2c84 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2c85 : 20 > db test_num`
`>`	`>`
`269c : 68 [ 4]> pla ;load status`	`2c86 : >skip2615`
	`>`
	`2c86 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`269d : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2c87 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`269f : dd2102 [ 4]> cmp fROL,x ;test flags`	`2c89 : dd2102 [ 4]> cmp fROL,x ;test flags`
`> trap_ne`	`> trap_ne`
`26a2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2c8c : f002 [ 3]> beq skip2618`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2c8e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2c8f : 20 > db test_num`
	`>`
	`2c90 : >skip2618`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 297`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`

`26a4 : ca [ 2] dex`	`2c90 : ca [ 2] dex`
`26a5 : 10e3 [ 3] bpl trol7`	`2c91 : 10df [ 3] bpl trol7`

`26a7 : a203 [ 2] ldx #3`	`2c93 : a203 [ 2] ldx #3`
`26a9 : trolc6`	`2c95 : trolc6`
`set_zx zp1,fc`	`set_zx zp1,fc`
`> load_flag fc`	`> load_flag fc`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 191`	`2c95 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`26a9 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`
`>`	`>`
`26ab : 48 [ 3]> pha ;use stack to load status`	`2c97 : 48 [ 3]> pha ;use stack to load status`
`26ac : b513 [ 4]> lda zp1,x ;load to indexed zeropage`	`2c98 : b5b9 [ 4]> lda zp1,x ;load to indexed zeropage`
`26ae : 950c [ 4]> sta zpt,x`	`2c9a : 95b2 [ 4]> sta zpt,x`
`26b0 : 28 [ 4]> plp`	`2c9c : 28 [ 4]> plp`

`26b1 : 360c [ 6] rol zpt,x`	`2c9d : 36b2 [ 6] rol zpt,x`
`tst_zx rROLc,fROLc,0`	`tst_zx rROLc,fROLc,0`
`26b3 : 08 [ 3]> php ;save flags`	`2c9f : 08 [ 3]> php ;save flags`
`26b4 : b50c [ 4]> lda zpt,x`	`2ca0 : b5b2 [ 4]> lda zpt,x`
`26b6 : dd1502 [ 4]> cmp rROLc,x ;test result`	`2ca2 : dd1502 [ 4]> cmp rROLc,x ;test result`
`> trap_ne`	`> trap_ne`
`26b9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2ca5 : f002 [ 3]> beq skip2623`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2ca7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2ca8 : 20 > db test_num`
`>`	`>`
`26bb : 68 [ 4]> pla ;load status`	`2ca9 : >skip2623`
	`>`
	`2ca9 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`26bc : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2caa : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`26be : dd2502 [ 4]> cmp fROLc,x ;test flags`	`2cac : dd2502 [ 4]> cmp fROLc,x ;test flags`
`> trap_ne`	`> trap_ne`
`26c1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2caf : f002 [ 3]> beq skip2626`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2cb1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2cb2 : 20 > db test_num`
	`>`
	`2cb3 : >skip2626`
`>`	`>`

`26c3 : ca [ 2] dex`	`2cb3 : ca [ 2] dex`
`26c4 : 10e3 [ 3] bpl trolc6`	`2cb4 : 10df [ 3] bpl trolc6`
`26c6 : a203 [ 2] ldx #3`	`2cb6 : a203 [ 2] ldx #3`
`26c8 : trolc7`	`2cb8 : trolc7`
`set_zx zp1,$ff`	`set_zx zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`26c8 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2cb8 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`26ca : 48 [ 3]> pha ;use stack to load status`	`2cba : 48 [ 3]> pha ;use stack to load status`
`26cb : b513 [ 4]> lda zp1,x ;load to indexed zeropage`	`2cbb : b5b9 [ 4]> lda zp1,x ;load to indexed zeropage`
`26cd : 950c [ 4]> sta zpt,x`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 298`
`26cf : 28 [ 4]> plp`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2cbd : 95b2 [ 4]> sta zpt,x`
	`2cbf : 28 [ 4]> plp`

`26d0 : 360c [ 6] rol zpt,x`	`2cc0 : 36b2 [ 6] rol zpt,x`
`tst_zx rROLc,fROLc,$ff-fnzc`	`tst_zx rROLc,fROLc,$ff-fnzc`
`26d2 : 08 [ 3]> php ;save flags`	`2cc2 : 08 [ 3]> php ;save flags`
`26d3 : b50c [ 4]> lda zpt,x`	`2cc3 : b5b2 [ 4]> lda zpt,x`
`26d5 : dd1502 [ 4]> cmp rROLc,x ;test result`	`2cc5 : dd1502 [ 4]> cmp rROLc,x ;test result`
`> trap_ne`	`> trap_ne`
`26d8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2cc8 : f002 [ 3]> beq skip2631`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2cca : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2ccb : 20 > db test_num`
	`>`
	`2ccc : >skip2631`
`>`	`>`
`26da : 68 [ 4]> pla ;load status`	`2ccc : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`26db : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2ccd : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`26dd : dd2502 [ 4]> cmp fROLc,x ;test flags`	`2ccf : dd2502 [ 4]> cmp fROLc,x ;test flags`
`> trap_ne`	`> trap_ne`
`26e0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2cd2 : f002 [ 3]> beq skip2634`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2cd4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2cd5 : 20 > db test_num`
	`>`
	`2cd6 : >skip2634`
`>`	`>`

`26e2 : ca [ 2] dex`	`2cd6 : ca [ 2] dex`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 192`	`2cd7 : 10df [ 3] bpl trolc7`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`26e3 : 10e3 [ 3] bpl trolc7`

`26e5 : a203 [ 2] ldx #3`	`2cd9 : a203 [ 2] ldx #3`
`26e7 : tror6`	`2cdb : tror6`
`set_zx zp1,0`	`set_zx zp1,0`
`> load_flag 0`	`> load_flag 0`
`26e7 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2cdb : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`26e9 : 48 [ 3]> pha ;use stack to load status`	`2cdd : 48 [ 3]> pha ;use stack to load status`
`26ea : b513 [ 4]> lda zp1,x ;load to indexed zeropage`	`2cde : b5b9 [ 4]> lda zp1,x ;load to indexed zeropage`
`26ec : 950c [ 4]> sta zpt,x`	`2ce0 : 95b2 [ 4]> sta zpt,x`
`26ee : 28 [ 4]> plp`	`2ce2 : 28 [ 4]> plp`

`26ef : 760c [ 6] ror zpt,x`	`2ce3 : 76b2 [ 6] ror zpt,x`
`tst_zx rROR,fROR,0`	`tst_zx rROR,fROR,0`
`26f1 : 08 [ 3]> php ;save flags`	`2ce5 : 08 [ 3]> php ;save flags`
`26f2 : b50c [ 4]> lda zpt,x`	`2ce6 : b5b2 [ 4]> lda zpt,x`
`26f4 : dd1902 [ 4]> cmp rROR,x ;test result`	`2ce8 : dd1902 [ 4]> cmp rROR,x ;test result`
`> trap_ne`	`> trap_ne`
`26f7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2ceb : f002 [ 3]> beq skip2639`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 299`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2ced : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2cee : 20 > db test_num`
`>`	`>`
`26f9 : 68 [ 4]> pla ;load status`	`2cef : >skip2639`
	`>`
	`2cef : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`26fa : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2cf0 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`26fc : dd2902 [ 4]> cmp fROR,x ;test flags`	`2cf2 : dd2902 [ 4]> cmp fROR,x ;test flags`
`> trap_ne`	`> trap_ne`
`26ff : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2cf5 : f002 [ 3]> beq skip2642`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2cf7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2cf8 : 20 > db test_num`
	`>`
	`2cf9 : >skip2642`
`>`	`>`

`2701 : ca [ 2] dex`	`2cf9 : ca [ 2] dex`
`2702 : 10e3 [ 4] bpl tror6`	`2cfa : 10df [ 3] bpl tror6`
`2704 : a203 [ 2] ldx #3`	`2cfc : a203 [ 2] ldx #3`
`2706 : tror7`	`2cfe : tror7`
`set_zx zp1,$ff-fc`	`set_zx zp1,$ff-fc`
`> load_flag $ff-fc`	`> load_flag $ff-fc`
`2706 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`	`2cfe : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`
`>`	`>`
`2708 : 48 [ 3]> pha ;use stack to load status`	`2d00 : 48 [ 3]> pha ;use stack to load status`
`2709 : b513 [ 4]> lda zp1,x ;load to indexed zeropage`	`2d01 : b5b9 [ 4]> lda zp1,x ;load to indexed zeropage`
`270b : 950c [ 4]> sta zpt,x`	`2d03 : 95b2 [ 4]> sta zpt,x`
`270d : 28 [ 4]> plp`	`2d05 : 28 [ 4]> plp`

`270e : 760c [ 6] ror zpt,x`	`2d06 : 76b2 [ 6] ror zpt,x`
`tst_zx rROR,fROR,$ff-fnzc`	`tst_zx rROR,fROR,$ff-fnzc`
`2710 : 08 [ 3]> php ;save flags`	`2d08 : 08 [ 3]> php ;save flags`
`2711 : b50c [ 4]> lda zpt,x`	`2d09 : b5b2 [ 4]> lda zpt,x`
`2713 : dd1902 [ 4]> cmp rROR,x ;test result`	`2d0b : dd1902 [ 4]> cmp rROR,x ;test result`
`> trap_ne`	`> trap_ne`
`2716 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2d0e : f002 [ 3]> beq skip2647`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2d10 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2d11 : 20 > db test_num`
`>`	`>`
`2718 : 68 [ 4]> pla ;load status`	`2d12 : >skip2647`
	`>`
	`2d12 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`2719 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2d13 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 193`	`2d15 : dd2902 [ 4]> cmp fROR,x ;test flags`
	`> trap_ne`
	`2d18 : f002 [ 3]> beq skip2650`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 300`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`271b : dd2902 [ 4]> cmp fROR,x ;test flags`	`>; db $db ; M65C02/M65C02A SToP instruction`
`> trap_ne`	`2d1a : 00 [ 7]> brk ; Use BRK to return to the monitor`
`271e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2d1b : 20 > db test_num`
	`>`
	`2d1c : >skip2650`
`>`	`>`

`2720 : ca [ 2] dex`	`2d1c : ca [ 2] dex`
`2721 : 10e3 [ 3] bpl tror7`	`2d1d : 10df [ 4] bpl tror7`

`2723 : a203 [ 2] ldx #3`	`2d1f : a203 [ 2] ldx #3`
`2725 : trorc6`	`2d21 : trorc6`
`set_zx zp1,fc`	`set_zx zp1,fc`
`> load_flag fc`	`> load_flag fc`
`2725 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`	`2d21 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`
`>`	`>`
`2727 : 48 [ 3]> pha ;use stack to load status`	`2d23 : 48 [ 3]> pha ;use stack to load status`
`2728 : b513 [ 4]> lda zp1,x ;load to indexed zeropage`	`2d24 : b5b9 [ 4]> lda zp1,x ;load to indexed zeropage`
`272a : 950c [ 4]> sta zpt,x`	`2d26 : 95b2 [ 4]> sta zpt,x`
`272c : 28 [ 4]> plp`	`2d28 : 28 [ 4]> plp`

`272d : 760c [ 6] ror zpt,x`	`2d29 : 76b2 [ 6] ror zpt,x`
`tst_zx rRORc,fRORc,0`	`tst_zx rRORc,fRORc,0`
`272f : 08 [ 3]> php ;save flags`	`2d2b : 08 [ 3]> php ;save flags`
`2730 : b50c [ 4]> lda zpt,x`	`2d2c : b5b2 [ 4]> lda zpt,x`
`2732 : dd1d02 [ 4]> cmp rRORc,x ;test result`	`2d2e : dd1d02 [ 4]> cmp rRORc,x ;test result`
`> trap_ne`	`> trap_ne`
`2735 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2d31 : f002 [ 3]> beq skip2655`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2d33 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2d34 : 20 > db test_num`
`>`	`>`
`2737 : 68 [ 4]> pla ;load status`	`2d35 : >skip2655`
	`>`
	`2d35 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2738 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2d36 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`273a : dd2d02 [ 4]> cmp fRORc,x ;test flags`	`2d38 : dd2d02 [ 4]> cmp fRORc,x ;test flags`
`> trap_ne`	`> trap_ne`
`273d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2d3b : f002 [ 3]> beq skip2658`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2d3d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2d3e : 20 > db test_num`
	`>`
	`2d3f : >skip2658`
`>`	`>`

`273f : ca [ 2] dex`	`2d3f : ca [ 2] dex`
`2740 : 10e3 [ 3] bpl trorc6`	`2d40 : 10df [ 3] bpl trorc6`
`2742 : a203 [ 2] ldx #3`	`2d42 : a203 [ 2] ldx #3`
`2744 : trorc7`	`2d44 : trorc7`
`set_zx zp1,$ff`	`set_zx zp1,$ff`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 301`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag $ff`	`> load_flag $ff`
`2744 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2d44 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2746 : 48 [ 3]> pha ;use stack to load status`	`2d46 : 48 [ 3]> pha ;use stack to load status`
`2747 : b513 [ 4]> lda zp1,x ;load to indexed zeropage`	`2d47 : b5b9 [ 4]> lda zp1,x ;load to indexed zeropage`
`2749 : 950c [ 4]> sta zpt,x`	`2d49 : 95b2 [ 4]> sta zpt,x`
`274b : 28 [ 4]> plp`	`2d4b : 28 [ 4]> plp`

`274c : 760c [ 6] ror zpt,x`	`2d4c : 76b2 [ 6] ror zpt,x`
`tst_zx rRORc,fRORc,$ff-fnzc`	`tst_zx rRORc,fRORc,$ff-fnzc`
`274e : 08 [ 3]> php ;save flags`	`2d4e : 08 [ 3]> php ;save flags`
`274f : b50c [ 4]> lda zpt,x`	`2d4f : b5b2 [ 4]> lda zpt,x`
`2751 : dd1d02 [ 4]> cmp rRORc,x ;test result`	`2d51 : dd1d02 [ 4]> cmp rRORc,x ;test result`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 194`	`2d54 : f002 [ 3]> beq skip2663`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`2754 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2d56 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2d57 : 20 > db test_num`
`>`	`>`
`2756 : 68 [ 4]> pla ;load status`	`2d58 : >skip2663`
	`>`
	`2d58 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`2757 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2d59 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`2759 : dd2d02 [ 4]> cmp fRORc,x ;test flags`	`2d5b : dd2d02 [ 4]> cmp fRORc,x ;test flags`
`> trap_ne`	`> trap_ne`
`275c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2d5e : f002 [ 3]> beq skip2666`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2d60 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2d61 : 20 > db test_num`
	`>`
	`2d62 : >skip2666`
`>`	`>`

`275e : ca [ 2] dex`	`2d62 : ca [ 2] dex`
`275f : 10e3 [ 3] bpl trorc7`	`2d63 : 10df [ 3] bpl trorc7`
`next_test`	`next_test`
`2761 : ad0002 [ 4]> lda test_case ;previous test`	`2d65 : ad0002 [ 4]> lda test_case ;previous test`
`2764 : c920 [ 2]> cmp #test_num`	`2d68 : c920 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`2766 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2d6a : f002 [ 3]> beq skip2669`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2d6c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2d6d : 20 > db test_num`
	`>`
	`2d6e : >skip2669`
`>`	`>`
`0021 = >test_num = test_num + 1`	`0021 = >test_num = test_num + 1`
`2768 : a921 [ 2]> lda #test_num ;*** this tests' number`	`2d6e : a921 [ 2]> lda #test_num ;*** this tests' number`
`276a : 8d0002 [ 4]> sta test_case`	`2d70 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 302`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`



`; shifts - abs indexed`	`; shifts - abs indexed`
`276d : a203 [ 2] ldx #3`
`276f : tasl8`	`2d73 : a203 [ 2] ldx #3`
	`2d75 : tasl8`
`set_absx zp1,0`	`set_absx zp1,0`
`> load_flag 0`	`> load_flag 0`
`276f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2d75 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2771 : 48 [ 3]> pha ;use stack to load status`	`2d77 : 48 [ 3]> pha ;use stack to load status`
`2772 : b513 [ 4]> lda zp1,x ;load to indexed memory`	`2d78 : b5b9 [ 4]> lda zp1,x ;load to indexed memory`
`2774 : 9d0302 [ 5]> sta abst,x`	`2d7a : 9d0302 [ 5]> sta abst,x`
`2777 : 28 [ 4]> plp`	`2d7d : 28 [ 4]> plp`

`2778 : 1e0302 [ 6] asl abst,x`	`2d7e : 1e0302 [ 7] asl abst,x`
`tst_absx rASL,fASL,0`	`tst_absx rASL,fASL,0`
`277b : 08 [ 3]> php ;save flags`	`2d81 : 08 [ 3]> php ;save flags`
`277c : bd0302 [ 4]> lda abst,x`	`2d82 : bd0302 [ 4]> lda abst,x`
`277f : dd1102 [ 4]> cmp rASL,x ;test result`	`2d85 : dd1102 [ 4]> cmp rASL,x ;test result`
`> trap_ne`	`> trap_ne`
`2782 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2d88 : f002 [ 3]> beq skip2674`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2d8a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2d8b : 21 > db test_num`
`>`	`>`
`2784 : 68 [ 4]> pla ;load status`	`2d8c : >skip2674`
	`>`
	`2d8c : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2785 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2d8d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2787 : dd2102 [ 4]> cmp fASL,x ;test flags`	`2d8f : dd2102 [ 4]> cmp fASL,x ;test flags`
`> trap_ne`	`> trap_ne`
`278a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2d92 : f002 [ 3]> beq skip2677`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2d94 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2d95 : 21 > db test_num`
	`>`
	`2d96 : >skip2677`
`>`	`>`

`278c : ca [ 2] dex`	`2d96 : ca [ 2] dex`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 195`	`2d97 : 10dc [ 3] bpl tasl8`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`2d99 : a203 [ 2] ldx #3`
	`2d9b : tasl9`
`278d : 10e0 [ 3] bpl tasl8`
`278f : a203 [ 2] ldx #3`
`2791 : tasl9`
`set_absx zp1,$ff`	`set_absx zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2791 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2d9b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2793 : 48 [ 3]> pha ;use stack to load status`	`2d9d : 48 [ 3]> pha ;use stack to load status`
`2794 : b513 [ 4]> lda zp1,x ;load to indexed memory`	`2d9e : b5b9 [ 4]> lda zp1,x ;load to indexed memory`
`2796 : 9d0302 [ 5]> sta abst,x`	`2da0 : 9d0302 [ 5]> sta abst,x`
`2799 : 28 [ 4]> plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 303`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`279a : 1e0302 [ 6] asl abst,x`	`2da3 : 28 [ 4]> plp`

	`2da4 : 1e0302 [ 7] asl abst,x`
`tst_absx rASL,fASL,$ff-fnzc`	`tst_absx rASL,fASL,$ff-fnzc`
`279d : 08 [ 3]> php ;save flags`	`2da7 : 08 [ 3]> php ;save flags`
`279e : bd0302 [ 4]> lda abst,x`	`2da8 : bd0302 [ 4]> lda abst,x`
`27a1 : dd1102 [ 4]> cmp rASL,x ;test result`	`2dab : dd1102 [ 4]> cmp rASL,x ;test result`
`> trap_ne`	`> trap_ne`
`27a4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2dae : f002 [ 3]> beq skip2682`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2db0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2db1 : 21 > db test_num`
`>`	`>`
`27a6 : 68 [ 4]> pla ;load status`	`2db2 : >skip2682`
	`>`
	`2db2 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`27a7 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2db3 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`27a9 : dd2102 [ 4]> cmp fASL,x ;test flags`	`2db5 : dd2102 [ 4]> cmp fASL,x ;test flags`
`> trap_ne`	`> trap_ne`
`27ac : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2db8 : f002 [ 3]> beq skip2685`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2dba : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2dbb : 21 > db test_num`
	`>`
	`2dbc : >skip2685`
`>`	`>`

`27ae : ca [ 2] dex`	`2dbc : ca [ 2] dex`
`27af : 10e0 [ 3] bpl tasl9`	`2dbd : 10dc [ 3] bpl tasl9`

`27b1 : a203 [ 2] ldx #3`	`2dbf : a203 [ 2] ldx #3`
`27b3 : tlsr8`	`2dc1 : tlsr8`
`set_absx zp1,0`	`set_absx zp1,0`
`> load_flag 0`	`> load_flag 0`
`27b3 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2dc1 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`27b5 : 48 [ 3]> pha ;use stack to load status`	`2dc3 : 48 [ 3]> pha ;use stack to load status`
`27b6 : b513 [ 4]> lda zp1,x ;load to indexed memory`	`2dc4 : b5b9 [ 4]> lda zp1,x ;load to indexed memory`
`27b8 : 9d0302 [ 5]> sta abst,x`	`2dc6 : 9d0302 [ 5]> sta abst,x`
`27bb : 28 [ 4]> plp`	`2dc9 : 28 [ 4]> plp`

`27bc : 5e0302 [ 6] lsr abst,x`	`2dca : 5e0302 [ 7] lsr abst,x`
`tst_absx rLSR,fLSR,0`	`tst_absx rLSR,fLSR,0`
`27bf : 08 [ 3]> php ;save flags`	`2dcd : 08 [ 3]> php ;save flags`
`27c0 : bd0302 [ 4]> lda abst,x`	`2dce : bd0302 [ 4]> lda abst,x`
`27c3 : dd1902 [ 4]> cmp rLSR,x ;test result`	`2dd1 : dd1902 [ 4]> cmp rLSR,x ;test result`
`> trap_ne`	`> trap_ne`
`27c6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2dd4 : f002 [ 3]> beq skip2690`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2dd6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 304`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2dd7 : 21 > db test_num`
`>`	`>`
`27c8 : 68 [ 4]> pla ;load status`	`2dd8 : >skip2690`
	`>`
	`2dd8 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`27c9 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2dd9 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 196`	`2ddb : dd2902 [ 4]> cmp fLSR,x ;test flags`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`27cb : dd2902 [ 4]> cmp fLSR,x ;test flags`
`> trap_ne`	`> trap_ne`
`27ce : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2dde : f002 [ 3]> beq skip2693`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2de0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2de1 : 21 > db test_num`
	`>`
	`2de2 : >skip2693`
`>`	`>`

`27d0 : ca [ 2] dex`	`2de2 : ca [ 2] dex`
`27d1 : 10e0 [ 3] bpl tlsr8`	`2de3 : 10dc [ 3] bpl tlsr8`
`27d3 : a203 [ 2] ldx #3`	`2de5 : a203 [ 2] ldx #3`
`27d5 : tlsr9`	`2de7 : tlsr9`
`set_absx zp1,$ff`	`set_absx zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`27d5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2de7 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`27d7 : 48 [ 3]> pha ;use stack to load status`	`2de9 : 48 [ 3]> pha ;use stack to load status`
`27d8 : b513 [ 4]> lda zp1,x ;load to indexed memory`	`2dea : b5b9 [ 4]> lda zp1,x ;load to indexed memory`
`27da : 9d0302 [ 5]> sta abst,x`	`2dec : 9d0302 [ 5]> sta abst,x`
`27dd : 28 [ 4]> plp`	`2def : 28 [ 4]> plp`

`27de : 5e0302 [ 6] lsr abst,x`	`2df0 : 5e0302 [ 7] lsr abst,x`
`tst_absx rLSR,fLSR,$ff-fnzc`	`tst_absx rLSR,fLSR,$ff-fnzc`
`27e1 : 08 [ 3]> php ;save flags`	`2df3 : 08 [ 3]> php ;save flags`
`27e2 : bd0302 [ 4]> lda abst,x`	`2df4 : bd0302 [ 4]> lda abst,x`
`27e5 : dd1902 [ 4]> cmp rLSR,x ;test result`	`2df7 : dd1902 [ 4]> cmp rLSR,x ;test result`
`> trap_ne`	`> trap_ne`
`27e8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2dfa : f002 [ 3]> beq skip2698`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2dfc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2dfd : 21 > db test_num`
`>`	`>`
`27ea : 68 [ 4]> pla ;load status`	`2dfe : >skip2698`
	`>`
	`2dfe : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`27eb : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2dff : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`27ed : dd2902 [ 4]> cmp fLSR,x ;test flags`	`2e01 : dd2902 [ 4]> cmp fLSR,x ;test flags`
`> trap_ne`	`> trap_ne`
`27f0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2e04 : f002 [ 3]> beq skip2701`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 305`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2e06 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2e07 : 21 > db test_num`
	`>`
	`2e08 : >skip2701`
`>`	`>`

`27f2 : ca [ 2] dex`	`2e08 : ca [ 2] dex`
`27f3 : 10e0 [ 3] bpl tlsr9`	`2e09 : 10dc [ 4] bpl tlsr9`

`27f5 : a203 [ 2] ldx #3`	`2e0b : a203 [ 2] ldx #3`
`27f7 : trol8`	`2e0d : trol8`
`set_absx zp1,0`	`set_absx zp1,0`
`> load_flag 0`	`> load_flag 0`
`27f7 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2e0d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`27f9 : 48 [ 3]> pha ;use stack to load status`	`2e0f : 48 [ 3]> pha ;use stack to load status`
`27fa : b513 [ 4]> lda zp1,x ;load to indexed memory`	`2e10 : b5b9 [ 4]> lda zp1,x ;load to indexed memory`
`27fc : 9d0302 [ 5]> sta abst,x`	`2e12 : 9d0302 [ 5]> sta abst,x`
`27ff : 28 [ 4]> plp`	`2e15 : 28 [ 4]> plp`

`2800 : 3e0302 [ 6] rol abst,x`	`2e16 : 3e0302 [ 7] rol abst,x`
`tst_absx rROL,fROL,0`	`tst_absx rROL,fROL,0`
`2803 : 08 [ 3]> php ;save flags`	`2e19 : 08 [ 3]> php ;save flags`
`2804 : bd0302 [ 4]> lda abst,x`	`2e1a : bd0302 [ 4]> lda abst,x`
`2807 : dd1102 [ 4]> cmp rROL,x ;test result`	`2e1d : dd1102 [ 4]> cmp rROL,x ;test result`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 197`	`2e20 : f002 [ 3]> beq skip2706`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`280a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2e22 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2e23 : 21 > db test_num`
`>`	`>`
`280c : 68 [ 4]> pla ;load status`	`2e24 : >skip2706`
	`>`
	`2e24 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`280d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2e25 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`280f : dd2102 [ 4]> cmp fROL,x ;test flags`	`2e27 : dd2102 [ 4]> cmp fROL,x ;test flags`
`> trap_ne`	`> trap_ne`
`2812 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2e2a : f002 [ 3]> beq skip2709`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2e2c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2e2d : 21 > db test_num`
	`>`
	`2e2e : >skip2709`
`>`	`>`

`2814 : ca [ 2] dex`	`2e2e : ca [ 2] dex`
`2815 : 10e0 [ 4] bpl trol8`	`2e2f : 10dc [ 3] bpl trol8`
`2817 : a203 [ 2] ldx #3`	`2e31 : a203 [ 2] ldx #3`
`2819 : trol9`	`2e33 : trol9`
`set_absx zp1,$ff-fc`	`set_absx zp1,$ff-fc`
`> load_flag $ff-fc`	`> load_flag $ff-fc`
`2819 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 306`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2e33 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`
`>`	`>`
`281b : 48 [ 3]> pha ;use stack to load status`	`2e35 : 48 [ 3]> pha ;use stack to load status`
`281c : b513 [ 4]> lda zp1,x ;load to indexed memory`	`2e36 : b5b9 [ 4]> lda zp1,x ;load to indexed memory`
`281e : 9d0302 [ 5]> sta abst,x`	`2e38 : 9d0302 [ 5]> sta abst,x`
`2821 : 28 [ 4]> plp`	`2e3b : 28 [ 4]> plp`

`2822 : 3e0302 [ 6] rol abst,x`	`2e3c : 3e0302 [ 7] rol abst,x`
`tst_absx rROL,fROL,$ff-fnzc`	`tst_absx rROL,fROL,$ff-fnzc`
`2825 : 08 [ 3]> php ;save flags`	`2e3f : 08 [ 3]> php ;save flags`
`2826 : bd0302 [ 4]> lda abst,x`	`2e40 : bd0302 [ 4]> lda abst,x`
`2829 : dd1102 [ 4]> cmp rROL,x ;test result`	`2e43 : dd1102 [ 4]> cmp rROL,x ;test result`
`> trap_ne`	`> trap_ne`
`282c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2e46 : f002 [ 3]> beq skip2714`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2e48 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2e49 : 21 > db test_num`
	`>`
	`2e4a : >skip2714`
`>`	`>`
`282e : 68 [ 4]> pla ;load status`	`2e4a : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`282f : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2e4b : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`2831 : dd2102 [ 4]> cmp fROL,x ;test flags`	`2e4d : dd2102 [ 4]> cmp fROL,x ;test flags`
`> trap_ne`	`> trap_ne`
`2834 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2e50 : f002 [ 3]> beq skip2717`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2e52 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2e53 : 21 > db test_num`
	`>`
	`2e54 : >skip2717`
`>`	`>`

`2836 : ca [ 2] dex`	`2e54 : ca [ 2] dex`
`2837 : 10e0 [ 3] bpl trol9`	`2e55 : 10dc [ 3] bpl trol9`

`2839 : a203 [ 2] ldx #3`	`2e57 : a203 [ 2] ldx #3`
`283b : trolc8`	`2e59 : trolc8`
`set_absx zp1,fc`	`set_absx zp1,fc`
`> load_flag fc`	`> load_flag fc`
`283b : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`	`2e59 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`
`>`	`>`
`283d : 48 [ 3]> pha ;use stack to load status`	`2e5b : 48 [ 3]> pha ;use stack to load status`
`283e : b513 [ 4]> lda zp1,x ;load to indexed memory`	`2e5c : b5b9 [ 4]> lda zp1,x ;load to indexed memory`
`2840 : 9d0302 [ 5]> sta abst,x`	`2e5e : 9d0302 [ 5]> sta abst,x`
`2843 : 28 [ 4]> plp`	`2e61 : 28 [ 4]> plp`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 198`	`2e62 : 3e0302 [ 7] rol abst,x`
	`tst_absx rROLc,fROLc,0`
	`2e65 : 08 [ 3]> php ;save flags`
	`2e66 : bd0302 [ 4]> lda abst,x`
	`2e69 : dd1502 [ 4]> cmp rROLc,x ;test result`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 307`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2844 : 3e0302 [ 6] rol abst,x`
`tst_absx rROLc,fROLc,0`
`2847 : 08 [ 3]> php ;save flags`
`2848 : bd0302 [ 4]> lda abst,x`
`284b : dd1502 [ 4]> cmp rROLc,x ;test result`
`> trap_ne`	`> trap_ne`
`284e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2e6c : f002 [ 3]> beq skip2722`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2e6e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2e6f : 21 > db test_num`
`>`	`>`
`2850 : 68 [ 4]> pla ;load status`	`2e70 : >skip2722`
	`>`
	`2e70 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2851 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2e71 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2853 : dd2502 [ 4]> cmp fROLc,x ;test flags`	`2e73 : dd2502 [ 4]> cmp fROLc,x ;test flags`
`> trap_ne`	`> trap_ne`
`2856 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2e76 : f002 [ 3]> beq skip2725`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2e78 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2e79 : 21 > db test_num`
	`>`
	`2e7a : >skip2725`
`>`	`>`

`2858 : ca [ 2] dex`	`2e7a : ca [ 2] dex`
`2859 : 10e0 [ 3] bpl trolc8`	`2e7b : 10dc [ 3] bpl trolc8`
`285b : a203 [ 2] ldx #3`	`2e7d : a203 [ 2] ldx #3`
`285d : trolc9`	`2e7f : trolc9`
`set_absx zp1,$ff`	`set_absx zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`285d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2e7f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`285f : 48 [ 3]> pha ;use stack to load status`	`2e81 : 48 [ 3]> pha ;use stack to load status`
`2860 : b513 [ 4]> lda zp1,x ;load to indexed memory`	`2e82 : b5b9 [ 4]> lda zp1,x ;load to indexed memory`
`2862 : 9d0302 [ 5]> sta abst,x`	`2e84 : 9d0302 [ 5]> sta abst,x`
`2865 : 28 [ 4]> plp`	`2e87 : 28 [ 4]> plp`

`2866 : 3e0302 [ 6] rol abst,x`	`2e88 : 3e0302 [ 7] rol abst,x`
`tst_absx rROLc,fROLc,$ff-fnzc`	`tst_absx rROLc,fROLc,$ff-fnzc`
`2869 : 08 [ 3]> php ;save flags`	`2e8b : 08 [ 3]> php ;save flags`
`286a : bd0302 [ 4]> lda abst,x`	`2e8c : bd0302 [ 4]> lda abst,x`
`286d : dd1502 [ 4]> cmp rROLc,x ;test result`	`2e8f : dd1502 [ 4]> cmp rROLc,x ;test result`
`> trap_ne`	`> trap_ne`
`2870 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2e92 : f002 [ 3]> beq skip2730`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2e94 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2e95 : 21 > db test_num`
`>`	`>`
`2872 : 68 [ 4]> pla ;load status`	`2e96 : >skip2730`
	`>`
	`2e96 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`2873 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2e97 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`2875 : dd2502 [ 4]> cmp fROLc,x ;test flags`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 308`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2e99 : dd2502 [ 4]> cmp fROLc,x ;test flags`
`> trap_ne`	`> trap_ne`
`2878 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2e9c : f002 [ 3]> beq skip2733`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2e9e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2e9f : 21 > db test_num`
	`>`
	`2ea0 : >skip2733`
`>`	`>`

`287a : ca [ 2] dex`	`2ea0 : ca [ 2] dex`
`287b : 10e0 [ 3] bpl trolc9`	`2ea1 : 10dc [ 3] bpl trolc9`

`287d : a203 [ 2] ldx #3`	`2ea3 : a203 [ 2] ldx #3`
`287f : tror8`	`2ea5 : tror8`
`set_absx zp1,0`	`set_absx zp1,0`
`> load_flag 0`	`> load_flag 0`
`287f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2ea5 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 199`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`2881 : 48 [ 3]> pha ;use stack to load status`	`2ea7 : 48 [ 3]> pha ;use stack to load status`
`2882 : b513 [ 4]> lda zp1,x ;load to indexed memory`	`2ea8 : b5b9 [ 4]> lda zp1,x ;load to indexed memory`
`2884 : 9d0302 [ 5]> sta abst,x`	`2eaa : 9d0302 [ 5]> sta abst,x`
`2887 : 28 [ 4]> plp`	`2ead : 28 [ 4]> plp`

`2888 : 7e0302 [ 6] ror abst,x`	`2eae : 7e0302 [ 7] ror abst,x`
`tst_absx rROR,fROR,0`	`tst_absx rROR,fROR,0`
`288b : 08 [ 3]> php ;save flags`	`2eb1 : 08 [ 3]> php ;save flags`
`288c : bd0302 [ 4]> lda abst,x`	`2eb2 : bd0302 [ 4]> lda abst,x`
`288f : dd1902 [ 4]> cmp rROR,x ;test result`	`2eb5 : dd1902 [ 4]> cmp rROR,x ;test result`
`> trap_ne`	`> trap_ne`
`2892 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2eb8 : f002 [ 3]> beq skip2738`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2eba : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2ebb : 21 > db test_num`
	`>`
	`2ebc : >skip2738`
`>`	`>`
`2894 : 68 [ 4]> pla ;load status`	`2ebc : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2895 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2ebd : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2897 : dd2902 [ 4]> cmp fROR,x ;test flags`	`2ebf : dd2902 [ 4]> cmp fROR,x ;test flags`
`> trap_ne`	`> trap_ne`
`289a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2ec2 : f002 [ 3]> beq skip2741`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2ec4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2ec5 : 21 > db test_num`
`>`	`>`
	`2ec6 : >skip2741`
	`>`

	`2ec6 : ca [ 2] dex`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 309`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`289c : ca [ 2] dex`	`2ec7 : 10dc [ 3] bpl tror8`
`289d : 10e0 [ 3] bpl tror8`	`2ec9 : a203 [ 2] ldx #3`
`289f : a203 [ 2] ldx #3`	`2ecb : tror9`
`28a1 : tror9`
`set_absx zp1,$ff-fc`	`set_absx zp1,$ff-fc`
`> load_flag $ff-fc`	`> load_flag $ff-fc`
`28a1 : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`	`2ecb : a9fe [ 2]> lda #$ff-fc ;allow test to change I-flag (no mask)`
`>`	`>`
`28a3 : 48 [ 3]> pha ;use stack to load status`	`2ecd : 48 [ 3]> pha ;use stack to load status`
`28a4 : b513 [ 4]> lda zp1,x ;load to indexed memory`	`2ece : b5b9 [ 4]> lda zp1,x ;load to indexed memory`
`28a6 : 9d0302 [ 5]> sta abst,x`	`2ed0 : 9d0302 [ 5]> sta abst,x`
`28a9 : 28 [ 4]> plp`	`2ed3 : 28 [ 4]> plp`

`28aa : 7e0302 [ 6] ror abst,x`	`2ed4 : 7e0302 [ 7] ror abst,x`
`tst_absx rROR,fROR,$ff-fnzc`	`tst_absx rROR,fROR,$ff-fnzc`
`28ad : 08 [ 3]> php ;save flags`	`2ed7 : 08 [ 3]> php ;save flags`
`28ae : bd0302 [ 4]> lda abst,x`	`2ed8 : bd0302 [ 4]> lda abst,x`
`28b1 : dd1902 [ 4]> cmp rROR,x ;test result`	`2edb : dd1902 [ 4]> cmp rROR,x ;test result`
`> trap_ne`	`> trap_ne`
`28b4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2ede : f002 [ 3]> beq skip2746`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2ee0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2ee1 : 21 > db test_num`
`>`	`>`
`28b6 : 68 [ 4]> pla ;load status`	`2ee2 : >skip2746`
	`>`
	`2ee2 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnzc`	`> eor_flag $ff-fnzc`
`28b7 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2ee3 : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
`>`	`>`
`28b9 : dd2902 [ 4]> cmp fROR,x ;test flags`	`2ee5 : dd2902 [ 4]> cmp fROR,x ;test flags`
`> trap_ne`	`> trap_ne`
`28bc : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2ee8 : f002 [ 3]> beq skip2749`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2eea : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2eeb : 21 > db test_num`
	`>`
	`2eec : >skip2749`
`>`	`>`

`28be : ca [ 2] dex`	`2eec : ca [ 2] dex`
`28bf : 10e0 [ 3] bpl tror9`	`2eed : 10dc [ 3] bpl tror9`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 200`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`28c1 : a203 [ 2] ldx #3`	`2eef : a203 [ 2] ldx #3`
`28c3 : trorc8`	`2ef1 : trorc8`
`set_absx zp1,fc`	`set_absx zp1,fc`
`> load_flag fc`	`> load_flag fc`
`28c3 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`	`2ef1 : a901 [ 2]> lda #fc ;allow test to change I-flag (no mask)`
`>`	`>`
`28c5 : 48 [ 3]> pha ;use stack to load status`	`2ef3 : 48 [ 3]> pha ;use stack to load status`
`28c6 : b513 [ 4]> lda zp1,x ;load to indexed memory`	`2ef4 : b5b9 [ 4]> lda zp1,x ;load to indexed memory`
`28c8 : 9d0302 [ 5]> sta abst,x`	`2ef6 : 9d0302 [ 5]> sta abst,x`
`28cb : 28 [ 4]> plp`	`2ef9 : 28 [ 4]> plp`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 310`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`28cc : 7e0302 [ 6] ror abst,x`	`2efa : 7e0302 [ 7] ror abst,x`
`tst_absx rRORc,fRORc,0`	`tst_absx rRORc,fRORc,0`
`28cf : 08 [ 3]> php ;save flags`	`2efd : 08 [ 3]> php ;save flags`
`28d0 : bd0302 [ 4]> lda abst,x`	`2efe : bd0302 [ 4]> lda abst,x`
`28d3 : dd1d02 [ 4]> cmp rRORc,x ;test result`	`2f01 : dd1d02 [ 4]> cmp rRORc,x ;test result`
`> trap_ne`	`> trap_ne`
`28d6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2f04 : f002 [ 3]> beq skip2754`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2f06 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2f07 : 21 > db test_num`
`>`	`>`
`28d8 : 68 [ 4]> pla ;load status`	`2f08 : >skip2754`
	`>`
	`2f08 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`28d9 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2f09 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`28db : dd2d02 [ 4]> cmp fRORc,x ;test flags`	`2f0b : dd2d02 [ 4]> cmp fRORc,x ;test flags`
`> trap_ne`	`> trap_ne`
`28de : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2f0e : f002 [ 3]> beq skip2757`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2f10 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2f11 : 21 > db test_num`
	`>`
	`2f12 : >skip2757`
`>`	`>`

`28e0 : ca [ 2] dex`	`2f12 : ca [ 2] dex`
`28e1 : 10e0 [ 3] bpl trorc8`	`2f13 : 10dc [ 4] bpl trorc8`
`28e3 : a203 [ 2] ldx #3`	`2f15 : a203 [ 2] ldx #3`
`28e5 : trorc9`	`2f17 : trorc9`
`set_absx zp1,$ff`	`set_absx zp1,$ff`
`> load_flag $ff`	`> load_flag $ff`
`28e5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2f17 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`28e7 : 48 [ 3]> pha ;use stack to load status`	`2f19 : 48 [ 3]> pha ;use stack to load status`
`28e8 : b513 [ 4]> lda zp1,x ;load to indexed memory`	`2f1a : b5b9 [ 4]> lda zp1,x ;load to indexed memory`
`28ea : 9d0302 [ 5]> sta abst,x`	`2f1c : 9d0302 [ 5]> sta abst,x`
`28ed : 28 [ 4]> plp`	`2f1f : 28 [ 4]> plp`

`28ee : 7e0302 [ 6] ror abst,x`	`2f20 : 7e0302 [ 7] ror abst,x`
`tst_absx rRORc,fRORc,$ff-fnzc`	`tst_absx rRORc,fRORc,$ff-fnzc`
`28f1 : 08 [ 3]> php ;save flags`	`2f23 : 08 [ 3]> php ;save flags`
`28f2 : bd0302 [ 4]> lda abst,x`	`2f24 : bd0302 [ 4]> lda abst,x`
`28f5 : dd1d02 [ 4]> cmp rRORc,x ;test result`	`2f27 : dd1d02 [ 4]> cmp rRORc,x ;test result`
`> trap_ne`	`> trap_ne`
`28f8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2f2a : f002 [ 3]> beq skip2762`
`>`	`> trap ;failed equal (zero)`
`28fa : 68 [ 4]> pla ;load status`	`>; db $db ; M65C02/M65C02A SToP instruction`
`> eor_flag $ff-fnzc`	`2f2c : 00 [ 7]> brk ; Use BRK to return to the monitor`
`28fb : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`	`2f2d : 21 > db test_num`
`>`	`>`
`28fd : dd2d02 [ 4]> cmp fRORc,x ;test flags`	`2f2e : >skip2762`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 201`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 311`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>`
	`2f2e : 68 [ 4]> pla ;load status`
	`> eor_flag $ff-fnzc`
	`2f2f : 497c [ 2]> eor #$ff-fnzc\|fao ;invert expected flags + always on bits`
	`>`
	`2f31 : dd2d02 [ 4]> cmp fRORc,x ;test flags`
`> trap_ne`	`> trap_ne`
`2900 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2f34 : f002 [ 3]> beq skip2765`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2f36 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2f37 : 21 > db test_num`
	`>`
	`2f38 : >skip2765`
`>`	`>`

`2902 : ca [ 2] dex`	`2f38 : ca [ 2] dex`
`2903 : 10e0 [ 4] bpl trorc9`	`2f39 : 10dc [ 3] bpl trorc9`
`next_test`	`next_test`
`2905 : ad0002 [ 4]> lda test_case ;previous test`	`2f3b : ad0002 [ 4]> lda test_case ;previous test`
`2908 : c921 [ 2]> cmp #test_num`	`2f3e : c921 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`290a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2f40 : f002 [ 3]> beq skip2768`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2f42 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2f43 : 21 > db test_num`
	`>`
	`2f44 : >skip2768`
`>`	`>`
`0022 = >test_num = test_num + 1`	`0022 = >test_num = test_num + 1`
`290c : a922 [ 2]> lda #test_num ;*** this tests' number`	`2f44 : a922 [ 2]> lda #test_num ;*** this tests' number`
`290e : 8d0002 [ 4]> sta test_case`	`2f46 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; testing memory increment/decrement - INC DEC all addressing modes`	`; testing memory increment/decrement - INC DEC all addressing modes`
`; zeropage`	`; zeropage`
`2911 : a200 [ 2] ldx #0`
`2913 : a97e [ 2] lda #$7e`	`2f49 : a200 [ 2] ldx #0`
`2915 : 850c [ 3] sta zpt`	`2f4b : a97e [ 2] lda #$7e`
`2917 : tinc`	`2f4d : 85b2 [ 3] sta zpt`
	`2f4f : tinc`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`2917 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2f4f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2919 : 48 [ 3]> pha ;use stack to load status`	`2f51 : 48 [ 3]> pha ;use stack to load status`
`291a : 28 [ 4]> plp`	`2f52 : 28 [ 4]> plp`

`291b : e60c [ 5] inc zpt`	`2f53 : e6b2 [ 5] inc zpt`
`tst_z rINC,fINC,0`	`tst_z rINC,fINC,0`
`291d : 08 [ 3]> php ;save flags`	`2f55 : 08 [ 3]> php ;save flags`
`291e : a50c [ 3]> lda zpt`	`2f56 : a5b2 [ 3]> lda zpt`
`2920 : dd3102 [ 4]> cmp rINC,x ;test result`	`2f58 : dd3102 [ 4]> cmp rINC,x ;test result`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 312`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> trap_ne`	`> trap_ne`
`2923 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2f5b : f002 [ 3]> beq skip2773`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2f5d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2f5e : 22 > db test_num`
	`>`
	`2f5f : >skip2773`
`>`	`>`
`2925 : 68 [ 4]> pla ;load status`	`2f5f : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2926 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2f60 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2928 : dd3602 [ 4]> cmp fINC,x ;test flags`	`2f62 : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`292b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2f65 : f002 [ 3]> beq skip2776`
`>`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`292d : e8 [ 2] inx`	`2f67 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`292e : e002 [ 2] cpx #2`	`2f68 : 22 > db test_num`
`2930 : d004 [ 3] bne tinc1`	`>`
`2932 : a9fe [ 2] lda #$fe`	`2f69 : >skip2776`
`2934 : 850c [ 3] sta zpt`	`>`
`2936 : e005 [ 2] tinc1 cpx #5`
`2938 : d0dd [ 3] bne tinc`	`2f69 : e8 [ 2] inx`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 202`	`2f6a : e002 [ 2] cpx #2`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`2f6c : d004 [ 3] bne tinc1`
	`2f6e : a9fe [ 2] lda #$fe`
`293a : ca [ 2] dex`	`2f70 : 85b2 [ 3] sta zpt`
`293b : e60c [ 5] inc zpt`	`2f72 : e005 [ 2] tinc1 cpx #5`
`293d : tdec`	`2f74 : d0d9 [ 3] bne tinc`
	`2f76 : ca [ 2] dex`
	`2f77 : e6b2 [ 5] inc zpt`
	`2f79 : tdec`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`293d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`2f79 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`293f : 48 [ 3]> pha ;use stack to load status`	`2f7b : 48 [ 3]> pha ;use stack to load status`
`2940 : 28 [ 4]> plp`	`2f7c : 28 [ 4]> plp`

`2941 : c60c [ 5] dec zpt`	`2f7d : c6b2 [ 5] dec zpt`
`tst_z rINC,fINC,0`	`tst_z rINC,fINC,0`
`2943 : 08 [ 3]> php ;save flags`	`2f7f : 08 [ 3]> php ;save flags`
`2944 : a50c [ 3]> lda zpt`	`2f80 : a5b2 [ 3]> lda zpt`
`2946 : dd3102 [ 4]> cmp rINC,x ;test result`	`2f82 : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2949 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2f85 : f002 [ 3]> beq skip2781`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2f87 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2f88 : 22 > db test_num`
	`>`
	`2f89 : >skip2781`
`>`	`>`
`294b : 68 [ 4]> pla ;load status`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 313`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2f89 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`294c : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`2f8a : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`294e : dd3602 [ 4]> cmp fINC,x ;test flags`	`2f8c : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`2951 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2f8f : f002 [ 3]> beq skip2784`
`>`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`2953 : ca [ 2] dex`	`2f91 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`2954 : 300a [ 3] bmi tdec1`	`2f92 : 22 > db test_num`
`2956 : e001 [ 2] cpx #1`	`>`
`2958 : d0e3 [ 3] bne tdec`	`2f93 : >skip2784`
`295a : a981 [ 2] lda #$81`	`>`
`295c : 850c [ 3] sta zpt`
`295e : d0dd [ 3] bne tdec`	`2f93 : ca [ 2] dex`
`2960 : tdec1`	`2f94 : 300a [ 3] bmi tdec1`
`2960 : a200 [ 2] ldx #0`	`2f96 : e001 [ 2] cpx #1`
`2962 : a97e [ 2] lda #$7e`	`2f98 : d0df [ 3] bne tdec`
`2964 : 850c [ 3] sta zpt`	`2f9a : a981 [ 2] lda #$81`
`2966 : tinc10`	`2f9c : 85b2 [ 3] sta zpt`
	`2f9e : d0d9 [ 3] bne tdec`
	`2fa0 : tdec1`
	`2fa0 : a200 [ 2] ldx #0`
	`2fa2 : a97e [ 2] lda #$7e`
	`2fa4 : 85b2 [ 3] sta zpt`
	`2fa6 : tinc10`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`2966 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2fa6 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2968 : 48 [ 3]> pha ;use stack to load status`	`2fa8 : 48 [ 3]> pha ;use stack to load status`
`2969 : 28 [ 4]> plp`	`2fa9 : 28 [ 4]> plp`

`296a : e60c [ 5] inc zpt`	`2faa : e6b2 [ 5] inc zpt`
`tst_z rINC,fINC,$ff-fnz`	`tst_z rINC,fINC,$ff-fnz`
`296c : 08 [ 3]> php ;save flags`	`2fac : 08 [ 3]> php ;save flags`
`296d : a50c [ 3]> lda zpt`	`2fad : a5b2 [ 3]> lda zpt`
`296f : dd3102 [ 4]> cmp rINC,x ;test result`	`2faf : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2972 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2fb2 : f002 [ 3]> beq skip2789`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2fb4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2fb5 : 22 > db test_num`
`>`	`>`
`2974 : 68 [ 4]> pla ;load status`	`2fb6 : >skip2789`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 203`	`>`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`2fb6 : 68 [ 4]> pla ;load status`

`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2975 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`2fb7 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2977 : dd3602 [ 4]> cmp fINC,x ;test flags`	`2fb9 : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`297a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2fbc : f002 [ 3]> beq skip2792`
`>`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 314`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`297c : e8 [ 2] inx`	`> trap ;failed equal (zero)`
`297d : e002 [ 2] cpx #2`	`>; db $db ; M65C02/M65C02A SToP instruction`
`297f : d004 [ 3] bne tinc11`	`2fbe : 00 [ 7]> brk ; Use BRK to return to the monitor`
`2981 : a9fe [ 2] lda #$fe`	`2fbf : 22 > db test_num`
`2983 : 850c [ 3] sta zpt`	`>`
`2985 : e005 [ 2] tinc11 cpx #5`	`2fc0 : >skip2792`
`2987 : d0dd [ 3] bne tinc10`	`>`
`2989 : ca [ 2] dex`
`298a : e60c [ 5] inc zpt`	`2fc0 : e8 [ 2] inx`
`298c : tdec10`	`2fc1 : e002 [ 2] cpx #2`
	`2fc3 : d004 [ 3] bne tinc11`
	`2fc5 : a9fe [ 2] lda #$fe`
	`2fc7 : 85b2 [ 3] sta zpt`
	`2fc9 : e005 [ 2] tinc11 cpx #5`
	`2fcb : d0d9 [ 3] bne tinc10`
	`2fcd : ca [ 2] dex`
	`2fce : e6b2 [ 5] inc zpt`
	`2fd0 : tdec10`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`298c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`2fd0 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`298e : 48 [ 3]> pha ;use stack to load status`	`2fd2 : 48 [ 3]> pha ;use stack to load status`
`298f : 28 [ 4]> plp`	`2fd3 : 28 [ 4]> plp`

`2990 : c60c [ 5] dec zpt`	`2fd4 : c6b2 [ 5] dec zpt`
`tst_z rINC,fINC,$ff-fnz`	`tst_z rINC,fINC,$ff-fnz`
`2992 : 08 [ 3]> php ;save flags`	`2fd6 : 08 [ 3]> php ;save flags`
`2993 : a50c [ 3]> lda zpt`	`2fd7 : a5b2 [ 3]> lda zpt`
`2995 : dd3102 [ 4]> cmp rINC,x ;test result`	`2fd9 : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2998 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2fdc : f002 [ 3]> beq skip2797`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2fde : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2fdf : 22 > db test_num`
`>`	`>`
`299a : 68 [ 4]> pla ;load status`	`2fe0 : >skip2797`
	`>`
	`2fe0 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`299b : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`2fe1 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`299d : dd3602 [ 4]> cmp fINC,x ;test flags`	`2fe3 : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`29a0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`2fe6 : f002 [ 3]> beq skip2800`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2fe8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2fe9 : 22 > db test_num`
	`>`
	`2fea : >skip2800`
`>`	`>`

`29a2 : ca [ 2] dex`	`2fea : ca [ 2] dex`
`29a3 : 300a [ 3] bmi tdec11`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 315`
`29a5 : e001 [ 2] cpx #1`
`29a7 : d0e3 [ 3] bne tdec10`
`29a9 : a981 [ 2] lda #$81`
`29ab : 850c [ 3] sta zpt`
`29ad : d0dd [ 3] bne tdec10`
`29af : tdec11`
`next_test`
`29af : ad0002 [ 4]> lda test_case ;previous test`
`29b2 : c922 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`
`29b4 : d0fe [ 3]> bne * ;failed not equal (non zero)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 204`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`2feb : 300a [ 3] bmi tdec11`
	`2fed : e001 [ 2] cpx #1`
	`2fef : d0df [ 3] bne tdec10`
	`2ff1 : a981 [ 2] lda #$81`
	`2ff3 : 85b2 [ 3] sta zpt`
	`2ff5 : d0d9 [ 3] bne tdec10`
	`2ff7 : tdec11`
	`next_test`
	`2ff7 : ad0002 [ 4]> lda test_case ;previous test`
	`2ffa : c922 [ 2]> cmp #test_num`
	`> trap_ne ;test is out of sequence`
	`2ffc : f002 [ 4]> beq skip2803`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`2ffe : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`2fff : 22 > db test_num`
	`>`
	`3000 : >skip2803`
`>`	`>`
`0023 = >test_num = test_num + 1`	`0023 = >test_num = test_num + 1`
`29b6 : a923 [ 2]> lda #test_num ;*** this tests' number`	`3000 : a923 [ 2]> lda #test_num ;*** this tests' number`
`29b8 : 8d0002 [ 4]> sta test_case`	`3002 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; absolute memory`	`; absolute memory`
`29bb : a200 [ 2] ldx #0`
`29bd : a97e [ 2] lda #$7e`	`3005 : a200 [ 2] ldx #0`
`29bf : 8d0302 [ 4] sta abst`	`3007 : a97e [ 2] lda #$7e`
`29c2 : tinc2`	`3009 : 8d0302 [ 4] sta abst`
	`300c : tinc2`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`29c2 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`300c : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`29c4 : 48 [ 3]> pha ;use stack to load status`	`300e : 48 [ 3]> pha ;use stack to load status`
`29c5 : 28 [ 4]> plp`	`300f : 28 [ 4]> plp`

`29c6 : ee0302 [ 6] inc abst`	`3010 : ee0302 [ 6] inc abst`
`tst_abs rINC,fINC,0`	`tst_abs rINC,fINC,0`
`29c9 : 08 [ 3]> php ;save flags`	`3013 : 08 [ 3]> php ;save flags`
`29ca : ad0302 [ 4]> lda abst`	`3014 : ad0302 [ 4]> lda abst`
`29cd : dd3102 [ 4]> cmp rINC,x ;test result`	`3017 : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`29d0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`301a : f002 [ 3]> beq skip2808`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`301c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`301d : 23 > db test_num`
`>`	`>`
`29d2 : 68 [ 4]> pla ;load status`	`301e : >skip2808`
	`>`
	`301e : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`29d3 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`301f : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 316`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`29d5 : dd3602 [ 4]> cmp fINC,x ;test flags`	`3021 : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`29d8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3024 : f002 [ 3]> beq skip2811`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3026 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3027 : 23 > db test_num`
	`>`
	`3028 : >skip2811`
`>`	`>`

`29da : e8 [ 2] inx`	`3028 : e8 [ 2] inx`
`29db : e002 [ 2] cpx #2`	`3029 : e002 [ 2] cpx #2`
`29dd : d005 [ 3] bne tinc3`	`302b : d005 [ 3] bne tinc3`
`29df : a9fe [ 2] lda #$fe`	`302d : a9fe [ 2] lda #$fe`
`29e1 : 8d0302 [ 4] sta abst`	`302f : 8d0302 [ 4] sta abst`
`29e4 : e005 [ 2] tinc3 cpx #5`	`3032 : e005 [ 2] tinc3 cpx #5`
`29e6 : d0da [ 3] bne tinc2`	`3034 : d0d6 [ 3] bne tinc2`
`29e8 : ca [ 2] dex`	`3036 : ca [ 2] dex`
`29e9 : ee0302 [ 6] inc abst`	`3037 : ee0302 [ 6] inc abst`
`29ec : tdec2`	`303a : tdec2`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`29ec : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`303a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`29ee : 48 [ 3]> pha ;use stack to load status`	`303c : 48 [ 3]> pha ;use stack to load status`
`29ef : 28 [ 4]> plp`	`303d : 28 [ 4]> plp`

`29f0 : ce0302 [ 6] dec abst`	`303e : ce0302 [ 6] dec abst`
`tst_abs rINC,fINC,0`	`tst_abs rINC,fINC,0`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 205`	`3041 : 08 [ 3]> php ;save flags`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`3042 : ad0302 [ 4]> lda abst`
	`3045 : dd3102 [ 4]> cmp rINC,x ;test result`
`29f3 : 08 [ 3]> php ;save flags`	`> trap_ne`
`29f4 : ad0302 [ 4]> lda abst`	`3048 : f002 [ 3]> beq skip2816`
`29f7 : dd3102 [ 4]> cmp rINC,x ;test result`	`> trap ;failed equal (zero)`
`> trap_ne`	`>; db $db ; M65C02/M65C02A SToP instruction`
`29fa : d0fe [ 3]> bne * ;failed not equal (non zero)`	`304a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`304b : 23 > db test_num`
`>`	`>`
`29fc : 68 [ 4]> pla ;load status`	`304c : >skip2816`
	`>`
	`304c : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`29fd : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`304d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`29ff : dd3602 [ 4]> cmp fINC,x ;test flags`	`304f : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`2a02 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3052 : f002 [ 3]> beq skip2819`
`>`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`2a04 : ca [ 2] dex`	`3054 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`2a05 : 300b [ 3] bmi tdec3`	`3055 : 23 > db test_num`
`2a07 : e001 [ 2] cpx #1`	`>`
`2a09 : d0e1 [ 4] bne tdec2`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 317`
`2a0b : a981 [ 2] lda #$81`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`2a0d : 8d0302 [ 4] sta abst`
`2a10 : d0da [ 4] bne tdec2`	`3056 : >skip2819`
`2a12 : tdec3`	`>`
`2a12 : a200 [ 2] ldx #0`
`2a14 : a97e [ 2] lda #$7e`	`3056 : ca [ 2] dex`
`2a16 : 8d0302 [ 4] sta abst`	`3057 : 300b [ 3] bmi tdec3`
`2a19 : tinc12`	`3059 : e001 [ 2] cpx #1`
	`305b : d0dd [ 3] bne tdec2`
	`305d : a981 [ 2] lda #$81`
	`305f : 8d0302 [ 4] sta abst`
	`3062 : d0d6 [ 3] bne tdec2`
	`3064 : tdec3`
	`3064 : a200 [ 2] ldx #0`
	`3066 : a97e [ 2] lda #$7e`
	`3068 : 8d0302 [ 4] sta abst`
	`306b : tinc12`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`2a19 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`306b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2a1b : 48 [ 3]> pha ;use stack to load status`	`306d : 48 [ 3]> pha ;use stack to load status`
`2a1c : 28 [ 4]> plp`	`306e : 28 [ 4]> plp`

`2a1d : ee0302 [ 6] inc abst`	`306f : ee0302 [ 6] inc abst`
`tst_abs rINC,fINC,$ff-fnz`	`tst_abs rINC,fINC,$ff-fnz`
`2a20 : 08 [ 3]> php ;save flags`	`3072 : 08 [ 3]> php ;save flags`
`2a21 : ad0302 [ 4]> lda abst`	`3073 : ad0302 [ 4]> lda abst`
`2a24 : dd3102 [ 4]> cmp rINC,x ;test result`	`3076 : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2a27 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3079 : f002 [ 3]> beq skip2824`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`307b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`307c : 23 > db test_num`
`>`	`>`
`2a29 : 68 [ 4]> pla ;load status`	`307d : >skip2824`
	`>`
	`307d : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2a2a : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`307e : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2a2c : dd3602 [ 4]> cmp fINC,x ;test flags`	`3080 : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`2a2f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3083 : f002 [ 3]> beq skip2827`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3085 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3086 : 23 > db test_num`
	`>`
	`3087 : >skip2827`
`>`	`>`

`2a31 : e8 [ 2] inx`	`3087 : e8 [ 2] inx`
`2a32 : e002 [ 2] cpx #2`	`3088 : e002 [ 2] cpx #2`
`2a34 : d005 [ 3] bne tinc13`	`308a : d005 [ 3] bne tinc13`
`2a36 : a9fe [ 2] lda #$fe`	`308c : a9fe [ 2] lda #$fe`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 206`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 318`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2a38 : 8d0302 [ 4] sta abst`	`308e : 8d0302 [ 4] sta abst`
`2a3b : e005 [ 2] tinc13 cpx #5`	`3091 : e005 [ 2] tinc13 cpx #5`
`2a3d : d0da [ 3] bne tinc12`	`3093 : d0d6 [ 3] bne tinc12`
`2a3f : ca [ 2] dex`	`3095 : ca [ 2] dex`
`2a40 : ee0302 [ 6] inc abst`	`3096 : ee0302 [ 6] inc abst`
`2a43 : tdec12`	`3099 : tdec12`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`2a43 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3099 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2a45 : 48 [ 3]> pha ;use stack to load status`	`309b : 48 [ 3]> pha ;use stack to load status`
`2a46 : 28 [ 4]> plp`	`309c : 28 [ 4]> plp`

`2a47 : ce0302 [ 6] dec abst`	`309d : ce0302 [ 6] dec abst`
`tst_abs rINC,fINC,$ff-fnz`	`tst_abs rINC,fINC,$ff-fnz`
`2a4a : 08 [ 3]> php ;save flags`	`30a0 : 08 [ 3]> php ;save flags`
`2a4b : ad0302 [ 4]> lda abst`	`30a1 : ad0302 [ 4]> lda abst`
`2a4e : dd3102 [ 4]> cmp rINC,x ;test result`	`30a4 : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2a51 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`30a7 : f002 [ 3]> beq skip2832`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`30a9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`30aa : 23 > db test_num`
`>`	`>`
`2a53 : 68 [ 4]> pla ;load status`	`30ab : >skip2832`
	`>`
	`30ab : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2a54 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`30ac : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2a56 : dd3602 [ 4]> cmp fINC,x ;test flags`	`30ae : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`2a59 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`30b1 : f002 [ 3]> beq skip2835`
`>`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`2a5b : ca [ 2] dex`	`30b3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`2a5c : 300b [ 3] bmi tdec13`	`30b4 : 23 > db test_num`
`2a5e : e001 [ 2] cpx #1`	`>`
`2a60 : d0e1 [ 3] bne tdec12`	`30b5 : >skip2835`
`2a62 : a981 [ 2] lda #$81`	`>`
`2a64 : 8d0302 [ 4] sta abst`
`2a67 : d0da [ 3] bne tdec12`	`30b5 : ca [ 2] dex`
`2a69 : tdec13`	`30b6 : 300b [ 3] bmi tdec13`
	`30b8 : e001 [ 2] cpx #1`
	`30ba : d0dd [ 3] bne tdec12`
	`30bc : a981 [ 2] lda #$81`
	`30be : 8d0302 [ 4] sta abst`
	`30c1 : d0d6 [ 3] bne tdec12`
	`30c3 : tdec13`
`next_test`	`next_test`
`2a69 : ad0002 [ 4]> lda test_case ;previous test`	`30c3 : ad0002 [ 4]> lda test_case ;previous test`
`2a6c : c923 [ 2]> cmp #test_num`	`30c6 : c923 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`2a6e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`30c8 : f002 [ 3]> beq skip2838`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 319`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`30ca : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`30cb : 23 > db test_num`
	`>`
	`30cc : >skip2838`
`>`	`>`
`0024 = >test_num = test_num + 1`	`0024 = >test_num = test_num + 1`
`2a70 : a924 [ 2]> lda #test_num ;*** this tests' number`	`30cc : a924 [ 2]> lda #test_num ;*** this tests' number`
`2a72 : 8d0002 [ 4]> sta test_case`	`30ce : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; zeropage indexed`	`; zeropage indexed`
`2a75 : a200 [ 2] ldx #0`
`2a77 : a97e [ 2] lda #$7e`
`2a79 : 950c [ 4] tinc4 sta zpt,x`
`set_stat 0`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 207`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`30d1 : a200 [ 2] ldx #0`
	`30d3 : a97e [ 2] lda #$7e`
	`30d5 : 95b2 [ 4] tinc4 sta zpt,x`
	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`2a7b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`30d7 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2a7d : 48 [ 3]> pha ;use stack to load status`	`30d9 : 48 [ 3]> pha ;use stack to load status`
`2a7e : 28 [ 4]> plp`	`30da : 28 [ 4]> plp`

`2a7f : f60c [ 6] inc zpt,x`	`30db : f6b2 [ 6] inc zpt,x`
`tst_zx rINC,fINC,0`	`tst_zx rINC,fINC,0`
`2a81 : 08 [ 3]> php ;save flags`	`30dd : 08 [ 3]> php ;save flags`
`2a82 : b50c [ 4]> lda zpt,x`	`30de : b5b2 [ 4]> lda zpt,x`
`2a84 : dd3102 [ 4]> cmp rINC,x ;test result`	`30e0 : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2a87 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`30e3 : f002 [ 3]> beq skip2843`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`30e5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`30e6 : 24 > db test_num`
	`>`
	`30e7 : >skip2843`
`>`	`>`
`2a89 : 68 [ 4]> pla ;load status`	`30e7 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2a8a : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`30e8 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2a8c : dd3602 [ 4]> cmp fINC,x ;test flags`	`30ea : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`2a8f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`30ed : f002 [ 3]> beq skip2846`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`30ef : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`30f0 : 24 > db test_num`
`>`	`>`
	`30f1 : >skip2846`
	`>`

	`30f1 : b5b2 [ 4] lda zpt,x`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 320`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2a91 : b50c [ 4] lda zpt,x`	`30f3 : e8 [ 2] inx`
`2a93 : e8 [ 2] inx`	`30f4 : e002 [ 2] cpx #2`
`2a94 : e002 [ 2] cpx #2`	`30f6 : d002 [ 3] bne tinc5`
`2a96 : d002 [ 3] bne tinc5`	`30f8 : a9fe [ 2] lda #$fe`
`2a98 : a9fe [ 2] lda #$fe`	`30fa : e005 [ 2] tinc5 cpx #5`
`2a9a : e005 [ 2] tinc5 cpx #5`	`30fc : d0d7 [ 3] bne tinc4`
`2a9c : d0db [ 3] bne tinc4`	`30fe : ca [ 2] dex`
`2a9e : ca [ 2] dex`	`30ff : a902 [ 2] lda #2`
`2a9f : a902 [ 2] lda #2`	`3101 : 95b2 [ 4] tdec4 sta zpt,x`
`2aa1 : 950c [ 4] tdec4 sta zpt,x`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`2aa3 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`3103 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2aa5 : 48 [ 3]> pha ;use stack to load status`	`3105 : 48 [ 3]> pha ;use stack to load status`
`2aa6 : 28 [ 4]> plp`	`3106 : 28 [ 4]> plp`

`2aa7 : d60c [ 6] dec zpt,x`	`3107 : d6b2 [ 6] dec zpt,x`
`tst_zx rINC,fINC,0`	`tst_zx rINC,fINC,0`
`2aa9 : 08 [ 3]> php ;save flags`	`3109 : 08 [ 3]> php ;save flags`
`2aaa : b50c [ 4]> lda zpt,x`	`310a : b5b2 [ 4]> lda zpt,x`
`2aac : dd3102 [ 4]> cmp rINC,x ;test result`	`310c : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2aaf : d0fe [ 3]> bne * ;failed not equal (non zero)`	`310f : f002 [ 3]> beq skip2851`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3111 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3112 : 24 > db test_num`
`>`	`>`
`2ab1 : 68 [ 4]> pla ;load status`	`3113 : >skip2851`
	`>`
	`3113 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2ab2 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`3114 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2ab4 : dd3602 [ 4]> cmp fINC,x ;test flags`	`3116 : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`2ab7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3119 : f002 [ 3]> beq skip2854`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 208`	`> trap ;failed equal (zero)`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`311b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`311c : 24 > db test_num`
`>`	`>`
	`311d : >skip2854`
	`>`

	`311d : b5b2 [ 4] lda zpt,x`
	`311f : ca [ 2] dex`
	`3120 : 3008 [ 3] bmi tdec5`
	`3122 : e001 [ 2] cpx #1`
	`3124 : d0db [ 3] bne tdec4`
	`3126 : a981 [ 2] lda #$81`
	`3128 : d0d7 [ 3] bne tdec4`
	`312a : tdec5`
	`312a : a200 [ 2] ldx #0`
	`312c : a97e [ 2] lda #$7e`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 321`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2ab9 : b50c [ 4] lda zpt,x`	`312e : 95b2 [ 4] tinc14 sta zpt,x`
`2abb : ca [ 2] dex`
`2abc : 3008 [ 3] bmi tdec5`
`2abe : e001 [ 2] cpx #1`
`2ac0 : d0df [ 3] bne tdec4`
`2ac2 : a981 [ 2] lda #$81`
`2ac4 : d0db [ 3] bne tdec4`
`2ac6 : tdec5`
`2ac6 : a200 [ 2] ldx #0`
`2ac8 : a97e [ 2] lda #$7e`
`2aca : 950c [ 4] tinc14 sta zpt,x`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`2acc : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3130 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2ace : 48 [ 3]> pha ;use stack to load status`	`3132 : 48 [ 3]> pha ;use stack to load status`
`2acf : 28 [ 4]> plp`	`3133 : 28 [ 4]> plp`

`2ad0 : f60c [ 6] inc zpt,x`	`3134 : f6b2 [ 6] inc zpt,x`
`tst_zx rINC,fINC,$ff-fnz`	`tst_zx rINC,fINC,$ff-fnz`
`2ad2 : 08 [ 3]> php ;save flags`	`3136 : 08 [ 3]> php ;save flags`
`2ad3 : b50c [ 4]> lda zpt,x`	`3137 : b5b2 [ 4]> lda zpt,x`
`2ad5 : dd3102 [ 4]> cmp rINC,x ;test result`	`3139 : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2ad8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`313c : f002 [ 3]> beq skip2859`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`313e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`313f : 24 > db test_num`
`>`	`>`
`2ada : 68 [ 4]> pla ;load status`	`3140 : >skip2859`
	`>`
	`3140 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2adb : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`3141 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2add : dd3602 [ 4]> cmp fINC,x ;test flags`	`3143 : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`2ae0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3146 : f002 [ 3]> beq skip2862`
`>`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`2ae2 : b50c [ 4] lda zpt,x`	`3148 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`2ae4 : e8 [ 2] inx`	`3149 : 24 > db test_num`
`2ae5 : e002 [ 2] cpx #2`	`>`
`2ae7 : d002 [ 3] bne tinc15`	`314a : >skip2862`
`2ae9 : a9fe [ 2] lda #$fe`	`>`
`2aeb : e005 [ 2] tinc15 cpx #5`
`2aed : d0db [ 3] bne tinc14`	`314a : b5b2 [ 4] lda zpt,x`
`2aef : ca [ 2] dex`	`314c : e8 [ 2] inx`
`2af0 : a902 [ 2] lda #2`	`314d : e002 [ 2] cpx #2`
`2af2 : 950c [ 4] tdec14 sta zpt,x`	`314f : d002 [ 3] bne tinc15`
	`3151 : a9fe [ 2] lda #$fe`
	`3153 : e005 [ 2] tinc15 cpx #5`
	`3155 : d0d7 [ 3] bne tinc14`
	`3157 : ca [ 2] dex`
	`3158 : a902 [ 2] lda #2`
	`315a : 95b2 [ 4] tdec14 sta zpt,x`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`2af4 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`315c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2af6 : 48 [ 3]> pha ;use stack to load status`	`315e : 48 [ 3]> pha ;use stack to load status`
`2af7 : 28 [ 4]> plp`	`315f : 28 [ 4]> plp`

`2af8 : d60c [ 6] dec zpt,x`	`3160 : d6b2 [ 6] dec zpt,x`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 209`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 322`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`tst_zx rINC,fINC,$ff-fnz`	`tst_zx rINC,fINC,$ff-fnz`
`2afa : 08 [ 3]> php ;save flags`	`3162 : 08 [ 3]> php ;save flags`
`2afb : b50c [ 4]> lda zpt,x`	`3163 : b5b2 [ 4]> lda zpt,x`
`2afd : dd3102 [ 4]> cmp rINC,x ;test result`	`3165 : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2b00 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3168 : f002 [ 3]> beq skip2867`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`316a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`316b : 24 > db test_num`
	`>`
	`316c : >skip2867`
`>`	`>`
`2b02 : 68 [ 4]> pla ;load status`	`316c : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2b03 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`316d : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2b05 : dd3602 [ 4]> cmp fINC,x ;test flags`	`316f : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`2b08 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3172 : f002 [ 3]> beq skip2870`
`>`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`2b0a : b50c [ 4] lda zpt,x`	`3174 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`2b0c : ca [ 2] dex`	`3175 : 24 > db test_num`
`2b0d : 3008 [ 3] bmi tdec15`	`>`
`2b0f : e001 [ 2] cpx #1`	`3176 : >skip2870`
`2b11 : d0df [ 4] bne tdec14`	`>`
`2b13 : a981 [ 2] lda #$81`
`2b15 : d0db [ 4] bne tdec14`	`3176 : b5b2 [ 4] lda zpt,x`
`2b17 : tdec15`	`3178 : ca [ 2] dex`
	`3179 : 3008 [ 3] bmi tdec15`
	`317b : e001 [ 2] cpx #1`
	`317d : d0db [ 3] bne tdec14`
	`317f : a981 [ 2] lda #$81`
	`3181 : d0d7 [ 3] bne tdec14`
	`3183 : tdec15`
`next_test`	`next_test`
`2b17 : ad0002 [ 4]> lda test_case ;previous test`	`3183 : ad0002 [ 4]> lda test_case ;previous test`
`2b1a : c924 [ 2]> cmp #test_num`	`3186 : c924 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`2b1c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3188 : f002 [ 3]> beq skip2873`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`318a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`318b : 24 > db test_num`
	`>`
	`318c : >skip2873`
`>`	`>`
`0025 = >test_num = test_num + 1`	`0025 = >test_num = test_num + 1`
`2b1e : a925 [ 2]> lda #test_num ;*** this tests' number`	`318c : a925 [ 2]> lda #test_num ;*** this tests' number`
`2b20 : 8d0002 [ 4]> sta test_case`	`318e : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; memory indexed`	`; memory indexed`
`2b23 : a200 [ 2] ldx #0`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 323`
`2b25 : a97e [ 2] lda #$7e`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`2b27 : 9d0302 [ 5] tinc6 sta abst,x`

	`3191 : a200 [ 2] ldx #0`
	`3193 : a97e [ 2] lda #$7e`
	`3195 : 9d0302 [ 5] tinc6 sta abst,x`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`2b2a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`3198 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2b2c : 48 [ 3]> pha ;use stack to load status`	`319a : 48 [ 3]> pha ;use stack to load status`
`2b2d : 28 [ 4]> plp`	`319b : 28 [ 4]> plp`

`2b2e : fe0302 [ 6] inc abst,x`	`319c : fe0302 [ 7] inc abst,x`
`tst_absx rINC,fINC,0`	`tst_absx rINC,fINC,0`
`2b31 : 08 [ 3]> php ;save flags`	`319f : 08 [ 3]> php ;save flags`
`2b32 : bd0302 [ 4]> lda abst,x`	`31a0 : bd0302 [ 4]> lda abst,x`
`2b35 : dd3102 [ 4]> cmp rINC,x ;test result`	`31a3 : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2b38 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`31a6 : f002 [ 3]> beq skip2878`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`31a8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`31a9 : 25 > db test_num`
`>`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 210`	`31aa : >skip2878`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`>`
	`31aa : 68 [ 4]> pla ;load status`
`2b3a : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2b3b : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`31ab : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2b3d : dd3602 [ 4]> cmp fINC,x ;test flags`	`31ad : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`2b40 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`31b0 : f002 [ 3]> beq skip2881`
`>`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`2b42 : bd0302 [ 4] lda abst,x`	`31b2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`2b45 : e8 [ 2] inx`	`31b3 : 25 > db test_num`
`2b46 : e002 [ 2] cpx #2`	`>`
`2b48 : d002 [ 3] bne tinc7`	`31b4 : >skip2881`
`2b4a : a9fe [ 2] lda #$fe`	`>`
`2b4c : e005 [ 2] tinc7 cpx #5`
`2b4e : d0d7 [ 3] bne tinc6`	`31b4 : bd0302 [ 4] lda abst,x`
`2b50 : ca [ 2] dex`	`31b7 : e8 [ 2] inx`
`2b51 : a902 [ 2] lda #2`	`31b8 : e002 [ 2] cpx #2`
`2b53 : 9d0302 [ 5] tdec6 sta abst,x`	`31ba : d002 [ 3] bne tinc7`
	`31bc : a9fe [ 2] lda #$fe`
	`31be : e005 [ 2] tinc7 cpx #5`
	`31c0 : d0d3 [ 3] bne tinc6`
	`31c2 : ca [ 2] dex`
	`31c3 : a902 [ 2] lda #2`
	`31c5 : 9d0302 [ 5] tdec6 sta abst,x`
`set_stat 0`	`set_stat 0`
`> load_flag 0`	`> load_flag 0`
`2b56 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`31c8 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2b58 : 48 [ 3]> pha ;use stack to load status`	`31ca : 48 [ 3]> pha ;use stack to load status`
`2b59 : 28 [ 4]> plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 324`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2b5a : de0302 [ 6] dec abst,x`	`31cb : 28 [ 4]> plp`

	`31cc : de0302 [ 7] dec abst,x`
`tst_absx rINC,fINC,0`	`tst_absx rINC,fINC,0`
`2b5d : 08 [ 3]> php ;save flags`	`31cf : 08 [ 3]> php ;save flags`
`2b5e : bd0302 [ 4]> lda abst,x`	`31d0 : bd0302 [ 4]> lda abst,x`
`2b61 : dd3102 [ 4]> cmp rINC,x ;test result`	`31d3 : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2b64 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`31d6 : f002 [ 3]> beq skip2886`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`31d8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`31d9 : 25 > db test_num`
`>`	`>`
`2b66 : 68 [ 4]> pla ;load status`	`31da : >skip2886`
	`>`
	`31da : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2b67 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`31db : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2b69 : dd3602 [ 4]> cmp fINC,x ;test flags`	`31dd : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`2b6c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`31e0 : f002 [ 3]> beq skip2889`
`>`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`2b6e : bd0302 [ 4] lda abst,x`	`31e2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`2b71 : ca [ 2] dex`	`31e3 : 25 > db test_num`
`2b72 : 3008 [ 3] bmi tdec7`	`>`
`2b74 : e001 [ 2] cpx #1`	`31e4 : >skip2889`
`2b76 : d0db [ 3] bne tdec6`	`>`
`2b78 : a981 [ 2] lda #$81`
`2b7a : d0d7 [ 3] bne tdec6`	`31e4 : bd0302 [ 4] lda abst,x`
`2b7c : tdec7`	`31e7 : ca [ 2] dex`
`2b7c : a200 [ 2] ldx #0`	`31e8 : 3008 [ 3] bmi tdec7`
`2b7e : a97e [ 2] lda #$7e`	`31ea : e001 [ 2] cpx #1`
`2b80 : 9d0302 [ 5] tinc16 sta abst,x`	`31ec : d0d7 [ 3] bne tdec6`
	`31ee : a981 [ 2] lda #$81`
	`31f0 : d0d3 [ 3] bne tdec6`
	`31f2 : tdec7`
	`31f2 : a200 [ 2] ldx #0`
	`31f4 : a97e [ 2] lda #$7e`
	`31f6 : 9d0302 [ 5] tinc16 sta abst,x`
`set_stat $ff`	`set_stat $ff`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 211`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag $ff`	`> load_flag $ff`
`2b83 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`31f9 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2b85 : 48 [ 3]> pha ;use stack to load status`	`31fb : 48 [ 3]> pha ;use stack to load status`
`2b86 : 28 [ 4]> plp`	`31fc : 28 [ 4]> plp`

`2b87 : fe0302 [ 6] inc abst,x`	`31fd : fe0302 [ 7] inc abst,x`
`tst_absx rINC,fINC,$ff-fnz`	`tst_absx rINC,fINC,$ff-fnz`
`2b8a : 08 [ 3]> php ;save flags`	`3200 : 08 [ 3]> php ;save flags`
`2b8b : bd0302 [ 4]> lda abst,x`	`3201 : bd0302 [ 4]> lda abst,x`
`2b8e : dd3102 [ 4]> cmp rINC,x ;test result`	`3204 : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2b91 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 325`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3207 : f002 [ 3]> beq skip2894`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3209 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`320a : 25 > db test_num`
`>`	`>`
`2b93 : 68 [ 4]> pla ;load status`	`320b : >skip2894`
	`>`
	`320b : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2b94 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`320c : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2b96 : dd3602 [ 4]> cmp fINC,x ;test flags`	`320e : dd3602 [ 4]> cmp fINC,x ;test flags`
`> trap_ne`	`> trap_ne`
`2b99 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3211 : f002 [ 3]> beq skip2897`
`>`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`2b9b : bd0302 [ 4] lda abst,x`	`3213 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`2b9e : e8 [ 2] inx`	`3214 : 25 > db test_num`
`2b9f : e002 [ 2] cpx #2`	`>`
`2ba1 : d002 [ 3] bne tinc17`	`3215 : >skip2897`
`2ba3 : a9fe [ 2] lda #$fe`	`>`
`2ba5 : e005 [ 2] tinc17 cpx #5`
`2ba7 : d0d7 [ 3] bne tinc16`	`3215 : bd0302 [ 4] lda abst,x`
`2ba9 : ca [ 2] dex`	`3218 : e8 [ 2] inx`
`2baa : a902 [ 2] lda #2`	`3219 : e002 [ 2] cpx #2`
`2bac : 9d0302 [ 5] tdec16 sta abst,x`	`321b : d002 [ 3] bne tinc17`
	`321d : a9fe [ 2] lda #$fe`
	`321f : e005 [ 2] tinc17 cpx #5`
	`3221 : d0d3 [ 4] bne tinc16`
	`3223 : ca [ 2] dex`
	`3224 : a902 [ 2] lda #2`
	`3226 : 9d0302 [ 5] tdec16 sta abst,x`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`2baf : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3229 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2bb1 : 48 [ 3]> pha ;use stack to load status`	`322b : 48 [ 3]> pha ;use stack to load status`
`2bb2 : 28 [ 4]> plp`	`322c : 28 [ 4]> plp`

`2bb3 : de0302 [ 6] dec abst,x`	`322d : de0302 [ 7] dec abst,x`
`tst_absx rINC,fINC,$ff-fnz`	`tst_absx rINC,fINC,$ff-fnz`
`2bb6 : 08 [ 3]> php ;save flags`	`3230 : 08 [ 3]> php ;save flags`
`2bb7 : bd0302 [ 4]> lda abst,x`	`3231 : bd0302 [ 4]> lda abst,x`
`2bba : dd3102 [ 4]> cmp rINC,x ;test result`	`3234 : dd3102 [ 4]> cmp rINC,x ;test result`
`> trap_ne`	`> trap_ne`
`2bbd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3237 : f002 [ 3]> beq skip2902`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3239 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`323a : 25 > db test_num`
`>`	`>`
`2bbf : 68 [ 4]> pla ;load status`	`323b : >skip2902`
`> eor_flag $ff-fnz`
`2bc0 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2bc2 : dd3602 [ 4]> cmp fINC,x ;test flags`	`323b : 68 [ 4]> pla ;load status`
`> trap_ne`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 326`
`2bc5 : d0fe [ 3]> bne * ;failed not equal (non zero)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 212`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> eor_flag $ff-fnz`
	`323c : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
	`323e : dd3602 [ 4]> cmp fINC,x ;test flags`
`2bc7 : bd0302 [ 4] lda abst,x`	`> trap_ne`
`2bca : ca [ 2] dex`	`3241 : f002 [ 3]> beq skip2905`
`2bcb : 3008 [ 3] bmi tdec17`	`> trap ;failed equal (zero)`
`2bcd : e001 [ 2] cpx #1`	`>; db $db ; M65C02/M65C02A SToP instruction`
`2bcf : d0db [ 3] bne tdec16`	`3243 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`2bd1 : a981 [ 2] lda #$81`	`3244 : 25 > db test_num`
`2bd3 : d0d7 [ 3] bne tdec16`	`>`
`2bd5 : tdec17`	`3245 : >skip2905`
	`>`

	`3245 : bd0302 [ 4] lda abst,x`
	`3248 : ca [ 2] dex`
	`3249 : 3008 [ 3] bmi tdec17`
	`324b : e001 [ 2] cpx #1`
	`324d : d0d7 [ 3] bne tdec16`
	`324f : a981 [ 2] lda #$81`
	`3251 : d0d3 [ 3] bne tdec16`
	`3253 : tdec17`
`next_test`	`next_test`
`2bd5 : ad0002 [ 4]> lda test_case ;previous test`	`3253 : ad0002 [ 4]> lda test_case ;previous test`
`2bd8 : c925 [ 2]> cmp #test_num`	`3256 : c925 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`2bda : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3258 : f002 [ 3]> beq skip2908`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`325a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`325b : 25 > db test_num`
	`>`
	`325c : >skip2908`
`>`	`>`
`0026 = >test_num = test_num + 1`	`0026 = >test_num = test_num + 1`
`2bdc : a926 [ 2]> lda #test_num ;*** this tests' number`	`325c : a926 [ 2]> lda #test_num ;*** this tests' number`
`2bde : 8d0002 [ 4]> sta test_case`	`325e : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; testing logical instructions - AND EOR ORA all addressing modes`	`; testing logical instructions - AND EOR ORA all addressing modes`
`; AND`	`; AND`
`2be1 : a203 [ 2] ldx #3 ;immediate - self modifying code`
`2be3 : b51c [ 4] tand lda zpAN,x`	`3261 : a203 [ 2] ldx #3 ;immediate - self modifying code`
`2be5 : 8df02b [ 4] sta tandi1`	`3263 : b5c2 [ 4] tand lda zpAN,x`
	`3265 : 8d7032 [ 4] sta tandi1`
`set_ax absANa,0`	`set_ax absANa,0`
`> load_flag 0`	`> load_flag 0`
`2be8 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`3268 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2bea : 48 [ 3]> pha ;use stack to load status`	`326a : 48 [ 3]> pha ;use stack to load status`
`2beb : bd4b02 [ 4]> lda absANa,x ;precharge accu`	`326b : bd4b02 [ 4]> lda absANa,x ;precharge accu`
`2bee : 28 [ 4]> plp`	`326e : 28 [ 4]> plp`

	`3270 = tandi1 equ *+1 ;target for immediate operand`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 327`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2bf0 = tandi1 equ *+1 ;target for immediate operand`	`326f : 2963 [ 2] and #99`
`2bef : 2963 [ 2] and #99`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`2bf1 : 08 [ 3]> php ;save flags`	`3271 : 08 [ 3]> php ;save flags`
`2bf2 : dd5302 [ 4]> cmp absrlo,x ;test result`	`3272 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2bf5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3275 : f002 [ 3]> beq skip2913`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3277 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3278 : 26 > db test_num`
`>`	`>`
`2bf7 : 68 [ 4]> pla ;load status`	`3279 : >skip2913`
	`>`
	`3279 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2bf8 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`327a : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2bfa : dd5702 [ 4]> cmp absflo,x ;test flags`	`327c : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2bfd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`327f : f002 [ 3]> beq skip2916`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3281 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3282 : 26 > db test_num`
	`>`
	`3283 : >skip2916`
`>`	`>`

`2bff : ca [ 2] dex`	`3283 : ca [ 2] dex`
`2c00 : 10e1 [ 4] bpl tand`	`3284 : 10dd [ 3] bpl tand`
`2c02 : a203 [ 2] ldx #3`	`3286 : a203 [ 2] ldx #3`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 213`	`3288 : b5c2 [ 4] tand1 lda zpAN,x`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`328a : 8d9532 [ 4] sta tandi2`

`2c04 : b51c [ 4] tand1 lda zpAN,x`
`2c06 : 8d112c [ 4] sta tandi2`
`set_ax absANa,$ff`	`set_ax absANa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2c09 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`328d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2c0b : 48 [ 3]> pha ;use stack to load status`	`328f : 48 [ 3]> pha ;use stack to load status`
`2c0c : bd4b02 [ 4]> lda absANa,x ;precharge accu`	`3290 : bd4b02 [ 4]> lda absANa,x ;precharge accu`
`2c0f : 28 [ 4]> plp`	`3293 : 28 [ 4]> plp`

`2c11 = tandi2 equ *+1 ;target for immediate operand`	`3295 = tandi2 equ *+1 ;target for immediate operand`
`2c10 : 2963 [ 2] and #99`	`3294 : 2963 [ 2] and #99`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`2c12 : 08 [ 3]> php ;save flags`	`3296 : 08 [ 3]> php ;save flags`
`2c13 : dd5302 [ 4]> cmp absrlo,x ;test result`	`3297 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2c16 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`329a : f002 [ 3]> beq skip2921`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`329c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`329d : 26 > db test_num`
	`>`
	`329e : >skip2921`
`>`	`>`
`2c18 : 68 [ 4]> pla ;load status`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 328`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`329e : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2c19 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`329f : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2c1b : dd5702 [ 4]> cmp absflo,x ;test flags`	`32a1 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2c1e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`32a4 : f002 [ 3]> beq skip2924`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`32a6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`32a7 : 26 > db test_num`
	`>`
	`32a8 : >skip2924`
`>`	`>`

`2c20 : ca [ 2] dex`	`32a8 : ca [ 2] dex`
`2c21 : 10e1 [ 3] bpl tand1`	`32a9 : 10dd [ 3] bpl tand1`

`2c23 : a203 [ 2] ldx #3 ;zp`	`32ab : a203 [ 2] ldx #3 ;zp`
`2c25 : b51c [ 4] tand2 lda zpAN,x`	`32ad : b5c2 [ 4] tand2 lda zpAN,x`
`2c27 : 850c [ 3] sta zpt`	`32af : 85b2 [ 3] sta zpt`
`set_ax absANa,0`	`set_ax absANa,0`
`> load_flag 0`	`> load_flag 0`
`2c29 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`32b1 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2c2b : 48 [ 3]> pha ;use stack to load status`	`32b3 : 48 [ 3]> pha ;use stack to load status`
`2c2c : bd4b02 [ 4]> lda absANa,x ;precharge accu`	`32b4 : bd4b02 [ 4]> lda absANa,x ;precharge accu`
`2c2f : 28 [ 4]> plp`	`32b7 : 28 [ 4]> plp`

`2c30 : 250c [ 3] and zpt`	`32b8 : 25b2 [ 3] and zpt`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`2c32 : 08 [ 3]> php ;save flags`	`32ba : 08 [ 3]> php ;save flags`
`2c33 : dd5302 [ 4]> cmp absrlo,x ;test result`	`32bb : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2c36 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`32be : f002 [ 3]> beq skip2929`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`32c0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`32c1 : 26 > db test_num`
	`>`
	`32c2 : >skip2929`
`>`	`>`
`2c38 : 68 [ 4]> pla ;load status`	`32c2 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2c39 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`32c3 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2c3b : dd5702 [ 4]> cmp absflo,x ;test flags`	`32c5 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2c3e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`32c8 : f002 [ 3]> beq skip2932`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 214`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`32ca : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`32cb : 26 > db test_num`
	`>`
	`32cc : >skip2932`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 329`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`

`2c40 : ca [ 2] dex`	`32cc : ca [ 2] dex`
`2c41 : 10e2 [ 3] bpl tand2`	`32cd : 10de [ 3] bpl tand2`
`2c43 : a203 [ 2] ldx #3`	`32cf : a203 [ 2] ldx #3`
`2c45 : b51c [ 4] tand3 lda zpAN,x`	`32d1 : b5c2 [ 4] tand3 lda zpAN,x`
`2c47 : 850c [ 3] sta zpt`	`32d3 : 85b2 [ 3] sta zpt`
`set_ax absANa,$ff`	`set_ax absANa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2c49 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`32d5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2c4b : 48 [ 3]> pha ;use stack to load status`	`32d7 : 48 [ 3]> pha ;use stack to load status`
`2c4c : bd4b02 [ 4]> lda absANa,x ;precharge accu`	`32d8 : bd4b02 [ 4]> lda absANa,x ;precharge accu`
`2c4f : 28 [ 4]> plp`	`32db : 28 [ 4]> plp`

`2c50 : 250c [ 3] and zpt`	`32dc : 25b2 [ 3] and zpt`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`2c52 : 08 [ 3]> php ;save flags`	`32de : 08 [ 3]> php ;save flags`
`2c53 : dd5302 [ 4]> cmp absrlo,x ;test result`	`32df : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2c56 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`32e2 : f002 [ 3]> beq skip2937`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`32e4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`32e5 : 26 > db test_num`
`>`	`>`
`2c58 : 68 [ 4]> pla ;load status`	`32e6 : >skip2937`
	`>`
	`32e6 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2c59 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`32e7 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2c5b : dd5702 [ 4]> cmp absflo,x ;test flags`	`32e9 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2c5e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`32ec : f002 [ 3]> beq skip2940`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`32ee : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`32ef : 26 > db test_num`
	`>`
	`32f0 : >skip2940`
`>`	`>`

`2c60 : ca [ 2] dex`	`32f0 : ca [ 2] dex`
`2c61 : 10e2 [ 3] bpl tand3`	`32f1 : 10de [ 3] bpl tand3`

`2c63 : a203 [ 2] ldx #3 ;abs`	`32f3 : a203 [ 2] ldx #3 ;abs`
`2c65 : b51c [ 4] tand4 lda zpAN,x`	`32f5 : b5c2 [ 4] tand4 lda zpAN,x`
`2c67 : 8d0302 [ 4] sta abst`	`32f7 : 8d0302 [ 4] sta abst`
`set_ax absANa,0`	`set_ax absANa,0`
`> load_flag 0`	`> load_flag 0`
`2c6a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`32fa : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2c6c : 48 [ 3]> pha ;use stack to load status`	`32fc : 48 [ 3]> pha ;use stack to load status`
`2c6d : bd4b02 [ 4]> lda absANa,x ;precharge accu`	`32fd : bd4b02 [ 4]> lda absANa,x ;precharge accu`
`2c70 : 28 [ 4]> plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 330`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3300 : 28 [ 4]> plp`

`2c71 : 2d0302 [ 4] and abst`	`3301 : 2d0302 [ 4] and abst`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`2c74 : 08 [ 3]> php ;save flags`	`3304 : 08 [ 3]> php ;save flags`
`2c75 : dd5302 [ 4]> cmp absrlo,x ;test result`	`3305 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2c78 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3308 : f002 [ 3]> beq skip2945`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`330a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`330b : 26 > db test_num`
`>`	`>`
`2c7a : 68 [ 4]> pla ;load status`	`330c : >skip2945`
	`>`
	`330c : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2c7b : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`330d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 215`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`2c7d : dd5702 [ 4]> cmp absflo,x ;test flags`	`330f : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2c80 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3312 : f002 [ 3]> beq skip2948`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3314 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3315 : 26 > db test_num`
	`>`
	`3316 : >skip2948`
`>`	`>`

`2c82 : ca [ 2] dex`	`3316 : ca [ 2] dex`
`2c83 : 10e0 [ 3] bpl tand4`	`3317 : 10dc [ 4] bpl tand4`
`2c85 : a203 [ 2] ldx #3`	`3319 : a203 [ 2] ldx #3`
`2c87 : b51c [ 4] tand5 lda zpAN,x`	`331b : b5c2 [ 4] tand5 lda zpAN,x`
`2c89 : 8d0302 [ 4] sta abst`	`331d : 8d0302 [ 4] sta abst`
`set_ax absANa,$ff`	`set_ax absANa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2c8c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3320 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2c8e : 48 [ 3]> pha ;use stack to load status`	`3322 : 48 [ 3]> pha ;use stack to load status`
`2c8f : bd4b02 [ 4]> lda absANa,x ;precharge accu`	`3323 : bd4b02 [ 4]> lda absANa,x ;precharge accu`
`2c92 : 28 [ 4]> plp`	`3326 : 28 [ 4]> plp`

`2c93 : 2d0302 [ 4] and abst`	`3327 : 2d0302 [ 4] and abst`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`2c96 : 08 [ 3]> php ;save flags`	`332a : 08 [ 3]> php ;save flags`
`2c97 : dd5302 [ 4]> cmp absrlo,x ;test result`	`332b : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2c9a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`332e : f002 [ 3]> beq skip2953`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3330 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3331 : 26 > db test_num`
`>`	`>`
`2c9c : 68 [ 4]> pla ;load status`	`3332 : >skip2953`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 331`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>`
	`3332 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2c9d : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`3333 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2c9f : dd5702 [ 4]> cmp absflo,x ;test flags`	`3335 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2ca2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3338 : f002 [ 3]> beq skip2956`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`333a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`333b : 26 > db test_num`
	`>`
	`333c : >skip2956`
`>`	`>`

`2ca4 : ca [ 2] dex`	`333c : ca [ 2] dex`
`2ca5 : 1002 [ 3] bpl tand6`	`333d : 1002 [ 3] bpl tand6`

`2ca7 : a203 [ 2] ldx #3 ;zp,x`	`333f : a203 [ 2] ldx #3 ;zp,x`
`2ca9 : tand6`	`3341 : tand6`
`set_ax absANa,0`	`set_ax absANa,0`
`> load_flag 0`	`> load_flag 0`
`2ca9 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`3341 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2cab : 48 [ 3]> pha ;use stack to load status`	`3343 : 48 [ 3]> pha ;use stack to load status`
`2cac : bd4b02 [ 4]> lda absANa,x ;precharge accu`	`3344 : bd4b02 [ 4]> lda absANa,x ;precharge accu`
`2caf : 28 [ 4]> plp`	`3347 : 28 [ 4]> plp`

`2cb0 : 351c [ 4] and zpAN,x`	`3348 : 35c2 [ 4] and zpAN,x`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`2cb2 : 08 [ 3]> php ;save flags`	`334a : 08 [ 3]> php ;save flags`
`2cb3 : dd5302 [ 4]> cmp absrlo,x ;test result`	`334b : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2cb6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`334e : f002 [ 3]> beq skip2961`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3350 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3351 : 26 > db test_num`
`>`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 216`	`3352 : >skip2961`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`>`
	`3352 : 68 [ 4]> pla ;load status`
`2cb8 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2cb9 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`3353 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2cbb : dd5702 [ 4]> cmp absflo,x ;test flags`	`3355 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2cbe : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3358 : f002 [ 3]> beq skip2964`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`335a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`335b : 26 > db test_num`
	`>`
	`335c : >skip2964`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 332`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`

`2cc0 : ca [ 2] dex`	`335c : ca [ 2] dex`
`2cc1 : 10e6 [ 3] bpl tand6`	`335d : 10e2 [ 3] bpl tand6`
`2cc3 : a203 [ 2] ldx #3`	`335f : a203 [ 2] ldx #3`
`2cc5 : tand7`	`3361 : tand7`
`set_ax absANa,$ff`	`set_ax absANa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2cc5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3361 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2cc7 : 48 [ 3]> pha ;use stack to load status`	`3363 : 48 [ 3]> pha ;use stack to load status`
`2cc8 : bd4b02 [ 4]> lda absANa,x ;precharge accu`	`3364 : bd4b02 [ 4]> lda absANa,x ;precharge accu`
`2ccb : 28 [ 4]> plp`	`3367 : 28 [ 4]> plp`

`2ccc : 351c [ 4] and zpAN,x`	`3368 : 35c2 [ 4] and zpAN,x`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`2cce : 08 [ 3]> php ;save flags`	`336a : 08 [ 3]> php ;save flags`
`2ccf : dd5302 [ 4]> cmp absrlo,x ;test result`	`336b : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2cd2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`336e : f002 [ 3]> beq skip2969`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3370 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3371 : 26 > db test_num`
	`>`
	`3372 : >skip2969`
`>`	`>`
`2cd4 : 68 [ 4]> pla ;load status`	`3372 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2cd5 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`3373 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2cd7 : dd5702 [ 4]> cmp absflo,x ;test flags`	`3375 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2cda : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3378 : f002 [ 3]> beq skip2972`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`337a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`337b : 26 > db test_num`
	`>`
	`337c : >skip2972`
`>`	`>`

`2cdc : ca [ 2] dex`	`337c : ca [ 2] dex`
`2cdd : 10e6 [ 3] bpl tand7`	`337d : 10e2 [ 3] bpl tand7`

`2cdf : a203 [ 2] ldx #3 ;abs,x`	`337f : a203 [ 2] ldx #3 ;abs,x`
`2ce1 : tand8`	`3381 : tand8`
`set_ax absANa,0`	`set_ax absANa,0`
`> load_flag 0`	`> load_flag 0`
`2ce1 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`3381 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2ce3 : 48 [ 3]> pha ;use stack to load status`	`3383 : 48 [ 3]> pha ;use stack to load status`
`2ce4 : bd4b02 [ 4]> lda absANa,x ;precharge accu`	`3384 : bd4b02 [ 4]> lda absANa,x ;precharge accu`
`2ce7 : 28 [ 4]> plp`	`3387 : 28 [ 4]> plp`

`2ce8 : 3d3f02 [ 4] and absAN,x`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 333`
`tst_ax absrlo,absflo,0`
`2ceb : 08 [ 3]> php ;save flags`
`2cec : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 217`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2cef : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3388 : 3d3f02 [ 4] and absAN,x`
	`tst_ax absrlo,absflo,0`
	`338b : 08 [ 3]> php ;save flags`
	`338c : dd5302 [ 4]> cmp absrlo,x ;test result`
	`> trap_ne`
	`338f : f002 [ 3]> beq skip2977`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3391 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3392 : 26 > db test_num`
`>`	`>`
`2cf1 : 68 [ 4]> pla ;load status`	`3393 : >skip2977`
	`>`
	`3393 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2cf2 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`3394 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2cf4 : dd5702 [ 4]> cmp absflo,x ;test flags`	`3396 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2cf7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3399 : f002 [ 3]> beq skip2980`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`339b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`339c : 26 > db test_num`
	`>`
	`339d : >skip2980`
`>`	`>`

`2cf9 : ca [ 2] dex`	`339d : ca [ 2] dex`
`2cfa : 10e5 [ 3] bpl tand8`	`339e : 10e1 [ 3] bpl tand8`
`2cfc : a203 [ 2] ldx #3`	`33a0 : a203 [ 2] ldx #3`
`2cfe : tand9`	`33a2 : tand9`
`set_ax absANa,$ff`	`set_ax absANa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2cfe : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`33a2 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2d00 : 48 [ 3]> pha ;use stack to load status`	`33a4 : 48 [ 3]> pha ;use stack to load status`
`2d01 : bd4b02 [ 4]> lda absANa,x ;precharge accu`	`33a5 : bd4b02 [ 4]> lda absANa,x ;precharge accu`
`2d04 : 28 [ 4]> plp`	`33a8 : 28 [ 4]> plp`

`2d05 : 3d3f02 [ 4] and absAN,x`	`33a9 : 3d3f02 [ 4] and absAN,x`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`2d08 : 08 [ 3]> php ;save flags`	`33ac : 08 [ 3]> php ;save flags`
`2d09 : dd5302 [ 4]> cmp absrlo,x ;test result`	`33ad : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2d0c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`33b0 : f002 [ 3]> beq skip2985`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`33b2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`33b3 : 26 > db test_num`
	`>`
	`33b4 : >skip2985`
`>`	`>`
`2d0e : 68 [ 4]> pla ;load status`	`33b4 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2d0f : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 334`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`33b5 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2d11 : dd5702 [ 4]> cmp absflo,x ;test flags`	`33b7 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2d14 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`33ba : f002 [ 3]> beq skip2988`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`33bc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`33bd : 26 > db test_num`
	`>`
	`33be : >skip2988`
`>`	`>`

`2d16 : ca [ 2] dex`	`33be : ca [ 2] dex`
`2d17 : 10e5 [ 4] bpl tand9`	`33bf : 10e1 [ 3] bpl tand9`

`2d19 : a003 [ 2] ldy #3 ;abs,y`	`33c1 : a003 [ 2] ldy #3 ;abs,y`
`2d1b : tand10`	`33c3 : tand10`
`set_ay absANa,0`	`set_ay absANa,0`
`> load_flag 0`	`> load_flag 0`
`2d1b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`33c3 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2d1d : 48 [ 3]> pha ;use stack to load status`	`33c5 : 48 [ 3]> pha ;use stack to load status`
`2d1e : b94b02 [ 4]> lda absANa,y ;precharge accu`	`33c6 : b94b02 [ 4]> lda absANa,y ;precharge accu`
`2d21 : 28 [ 4]> plp`	`33c9 : 28 [ 4]> plp`

`2d22 : 393f02 [ 4] and absAN,y`	`33ca : 393f02 [ 4] and absAN,y`
`tst_ay absrlo,absflo,0`	`tst_ay absrlo,absflo,0`
`2d25 : 08 [ 3]> php ;save flags`	`33cd : 08 [ 3]> php ;save flags`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 218`	`33ce : d95302 [ 4]> cmp absrlo,y ;test result`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2d26 : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`2d29 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`33d1 : f002 [ 3]> beq skip2993`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`33d3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`33d4 : 26 > db test_num`
`>`	`>`
`2d2b : 68 [ 4]> pla ;load status`	`33d5 : >skip2993`
	`>`
	`33d5 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2d2c : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`33d6 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2d2e : d95702 [ 4]> cmp absflo,y ;test flags`	`33d8 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`2d31 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`33db : f002 [ 3]> beq skip2996`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`33dd : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`33de : 26 > db test_num`
	`>`
	`33df : >skip2996`
`>`	`>`

`2d33 : 88 [ 2] dey`	`33df : 88 [ 2] dey`
`2d34 : 10e5 [ 3] bpl tand10`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 335`
`2d36 : a003 [ 2] ldy #3`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`2d38 : tand11`
	`33e0 : 10e1 [ 3] bpl tand10`
	`33e2 : a003 [ 2] ldy #3`
	`33e4 : tand11`
`set_ay absANa,$ff`	`set_ay absANa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2d38 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`33e4 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2d3a : 48 [ 3]> pha ;use stack to load status`	`33e6 : 48 [ 3]> pha ;use stack to load status`
`2d3b : b94b02 [ 4]> lda absANa,y ;precharge accu`	`33e7 : b94b02 [ 4]> lda absANa,y ;precharge accu`
`2d3e : 28 [ 4]> plp`	`33ea : 28 [ 4]> plp`

`2d3f : 393f02 [ 4] and absAN,y`	`33eb : 393f02 [ 4] and absAN,y`
`tst_ay absrlo,absflo,$ff-fnz`	`tst_ay absrlo,absflo,$ff-fnz`
`2d42 : 08 [ 3]> php ;save flags`	`33ee : 08 [ 3]> php ;save flags`
`2d43 : d95302 [ 4]> cmp absrlo,y ;test result`	`33ef : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`2d46 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`33f2 : f002 [ 3]> beq skip3001`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`33f4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`33f5 : 26 > db test_num`
`>`	`>`
`2d48 : 68 [ 4]> pla ;load status`	`33f6 : >skip3001`
	`>`
	`33f6 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2d49 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`33f7 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2d4b : d95702 [ 4]> cmp absflo,y ;test flags`	`33f9 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`2d4e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`33fc : f002 [ 4]> beq skip3004`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`33fe : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`33ff : 26 > db test_num`
	`>`
	`3400 : >skip3004`
`>`	`>`

`2d50 : 88 [ 2] dey`	`3400 : 88 [ 2] dey`
`2d51 : 10e5 [ 3] bpl tand11`	`3401 : 10e1 [ 4] bpl tand11`

`2d53 : a206 [ 2] ldx #6 ;(zp,x)`	`3403 : a206 [ 2] ldx #6 ;(zp,x)`
`2d55 : a003 [ 2] ldy #3`	`3405 : a003 [ 2] ldy #3`
`2d57 : tand12`	`3407 : tand12`
`set_ay absANa,0`	`set_ay absANa,0`
`> load_flag 0`	`> load_flag 0`
`2d57 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`3407 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2d59 : 48 [ 3]> pha ;use stack to load status`	`3409 : 48 [ 3]> pha ;use stack to load status`
`2d5a : b94b02 [ 4]> lda absANa,y ;precharge accu`	`340a : b94b02 [ 4]> lda absANa,y ;precharge accu`
`2d5d : 28 [ 4]> plp`	`340d : 28 [ 4]> plp`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 219`	`340e : 21e0 [ 6] and (indAN,x)`
	`tst_ay absrlo,absflo,0`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 336`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2d5e : 213a [ 6] and (indAN,x)`	`3410 : 08 [ 3]> php ;save flags`
`tst_ay absrlo,absflo,0`	`3411 : d95302 [ 4]> cmp absrlo,y ;test result`
`2d60 : 08 [ 3]> php ;save flags`
`2d61 : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`2d64 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3414 : f002 [ 3]> beq skip3009`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3416 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3417 : 26 > db test_num`
	`>`
	`3418 : >skip3009`
`>`	`>`
`2d66 : 68 [ 4]> pla ;load status`	`3418 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2d67 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`3419 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2d69 : d95702 [ 4]> cmp absflo,y ;test flags`	`341b : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`2d6c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`341e : f002 [ 3]> beq skip3012`
`>`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`2d6e : ca [ 2] dex`	`3420 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`2d6f : ca [ 2] dex`	`3421 : 26 > db test_num`
`2d70 : 88 [ 2] dey`	`>`
`2d71 : 10e4 [ 3] bpl tand12`	`3422 : >skip3012`
`2d73 : a206 [ 2] ldx #6`	`>`
`2d75 : a003 [ 2] ldy #3`
`2d77 : tand13`	`3422 : ca [ 2] dex`
	`3423 : ca [ 2] dex`
	`3424 : 88 [ 2] dey`
	`3425 : 10e0 [ 3] bpl tand12`
	`3427 : a206 [ 2] ldx #6`
	`3429 : a003 [ 2] ldy #3`
	`342b : tand13`
`set_ay absANa,$ff`	`set_ay absANa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2d77 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`342b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2d79 : 48 [ 3]> pha ;use stack to load status`	`342d : 48 [ 3]> pha ;use stack to load status`
`2d7a : b94b02 [ 4]> lda absANa,y ;precharge accu`	`342e : b94b02 [ 4]> lda absANa,y ;precharge accu`
`2d7d : 28 [ 4]> plp`	`3431 : 28 [ 4]> plp`

`2d7e : 213a [ 6] and (indAN,x)`	`3432 : 21e0 [ 6] and (indAN,x)`
`tst_ay absrlo,absflo,$ff-fnz`	`tst_ay absrlo,absflo,$ff-fnz`
`2d80 : 08 [ 3]> php ;save flags`	`3434 : 08 [ 3]> php ;save flags`
`2d81 : d95302 [ 4]> cmp absrlo,y ;test result`	`3435 : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`2d84 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3438 : f002 [ 3]> beq skip3017`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`343a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`343b : 26 > db test_num`
	`>`
	`343c : >skip3017`
`>`	`>`
`2d86 : 68 [ 4]> pla ;load status`	`343c : 68 [ 4]> pla ;load status`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 337`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2d87 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`343d : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2d89 : d95702 [ 4]> cmp absflo,y ;test flags`	`343f : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`2d8c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3442 : f002 [ 3]> beq skip3020`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3444 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3445 : 26 > db test_num`
	`>`
	`3446 : >skip3020`
`>`	`>`

`2d8e : ca [ 2] dex`	`3446 : ca [ 2] dex`
`2d8f : ca [ 2] dex`	`3447 : ca [ 2] dex`
`2d90 : 88 [ 2] dey`	`3448 : 88 [ 2] dey`
`2d91 : 10e4 [ 3] bpl tand13`	`3449 : 10e0 [ 3] bpl tand13`

`2d93 : a003 [ 2] ldy #3 ;(zp),y`	`344b : a003 [ 2] ldy #3 ;(zp),y`
`2d95 : tand14`	`344d : tand14`
`set_ay absANa,0`	`set_ay absANa,0`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 220`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag 0`	`> load_flag 0`
`2d95 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`344d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2d97 : 48 [ 3]> pha ;use stack to load status`	`344f : 48 [ 3]> pha ;use stack to load status`
`2d98 : b94b02 [ 4]> lda absANa,y ;precharge accu`	`3450 : b94b02 [ 4]> lda absANa,y ;precharge accu`
`2d9b : 28 [ 4]> plp`	`3453 : 28 [ 4]> plp`

`2d9c : 313a [ 5] and (indAN),y`	`3454 : 31e0 [ 5] and (indAN),y`
`tst_ay absrlo,absflo,0`	`tst_ay absrlo,absflo,0`
`2d9e : 08 [ 3]> php ;save flags`	`3456 : 08 [ 3]> php ;save flags`
`2d9f : d95302 [ 4]> cmp absrlo,y ;test result`	`3457 : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`2da2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`345a : f002 [ 3]> beq skip3025`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`345c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`345d : 26 > db test_num`
`>`	`>`
`2da4 : 68 [ 4]> pla ;load status`	`345e : >skip3025`
	`>`
	`345e : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2da5 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`345f : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2da7 : d95702 [ 4]> cmp absflo,y ;test flags`	`3461 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`2daa : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3464 : f002 [ 3]> beq skip3028`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3466 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3467 : 26 > db test_num`
`>`	`>`
	`3468 : >skip3028`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 338`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2dac : 88 [ 2] dey`	`>`
`2dad : 10e6 [ 3] bpl tand14`
`2daf : a003 [ 2] ldy #3`	`3468 : 88 [ 2] dey`
`2db1 : tand15`	`3469 : 10e2 [ 3] bpl tand14`
	`346b : a003 [ 2] ldy #3`
	`346d : tand15`
`set_ay absANa,$ff`	`set_ay absANa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2db1 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`346d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2db3 : 48 [ 3]> pha ;use stack to load status`	`346f : 48 [ 3]> pha ;use stack to load status`
`2db4 : b94b02 [ 4]> lda absANa,y ;precharge accu`	`3470 : b94b02 [ 4]> lda absANa,y ;precharge accu`
`2db7 : 28 [ 4]> plp`	`3473 : 28 [ 4]> plp`

`2db8 : 313a [ 5] and (indAN),y`	`3474 : 31e0 [ 5] and (indAN),y`
`tst_ay absrlo,absflo,$ff-fnz`	`tst_ay absrlo,absflo,$ff-fnz`
`2dba : 08 [ 3]> php ;save flags`	`3476 : 08 [ 3]> php ;save flags`
`2dbb : d95302 [ 4]> cmp absrlo,y ;test result`	`3477 : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`2dbe : d0fe [ 3]> bne * ;failed not equal (non zero)`	`347a : f002 [ 3]> beq skip3033`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`347c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`347d : 26 > db test_num`
	`>`
	`347e : >skip3033`
`>`	`>`
`2dc0 : 68 [ 4]> pla ;load status`	`347e : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2dc1 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`347f : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2dc3 : d95702 [ 4]> cmp absflo,y ;test flags`	`3481 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`2dc6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3484 : f002 [ 3]> beq skip3036`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3486 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3487 : 26 > db test_num`
	`>`
	`3488 : >skip3036`
`>`	`>`

`2dc8 : 88 [ 2] dey`	`3488 : 88 [ 2] dey`
`2dc9 : 10e6 [ 3] bpl tand15`	`3489 : 10e2 [ 3] bpl tand15`
`next_test`	`next_test`
`2dcb : ad0002 [ 4]> lda test_case ;previous test`	`348b : ad0002 [ 4]> lda test_case ;previous test`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 221`	`348e : c926 [ 2]> cmp #test_num`
	`> trap_ne ;test is out of sequence`
	`3490 : f002 [ 3]> beq skip3039`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3492 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3493 : 26 > db test_num`
	`>`
	`3494 : >skip3039`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 339`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2dce : c926 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`
`2dd0 : d0fe [ 3]> bne * ;failed not equal (non zero)`
`>`	`>`
`0027 = >test_num = test_num + 1`	`0027 = >test_num = test_num + 1`
`2dd2 : a927 [ 2]> lda #test_num ;*** this tests' number`	`3494 : a927 [ 2]> lda #test_num ;*** this tests' number`
`2dd4 : 8d0002 [ 4]> sta test_case`	`3496 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; EOR`	`; EOR`
`2dd7 : a203 [ 2] ldx #3 ;immediate - self modifying code`
`2dd9 : b520 [ 4] teor lda zpEO,x`	`3499 : a203 [ 2] ldx #3 ;immediate - self modifying code`
`2ddb : 8de62d [ 4] sta teori1`	`349b : b5c6 [ 4] teor lda zpEO,x`
	`349d : 8da834 [ 4] sta teori1`
`set_ax absEOa,0`	`set_ax absEOa,0`
`> load_flag 0`	`> load_flag 0`
`2dde : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`34a0 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2de0 : 48 [ 3]> pha ;use stack to load status`	`34a2 : 48 [ 3]> pha ;use stack to load status`
`2de1 : bd4f02 [ 4]> lda absEOa,x ;precharge accu`	`34a3 : bd4f02 [ 4]> lda absEOa,x ;precharge accu`
`2de4 : 28 [ 4]> plp`	`34a6 : 28 [ 4]> plp`

`2de6 = teori1 equ *+1 ;target for immediate operand`	`34a8 = teori1 equ *+1 ;target for immediate operand`
`2de5 : 4963 [ 2] eor #99`	`34a7 : 4963 [ 2] eor #99`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`2de7 : 08 [ 3]> php ;save flags`	`34a9 : 08 [ 3]> php ;save flags`
`2de8 : dd5302 [ 4]> cmp absrlo,x ;test result`	`34aa : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2deb : d0fe [ 3]> bne * ;failed not equal (non zero)`	`34ad : f002 [ 3]> beq skip3044`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`34af : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`34b0 : 27 > db test_num`
	`>`
	`34b1 : >skip3044`
`>`	`>`
`2ded : 68 [ 4]> pla ;load status`	`34b1 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2dee : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`34b2 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2df0 : dd5702 [ 4]> cmp absflo,x ;test flags`	`34b4 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2df3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`34b7 : f002 [ 3]> beq skip3047`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`34b9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`34ba : 27 > db test_num`
	`>`
	`34bb : >skip3047`
`>`	`>`

`2df5 : ca [ 2] dex`	`34bb : ca [ 2] dex`
`2df6 : 10e1 [ 3] bpl teor`	`34bc : 10dd [ 3] bpl teor`
`2df8 : a203 [ 2] ldx #3`	`34be : a203 [ 2] ldx #3`
`2dfa : b520 [ 4] teor1 lda zpEO,x`	`34c0 : b5c6 [ 4] teor1 lda zpEO,x`
`2dfc : 8d072e [ 4] sta teori2`	`34c2 : 8dcd34 [ 4] sta teori2`
`set_ax absEOa,$ff`	`set_ax absEOa,$ff`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 340`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`> load_flag $ff`	`> load_flag $ff`
`2dff : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`34c5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2e01 : 48 [ 3]> pha ;use stack to load status`	`34c7 : 48 [ 3]> pha ;use stack to load status`
`2e02 : bd4f02 [ 4]> lda absEOa,x ;precharge accu`	`34c8 : bd4f02 [ 4]> lda absEOa,x ;precharge accu`
`2e05 : 28 [ 4]> plp`	`34cb : 28 [ 4]> plp`

`2e07 = teori2 equ *+1 ;target for immediate operand`	`34cd = teori2 equ *+1 ;target for immediate operand`
`2e06 : 4963 [ 2] eor #99`	`34cc : 4963 [ 2] eor #99`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 222`	`34ce : 08 [ 3]> php ;save flags`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`34cf : dd5302 [ 4]> cmp absrlo,x ;test result`

`2e08 : 08 [ 3]> php ;save flags`
`2e09 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2e0c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`34d2 : f002 [ 3]> beq skip3052`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`34d4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`34d5 : 27 > db test_num`
	`>`
	`34d6 : >skip3052`
`>`	`>`
`2e0e : 68 [ 4]> pla ;load status`	`34d6 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2e0f : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`34d7 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2e11 : dd5702 [ 4]> cmp absflo,x ;test flags`	`34d9 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2e14 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`34dc : f002 [ 3]> beq skip3055`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`34de : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`34df : 27 > db test_num`
	`>`
	`34e0 : >skip3055`
`>`	`>`

`2e16 : ca [ 2] dex`	`34e0 : ca [ 2] dex`
`2e17 : 10e1 [ 4] bpl teor1`	`34e1 : 10dd [ 3] bpl teor1`

`2e19 : a203 [ 2] ldx #3 ;zp`	`34e3 : a203 [ 2] ldx #3 ;zp`
`2e1b : b520 [ 4] teor2 lda zpEO,x`	`34e5 : b5c6 [ 4] teor2 lda zpEO,x`
`2e1d : 850c [ 3] sta zpt`	`34e7 : 85b2 [ 3] sta zpt`
`set_ax absEOa,0`	`set_ax absEOa,0`
`> load_flag 0`	`> load_flag 0`
`2e1f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`34e9 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2e21 : 48 [ 3]> pha ;use stack to load status`	`34eb : 48 [ 3]> pha ;use stack to load status`
`2e22 : bd4f02 [ 4]> lda absEOa,x ;precharge accu`	`34ec : bd4f02 [ 4]> lda absEOa,x ;precharge accu`
`2e25 : 28 [ 4]> plp`	`34ef : 28 [ 4]> plp`

`2e26 : 450c [ 3] eor zpt`	`34f0 : 45b2 [ 3] eor zpt`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`2e28 : 08 [ 3]> php ;save flags`	`34f2 : 08 [ 3]> php ;save flags`
`2e29 : dd5302 [ 4]> cmp absrlo,x ;test result`	`34f3 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2e2c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 341`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`34f6 : f002 [ 3]> beq skip3060`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`34f8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`34f9 : 27 > db test_num`
`>`	`>`
`2e2e : 68 [ 4]> pla ;load status`	`34fa : >skip3060`
	`>`
	`34fa : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2e2f : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`34fb : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2e31 : dd5702 [ 4]> cmp absflo,x ;test flags`	`34fd : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2e34 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3500 : f002 [ 3]> beq skip3063`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3502 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3503 : 27 > db test_num`
	`>`
	`3504 : >skip3063`
`>`	`>`

`2e36 : ca [ 2] dex`	`3504 : ca [ 2] dex`
`2e37 : 10e2 [ 3] bpl teor2`	`3505 : 10de [ 4] bpl teor2`
`2e39 : a203 [ 2] ldx #3`	`3507 : a203 [ 2] ldx #3`
`2e3b : b520 [ 4] teor3 lda zpEO,x`	`3509 : b5c6 [ 4] teor3 lda zpEO,x`
`2e3d : 850c [ 3] sta zpt`	`350b : 85b2 [ 3] sta zpt`
`set_ax absEOa,$ff`	`set_ax absEOa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2e3f : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`350d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2e41 : 48 [ 3]> pha ;use stack to load status`	`350f : 48 [ 3]> pha ;use stack to load status`
`2e42 : bd4f02 [ 4]> lda absEOa,x ;precharge accu`	`3510 : bd4f02 [ 4]> lda absEOa,x ;precharge accu`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 223`	`3513 : 28 [ 4]> plp`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2e45 : 28 [ 4]> plp`

`2e46 : 450c [ 3] eor zpt`	`3514 : 45b2 [ 3] eor zpt`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`2e48 : 08 [ 3]> php ;save flags`	`3516 : 08 [ 3]> php ;save flags`
`2e49 : dd5302 [ 4]> cmp absrlo,x ;test result`	`3517 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2e4c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`351a : f002 [ 3]> beq skip3068`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`351c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`351d : 27 > db test_num`
	`>`
	`351e : >skip3068`
`>`	`>`
`2e4e : 68 [ 4]> pla ;load status`	`351e : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2e4f : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`351f : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2e51 : dd5702 [ 4]> cmp absflo,x ;test flags`	`3521 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2e54 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 342`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3524 : f002 [ 3]> beq skip3071`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3526 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3527 : 27 > db test_num`
	`>`
	`3528 : >skip3071`
`>`	`>`

`2e56 : ca [ 2] dex`	`3528 : ca [ 2] dex`
`2e57 : 10e2 [ 3] bpl teor3`	`3529 : 10de [ 3] bpl teor3`

`2e59 : a203 [ 2] ldx #3 ;abs`	`352b : a203 [ 2] ldx #3 ;abs`
`2e5b : b520 [ 4] teor4 lda zpEO,x`	`352d : b5c6 [ 4] teor4 lda zpEO,x`
`2e5d : 8d0302 [ 4] sta abst`	`352f : 8d0302 [ 4] sta abst`
`set_ax absEOa,0`	`set_ax absEOa,0`
`> load_flag 0`	`> load_flag 0`
`2e60 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`3532 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2e62 : 48 [ 3]> pha ;use stack to load status`	`3534 : 48 [ 3]> pha ;use stack to load status`
`2e63 : bd4f02 [ 4]> lda absEOa,x ;precharge accu`	`3535 : bd4f02 [ 4]> lda absEOa,x ;precharge accu`
`2e66 : 28 [ 4]> plp`	`3538 : 28 [ 4]> plp`

`2e67 : 4d0302 [ 4] eor abst`	`3539 : 4d0302 [ 4] eor abst`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`2e6a : 08 [ 3]> php ;save flags`	`353c : 08 [ 3]> php ;save flags`
`2e6b : dd5302 [ 4]> cmp absrlo,x ;test result`	`353d : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2e6e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3540 : f002 [ 3]> beq skip3076`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3542 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3543 : 27 > db test_num`
`>`	`>`
`2e70 : 68 [ 4]> pla ;load status`	`3544 : >skip3076`
	`>`
	`3544 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2e71 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`3545 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2e73 : dd5702 [ 4]> cmp absflo,x ;test flags`	`3547 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2e76 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`354a : f002 [ 3]> beq skip3079`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`354c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`354d : 27 > db test_num`
	`>`
	`354e : >skip3079`
`>`	`>`

`2e78 : ca [ 2] dex`	`354e : ca [ 2] dex`
`2e79 : 10e0 [ 3] bpl teor4`	`354f : 10dc [ 3] bpl teor4`
`2e7b : a203 [ 2] ldx #3`	`3551 : a203 [ 2] ldx #3`
`2e7d : b520 [ 4] teor5 lda zpEO,x`	`3553 : b5c6 [ 4] teor5 lda zpEO,x`
`2e7f : 8d0302 [ 4] sta abst`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 343`
`set_ax absEOa,$ff`
`> load_flag $ff`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 224`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2e82 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3555 : 8d0302 [ 4] sta abst`
	`set_ax absEOa,$ff`
	`> load_flag $ff`
	`3558 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2e84 : 48 [ 3]> pha ;use stack to load status`	`355a : 48 [ 3]> pha ;use stack to load status`
`2e85 : bd4f02 [ 4]> lda absEOa,x ;precharge accu`	`355b : bd4f02 [ 4]> lda absEOa,x ;precharge accu`
`2e88 : 28 [ 4]> plp`	`355e : 28 [ 4]> plp`

`2e89 : 4d0302 [ 4] eor abst`	`355f : 4d0302 [ 4] eor abst`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`2e8c : 08 [ 3]> php ;save flags`	`3562 : 08 [ 3]> php ;save flags`
`2e8d : dd5302 [ 4]> cmp absrlo,x ;test result`	`3563 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2e90 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3566 : f002 [ 3]> beq skip3084`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3568 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3569 : 27 > db test_num`
	`>`
	`356a : >skip3084`
`>`	`>`
`2e92 : 68 [ 4]> pla ;load status`	`356a : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2e93 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`356b : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2e95 : dd5702 [ 4]> cmp absflo,x ;test flags`	`356d : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2e98 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3570 : f002 [ 3]> beq skip3087`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3572 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3573 : 27 > db test_num`
	`>`
	`3574 : >skip3087`
`>`	`>`

`2e9a : ca [ 2] dex`	`3574 : ca [ 2] dex`
`2e9b : 1002 [ 3] bpl teor6`	`3575 : 1002 [ 3] bpl teor6`

`2e9d : a203 [ 2] ldx #3 ;zp,x`	`3577 : a203 [ 2] ldx #3 ;zp,x`
`2e9f : teor6`	`3579 : teor6`
`set_ax absEOa,0`	`set_ax absEOa,0`
`> load_flag 0`	`> load_flag 0`
`2e9f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`3579 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2ea1 : 48 [ 3]> pha ;use stack to load status`	`357b : 48 [ 3]> pha ;use stack to load status`
`2ea2 : bd4f02 [ 4]> lda absEOa,x ;precharge accu`	`357c : bd4f02 [ 4]> lda absEOa,x ;precharge accu`
`2ea5 : 28 [ 4]> plp`	`357f : 28 [ 4]> plp`

`2ea6 : 5520 [ 4] eor zpEO,x`	`3580 : 55c6 [ 4] eor zpEO,x`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`2ea8 : 08 [ 3]> php ;save flags`	`3582 : 08 [ 3]> php ;save flags`
`2ea9 : dd5302 [ 4]> cmp absrlo,x ;test result`	`3583 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2eac : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 344`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3586 : f002 [ 3]> beq skip3092`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3588 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3589 : 27 > db test_num`
`>`	`>`
`2eae : 68 [ 4]> pla ;load status`	`358a : >skip3092`
	`>`
	`358a : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2eaf : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`358b : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2eb1 : dd5702 [ 4]> cmp absflo,x ;test flags`	`358d : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2eb4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3590 : f002 [ 3]> beq skip3095`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3592 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3593 : 27 > db test_num`
	`>`
	`3594 : >skip3095`
`>`	`>`

`2eb6 : ca [ 2] dex`	`3594 : ca [ 2] dex`
`2eb7 : 10e6 [ 3] bpl teor6`	`3595 : 10e2 [ 3] bpl teor6`
`2eb9 : a203 [ 2] ldx #3`	`3597 : a203 [ 2] ldx #3`
`2ebb : teor7`	`3599 : teor7`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 225`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`set_ax absEOa,$ff`	`set_ax absEOa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2ebb : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3599 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2ebd : 48 [ 3]> pha ;use stack to load status`	`359b : 48 [ 3]> pha ;use stack to load status`
`2ebe : bd4f02 [ 4]> lda absEOa,x ;precharge accu`	`359c : bd4f02 [ 4]> lda absEOa,x ;precharge accu`
`2ec1 : 28 [ 4]> plp`	`359f : 28 [ 4]> plp`

`2ec2 : 5520 [ 4] eor zpEO,x`	`35a0 : 55c6 [ 4] eor zpEO,x`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`2ec4 : 08 [ 3]> php ;save flags`	`35a2 : 08 [ 3]> php ;save flags`
`2ec5 : dd5302 [ 4]> cmp absrlo,x ;test result`	`35a3 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2ec8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`35a6 : f002 [ 3]> beq skip3100`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`35a8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`35a9 : 27 > db test_num`
	`>`
	`35aa : >skip3100`
`>`	`>`
`2eca : 68 [ 4]> pla ;load status`	`35aa : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2ecb : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`35ab : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2ecd : dd5702 [ 4]> cmp absflo,x ;test flags`	`35ad : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2ed0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`35b0 : f002 [ 3]> beq skip3103`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 345`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`35b2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`35b3 : 27 > db test_num`
	`>`
	`35b4 : >skip3103`
`>`	`>`

`2ed2 : ca [ 2] dex`	`35b4 : ca [ 2] dex`
`2ed3 : 10e6 [ 3] bpl teor7`	`35b5 : 10e2 [ 3] bpl teor7`

`2ed5 : a203 [ 2] ldx #3 ;abs,x`	`35b7 : a203 [ 2] ldx #3 ;abs,x`
`2ed7 : teor8`	`35b9 : teor8`
`set_ax absEOa,0`	`set_ax absEOa,0`
`> load_flag 0`	`> load_flag 0`
`2ed7 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`35b9 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2ed9 : 48 [ 3]> pha ;use stack to load status`	`35bb : 48 [ 3]> pha ;use stack to load status`
`2eda : bd4f02 [ 4]> lda absEOa,x ;precharge accu`	`35bc : bd4f02 [ 4]> lda absEOa,x ;precharge accu`
`2edd : 28 [ 4]> plp`	`35bf : 28 [ 4]> plp`

`2ede : 5d4302 [ 4] eor absEO,x`	`35c0 : 5d4302 [ 4] eor absEO,x`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`2ee1 : 08 [ 3]> php ;save flags`	`35c3 : 08 [ 3]> php ;save flags`
`2ee2 : dd5302 [ 4]> cmp absrlo,x ;test result`	`35c4 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2ee5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`35c7 : f002 [ 3]> beq skip3108`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`35c9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`35ca : 27 > db test_num`
`>`	`>`
`2ee7 : 68 [ 4]> pla ;load status`	`35cb : >skip3108`
	`>`
	`35cb : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2ee8 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`35cc : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2eea : dd5702 [ 4]> cmp absflo,x ;test flags`	`35ce : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2eed : d0fe [ 3]> bne * ;failed not equal (non zero)`	`35d1 : f002 [ 3]> beq skip3111`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`35d3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`35d4 : 27 > db test_num`
	`>`
	`35d5 : >skip3111`
`>`	`>`

`2eef : ca [ 2] dex`	`35d5 : ca [ 2] dex`
`2ef0 : 10e5 [ 3] bpl teor8`	`35d6 : 10e1 [ 3] bpl teor8`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 226`	`35d8 : a203 [ 2] ldx #3`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`35da : teor9`

`2ef2 : a203 [ 2] ldx #3`
`2ef4 : teor9`
`set_ax absEOa,$ff`	`set_ax absEOa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2ef4 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 346`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`35da : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2ef6 : 48 [ 3]> pha ;use stack to load status`	`35dc : 48 [ 3]> pha ;use stack to load status`
`2ef7 : bd4f02 [ 4]> lda absEOa,x ;precharge accu`	`35dd : bd4f02 [ 4]> lda absEOa,x ;precharge accu`
`2efa : 28 [ 4]> plp`	`35e0 : 28 [ 4]> plp`

`2efb : 5d4302 [ 4] eor absEO,x`	`35e1 : 5d4302 [ 4] eor absEO,x`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`2efe : 08 [ 3]> php ;save flags`	`35e4 : 08 [ 3]> php ;save flags`
`2eff : dd5302 [ 4]> cmp absrlo,x ;test result`	`35e5 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2f02 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`35e8 : f002 [ 3]> beq skip3116`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`35ea : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`35eb : 27 > db test_num`
	`>`
	`35ec : >skip3116`
`>`	`>`
`2f04 : 68 [ 4]> pla ;load status`	`35ec : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2f05 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`35ed : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2f07 : dd5702 [ 4]> cmp absflo,x ;test flags`	`35ef : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2f0a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`35f2 : f002 [ 3]> beq skip3119`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`35f4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`35f5 : 27 > db test_num`
	`>`
	`35f6 : >skip3119`
`>`	`>`

`2f0c : ca [ 2] dex`	`35f6 : ca [ 2] dex`
`2f0d : 10e5 [ 4] bpl teor9`	`35f7 : 10e1 [ 3] bpl teor9`

`2f0f : a003 [ 2] ldy #3 ;abs,y`	`35f9 : a003 [ 2] ldy #3 ;abs,y`
`2f11 : teor10`	`35fb : teor10`
`set_ay absEOa,0`	`set_ay absEOa,0`
`> load_flag 0`	`> load_flag 0`
`2f11 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`35fb : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2f13 : 48 [ 3]> pha ;use stack to load status`	`35fd : 48 [ 3]> pha ;use stack to load status`
`2f14 : b94f02 [ 4]> lda absEOa,y ;precharge accu`	`35fe : b94f02 [ 4]> lda absEOa,y ;precharge accu`
`2f17 : 28 [ 4]> plp`	`3601 : 28 [ 4]> plp`

`2f18 : 594302 [ 4] eor absEO,y`	`3602 : 594302 [ 4] eor absEO,y`
`tst_ay absrlo,absflo,0`	`tst_ay absrlo,absflo,0`
`2f1b : 08 [ 3]> php ;save flags`	`3605 : 08 [ 3]> php ;save flags`
`2f1c : d95302 [ 4]> cmp absrlo,y ;test result`	`3606 : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`2f1f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3609 : f002 [ 3]> beq skip3124`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 347`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`360b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`360c : 27 > db test_num`
`>`	`>`
`2f21 : 68 [ 4]> pla ;load status`	`360d : >skip3124`
	`>`
	`360d : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2f22 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`360e : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2f24 : d95702 [ 4]> cmp absflo,y ;test flags`	`3610 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`2f27 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3613 : f002 [ 3]> beq skip3127`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3615 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3616 : 27 > db test_num`
	`>`
	`3617 : >skip3127`
`>`	`>`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 227`	`3617 : 88 [ 2] dey`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`3618 : 10e1 [ 4] bpl teor10`
	`361a : a003 [ 2] ldy #3`
`2f29 : 88 [ 2] dey`	`361c : teor11`
`2f2a : 10e5 [ 3] bpl teor10`
`2f2c : a003 [ 2] ldy #3`
`2f2e : teor11`
`set_ay absEOa,$ff`	`set_ay absEOa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2f2e : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`361c : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2f30 : 48 [ 3]> pha ;use stack to load status`	`361e : 48 [ 3]> pha ;use stack to load status`
`2f31 : b94f02 [ 4]> lda absEOa,y ;precharge accu`	`361f : b94f02 [ 4]> lda absEOa,y ;precharge accu`
`2f34 : 28 [ 4]> plp`	`3622 : 28 [ 4]> plp`

`2f35 : 594302 [ 4] eor absEO,y`	`3623 : 594302 [ 4] eor absEO,y`
`tst_ay absrlo,absflo,$ff-fnz`	`tst_ay absrlo,absflo,$ff-fnz`
`2f38 : 08 [ 3]> php ;save flags`	`3626 : 08 [ 3]> php ;save flags`
`2f39 : d95302 [ 4]> cmp absrlo,y ;test result`	`3627 : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`2f3c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`362a : f002 [ 3]> beq skip3132`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`362c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`362d : 27 > db test_num`
	`>`
	`362e : >skip3132`
`>`	`>`
`2f3e : 68 [ 4]> pla ;load status`	`362e : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2f3f : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`362f : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2f41 : d95702 [ 4]> cmp absflo,y ;test flags`	`3631 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`2f44 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3634 : f002 [ 3]> beq skip3135`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3636 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 348`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3637 : 27 > db test_num`
	`>`
	`3638 : >skip3135`
`>`	`>`

`2f46 : 88 [ 2] dey`	`3638 : 88 [ 2] dey`
`2f47 : 10e5 [ 3] bpl teor11`	`3639 : 10e1 [ 3] bpl teor11`

`2f49 : a206 [ 2] ldx #6 ;(zp,x)`	`363b : a206 [ 2] ldx #6 ;(zp,x)`
`2f4b : a003 [ 2] ldy #3`	`363d : a003 [ 2] ldy #3`
`2f4d : teor12`	`363f : teor12`
`set_ay absEOa,0`	`set_ay absEOa,0`
`> load_flag 0`	`> load_flag 0`
`2f4d : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`363f : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2f4f : 48 [ 3]> pha ;use stack to load status`	`3641 : 48 [ 3]> pha ;use stack to load status`
`2f50 : b94f02 [ 4]> lda absEOa,y ;precharge accu`	`3642 : b94f02 [ 4]> lda absEOa,y ;precharge accu`
`2f53 : 28 [ 4]> plp`	`3645 : 28 [ 4]> plp`

`2f54 : 4142 [ 6] eor (indEO,x)`	`3646 : 41e8 [ 6] eor (indEO,x)`
`tst_ay absrlo,absflo,0`	`tst_ay absrlo,absflo,0`
`2f56 : 08 [ 3]> php ;save flags`	`3648 : 08 [ 3]> php ;save flags`
`2f57 : d95302 [ 4]> cmp absrlo,y ;test result`	`3649 : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`2f5a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`364c : f002 [ 3]> beq skip3140`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`364e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`364f : 27 > db test_num`
`>`	`>`
`2f5c : 68 [ 4]> pla ;load status`	`3650 : >skip3140`
	`>`
	`3650 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2f5d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`3651 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2f5f : d95702 [ 4]> cmp absflo,y ;test flags`	`3653 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 228`	`3656 : f002 [ 3]> beq skip3143`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3658 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3659 : 27 > db test_num`
	`>`
	`365a : >skip3143`
	`>`

	`365a : ca [ 2] dex`
	`365b : ca [ 2] dex`
	`365c : 88 [ 2] dey`
	`365d : 10e0 [ 3] bpl teor12`
	`365f : a206 [ 2] ldx #6`
	`3661 : a003 [ 2] ldy #3`
	`3663 : teor13`
	`set_ay absEOa,$ff`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 349`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2f62 : d0fe [ 3]> bne * ;failed not equal (non zero)`
`>`

`2f64 : ca [ 2] dex`
`2f65 : ca [ 2] dex`
`2f66 : 88 [ 2] dey`
`2f67 : 10e4 [ 3] bpl teor12`
`2f69 : a206 [ 2] ldx #6`
`2f6b : a003 [ 2] ldy #3`
`2f6d : teor13`
`set_ay absEOa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2f6d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3663 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2f6f : 48 [ 3]> pha ;use stack to load status`	`3665 : 48 [ 3]> pha ;use stack to load status`
`2f70 : b94f02 [ 4]> lda absEOa,y ;precharge accu`	`3666 : b94f02 [ 4]> lda absEOa,y ;precharge accu`
`2f73 : 28 [ 4]> plp`	`3669 : 28 [ 4]> plp`

`2f74 : 4142 [ 6] eor (indEO,x)`	`366a : 41e8 [ 6] eor (indEO,x)`
`tst_ay absrlo,absflo,$ff-fnz`	`tst_ay absrlo,absflo,$ff-fnz`
`2f76 : 08 [ 3]> php ;save flags`	`366c : 08 [ 3]> php ;save flags`
`2f77 : d95302 [ 4]> cmp absrlo,y ;test result`	`366d : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`2f7a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3670 : f002 [ 3]> beq skip3148`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3672 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3673 : 27 > db test_num`
	`>`
	`3674 : >skip3148`
`>`	`>`
`2f7c : 68 [ 4]> pla ;load status`	`3674 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2f7d : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`3675 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2f7f : d95702 [ 4]> cmp absflo,y ;test flags`	`3677 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`2f82 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`367a : f002 [ 3]> beq skip3151`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`367c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`367d : 27 > db test_num`
	`>`
	`367e : >skip3151`
`>`	`>`

`2f84 : ca [ 2] dex`	`367e : ca [ 2] dex`
`2f85 : ca [ 2] dex`	`367f : ca [ 2] dex`
`2f86 : 88 [ 2] dey`	`3680 : 88 [ 2] dey`
`2f87 : 10e4 [ 3] bpl teor13`	`3681 : 10e0 [ 3] bpl teor13`

`2f89 : a003 [ 2] ldy #3 ;(zp),y`	`3683 : a003 [ 2] ldy #3 ;(zp),y`
`2f8b : teor14`	`3685 : teor14`
`set_ay absEOa,0`	`set_ay absEOa,0`
`> load_flag 0`	`> load_flag 0`
`2f8b : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`3685 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2f8d : 48 [ 3]> pha ;use stack to load status`	`3687 : 48 [ 3]> pha ;use stack to load status`
`2f8e : b94f02 [ 4]> lda absEOa,y ;precharge accu`	`3688 : b94f02 [ 4]> lda absEOa,y ;precharge accu`
`2f91 : 28 [ 4]> plp`	`368b : 28 [ 4]> plp`

`2f92 : 5142 [ 5] eor (indEO),y`	`368c : 51e8 [ 5] eor (indEO),y`
`tst_ay absrlo,absflo,0`	`tst_ay absrlo,absflo,0`
`2f94 : 08 [ 3]> php ;save flags`	`368e : 08 [ 3]> php ;save flags`
`2f95 : d95302 [ 4]> cmp absrlo,y ;test result`	`368f : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`2f98 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 350`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 229`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3692 : f002 [ 3]> beq skip3156`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3694 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3695 : 27 > db test_num`
`>`	`>`
`2f9a : 68 [ 4]> pla ;load status`	`3696 : >skip3156`
	`>`
	`3696 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2f9b : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`3697 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2f9d : d95702 [ 4]> cmp absflo,y ;test flags`	`3699 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`2fa0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`369c : f002 [ 3]> beq skip3159`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`369e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`369f : 27 > db test_num`
	`>`
	`36a0 : >skip3159`
`>`	`>`

`2fa2 : 88 [ 2] dey`	`36a0 : 88 [ 2] dey`
`2fa3 : 10e6 [ 3] bpl teor14`	`36a1 : 10e2 [ 3] bpl teor14`
`2fa5 : a003 [ 2] ldy #3`	`36a3 : a003 [ 2] ldy #3`
`2fa7 : teor15`	`36a5 : teor15`
`set_ay absEOa,$ff`	`set_ay absEOa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2fa7 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`36a5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2fa9 : 48 [ 3]> pha ;use stack to load status`	`36a7 : 48 [ 3]> pha ;use stack to load status`
`2faa : b94f02 [ 4]> lda absEOa,y ;precharge accu`	`36a8 : b94f02 [ 4]> lda absEOa,y ;precharge accu`
`2fad : 28 [ 4]> plp`	`36ab : 28 [ 4]> plp`

`2fae : 5142 [ 5] eor (indEO),y`	`36ac : 51e8 [ 5] eor (indEO),y`
`tst_ay absrlo,absflo,$ff-fnz`	`tst_ay absrlo,absflo,$ff-fnz`
`2fb0 : 08 [ 3]> php ;save flags`	`36ae : 08 [ 3]> php ;save flags`
`2fb1 : d95302 [ 4]> cmp absrlo,y ;test result`	`36af : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`2fb4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`36b2 : f002 [ 3]> beq skip3164`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`36b4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`36b5 : 27 > db test_num`
`>`	`>`
`2fb6 : 68 [ 4]> pla ;load status`	`36b6 : >skip3164`
	`>`
	`36b6 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`2fb7 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`36b7 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`2fb9 : d95702 [ 4]> cmp absflo,y ;test flags`	`36b9 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`2fbc : d0fe [ 3]> bne * ;failed not equal (non zero)`	`36bc : f002 [ 3]> beq skip3167`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 351`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`36be : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`36bf : 27 > db test_num`
	`>`
	`36c0 : >skip3167`
`>`	`>`

`2fbe : 88 [ 2] dey`	`36c0 : 88 [ 2] dey`
`2fbf : 10e6 [ 3] bpl teor15`	`36c1 : 10e2 [ 3] bpl teor15`
`next_test`	`next_test`
`2fc1 : ad0002 [ 4]> lda test_case ;previous test`	`36c3 : ad0002 [ 4]> lda test_case ;previous test`
`2fc4 : c927 [ 2]> cmp #test_num`	`36c6 : c927 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`2fc6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`36c8 : f002 [ 3]> beq skip3170`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`36ca : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`36cb : 27 > db test_num`
	`>`
	`36cc : >skip3170`
`>`	`>`
`0028 = >test_num = test_num + 1`	`0028 = >test_num = test_num + 1`
`2fc8 : a928 [ 2]> lda #test_num ;*** this tests' number`	`36cc : a928 [ 2]> lda #test_num ;*** this tests' number`
`2fca : 8d0002 [ 4]> sta test_case`	`36ce : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; OR`	`; OR`
`2fcd : a203 [ 2] ldx #3 ;immediate - self modifying code`
`2fcf : b518 [ 4] tora lda zpOR,x`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 230`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`2fd1 : 8ddc2f [ 4] sta torai1`	`36d1 : a203 [ 2] ldx #3 ;immediate - self modifying code`
	`36d3 : b5be [ 4] tora lda zpOR,x`
	`36d5 : 8de036 [ 4] sta torai1`
`set_ax absORa,0`	`set_ax absORa,0`
`> load_flag 0`	`> load_flag 0`
`2fd4 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`36d8 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`2fd6 : 48 [ 3]> pha ;use stack to load status`	`36da : 48 [ 3]> pha ;use stack to load status`
`2fd7 : bd4702 [ 4]> lda absORa,x ;precharge accu`	`36db : bd4702 [ 4]> lda absORa,x ;precharge accu`
`2fda : 28 [ 4]> plp`	`36de : 28 [ 4]> plp`

`2fdc = torai1 equ *+1 ;target for immediate operand`	`36e0 = torai1 equ *+1 ;target for immediate operand`
`2fdb : 0963 [ 2] ora #99`	`36df : 0963 [ 2] ora #99`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`2fdd : 08 [ 3]> php ;save flags`	`36e1 : 08 [ 3]> php ;save flags`
`2fde : dd5302 [ 4]> cmp absrlo,x ;test result`	`36e2 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`2fe1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`36e5 : f002 [ 3]> beq skip3175`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`36e7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`36e8 : 28 > db test_num`
	`>`
	`36e9 : >skip3175`
`>`	`>`
`2fe3 : 68 [ 4]> pla ;load status`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 352`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`36e9 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`2fe4 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`36ea : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`2fe6 : dd5702 [ 4]> cmp absflo,x ;test flags`	`36ec : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`2fe9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`36ef : f002 [ 3]> beq skip3178`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`36f1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`36f2 : 28 > db test_num`
	`>`
	`36f3 : >skip3178`
`>`	`>`

`2feb : ca [ 2] dex`	`36f3 : ca [ 2] dex`
`2fec : 10e1 [ 3] bpl tora`	`36f4 : 10dd [ 3] bpl tora`
`2fee : a203 [ 2] ldx #3`	`36f6 : a203 [ 2] ldx #3`
`2ff0 : b518 [ 4] tora1 lda zpOR,x`	`36f8 : b5be [ 4] tora1 lda zpOR,x`
`2ff2 : 8dfd2f [ 4] sta torai2`	`36fa : 8d0537 [ 4] sta torai2`
`set_ax absORa,$ff`	`set_ax absORa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`2ff5 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`36fd : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`2ff7 : 48 [ 3]> pha ;use stack to load status`	`36ff : 48 [ 3]> pha ;use stack to load status`
`2ff8 : bd4702 [ 4]> lda absORa,x ;precharge accu`	`3700 : bd4702 [ 4]> lda absORa,x ;precharge accu`
`2ffb : 28 [ 4]> plp`	`3703 : 28 [ 4]> plp`

`2ffd = torai2 equ *+1 ;target for immediate operand`	`3705 = torai2 equ *+1 ;target for immediate operand`
`2ffc : 0963 [ 2] ora #99`	`3704 : 0963 [ 2] ora #99`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`2ffe : 08 [ 3]> php ;save flags`	`3706 : 08 [ 3]> php ;save flags`
`2fff : dd5302 [ 4]> cmp absrlo,x ;test result`	`3707 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`3002 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`370a : f002 [ 3]> beq skip3183`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`370c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`370d : 28 > db test_num`
`>`	`>`
`3004 : 68 [ 4]> pla ;load status`	`370e : >skip3183`
	`>`
	`370e : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`3005 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`370f : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`3007 : dd5702 [ 4]> cmp absflo,x ;test flags`	`3711 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`300a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3714 : f002 [ 3]> beq skip3186`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3716 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3717 : 28 > db test_num`
`>`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 231`	`3718 : >skip3186`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 353`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>`

`300c : ca [ 2] dex`	`3718 : ca [ 2] dex`
`300d : 10e1 [ 4] bpl tora1`	`3719 : 10dd [ 4] bpl tora1`

`300f : a203 [ 2] ldx #3 ;zp`	`371b : a203 [ 2] ldx #3 ;zp`
`3011 : b518 [ 4] tora2 lda zpOR,x`	`371d : b5be [ 4] tora2 lda zpOR,x`
`3013 : 850c [ 3] sta zpt`	`371f : 85b2 [ 3] sta zpt`
`set_ax absORa,0`	`set_ax absORa,0`
`> load_flag 0`	`> load_flag 0`
`3015 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`3721 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`3017 : 48 [ 3]> pha ;use stack to load status`	`3723 : 48 [ 3]> pha ;use stack to load status`
`3018 : bd4702 [ 4]> lda absORa,x ;precharge accu`	`3724 : bd4702 [ 4]> lda absORa,x ;precharge accu`
`301b : 28 [ 4]> plp`	`3727 : 28 [ 4]> plp`

`301c : 050c [ 3] ora zpt`	`3728 : 05b2 [ 3] ora zpt`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`301e : 08 [ 3]> php ;save flags`	`372a : 08 [ 3]> php ;save flags`
`301f : dd5302 [ 4]> cmp absrlo,x ;test result`	`372b : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`3022 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`372e : f002 [ 3]> beq skip3191`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3730 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3731 : 28 > db test_num`
`>`	`>`
`3024 : 68 [ 4]> pla ;load status`	`3732 : >skip3191`
	`>`
	`3732 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`3025 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`3733 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`3027 : dd5702 [ 4]> cmp absflo,x ;test flags`	`3735 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`302a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3738 : f002 [ 3]> beq skip3194`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`373a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`373b : 28 > db test_num`
	`>`
	`373c : >skip3194`
`>`	`>`

`302c : ca [ 2] dex`	`373c : ca [ 2] dex`
`302d : 10e2 [ 3] bpl tora2`	`373d : 10de [ 3] bpl tora2`
`302f : a203 [ 2] ldx #3`	`373f : a203 [ 2] ldx #3`
`3031 : b518 [ 4] tora3 lda zpOR,x`	`3741 : b5be [ 4] tora3 lda zpOR,x`
`3033 : 850c [ 3] sta zpt`	`3743 : 85b2 [ 3] sta zpt`
`set_ax absORa,$ff`	`set_ax absORa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`3035 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3745 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`3037 : 48 [ 3]> pha ;use stack to load status`	`3747 : 48 [ 3]> pha ;use stack to load status`
`3038 : bd4702 [ 4]> lda absORa,x ;precharge accu`	`3748 : bd4702 [ 4]> lda absORa,x ;precharge accu`
`303b : 28 [ 4]> plp`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 354`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`303c : 050c [ 3] ora zpt`	`374b : 28 [ 4]> plp`

	`374c : 05b2 [ 3] ora zpt`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`303e : 08 [ 3]> php ;save flags`	`374e : 08 [ 3]> php ;save flags`
`303f : dd5302 [ 4]> cmp absrlo,x ;test result`	`374f : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`3042 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3752 : f002 [ 3]> beq skip3199`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3754 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3755 : 28 > db test_num`
	`>`
	`3756 : >skip3199`
`>`	`>`
`3044 : 68 [ 4]> pla ;load status`	`3756 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`3045 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`3757 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 232`	`3759 : dd5702 [ 4]> cmp absflo,x ;test flags`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`3047 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`304a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`375c : f002 [ 3]> beq skip3202`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`375e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`375f : 28 > db test_num`
	`>`
	`3760 : >skip3202`
`>`	`>`

`304c : ca [ 2] dex`	`3760 : ca [ 2] dex`
`304d : 10e2 [ 3] bpl tora3`	`3761 : 10de [ 3] bpl tora3`

`304f : a203 [ 2] ldx #3 ;abs`	`3763 : a203 [ 2] ldx #3 ;abs`
`3051 : b518 [ 4] tora4 lda zpOR,x`	`3765 : b5be [ 4] tora4 lda zpOR,x`
`3053 : 8d0302 [ 4] sta abst`	`3767 : 8d0302 [ 4] sta abst`
`set_ax absORa,0`	`set_ax absORa,0`
`> load_flag 0`	`> load_flag 0`
`3056 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`376a : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`3058 : 48 [ 3]> pha ;use stack to load status`	`376c : 48 [ 3]> pha ;use stack to load status`
`3059 : bd4702 [ 4]> lda absORa,x ;precharge accu`	`376d : bd4702 [ 4]> lda absORa,x ;precharge accu`
`305c : 28 [ 4]> plp`	`3770 : 28 [ 4]> plp`

`305d : 0d0302 [ 4] ora abst`	`3771 : 0d0302 [ 4] ora abst`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`3060 : 08 [ 3]> php ;save flags`	`3774 : 08 [ 3]> php ;save flags`
`3061 : dd5302 [ 4]> cmp absrlo,x ;test result`	`3775 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`3064 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3778 : f002 [ 3]> beq skip3207`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`377a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`377b : 28 > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 355`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`377c : >skip3207`
`>`	`>`
`3066 : 68 [ 4]> pla ;load status`	`377c : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`3067 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`377d : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`3069 : dd5702 [ 4]> cmp absflo,x ;test flags`	`377f : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`306c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3782 : f002 [ 3]> beq skip3210`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3784 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3785 : 28 > db test_num`
	`>`
	`3786 : >skip3210`
`>`	`>`

`306e : ca [ 2] dex`	`3786 : ca [ 2] dex`
`306f : 10e0 [ 3] bpl tora4`	`3787 : 10dc [ 3] bpl tora4`
`3071 : a203 [ 2] ldx #3`	`3789 : a203 [ 2] ldx #3`
`3073 : b518 [ 4] tora5 lda zpOR,x`	`378b : b5be [ 4] tora5 lda zpOR,x`
`3075 : 8d0302 [ 4] sta abst`	`378d : 8d0302 [ 4] sta abst`
`set_ax absORa,$ff`	`set_ax absORa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`3078 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3790 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`307a : 48 [ 3]> pha ;use stack to load status`	`3792 : 48 [ 3]> pha ;use stack to load status`
`307b : bd4702 [ 4]> lda absORa,x ;precharge accu`	`3793 : bd4702 [ 4]> lda absORa,x ;precharge accu`
`307e : 28 [ 4]> plp`	`3796 : 28 [ 4]> plp`

`307f : 0d0302 [ 4] ora abst`	`3797 : 0d0302 [ 4] ora abst`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`3082 : 08 [ 3]> php ;save flags`	`379a : 08 [ 3]> php ;save flags`
`3083 : dd5302 [ 4]> cmp absrlo,x ;test result`	`379b : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`3086 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`379e : f002 [ 3]> beq skip3215`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`37a0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`37a1 : 28 > db test_num`
`>`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 233`	`37a2 : >skip3215`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`>`
	`37a2 : 68 [ 4]> pla ;load status`
`3088 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`3089 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`37a3 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`308b : dd5702 [ 4]> cmp absflo,x ;test flags`	`37a5 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`308e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`37a8 : f002 [ 3]> beq skip3218`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`37aa : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`37ab : 28 > db test_num`
`>`	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 356`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`3090 : ca [ 2] dex`	`37ac : >skip3218`
`3091 : 1002 [ 3] bpl tora6`	`>`

`3093 : a203 [ 2] ldx #3 ;zp,x`	`37ac : ca [ 2] dex`
`3095 : tora6`	`37ad : 1002 [ 3] bpl tora6`

	`37af : a203 [ 2] ldx #3 ;zp,x`
	`37b1 : tora6`
`set_ax absORa,0`	`set_ax absORa,0`
`> load_flag 0`	`> load_flag 0`
`3095 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`37b1 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`3097 : 48 [ 3]> pha ;use stack to load status`	`37b3 : 48 [ 3]> pha ;use stack to load status`
`3098 : bd4702 [ 4]> lda absORa,x ;precharge accu`	`37b4 : bd4702 [ 4]> lda absORa,x ;precharge accu`
`309b : 28 [ 4]> plp`	`37b7 : 28 [ 4]> plp`

`309c : 1518 [ 4] ora zpOR,x`	`37b8 : 15be [ 4] ora zpOR,x`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`309e : 08 [ 3]> php ;save flags`	`37ba : 08 [ 3]> php ;save flags`
`309f : dd5302 [ 4]> cmp absrlo,x ;test result`	`37bb : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`30a2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`37be : f002 [ 3]> beq skip3223`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`37c0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`37c1 : 28 > db test_num`
	`>`
	`37c2 : >skip3223`
`>`	`>`
`30a4 : 68 [ 4]> pla ;load status`	`37c2 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`30a5 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`37c3 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`30a7 : dd5702 [ 4]> cmp absflo,x ;test flags`	`37c5 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`30aa : d0fe [ 3]> bne * ;failed not equal (non zero)`	`37c8 : f002 [ 3]> beq skip3226`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`37ca : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`37cb : 28 > db test_num`
	`>`
	`37cc : >skip3226`
`>`	`>`

`30ac : ca [ 2] dex`	`37cc : ca [ 2] dex`
`30ad : 10e6 [ 3] bpl tora6`	`37cd : 10e2 [ 3] bpl tora6`
`30af : a203 [ 2] ldx #3`	`37cf : a203 [ 2] ldx #3`
`30b1 : tora7`	`37d1 : tora7`
`set_ax absORa,$ff`	`set_ax absORa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`30b1 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`37d1 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`30b3 : 48 [ 3]> pha ;use stack to load status`	`37d3 : 48 [ 3]> pha ;use stack to load status`
`30b4 : bd4702 [ 4]> lda absORa,x ;precharge accu`	`37d4 : bd4702 [ 4]> lda absORa,x ;precharge accu`
`30b7 : 28 [ 4]> plp`	`37d7 : 28 [ 4]> plp`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 357`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`30b8 : 1518 [ 4] ora zpOR,x`
	`37d8 : 15be [ 4] ora zpOR,x`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`30ba : 08 [ 3]> php ;save flags`	`37da : 08 [ 3]> php ;save flags`
`30bb : dd5302 [ 4]> cmp absrlo,x ;test result`	`37db : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 234`	`37de : f002 [ 3]> beq skip3231`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
`30be : d0fe [ 3]> bne * ;failed not equal (non zero)`	`37e0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`37e1 : 28 > db test_num`
`>`	`>`
`30c0 : 68 [ 4]> pla ;load status`	`37e2 : >skip3231`
	`>`
	`37e2 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`30c1 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`37e3 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`30c3 : dd5702 [ 4]> cmp absflo,x ;test flags`	`37e5 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`30c6 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`37e8 : f002 [ 3]> beq skip3234`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`37ea : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`37eb : 28 > db test_num`
	`>`
	`37ec : >skip3234`
`>`	`>`

`30c8 : ca [ 2] dex`	`37ec : ca [ 2] dex`
`30c9 : 10e6 [ 3] bpl tora7`	`37ed : 10e2 [ 3] bpl tora7`

`30cb : a203 [ 2] ldx #3 ;abs,x`	`37ef : a203 [ 2] ldx #3 ;abs,x`
`30cd : tora8`	`37f1 : tora8`
`set_ax absORa,0`	`set_ax absORa,0`
`> load_flag 0`	`> load_flag 0`
`30cd : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`37f1 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`30cf : 48 [ 3]> pha ;use stack to load status`	`37f3 : 48 [ 3]> pha ;use stack to load status`
`30d0 : bd4702 [ 4]> lda absORa,x ;precharge accu`	`37f4 : bd4702 [ 4]> lda absORa,x ;precharge accu`
`30d3 : 28 [ 4]> plp`	`37f7 : 28 [ 4]> plp`

`30d4 : 1d3b02 [ 4] ora absOR,x`	`37f8 : 1d3b02 [ 4] ora absOR,x`
`tst_ax absrlo,absflo,0`	`tst_ax absrlo,absflo,0`
`30d7 : 08 [ 3]> php ;save flags`	`37fb : 08 [ 3]> php ;save flags`
`30d8 : dd5302 [ 4]> cmp absrlo,x ;test result`	`37fc : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`30db : d0fe [ 3]> bne * ;failed not equal (non zero)`	`37ff : f002 [ 4]> beq skip3239`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3801 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3802 : 28 > db test_num`
	`>`
	`3803 : >skip3239`
`>`	`>`
`30dd : 68 [ 4]> pla ;load status`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 358`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3803 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`30de : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`3804 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`30e0 : dd5702 [ 4]> cmp absflo,x ;test flags`	`3806 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`30e3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3809 : f002 [ 3]> beq skip3242`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`380b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`380c : 28 > db test_num`
	`>`
	`380d : >skip3242`
`>`	`>`

`30e5 : ca [ 2] dex`	`380d : ca [ 2] dex`
`30e6 : 10e5 [ 3] bpl tora8`	`380e : 10e1 [ 4] bpl tora8`
`30e8 : a203 [ 2] ldx #3`	`3810 : a203 [ 2] ldx #3`
`30ea : tora9`	`3812 : tora9`
`set_ax absORa,$ff`	`set_ax absORa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`30ea : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3812 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`30ec : 48 [ 3]> pha ;use stack to load status`	`3814 : 48 [ 3]> pha ;use stack to load status`
`30ed : bd4702 [ 4]> lda absORa,x ;precharge accu`	`3815 : bd4702 [ 4]> lda absORa,x ;precharge accu`
`30f0 : 28 [ 4]> plp`	`3818 : 28 [ 4]> plp`

`30f1 : 1d3b02 [ 4] ora absOR,x`	`3819 : 1d3b02 [ 4] ora absOR,x`
`tst_ax absrlo,absflo,$ff-fnz`	`tst_ax absrlo,absflo,$ff-fnz`
`30f4 : 08 [ 3]> php ;save flags`	`381c : 08 [ 3]> php ;save flags`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 235`	`381d : dd5302 [ 4]> cmp absrlo,x ;test result`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`30f5 : dd5302 [ 4]> cmp absrlo,x ;test result`
`> trap_ne`	`> trap_ne`
`30f8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3820 : f002 [ 3]> beq skip3247`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3822 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3823 : 28 > db test_num`
	`>`
	`3824 : >skip3247`
`>`	`>`
`30fa : 68 [ 4]> pla ;load status`	`3824 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`30fb : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`3825 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`30fd : dd5702 [ 4]> cmp absflo,x ;test flags`	`3827 : dd5702 [ 4]> cmp absflo,x ;test flags`
`> trap_ne ;`	`> trap_ne ;`
`3100 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`382a : f002 [ 3]> beq skip3250`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`382c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`382d : 28 > db test_num`
	`>`
	`382e : >skip3250`
`>`	`>`

`3102 : ca [ 2] dex`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 359`
`3103 : 10e5 [ 4] bpl tora9`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`382e : ca [ 2] dex`
	`382f : 10e1 [ 3] bpl tora9`

`3105 : a003 [ 2] ldy #3 ;abs,y`	`3831 : a003 [ 2] ldy #3 ;abs,y`
`3107 : tora10`	`3833 : tora10`
`set_ay absORa,0`	`set_ay absORa,0`
`> load_flag 0`	`> load_flag 0`
`3107 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`3833 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`3109 : 48 [ 3]> pha ;use stack to load status`	`3835 : 48 [ 3]> pha ;use stack to load status`
`310a : b94702 [ 4]> lda absORa,y ;precharge accu`	`3836 : b94702 [ 4]> lda absORa,y ;precharge accu`
`310d : 28 [ 4]> plp`	`3839 : 28 [ 4]> plp`

`310e : 193b02 [ 4] ora absOR,y`	`383a : 193b02 [ 4] ora absOR,y`
`tst_ay absrlo,absflo,0`	`tst_ay absrlo,absflo,0`
`3111 : 08 [ 3]> php ;save flags`	`383d : 08 [ 3]> php ;save flags`
`3112 : d95302 [ 4]> cmp absrlo,y ;test result`	`383e : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`3115 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3841 : f002 [ 3]> beq skip3255`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3843 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3844 : 28 > db test_num`
`>`	`>`
`3117 : 68 [ 4]> pla ;load status`	`3845 : >skip3255`
	`>`
	`3845 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`3118 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`3846 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`311a : d95702 [ 4]> cmp absflo,y ;test flags`	`3848 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`311d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`384b : f002 [ 3]> beq skip3258`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`384d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`384e : 28 > db test_num`
	`>`
	`384f : >skip3258`
`>`	`>`

`311f : 88 [ 2] dey`	`384f : 88 [ 2] dey`
`3120 : 10e5 [ 3] bpl tora10`	`3850 : 10e1 [ 3] bpl tora10`
`3122 : a003 [ 2] ldy #3`	`3852 : a003 [ 2] ldy #3`
`3124 : tora11`	`3854 : tora11`
`set_ay absORa,$ff`	`set_ay absORa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`3124 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3854 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`3126 : 48 [ 3]> pha ;use stack to load status`	`3856 : 48 [ 3]> pha ;use stack to load status`
`3127 : b94702 [ 4]> lda absORa,y ;precharge accu`	`3857 : b94702 [ 4]> lda absORa,y ;precharge accu`
`312a : 28 [ 4]> plp`	`385a : 28 [ 4]> plp`

`312b : 193b02 [ 4] ora absOR,y`	`385b : 193b02 [ 4] ora absOR,y`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 236`	`tst_ay absrlo,absflo,$ff-fnz`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 360`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`tst_ay absrlo,absflo,$ff-fnz`	`385e : 08 [ 3]> php ;save flags`
`312e : 08 [ 3]> php ;save flags`	`385f : d95302 [ 4]> cmp absrlo,y ;test result`
`312f : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`3132 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3862 : f002 [ 3]> beq skip3263`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3864 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3865 : 28 > db test_num`
`>`	`>`
`3134 : 68 [ 4]> pla ;load status`	`3866 : >skip3263`
	`>`
	`3866 : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`3135 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`3867 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`3137 : d95702 [ 4]> cmp absflo,y ;test flags`	`3869 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`313a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`386c : f002 [ 3]> beq skip3266`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`386e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`386f : 28 > db test_num`
	`>`
	`3870 : >skip3266`
`>`	`>`

`313c : 88 [ 2] dey`	`3870 : 88 [ 2] dey`
`313d : 10e5 [ 3] bpl tora11`	`3871 : 10e1 [ 3] bpl tora11`

`313f : a206 [ 2] ldx #6 ;(zp,x)`	`3873 : a206 [ 2] ldx #6 ;(zp,x)`
`3141 : a003 [ 2] ldy #3`	`3875 : a003 [ 2] ldy #3`
`3143 : tora12`	`3877 : tora12`
`set_ay absORa,0`	`set_ay absORa,0`
`> load_flag 0`	`> load_flag 0`
`3143 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`3877 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`3145 : 48 [ 3]> pha ;use stack to load status`	`3879 : 48 [ 3]> pha ;use stack to load status`
`3146 : b94702 [ 4]> lda absORa,y ;precharge accu`	`387a : b94702 [ 4]> lda absORa,y ;precharge accu`
`3149 : 28 [ 4]> plp`	`387d : 28 [ 4]> plp`

`314a : 014a [ 6] ora (indOR,x)`	`387e : 01f0 [ 6] ora (indOR,x)`
`tst_ay absrlo,absflo,0`	`tst_ay absrlo,absflo,0`
`314c : 08 [ 3]> php ;save flags`	`3880 : 08 [ 3]> php ;save flags`
`314d : d95302 [ 4]> cmp absrlo,y ;test result`	`3881 : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`3150 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3884 : f002 [ 3]> beq skip3271`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3886 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3887 : 28 > db test_num`
`>`	`>`
`3152 : 68 [ 4]> pla ;load status`	`3888 : >skip3271`
	`>`
	`3888 : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`3153 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 361`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3889 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`3155 : d95702 [ 4]> cmp absflo,y ;test flags`	`388b : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`3158 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`388e : f002 [ 3]> beq skip3274`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3890 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3891 : 28 > db test_num`
	`>`
	`3892 : >skip3274`
`>`	`>`

`315a : ca [ 2] dex`	`3892 : ca [ 2] dex`
`315b : ca [ 2] dex`	`3893 : ca [ 2] dex`
`315c : 88 [ 2] dey`	`3894 : 88 [ 2] dey`
`315d : 10e4 [ 3] bpl tora12`	`3895 : 10e0 [ 3] bpl tora12`
`315f : a206 [ 2] ldx #6`	`3897 : a206 [ 2] ldx #6`
`3161 : a003 [ 2] ldy #3`	`3899 : a003 [ 2] ldy #3`
`3163 : tora13`	`389b : tora13`
`set_ay absORa,$ff`	`set_ay absORa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`3163 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`389b : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 237`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`>`	`>`
`3165 : 48 [ 3]> pha ;use stack to load status`	`389d : 48 [ 3]> pha ;use stack to load status`
`3166 : b94702 [ 4]> lda absORa,y ;precharge accu`	`389e : b94702 [ 4]> lda absORa,y ;precharge accu`
`3169 : 28 [ 4]> plp`	`38a1 : 28 [ 4]> plp`

`316a : 014a [ 6] ora (indOR,x)`	`38a2 : 01f0 [ 6] ora (indOR,x)`
`tst_ay absrlo,absflo,$ff-fnz`	`tst_ay absrlo,absflo,$ff-fnz`
`316c : 08 [ 3]> php ;save flags`	`38a4 : 08 [ 3]> php ;save flags`
`316d : d95302 [ 4]> cmp absrlo,y ;test result`	`38a5 : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`3170 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`38a8 : f002 [ 3]> beq skip3279`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`38aa : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`38ab : 28 > db test_num`
`>`	`>`
`3172 : 68 [ 4]> pla ;load status`	`38ac : >skip3279`
	`>`
	`38ac : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`3173 : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`38ad : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`3175 : d95702 [ 4]> cmp absflo,y ;test flags`	`38af : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`3178 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`38b2 : f002 [ 3]> beq skip3282`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`38b4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`38b5 : 28 > db test_num`
	`>`
	`38b6 : >skip3282`
`>`	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 362`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`317a : ca [ 2] dex`	`38b6 : ca [ 2] dex`
`317b : ca [ 2] dex`	`38b7 : ca [ 2] dex`
`317c : 88 [ 2] dey`	`38b8 : 88 [ 2] dey`
`317d : 10e4 [ 3] bpl tora13`	`38b9 : 10e0 [ 3] bpl tora13`

`317f : a003 [ 2] ldy #3 ;(zp),y`	`38bb : a003 [ 2] ldy #3 ;(zp),y`
`3181 : tora14`	`38bd : tora14`
`set_ay absORa,0`	`set_ay absORa,0`
`> load_flag 0`	`> load_flag 0`
`3181 : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`	`38bd : a900 [ 2]> lda #0 ;allow test to change I-flag (no mask)`
`>`	`>`
`3183 : 48 [ 3]> pha ;use stack to load status`	`38bf : 48 [ 3]> pha ;use stack to load status`
`3184 : b94702 [ 4]> lda absORa,y ;precharge accu`	`38c0 : b94702 [ 4]> lda absORa,y ;precharge accu`
`3187 : 28 [ 4]> plp`	`38c3 : 28 [ 4]> plp`

`3188 : 114a [ 5] ora (indOR),y`	`38c4 : 11f0 [ 5] ora (indOR),y`
`tst_ay absrlo,absflo,0`	`tst_ay absrlo,absflo,0`
`318a : 08 [ 3]> php ;save flags`	`38c6 : 08 [ 3]> php ;save flags`
`318b : d95302 [ 4]> cmp absrlo,y ;test result`	`38c7 : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`318e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`38ca : f002 [ 3]> beq skip3287`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`38cc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`38cd : 28 > db test_num`
	`>`
	`38ce : >skip3287`
`>`	`>`
`3190 : 68 [ 4]> pla ;load status`	`38ce : 68 [ 4]> pla ;load status`
`> eor_flag 0`	`> eor_flag 0`
`3191 : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`	`38cf : 4930 [ 2]> eor #0\|fao ;invert expected flags + always on bits`
`>`	`>`
`3193 : d95702 [ 4]> cmp absflo,y ;test flags`	`38d1 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`3196 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`38d4 : f002 [ 3]> beq skip3290`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`38d6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`38d7 : 28 > db test_num`
	`>`
	`38d8 : >skip3290`
`>`	`>`

`3198 : 88 [ 2] dey`	`38d8 : 88 [ 2] dey`
`3199 : 10e6 [ 3] bpl tora14`	`38d9 : 10e2 [ 3] bpl tora14`
`319b : a003 [ 2] ldy #3`	`38db : a003 [ 2] ldy #3`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 238`	`38dd : tora15`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`319d : tora15`
`set_ay absORa,$ff`	`set_ay absORa,$ff`
`> load_flag $ff`	`> load_flag $ff`
`319d : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`38dd : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`319f : 48 [ 3]> pha ;use stack to load status`	`38df : 48 [ 3]> pha ;use stack to load status`
`31a0 : b94702 [ 4]> lda absORa,y ;precharge accu`	`38e0 : b94702 [ 4]> lda absORa,y ;precharge accu`
`31a3 : 28 [ 4]> plp`	`38e3 : 28 [ 4]> plp`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 363`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`31a4 : 114a [ 5] ora (indOR),y`	`38e4 : 11f0 [ 5] ora (indOR),y`
`tst_ay absrlo,absflo,$ff-fnz`	`tst_ay absrlo,absflo,$ff-fnz`
`31a6 : 08 [ 3]> php ;save flags`	`38e6 : 08 [ 3]> php ;save flags`
`31a7 : d95302 [ 4]> cmp absrlo,y ;test result`	`38e7 : d95302 [ 4]> cmp absrlo,y ;test result`
`> trap_ne ;`	`> trap_ne ;`
`31aa : d0fe [ 3]> bne * ;failed not equal (non zero)`	`38ea : f002 [ 3]> beq skip3295`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`38ec : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`38ed : 28 > db test_num`
	`>`
	`38ee : >skip3295`
`>`	`>`
`31ac : 68 [ 4]> pla ;load status`	`38ee : 68 [ 4]> pla ;load status`
`> eor_flag $ff-fnz`	`> eor_flag $ff-fnz`
`31ad : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`	`38ef : 497d [ 2]> eor #$ff-fnz\|fao ;invert expected flags + always on bits`
`>`	`>`
`31af : d95702 [ 4]> cmp absflo,y ;test flags`	`38f1 : d95702 [ 4]> cmp absflo,y ;test flags`
`> trap_ne`	`> trap_ne`
`31b2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`38f4 : f002 [ 3]> beq skip3298`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`38f6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`38f7 : 28 > db test_num`
`>`	`>`
	`38f8 : >skip3298`
	`>`

	`38f8 : 88 [ 2] dey`
	`38f9 : 10e2 [ 3] bpl tora15`

`31b4 : 88 [ 2] dey`
`31b5 : 10e6 [ 3] bpl tora15`
`if I_flag = 3`	`if I_flag = 3`
`31b7 : 58 [ 2] cli`
	`38fb : 58 [ 2] cli`

`endif`	`endif`

`31b8 : bin_test`	`38fc : bin_test`
`if skip_bin_test = 1`	`if skip_bin_test = 1`
`31b8 : 4c2032 [ 3] jmp dec_test`
	`jmp dec_test`

`else`	`else`
`lda #test_num`
`sta test_case`	`38fc : a928 [ 2] lda #test_num`
	`38fe : 8d0002 [ 4] sta test_case`

`endif`	`endif`

`next_test`	`next_test`
`31bb : ad0002 [ 4]> lda test_case ;previous test`	`3901 : ad0002 [ 4]> lda test_case ;previous test`
`31be : c928 [ 2]> cmp #test_num`	`3904 : c928 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`31c0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3906 : f002 [ 3]> beq skip3301`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 364`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3908 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3909 : 28 > db test_num`
	`>`
	`390a : >skip3301`
`>`	`>`
`0029 = >test_num = test_num + 1`	`0029 = >test_num = test_num + 1`
`31c2 : a929 [ 2]> lda #test_num ;*** this tests' number`	`390a : a929 [ 2]> lda #test_num ;*** this tests' number`
`31c4 : 8d0002 [ 4]> sta test_case`	`390c : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`



`; full binary add/subtract test`	`; full binary add/subtract test`
`; iterates through all combinations of operands and carry input`	`; iterates through all combinations of operands and carry input`
`; uses increments/decrements to predict result & result flags`	`; uses increments/decrements to predict result & result flags`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 239`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`31c7 : d8 [ 2] cld`	`390f : d8 [ 2] cld`
`31c8 : a20e [ 2] ldx #ad2 ;for indexed test`	`3910 : a2b4 [ 2] ldx #ad2 ;for indexed test`
`31ca : a0ff [ 2] ldy #$ff ;max range`	`3912 : a0ff [ 2] ldy #$ff ;max range`
`31cc : a900 [ 2] lda #0 ;start with adding zeroes & no carry`	`3914 : a900 [ 2] lda #0 ;start with adding zeroes & no carry`
`31ce : 850c [ 3] sta adfc ;carry in - for diag`	`3916 : 85b2 [ 3] sta adfc ;carry in - for diag`
`31d0 : 850d [ 3] sta ad1 ;operand 1 - accumulator`	`3918 : 85b3 [ 3] sta ad1 ;operand 1 - accumulator`
`31d2 : 850e [ 3] sta ad2 ;operand 2 - memory or immediate`	`391a : 85b4 [ 3] sta ad2 ;operand 2 - memory or immediate`
`31d4 : 8d0302 [ 4] sta ada2 ;non zp`	`391c : 8d0302 [ 4] sta ada2 ;non zp`
`31d7 : 850f [ 3] sta adrl ;expected result bits 0-7`	`391f : 85b5 [ 3] sta adrl ;expected result bits 0-7`
`31d9 : 8510 [ 3] sta adrh ;expected result bit 8 (carry out)`	`3921 : 85b6 [ 3] sta adrh ;expected result bit 8 (carry out)`
`31db : a9ff [ 2] lda #$ff ;complemented operand 2 for subtract`	`3923 : a9ff [ 2] lda #$ff ;complemented operand 2 for subtract`
`31dd : 8512 [ 3] sta sb2`	`3925 : 85b8 [ 3] sta sb2`
`31df : 8d0402 [ 4] sta sba2 ;non zp`	`3927 : 8d0402 [ 4] sta sba2 ;non zp`
`31e2 : a902 [ 2] lda #2 ;expected Z-flag`	`392a : a902 [ 2] lda #2 ;expected Z-flag`
`31e4 : 8511 [ 3] sta adrf`	`392c : 85b7 [ 3] sta adrf`
`31e6 : 18 [ 2] tadd clc ;test with carry clear`	`392e : 18 [ 2] tadd clc ;test with carry clear`
`31e7 : 200334 [ 6] jsr chkadd`	`392f : 20903b [ 6] jsr chkadd`
`31ea : e60c [ 5] inc adfc ;now with carry`	`3932 : e6b2 [ 5] inc adfc ;now with carry`
`31ec : e60f [ 5] inc adrl ;result +1`	`3934 : e6b5 [ 5] inc adrl ;result +1`
`31ee : 08 [ 3] php ;save N & Z from low result`	`3936 : 08 [ 3] php ;save N & Z from low result`
`31ef : 08 [ 3] php`	`3937 : 08 [ 3] php`
`31f0 : 68 [ 4] pla ;accu holds expected flags`	`3938 : 68 [ 4] pla ;accu holds expected flags`
`31f1 : 2982 [ 2] and #$82 ;mask N & Z`	`3939 : 2982 [ 2] and #$82 ;mask N & Z`
`31f3 : 28 [ 4] plp`	`393b : 28 [ 4] plp`
`31f4 : d002 [ 3] bne tadd1`	`393c : d002 [ 3] bne tadd1`
`31f6 : e610 [ 5] inc adrh ;result bit 8 - carry`	`393e : e6b6 [ 5] inc adrh ;result bit 8 - carry`
`31f8 : 0510 [ 3] tadd1 ora adrh ;merge C to expected flags`	`3940 : 05b6 [ 3] tadd1 ora adrh ;merge C to expected flags`
`31fa : 8511 [ 3] sta adrf ;save expected flags except overflow`	`3942 : 85b7 [ 3] sta adrf ;save expected flags except overflow`
`31fc : 38 [ 2] sec ;test with carry set`	`3944 : 38 [ 2] sec ;test with carry set`
`31fd : 200334 [ 6] jsr chkadd`	`3945 : 20903b [ 6] jsr chkadd`
`3200 : c60c [ 5] dec adfc ;same for operand +1 but no carry`	`3948 : c6b2 [ 5] dec adfc ;same for operand +1 but no carry`
`3202 : e60d [ 5] inc ad1`	`394a : e6b3 [ 5] inc ad1`
`3204 : d0e0 [ 4] bne tadd ;iterate op1`	`394c : d0e0 [ 3] bne tadd ;iterate op1`
`3206 : a900 [ 2] lda #0 ;preset result to op2 when op1 = 0`	`394e : a900 [ 2] lda #0 ;preset result to op2 when op1 = 0`
`3208 : 8510 [ 3] sta adrh`	`3950 : 85b6 [ 3] sta adrh`
`320a : ee0302 [ 6] inc ada2`	`3952 : ee0302 [ 6] inc ada2`
`320d : e60e [ 5] inc ad2`	`3955 : e6b4 [ 5] inc ad2`
`320f : 08 [ 3] php ;save NZ as operand 2 becomes the new result`	`3957 : 08 [ 3] php ;save NZ as operand 2 becomes the new result`
`3210 : 68 [ 4] pla`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 365`
`3211 : 2982 [ 2] and #$82 ;mask N00000Z0`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`3213 : 8511 [ 3] sta adrf ;no need to check carry as we are adding to 0`
`3215 : c612 [ 5] dec sb2 ;complement subtract operand 2`	`3958 : 68 [ 4] pla`
`3217 : ce0402 [ 6] dec sba2`	`3959 : 2982 [ 2] and #$82 ;mask N00000Z0`
`321a : a50e [ 3] lda ad2`	`395b : 85b7 [ 3] sta adrf ;no need to check carry as we are adding to 0`
`321c : 850f [ 3] sta adrl`	`395d : c6b8 [ 5] dec sb2 ;complement subtract operand 2`
`321e : d0c6 [ 4] bne tadd ;iterate op2`	`395f : ce0402 [ 6] dec sba2`
	`3962 : a5b4 [ 3] lda ad2`
	`3964 : 85b5 [ 3] sta adrl`
	`3966 : d0c6 [ 3] bne tadd ;iterate op2`

	`3968 : dec_test`

`3220 : dec_test`
`if skip_dec_test = 1`	`if skip_dec_test = 1`
`3220 : 4ccf32 [ 3] jmp success`
	`success`

`else`	`else`
`lda #test_num`
`sta test_case`
`endif`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 240`	`3968 : a929 [ 2] lda #test_num`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`396a : 8d0002 [ 4] sta test_case`

	`endif`

`next_test`	`next_test`
`3223 : ad0002 [ 4]> lda test_case ;previous test`	`396d : ad0002 [ 4]> lda test_case ;previous test`
`3226 : c929 [ 2]> cmp #test_num`	`3970 : c929 [ 2]> cmp #test_num`
`> trap_ne ;test is out of sequence`	`> trap_ne ;test is out of sequence`
`3228 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3972 : f002 [ 3]> beq skip3304`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3974 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3975 : 29 > db test_num`
	`>`
	`3976 : >skip3304`
`>`	`>`
`002a = >test_num = test_num + 1`	`002a = >test_num = test_num + 1`
`322a : a92a [ 2]> lda #test_num ;*** this tests' number`	`3976 : a92a [ 2]> lda #test_num ;*** this tests' number`
`322c : 8d0002 [ 4]> sta test_case`	`3978 : 8d0002 [ 4]> sta test_case`
`> ;check_ram ;uncomment to find altered RAM after each test`	`> ;check_ram ;uncomment to find altered RAM after each test`


`; decimal add/subtract test`	`; decimal add/subtract test`
`; * WARNING - tests documented behavior only! *`	`; * WARNING - tests documented behavior only! *`
`; only valid BCD operands are tested, N V Z flags are ignored`	`; only valid BCD operands are tested, N V Z flags are ignored`
`; iterates through all valid combinations of operands and carry input`	`; iterates through all valid combinations of operands and carry input`
`; uses increments/decrements to predict result & carry flag`	`; uses increments/decrements to predict result & carry flag`
`322f : f8 [ 2] sed`
`3230 : a20e [ 2] ldx #ad2 ;for indexed test`
`3232 : a0ff [ 2] ldy #$ff ;max range`
`3234 : a999 [ 2] lda #$99 ;start with adding 99 to 99 with carry`
`3236 : 850d [ 3] sta ad1 ;operand 1 - accumulator`
`3238 : 850e [ 3] sta ad2 ;operand 2 - memory or immediate`
`323a : 8d0302 [ 4] sta ada2 ;non zp`
`323d : 850f [ 3] sta adrl ;expected result bits 0-7`
`323f : a901 [ 2] lda #1 ;set carry in & out`
`3241 : 850c [ 3] sta adfc ;carry in - for diag`
`3243 : 8510 [ 3] sta adrh ;expected result bit 8 (carry out)`
`3245 : a900 [ 2] lda #0 ;complemented operand 2 for subtract`
`3247 : 8512 [ 3] sta sb2`
`3249 : 8d0402 [ 4] sta sba2 ;non zp`
`324c : 38 [ 2] tdad sec ;test with carry set`
`324d : 20d232 [ 6] jsr chkdad`
`3250 : c60c [ 5] dec adfc ;now with carry clear`
`3252 : a50f [ 3] lda adrl ;decimal adjust result`
`3254 : d008 [ 3] bne tdad1 ;skip clear carry & preset result 99 (9A-1)`
`3256 : c610 [ 5] dec adrh`
`3258 : a999 [ 2] lda #$99`
`325a : 850f [ 3] sta adrl`
`325c : d012 [ 3] bne tdad3`
`325e : 290f [ 2] tdad1 and #$f ;lower nibble mask`
`3260 : d00c [ 3] bne tdad2 ;no decimal adjust needed`
`3262 : c60f [ 5] dec adrl ;decimal adjust (?0-6)`
`3264 : c60f [ 5] dec adrl`
`3266 : c60f [ 5] dec adrl`
`3268 : c60f [ 5] dec adrl`
`326a : c60f [ 5] dec adrl`
`326c : c60f [ 5] dec adrl`
`326e : c60f [ 5] tdad2 dec adrl ;result -1`
`3270 : 18 [ 2] tdad3 clc ;test with carry clear`
`3271 : 20d232 [ 6] jsr chkdad`
`3274 : e60c [ 5] inc adfc ;same for operand -1 but with carry`
`3276 : a50d [ 3] lda ad1 ;decimal adjust operand 1`
`3278 : f015 [ 3] beq tdad5 ;iterate operand 2`
`327a : 290f [ 2] and #$f ;lower nibble mask`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 241`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`327c : d00c [ 3] bne tdad4 ;skip decimal adjust`	`397b : f8 [ 2] sed`
`327e : c60d [ 5] dec ad1 ;decimal adjust (?0-6)`	`397c : a2b4 [ 2] ldx #ad2 ;for indexed test`
`3280 : c60d [ 5] dec ad1`	`397e : a0ff [ 2] ldy #$ff ;max range`
`3282 : c60d [ 5] dec ad1`	`3980 : a999 [ 2] lda #$99 ;start with adding 99 to 99 with carry`
`3284 : c60d [ 5] dec ad1`	`3982 : 85b3 [ 3] sta ad1 ;operand 1 - accumulator`
`3286 : c60d [ 5] dec ad1`	`3984 : 85b4 [ 3] sta ad2 ;operand 2 - memory or immediate`
`3288 : c60d [ 5] dec ad1`	`3986 : 8d0302 [ 4] sta ada2 ;non zp`
`328a : c60d [ 5] tdad4 dec ad1 ;operand 1 -1`	`3989 : 85b5 [ 3] sta adrl ;expected result bits 0-7`
`328c : 4c4c32 [ 3] jmp tdad ;iterate op1`	`398b : a901 [ 2] lda #1 ;set carry in & out`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 366`
`328f : a999 [ 2] tdad5 lda #$99 ;precharge op1 max`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`3291 : 850d [ 3] sta ad1`
`3293 : a50e [ 3] lda ad2 ;decimal adjust operand 2`	`398d : 85b2 [ 3] sta adfc ;carry in - for diag`
`3295 : f030 [ 3] beq tdad7 ;end of iteration`	`398f : 85b6 [ 3] sta adrh ;expected result bit 8 (carry out)`
`3297 : 290f [ 2] and #$f ;lower nibble mask`	`3991 : a900 [ 2] lda #0 ;complemented operand 2 for subtract`
`3299 : d018 [ 3] bne tdad6 ;skip decimal adjust`	`3993 : 85b8 [ 3] sta sb2`
`329b : c60e [ 5] dec ad2 ;decimal adjust (?0-6)`	`3995 : 8d0402 [ 4] sta sba2 ;non zp`
`329d : c60e [ 5] dec ad2`	`3998 : 38 [ 2] tdad sec ;test with carry set`
`329f : c60e [ 5] dec ad2`	`3999 : 201f3a [ 6] jsr chkdad`
`32a1 : c60e [ 5] dec ad2`	`399c : c6b2 [ 5] dec adfc ;now with carry clear`
`32a3 : c60e [ 5] dec ad2`	`399e : a5b5 [ 3] lda adrl ;decimal adjust result`
`32a5 : c60e [ 5] dec ad2`	`39a0 : d008 [ 3] bne tdad1 ;skip clear carry & preset result 99 (9A-1)`
`32a7 : e612 [ 5] inc sb2 ;complemented decimal adjust for subtract (?9+6)`	`39a2 : c6b6 [ 5] dec adrh`
`32a9 : e612 [ 5] inc sb2`	`39a4 : a999 [ 2] lda #$99`
`32ab : e612 [ 5] inc sb2`	`39a6 : 85b5 [ 3] sta adrl`
`32ad : e612 [ 5] inc sb2`	`39a8 : d012 [ 3] bne tdad3`
`32af : e612 [ 5] inc sb2`	`39aa : 290f [ 2] tdad1 and #$f ;lower nibble mask`
`32b1 : e612 [ 5] inc sb2`	`39ac : d00c [ 3] bne tdad2 ;no decimal adjust needed`
`32b3 : c60e [ 5] tdad6 dec ad2 ;operand 2 -1`	`39ae : c6b5 [ 5] dec adrl ;decimal adjust (?0-6)`
`32b5 : e612 [ 5] inc sb2 ;complemented operand for subtract`	`39b0 : c6b5 [ 5] dec adrl`
`32b7 : a512 [ 3] lda sb2`	`39b2 : c6b5 [ 5] dec adrl`
`32b9 : 8d0402 [ 4] sta sba2 ;copy as non zp operand`	`39b4 : c6b5 [ 5] dec adrl`
`32bc : a50e [ 3] lda ad2`	`39b6 : c6b5 [ 5] dec adrl`
`32be : 8d0302 [ 4] sta ada2 ;copy as non zp operand`	`39b8 : c6b5 [ 5] dec adrl`
`32c1 : 850f [ 3] sta adrl ;new result since op1+carry=00+carry +op2=op2`	`39ba : c6b5 [ 5] tdad2 dec adrl ;result -1`
`32c3 : e610 [ 5] inc adrh ;result carry`	`39bc : 18 [ 2] tdad3 clc ;test with carry clear`
`32c5 : d085 [ 3] bne tdad ;iterate op2`	`39bd : 201f3a [ 6] jsr chkdad`
`32c7 : d8 [ 2] tdad7 cld`	`39c0 : e6b2 [ 5] inc adfc ;same for operand -1 but with carry`
	`39c2 : a5b3 [ 3] lda ad1 ;decimal adjust operand 1`
	`39c4 : f015 [ 3] beq tdad5 ;iterate operand 2`
	`39c6 : 290f [ 2] and #$f ;lower nibble mask`
	`39c8 : d00c [ 3] bne tdad4 ;skip decimal adjust`
	`39ca : c6b3 [ 5] dec ad1 ;decimal adjust (?0-6)`
	`39cc : c6b3 [ 5] dec ad1`
	`39ce : c6b3 [ 5] dec ad1`
	`39d0 : c6b3 [ 5] dec ad1`
	`39d2 : c6b3 [ 5] dec ad1`
	`39d4 : c6b3 [ 5] dec ad1`
	`39d6 : c6b3 [ 5] tdad4 dec ad1 ;operand 1 -1`
	`39d8 : 4c9839 [ 3] jmp tdad ;iterate op1`

	`39db : a999 [ 2] tdad5 lda #$99 ;precharge op1 max`
	`39dd : 85b3 [ 3] sta ad1`
	`39df : a5b4 [ 3] lda ad2 ;decimal adjust operand 2`
	`39e1 : f030 [ 4] beq tdad7 ;end of iteration`
	`39e3 : 290f [ 2] and #$f ;lower nibble mask`
	`39e5 : d018 [ 3] bne tdad6 ;skip decimal adjust`
	`39e7 : c6b4 [ 5] dec ad2 ;decimal adjust (?0-6)`
	`39e9 : c6b4 [ 5] dec ad2`
	`39eb : c6b4 [ 5] dec ad2`
	`39ed : c6b4 [ 5] dec ad2`
	`39ef : c6b4 [ 5] dec ad2`
	`39f1 : c6b4 [ 5] dec ad2`
	`39f3 : e6b8 [ 5] inc sb2 ;complemented decimal adjust for subtract (?9+6)`
	`39f5 : e6b8 [ 5] inc sb2`
	`39f7 : e6b8 [ 5] inc sb2`
	`39f9 : e6b8 [ 5] inc sb2`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 367`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`39fb : e6b8 [ 5] inc sb2`
	`39fd : e6b8 [ 5] inc sb2`
	`39ff : c6b4 [ 5] tdad6 dec ad2 ;operand 2 -1`
	`3a01 : e6b8 [ 5] inc sb2 ;complemented operand for subtract`
	`3a03 : a5b8 [ 3] lda sb2`
	`3a05 : 8d0402 [ 4] sta sba2 ;copy as non zp operand`
	`3a08 : a5b4 [ 3] lda ad2`
	`3a0a : 8d0302 [ 4] sta ada2 ;copy as non zp operand`
	`3a0d : 85b5 [ 3] sta adrl ;new result since op1+carry=00+carry +op2=op2`
	`3a0f : e6b6 [ 5] inc adrh ;result carry`
	`3a11 : d085 [ 4] bne tdad ;iterate op2`
	`3a13 : d8 [ 2] tdad7 cld`

`32c8 : ad0002 [ 4] lda test_case`	`3a14 : ad0002 [ 4] lda test_case`
`32cb : c92a [ 2] cmp #test_num`	`3a17 : c92a [ 2] cmp #test_num`
`trap_ne ;test is out of sequence`	`trap_ne ;test is out of sequence`
`32cd : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3a19 : f002 [ 3]> beq skip3306`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3a1b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3a1c : 2a > db test_num`
	`>`
	`3a1d : >skip3306`


`; final RAM integrity test`	`; final RAM integrity test`
`; verifies that none of the previous tests has altered RAM outside of the`	`; verifies that none of the previous tests has altered RAM outside of the`
`; designated write areas.`	`; designated write areas.`

`check_ram`	`check_ram`
`> ;RAM check disabled - RAM size not set`	`> ;RAM check disabled - RAM size not set`


`; * DEBUG INFO *`	`; * DEBUG INFO *`
	`;`
`; to debug checksum errors uncomment check_ram in the next_test macro to`	`; to debug checksum errors uncomment check_ram in the next_test macro to`
`; narrow down the responsible opcode.`	`; narrow down the responsible opcode.`
`; may give false errors when monitor, OS or other background activity is`	`; may give false errors when monitor, OS or other background activity is`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 242`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`; allowed during previous tests.`	`; allowed during previous tests.`



`; S U C C E S S ************************************************`	`; S U C C E S S ************************************************`
`; -------------`	`; -------------`
`32cf : 4c0004 [ 3] success jmp start ;if you get here everything went well`
	`;success jmp start ;if you get here everything went well`
	`success`
	`3a1d : 00 [ 7]> brk`
	`3a1e : 2b > db test_num+1`

`; -------------`	`; -------------`
`; S U C C E S S ************************************************`	`; S U C C E S S ************************************************`

`; core subroutine of the decimal add/subtract test`	`; core subroutine of the decimal add/subtract test`
	`;`
`; * WARNING - tests documented behavior only! *`	`; * WARNING - tests documented behavior only! *`
`; only valid BCD operands are tested, N V Z flags are ignored`	`; only valid BCD operands are tested, N V Z flags are ignored`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 368`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`; iterates through all valid combinations of operands and carry input`	`; iterates through all valid combinations of operands and carry input`
`; uses increments/decrements to predict result & carry flag`	`; uses increments/decrements to predict result & carry flag`
`32d2 : chkdad`
	`3a1f : chkdad`

`; decimal ADC / SBC zp`	`; decimal ADC / SBC zp`
`32d2 : 08 [ 3] php ;save carry for subtract`
`32d3 : a50d [ 3] lda ad1`
`32d5 : 650e [ 3] adc ad2 ;perform add`
`32d7 : 08 [ 3] php`
`32d8 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`32da : d0fe [ 3]> bne * ;failed not equal (non zero)`

`32dc : 68 [ 4] pla ;check flags`	`3a1f : 08 [ 3] php ;save carry for subtract`
`32dd : 2901 [ 2] and #1 ;mask carry`	`3a20 : a5b3 [ 3] lda ad1`
`32df : c510 [ 3] cmp adrh`	`3a22 : 65b4 [ 3] adc ad2 ;perform add`
	`3a24 : 08 [ 3] php`
	`3a25 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3a27 : f002 [ 3]> beq skip3310`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3a29 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3a2a : 2a > db test_num`
	`>`
	`3a2b : >skip3310`

	`3a2b : 68 [ 4] pla ;check flags`
	`3a2c : 2901 [ 2] and #1 ;mask carry`
	`3a2e : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`32e1 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3a30 : f002 [ 3]> beq skip3312`
	`> trap ;failed equal (zero)`
`32e3 : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`32e4 : 08 [ 3] php ;save carry for next add`	`3a32 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`32e5 : a50d [ 3] lda ad1`	`3a33 : 2a > db test_num`
`32e7 : e512 [ 3] sbc sb2 ;perform subtract`	`>`
`32e9 : 08 [ 3] php`	`3a34 : >skip3312`
`32ea : c50f [ 3] cmp adrl ;check result`
	`3a34 : 28 [ 4] plp`
	`3a35 : 08 [ 3] php ;save carry for next add`
	`3a36 : a5b3 [ 3] lda ad1`
	`3a38 : e5b8 [ 3] sbc sb2 ;perform subtract`
	`3a3a : 08 [ 3] php`
	`3a3b : c5b5 [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`32ec : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3a3d : f002 [ 3]> beq skip3314`
	`> trap ;failed equal (zero)`
`32ee : 68 [ 4] pla ;check flags`	`>; db $db ; M65C02/M65C02A SToP instruction`
`32ef : 2901 [ 2] and #1 ;mask carry`	`3a3f : 00 [ 7]> brk ; Use BRK to return to the monitor`
`32f1 : c510 [ 3] cmp adrh`	`3a40 : 2a > db test_num`
	`>`
	`3a41 : >skip3314`

	`3a41 : 68 [ 4] pla ;check flags`
	`3a42 : 2901 [ 2] and #1 ;mask carry`
	`3a44 : c5b6 [ 3] cmp adrh`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`32f3 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3a46 : f002 [ 3]> beq skip3316`
	`> trap ;failed equal (zero)`
`32f5 : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`; decimal ADC / SBC abs`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 369`
`32f6 : 08 [ 3] php ;save carry for subtract`
`32f7 : a50d [ 3] lda ad1`
`32f9 : 6d0302 [ 4] adc ada2 ;perform add`
`32fc : 08 [ 3] php`
`32fd : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`32ff : d0fe [ 3]> bne * ;failed not equal (non zero)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 243`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3a48 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3a49 : 2a > db test_num`
	`>`
	`3a4a : >skip3316`

`3301 : 68 [ 4] pla ;check flags`	`3a4a : 28 [ 4] plp`
`3302 : 2901 [ 2] and #1 ;mask carry`
`3304 : c510 [ 3] cmp adrh`
`trap_ne ;bad carry`
`3306 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`3308 : 28 [ 4] plp`	`; decimal ADC / SBC abs`
`3309 : 08 [ 3] php ;save carry for next add`
`330a : a50d [ 3] lda ad1`
`330c : ed0402 [ 4] sbc sba2 ;perform subtract`
`330f : 08 [ 3] php`
`3310 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`3312 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`3314 : 68 [ 4] pla ;check flags`	`3a4b : 08 [ 3] php ;save carry for subtract`
`3315 : 2901 [ 2] and #1 ;mask carry`	`3a4c : a5b3 [ 3] lda ad1`
`3317 : c510 [ 3] cmp adrh`	`3a4e : 6d0302 [ 4] adc ada2 ;perform add`
	`3a51 : 08 [ 3] php`
	`3a52 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3a54 : f002 [ 3]> beq skip3318`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3a56 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3a57 : 2a > db test_num`
	`>`
	`3a58 : >skip3318`

	`3a58 : 68 [ 4] pla ;check flags`
	`3a59 : 2901 [ 2] and #1 ;mask carry`
	`3a5b : c5b6 [ 3] cmp adrh`
	`trap_ne ;bad carry`
	`3a5d : f002 [ 3]> beq skip3320`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3a5f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3a60 : 2a > db test_num`
	`>`
	`3a61 : >skip3320`

	`3a61 : 28 [ 4] plp`
	`3a62 : 08 [ 3] php ;save carry for next add`
	`3a63 : a5b3 [ 3] lda ad1`
	`3a65 : ed0402 [ 4] sbc sba2 ;perform subtract`
	`3a68 : 08 [ 3] php`
	`3a69 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3a6b : f002 [ 3]> beq skip3322`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3a6d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3a6e : 2a > db test_num`
	`>`
	`3a6f : >skip3322`

	`3a6f : 68 [ 4] pla ;check flags`
	`3a70 : 2901 [ 2] and #1 ;mask carry`
	`3a72 : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`3319 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3a74 : f002 [ 3]> beq skip3324`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 370`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3a76 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3a77 : 2a > db test_num`
	`>`
	`3a78 : >skip3324`

	`3a78 : 28 [ 4] plp`

`331b : 28 [ 4] plp`
`; decimal ADC / SBC #`	`; decimal ADC / SBC #`
`331c : 08 [ 3] php ;save carry for subtract`
`331d : a50e [ 3] lda ad2`
`331f : 8d2533 [ 4] sta chkdadi ;self modify immediate`
`3322 : a50d [ 3] lda ad1`
`3325 = chkdadi = * + 1 ;operand of the immediate ADC`
`3324 : 6900 [ 2] adc #0 ;perform add`
`3326 : 08 [ 3] php`
`3327 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`3329 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`332b : 68 [ 4] pla ;check flags`	`3a79 : 08 [ 3] php ;save carry for subtract`
`332c : 2901 [ 2] and #1 ;mask carry`	`3a7a : a5b4 [ 3] lda ad2`
`332e : c510 [ 3] cmp adrh`	`3a7c : 8d823a [ 4] sta chkdadi ;self modify immediate`
	`3a7f : a5b3 [ 3] lda ad1`

	`3a82 = chkdadi = * + 1 ;operand of the immediate ADC`

	`3a81 : 6900 [ 2] adc #0 ;perform add`
	`3a83 : 08 [ 3] php`
	`3a84 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3a86 : f002 [ 3]> beq skip3326`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3a88 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3a89 : 2a > db test_num`
	`>`
	`3a8a : >skip3326`

	`3a8a : 68 [ 4] pla ;check flags`
	`3a8b : 2901 [ 2] and #1 ;mask carry`
	`3a8d : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`3330 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3a8f : f002 [ 3]> beq skip3328`
	`> trap ;failed equal (zero)`
`3332 : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`3333 : 08 [ 3] php ;save carry for next add`	`3a91 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`3334 : a512 [ 3] lda sb2`	`3a92 : 2a > db test_num`
`3336 : 8d3c33 [ 4] sta chkdsbi ;self modify immediate`	`>`
`3339 : a50d [ 3] lda ad1`	`3a93 : >skip3328`
`333c = chkdsbi = * + 1 ;operand of the immediate SBC`
`333b : e900 [ 2] sbc #0 ;perform subtract`	`3a93 : 28 [ 4] plp`
`333d : 08 [ 3] php`	`3a94 : 08 [ 3] php ;save carry for next add`
`333e : c50f [ 3] cmp adrl ;check result`	`3a95 : a5b8 [ 3] lda sb2`
	`3a97 : 8d9d3a [ 4] sta chkdsbi ;self modify immediate`
	`3a9a : a5b3 [ 3] lda ad1`

	`3a9d = chkdsbi = * + 1 ;operand of the immediate SBC`

	`3a9c : e900 [ 2] sbc #0 ;perform subtract`
	`3a9e : 08 [ 3] php`
	`3a9f : c5b5 [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`3340 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3aa1 : f002 [ 3]> beq skip3330`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 371`
`3342 : 68 [ 4] pla ;check flags`
`3343 : 2901 [ 2] and #1 ;mask carry`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 244`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`3345 : c510 [ 3] cmp adrh`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3aa3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3aa4 : 2a > db test_num`
	`>`
	`3aa5 : >skip3330`

	`3aa5 : 68 [ 4] pla ;check flags`
	`3aa6 : 2901 [ 2] and #1 ;mask carry`
	`3aa8 : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`3347 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3aaa : f002 [ 3]> beq skip3332`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3aac : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3aad : 2a > db test_num`
	`>`
	`3aae : >skip3332`

	`3aae : 28 [ 4] plp`

`3349 : 28 [ 4] plp`
`; decimal ADC / SBC zp,x`	`; decimal ADC / SBC zp,x`
`334a : 08 [ 3] php ;save carry for subtract`
`334b : a50d [ 3] lda ad1`
`334d : 7500 [ 4] adc 0,x ;perform add`
`334f : 08 [ 3] php`
`3350 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`3352 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`3354 : 68 [ 4] pla ;check flags`	`3aaf : 08 [ 3] php ;save carry for subtract`
`3355 : 2901 [ 2] and #1 ;mask carry`	`3ab0 : a5b3 [ 3] lda ad1`
`3357 : c510 [ 3] cmp adrh`	`3ab2 : 7500 [ 4] adc 0,x ;perform add`
	`3ab4 : 08 [ 3] php`
	`3ab5 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3ab7 : f002 [ 3]> beq skip3334`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3ab9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3aba : 2a > db test_num`
	`>`
	`3abb : >skip3334`

	`3abb : 68 [ 4] pla ;check flags`
	`3abc : 2901 [ 2] and #1 ;mask carry`
	`3abe : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`3359 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3ac0 : f002 [ 3]> beq skip3336`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3ac2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3ac3 : 2a > db test_num`
	`>`
	`3ac4 : >skip3336`

	`3ac4 : 28 [ 4] plp`
	`3ac5 : 08 [ 3] php ;save carry for next add`
	`3ac6 : a5b3 [ 3] lda ad1`
	`3ac8 : f504 [ 4] sbc sb2-ad2,x ;perform subtract`
	`3aca : 08 [ 3] php`
	`3acb : c5b5 [ 3] cmp adrl ;check result`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 372`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`335b : 28 [ 4] plp`
`335c : 08 [ 3] php ;save carry for next add`
`335d : a50d [ 3] lda ad1`
`335f : f504 [ 4] sbc sb2-ad2,x ;perform subtract`
`3361 : 08 [ 3] php`
`3362 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`3364 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3acd : f002 [ 3]> beq skip3338`
	`> trap ;failed equal (zero)`
`3366 : 68 [ 4] pla ;check flags`	`>; db $db ; M65C02/M65C02A SToP instruction`
`3367 : 2901 [ 2] and #1 ;mask carry`	`3acf : 00 [ 7]> brk ; Use BRK to return to the monitor`
`3369 : c510 [ 3] cmp adrh`	`3ad0 : 2a > db test_num`
	`>`
	`3ad1 : >skip3338`

	`3ad1 : 68 [ 4] pla ;check flags`
	`3ad2 : 2901 [ 2] and #1 ;mask carry`
	`3ad4 : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`336b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3ad6 : f002 [ 3]> beq skip3340`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3ad8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3ad9 : 2a > db test_num`
	`>`
	`3ada : >skip3340`

	`3ada : 28 [ 4] plp`

`336d : 28 [ 4] plp`
`; decimal ADC / SBC abs,x`	`; decimal ADC / SBC abs,x`
`336e : 08 [ 3] php ;save carry for subtract`
`336f : a50d [ 3] lda ad1`
`3371 : 7df501 [ 4] adc ada2-ad2,x ;perform add`
`3374 : 08 [ 3] php`
`3375 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`3377 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`3379 : 68 [ 4] pla ;check flags`	`3adb : 08 [ 3] php ;save carry for subtract`
`337a : 2901 [ 2] and #1 ;mask carry`	`3adc : a5b3 [ 3] lda ad1`
`337c : c510 [ 3] cmp adrh`	`3ade : 7d4f01 [ 4] adc ada2-ad2,x ;perform add`
	`3ae1 : 08 [ 3] php`
	`3ae2 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3ae4 : f002 [ 3]> beq skip3342`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3ae6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3ae7 : 2a > db test_num`
	`>`
	`3ae8 : >skip3342`

	`3ae8 : 68 [ 4] pla ;check flags`
	`3ae9 : 2901 [ 2] and #1 ;mask carry`
	`3aeb : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`337e : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3aed : f002 [ 3]> beq skip3344`
	`> trap ;failed equal (zero)`
`3380 : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`3381 : 08 [ 3] php ;save carry for next add`	`3aef : 00 [ 7]> brk ; Use BRK to return to the monitor`
`3382 : a50d [ 3] lda ad1`	`3af0 : 2a > db test_num`
`3384 : fdf601 [ 4] sbc sba2-ad2,x ;perform subtract`	`>`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 245`	`3af1 : >skip3344`

	`3af1 : 28 [ 4] plp`
	`3af2 : 08 [ 3] php ;save carry for next add`
	`3af3 : a5b3 [ 3] lda ad1`
	`3af5 : fd5001 [ 4] sbc sba2-ad2,x ;perform subtract`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 373`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`3387 : 08 [ 3] php`	`3af8 : 08 [ 3] php`
`3388 : c50f [ 3] cmp adrl ;check result`	`3af9 : c5b5 [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`338a : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3afb : f002 [ 3]> beq skip3346`
	`> trap ;failed equal (zero)`
`338c : 68 [ 4] pla ;check flags`	`>; db $db ; M65C02/M65C02A SToP instruction`
`338d : 2901 [ 2] and #1 ;mask carry`	`3afd : 00 [ 7]> brk ; Use BRK to return to the monitor`
`338f : c510 [ 3] cmp adrh`	`3afe : 2a > db test_num`
	`>`
	`3aff : >skip3346`

	`3aff : 68 [ 4] pla ;check flags`
	`3b00 : 2901 [ 2] and #1 ;mask carry`
	`3b02 : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`3391 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3b04 : f002 [ 3]> beq skip3348`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3b06 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3b07 : 2a > db test_num`
	`>`
	`3b08 : >skip3348`

	`3b08 : 28 [ 4] plp`

`3393 : 28 [ 4] plp`
`; decimal ADC / SBC abs,y`	`; decimal ADC / SBC abs,y`
`3394 : 08 [ 3] php ;save carry for subtract`
`3395 : a50d [ 3] lda ad1`
`3397 : 790401 [ 4] adc ada2-$ff,y ;perform add`
`339a : 08 [ 3] php`
`339b : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`339d : d0fe [ 3]> bne * ;failed not equal (non zero)`

`339f : 68 [ 4] pla ;check flags`	`3b09 : 08 [ 3] php ;save carry for subtract`
`33a0 : 2901 [ 2] and #1 ;mask carry`	`3b0a : a5b3 [ 3] lda ad1`
`33a2 : c510 [ 3] cmp adrh`	`3b0c : 790401 [ 4] adc ada2-$ff,y ;perform add`
	`3b0f : 08 [ 3] php`
	`3b10 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3b12 : f002 [ 3]> beq skip3350`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3b14 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3b15 : 2a > db test_num`
	`>`
	`3b16 : >skip3350`

	`3b16 : 68 [ 4] pla ;check flags`
	`3b17 : 2901 [ 2] and #1 ;mask carry`
	`3b19 : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`33a4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3b1b : f002 [ 3]> beq skip3352`
	`> trap ;failed equal (zero)`
`33a6 : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`33a7 : 08 [ 3] php ;save carry for next add`	`3b1d : 00 [ 7]> brk ; Use BRK to return to the monitor`
`33a8 : a50d [ 3] lda ad1`	`3b1e : 2a > db test_num`
`33aa : f90501 [ 4] sbc sba2-$ff,y ;perform subtract`	`>`
`33ad : 08 [ 3] php`	`3b1f : >skip3352`
`33ae : c50f [ 3] cmp adrl ;check result`
	`3b1f : 28 [ 4] plp`
	`3b20 : 08 [ 3] php ;save carry for next add`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 374`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3b21 : a5b3 [ 3] lda ad1`
	`3b23 : f90501 [ 4] sbc sba2-$ff,y ;perform subtract`
	`3b26 : 08 [ 3] php`
	`3b27 : c5b5 [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`33b0 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3b29 : f002 [ 3]> beq skip3354`
	`> trap ;failed equal (zero)`
`33b2 : 68 [ 4] pla ;check flags`	`>; db $db ; M65C02/M65C02A SToP instruction`
`33b3 : 2901 [ 2] and #1 ;mask carry`	`3b2b : 00 [ 7]> brk ; Use BRK to return to the monitor`
`33b5 : c510 [ 3] cmp adrh`	`3b2c : 2a > db test_num`
	`>`
	`3b2d : >skip3354`

	`3b2d : 68 [ 4] pla ;check flags`
	`3b2e : 2901 [ 2] and #1 ;mask carry`
	`3b30 : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`33b7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3b32 : f002 [ 3]> beq skip3356`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3b34 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3b35 : 2a > db test_num`
	`>`
	`3b36 : >skip3356`

`33b9 : 28 [ 4] plp`	`3b36 : 28 [ 4] plp`
`; decimal ADC / SBC (zp,x)`
`33ba : 08 [ 3] php ;save carry for subtract`
`33bb : a50d [ 3] lda ad1`
`33bd : 6144 [ 6] adc (lo adi2-ad2,x) ;perform add`
`33bf : 08 [ 3] php`
`33c0 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`33c2 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`33c4 : 68 [ 4] pla ;check flags`	`; decimal ADC / SBC (zp,x)`
`33c5 : 2901 [ 2] and #1 ;mask carry`
`33c7 : c510 [ 3] cmp adrh`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 246`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3b37 : 08 [ 3] php ;save carry for subtract`
	`3b38 : a5b3 [ 3] lda ad1`
	`3b3a : 6144 [ 6] adc (lo adi2-ad2,x) ;perform add`
	`3b3c : 08 [ 3] php`
	`3b3d : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3b3f : f002 [ 3]> beq skip3358`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3b41 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3b42 : 2a > db test_num`
	`>`
	`3b43 : >skip3358`

	`3b43 : 68 [ 4] pla ;check flags`
	`3b44 : 2901 [ 2] and #1 ;mask carry`
	`3b46 : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`33c9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3b48 : f002 [ 3]> beq skip3360`
	`> trap ;failed equal (zero)`
`33cb : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`33cc : 08 [ 3] php ;save carry for next add`	`3b4a : 00 [ 7]> brk ; Use BRK to return to the monitor`
`33cd : a50d [ 3] lda ad1`	`3b4b : 2a > db test_num`
`33cf : e146 [ 6] sbc (lo sbi2-ad2,x) ;perform subtract`	`>`
`33d1 : 08 [ 3] php`	`3b4c : >skip3360`
`33d2 : c50f [ 3] cmp adrl ;check result`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 375`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3b4c : 28 [ 4] plp`
	`3b4d : 08 [ 3] php ;save carry for next add`
	`3b4e : a5b3 [ 3] lda ad1`
	`3b50 : e146 [ 6] sbc (lo sbi2-ad2,x) ;perform subtract`
	`3b52 : 08 [ 3] php`
	`3b53 : c5b5 [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`33d4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3b55 : f002 [ 3]> beq skip3362`
	`> trap ;failed equal (zero)`
`33d6 : 68 [ 4] pla ;check flags`	`>; db $db ; M65C02/M65C02A SToP instruction`
`33d7 : 2901 [ 2] and #1 ;mask carry`	`3b57 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`33d9 : c510 [ 3] cmp adrh`	`3b58 : 2a > db test_num`
	`>`
	`3b59 : >skip3362`

	`3b59 : 68 [ 4] pla ;check flags`
	`3b5a : 2901 [ 2] and #1 ;mask carry`
	`3b5c : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`33db : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3b5e : f002 [ 3]> beq skip3364`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3b60 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3b61 : 2a > db test_num`
	`>`
	`3b62 : >skip3364`

	`3b62 : 28 [ 4] plp`

`33dd : 28 [ 4] plp`
`; decimal ADC / SBC (abs),y`	`; decimal ADC / SBC (abs),y`
`33de : 08 [ 3] php ;save carry for subtract`
`33df : a50d [ 3] lda ad1`
`33e1 : 7156 [ 5] adc (adiy2),y ;perform add`
`33e3 : 08 [ 3] php`
`33e4 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`33e6 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`33e8 : 68 [ 4] pla ;check flags`	`3b63 : 08 [ 3] php ;save carry for subtract`
`33e9 : 2901 [ 2] and #1 ;mask carry`	`3b64 : a5b3 [ 3] lda ad1`
`33eb : c510 [ 3] cmp adrh`	`3b66 : 71fc [ 5] adc (adiy2),y ;perform add`
	`3b68 : 08 [ 3] php`
	`3b69 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3b6b : f002 [ 3]> beq skip3366`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3b6d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3b6e : 2a > db test_num`
	`>`
	`3b6f : >skip3366`

	`3b6f : 68 [ 4] pla ;check flags`
	`3b70 : 2901 [ 2] and #1 ;mask carry`
	`3b72 : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`33ed : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3b74 : f002 [ 3]> beq skip3368`
	`> trap ;failed equal (zero)`
`33ef : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`33f0 : 08 [ 3] php ;save carry for next add`	`3b76 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`33f1 : a50d [ 3] lda ad1`	`3b77 : 2a > db test_num`
`33f3 : f158 [ 5] sbc (sbiy2),y ;perform subtract`	`>`
`33f5 : 08 [ 3] php`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 376`
`33f6 : c50f [ 3] cmp adrl ;check result`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3b78 : >skip3368`

	`3b78 : 28 [ 4] plp`
	`3b79 : 08 [ 3] php ;save carry for next add`
	`3b7a : a5b3 [ 3] lda ad1`
	`3b7c : f1fe [ 5] sbc (sbiy2),y ;perform subtract`
	`3b7e : 08 [ 3] php`
	`3b7f : c5b5 [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`33f8 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3b81 : f002 [ 3]> beq skip3370`
	`> trap ;failed equal (zero)`
`33fa : 68 [ 4] pla ;check flags`	`>; db $db ; M65C02/M65C02A SToP instruction`
`33fb : 2901 [ 2] and #1 ;mask carry`	`3b83 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`33fd : c510 [ 3] cmp adrh`	`3b84 : 2a > db test_num`
	`>`
	`3b85 : >skip3370`

	`3b85 : 68 [ 4] pla ;check flags`
	`3b86 : 2901 [ 2] and #1 ;mask carry`
	`3b88 : c5b6 [ 3] cmp adrh`
`trap_ne ;bad carry`	`trap_ne ;bad carry`
`33ff : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3b8a : f002 [ 3]> beq skip3372`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3b8c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3b8d : 2a > db test_num`
	`>`
	`3b8e : >skip3372`

`3401 : 28 [ 4] plp`	`3b8e : 28 [ 4] plp`
`3402 : 60 [ 6] rts`	`3b8f : 60 [ 6] rts`

`; core subroutine of the full binary add/subtract test`	`; core subroutine of the full binary add/subtract test`
`; iterates through all combinations of operands and carry input`	`; iterates through all combinations of operands and carry input`
`; uses increments/decrements to predict result & result flags`	`; uses increments/decrements to predict result & result flags`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 247`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`3403 : a511 [ 3] chkadd lda adrf ;add V-flag if overflow`	`3b90 : a5b7 [ 3] chkadd lda adrf ;add V-flag if overflow`
`3405 : 2983 [ 2] and #$83 ;keep N-----ZC / clear V`	`3b92 : 2983 [ 2] and #$83 ;keep N-----ZC / clear V`
`3407 : 48 [ 3] pha`	`3b94 : 48 [ 3] pha`
`3408 : a50d [ 3] lda ad1 ;test sign unequal between operands`	`3b95 : a5b3 [ 3] lda ad1 ;test sign unequal between operands`
`340a : 450e [ 3] eor ad2`	`3b97 : 45b4 [ 3] eor ad2`
`340c : 300a [ 3] bmi ckad1 ;no overflow possible - operands have different sign`	`3b99 : 300a [ 3] bmi ckad1 ;no overflow possible - operands have different sign`
`340e : a50d [ 3] lda ad1 ;test sign equal between operands and result`	`3b9b : a5b3 [ 3] lda ad1 ;test sign equal between operands and result`
`3410 : 450f [ 3] eor adrl`	`3b9d : 45b5 [ 3] eor adrl`
`3412 : 1004 [ 3] bpl ckad1 ;no overflow occured - operand and result have same sign`	`3b9f : 1004 [ 3] bpl ckad1 ;no overflow occured - operand and result have same sign`
`3414 : 68 [ 4] pla`	`3ba1 : 68 [ 4] pla`
`3415 : 0940 [ 2] ora #$40 ;set V`	`3ba2 : 0940 [ 2] ora #$40 ;set V`
`3417 : 48 [ 3] pha`	`3ba4 : 48 [ 3] pha`
`3418 : 68 [ 4] ckad1 pla`	`3ba5 : 68 [ 4] ckad1 pla`
`3419 : 8511 [ 3] sta adrf ;save expected flags`	`3ba6 : 85b7 [ 3] sta adrf ;save expected flags`

`; binary ADC / SBC zp`	`; binary ADC / SBC zp`
`341b : 08 [ 3] php ;save carry for subtract`
`341c : a50d [ 3] lda ad1`
`341e : 650e [ 3] adc ad2 ;perform add`
`3420 : 08 [ 3] php`
`3421 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`3423 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`3425 : 68 [ 4] pla ;check flags`	`3ba8 : 08 [ 3] php ;save carry for subtract`
`3426 : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`3ba9 : a5b3 [ 3] lda ad1`
`3428 : c511 [ 3] cmp adrf`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 377`
`trap_ne ;bad flags`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`342a : d0fe [ 3]> bne * ;failed not equal (non zero)`

`342c : 28 [ 4] plp`	`3bab : 65b4 [ 3] adc ad2 ;perform add`
`342d : 08 [ 3] php ;save carry for next add`	`3bad : 08 [ 3] php`
`342e : a50d [ 3] lda ad1`	`3bae : c5b5 [ 3] cmp adrl ;check result`
`3430 : e512 [ 3] sbc sb2 ;perform subtract`
`3432 : 08 [ 3] php`
`3433 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`3435 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3bb0 : f002 [ 3]> beq skip3374`
	`> trap ;failed equal (zero)`
`3437 : 68 [ 4] pla ;check flags`	`>; db $db ; M65C02/M65C02A SToP instruction`
`3438 : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`3bb2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`343a : c511 [ 3] cmp adrf`	`3bb3 : 2a > db test_num`
	`>`
	`3bb4 : >skip3374`

	`3bb4 : 68 [ 4] pla ;check flags`
	`3bb5 : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3bb7 : c5b7 [ 3] cmp adrf`
	`trap_ne ;bad flags`
	`3bb9 : f002 [ 3]> beq skip3376`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3bbb : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3bbc : 2a > db test_num`
	`>`
	`3bbd : >skip3376`

	`3bbd : 28 [ 4] plp`
	`3bbe : 08 [ 3] php ;save carry for next add`
	`3bbf : a5b3 [ 3] lda ad1`
	`3bc1 : e5b8 [ 3] sbc sb2 ;perform subtract`
	`3bc3 : 08 [ 3] php`
	`3bc4 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3bc6 : f002 [ 3]> beq skip3378`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3bc8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3bc9 : 2a > db test_num`
	`>`
	`3bca : >skip3378`

	`3bca : 68 [ 4] pla ;check flags`
	`3bcb : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3bcd : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`343c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3bcf : f002 [ 3]> beq skip3380`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3bd1 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3bd2 : 2a > db test_num`
	`>`
	`3bd3 : >skip3380`

	`3bd3 : 28 [ 4] plp`

`343e : 28 [ 4] plp`
`; binary ADC / SBC abs`	`; binary ADC / SBC abs`
`343f : 08 [ 3] php ;save carry for subtract`
`3440 : a50d [ 3] lda ad1`
`3442 : 6d0302 [ 4] adc ada2 ;perform add`
`3445 : 08 [ 3] php`
`3446 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`3448 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`344a : 68 [ 4] pla ;check flags`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 378`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 248`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`344b : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`3bd4 : 08 [ 3] php ;save carry for subtract`
`344d : c511 [ 3] cmp adrf`	`3bd5 : a5b3 [ 3] lda ad1`
	`3bd7 : 6d0302 [ 4] adc ada2 ;perform add`
	`3bda : 08 [ 3] php`
	`3bdb : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3bdd : f002 [ 3]> beq skip3382`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3bdf : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3be0 : 2a > db test_num`
	`>`
	`3be1 : >skip3382`

	`3be1 : 68 [ 4] pla ;check flags`
	`3be2 : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3be4 : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`344f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3be6 : f002 [ 3]> beq skip3384`
	`> trap ;failed equal (zero)`
`3451 : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`3452 : 08 [ 3] php ;save carry for next add`	`3be8 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`3453 : a50d [ 3] lda ad1`	`3be9 : 2a > db test_num`
`3455 : ed0402 [ 4] sbc sba2 ;perform subtract`	`>`
`3458 : 08 [ 3] php`	`3bea : >skip3384`
`3459 : c50f [ 3] cmp adrl ;check result`
	`3bea : 28 [ 4] plp`
	`3beb : 08 [ 3] php ;save carry for next add`
	`3bec : a5b3 [ 3] lda ad1`
	`3bee : ed0402 [ 4] sbc sba2 ;perform subtract`
	`3bf1 : 08 [ 3] php`
	`3bf2 : c5b5 [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`345b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3bf4 : f002 [ 3]> beq skip3386`
	`> trap ;failed equal (zero)`
`345d : 68 [ 4] pla ;check flags`	`>; db $db ; M65C02/M65C02A SToP instruction`
`345e : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`3bf6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`3460 : c511 [ 3] cmp adrf`	`3bf7 : 2a > db test_num`
	`>`
	`3bf8 : >skip3386`

	`3bf8 : 68 [ 4] pla ;check flags`
	`3bf9 : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3bfb : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`3462 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3bfd : f002 [ 4]> beq skip3388`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3bff : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3c00 : 2a > db test_num`
	`>`
	`3c01 : >skip3388`

	`3c01 : 28 [ 4] plp`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 379`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`3464 : 28 [ 4] plp`
`; binary ADC / SBC #`	`; binary ADC / SBC #`
`3465 : 08 [ 3] php ;save carry for subtract`
`3466 : a50e [ 3] lda ad2`
`3468 : 8d6e34 [ 4] sta chkadi ;self modify immediate`
`346b : a50d [ 3] lda ad1`
`346e = chkadi = * + 1 ;operand of the immediate ADC`
`346d : 6900 [ 2] adc #0 ;perform add`
`346f : 08 [ 3] php`
`3470 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`3472 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`3474 : 68 [ 4] pla ;check flags`	`3c02 : 08 [ 3] php ;save carry for subtract`
`3475 : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`3c03 : a5b4 [ 3] lda ad2`
`3477 : c511 [ 3] cmp adrf`	`3c05 : 8d0b3c [ 4] sta chkadi ;self modify immediate`
	`3c08 : a5b3 [ 3] lda ad1`

	`3c0b = chkadi = * + 1 ;operand of the immediate ADC`

	`3c0a : 6900 [ 2] adc #0 ;perform add`
	`3c0c : 08 [ 3] php`
	`3c0d : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3c0f : f002 [ 3]> beq skip3390`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3c11 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3c12 : 2a > db test_num`
	`>`
	`3c13 : >skip3390`

	`3c13 : 68 [ 4] pla ;check flags`
	`3c14 : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3c16 : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`3479 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3c18 : f002 [ 3]> beq skip3392`
	`> trap ;failed equal (zero)`
`347b : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`347c : 08 [ 3] php ;save carry for next add`	`3c1a : 00 [ 7]> brk ; Use BRK to return to the monitor`
`347d : a512 [ 3] lda sb2`	`3c1b : 2a > db test_num`
`347f : 8d8534 [ 4] sta chksbi ;self modify immediate`	`>`
`3482 : a50d [ 3] lda ad1`	`3c1c : >skip3392`
`3485 = chksbi = * + 1 ;operand of the immediate SBC`
`3484 : e900 [ 2] sbc #0 ;perform subtract`	`3c1c : 28 [ 4] plp`
`3486 : 08 [ 3] php`	`3c1d : 08 [ 3] php ;save carry for next add`
`3487 : c50f [ 3] cmp adrl ;check result`	`3c1e : a5b8 [ 3] lda sb2`
	`3c20 : 8d263c [ 4] sta chksbi ;self modify immediate`
	`3c23 : a5b3 [ 3] lda ad1`

	`3c26 = chksbi = * + 1 ;operand of the immediate SBC`

	`3c25 : e900 [ 2] sbc #0 ;perform subtract`
	`3c27 : 08 [ 3] php`
	`3c28 : c5b5 [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`3489 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3c2a : f002 [ 3]> beq skip3394`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3c2c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3c2d : 2a > db test_num`
	`>`
	`3c2e : >skip3394`

`348b : 68 [ 4] pla ;check flags`	`3c2e : 68 [ 4] pla ;check flags`
`348c : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`3c2f : 29c3 [ 2] and #$c3 ;mask NV----ZC`
`348e : c511 [ 3] cmp adrf`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 380`
`trap_ne ;bad flags`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 249`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`3490 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3c31 : c5b7 [ 3] cmp adrf`
	`trap_ne ;bad flags`
	`3c33 : f002 [ 3]> beq skip3396`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3c35 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3c36 : 2a > db test_num`
	`>`
	`3c37 : >skip3396`

	`3c37 : 28 [ 4] plp`

`3492 : 28 [ 4] plp`
`; binary ADC / SBC zp,x`	`; binary ADC / SBC zp,x`
`3493 : 08 [ 3] php ;save carry for subtract`
`3494 : a50d [ 3] lda ad1`
`3496 : 7500 [ 4] adc 0,x ;perform add`
`3498 : 08 [ 3] php`
`3499 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`349b : d0fe [ 3]> bne * ;failed not equal (non zero)`

`349d : 68 [ 4] pla ;check flags`	`3c38 : 08 [ 3] php ;save carry for subtract`
`349e : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`3c39 : a5b3 [ 3] lda ad1`
`34a0 : c511 [ 3] cmp adrf`	`3c3b : 7500 [ 4] adc 0,x ;perform add`
	`3c3d : 08 [ 3] php`
	`3c3e : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3c40 : f002 [ 3]> beq skip3398`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3c42 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3c43 : 2a > db test_num`
	`>`
	`3c44 : >skip3398`

	`3c44 : 68 [ 4] pla ;check flags`
	`3c45 : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3c47 : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`34a2 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3c49 : f002 [ 3]> beq skip3400`
	`> trap ;failed equal (zero)`
`34a4 : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`34a5 : 08 [ 3] php ;save carry for next add`	`3c4b : 00 [ 7]> brk ; Use BRK to return to the monitor`
`34a6 : a50d [ 3] lda ad1`	`3c4c : 2a > db test_num`
`34a8 : f504 [ 4] sbc sb2-ad2,x ;perform subtract`	`>`
`34aa : 08 [ 3] php`	`3c4d : >skip3400`
`34ab : c50f [ 3] cmp adrl ;check result`
	`3c4d : 28 [ 4] plp`
	`3c4e : 08 [ 3] php ;save carry for next add`
	`3c4f : a5b3 [ 3] lda ad1`
	`3c51 : f504 [ 4] sbc sb2-ad2,x ;perform subtract`
	`3c53 : 08 [ 3] php`
	`3c54 : c5b5 [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`34ad : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3c56 : f002 [ 3]> beq skip3402`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3c58 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3c59 : 2a > db test_num`
	`>`
	`3c5a : >skip3402`

`34af : 68 [ 4] pla ;check flags`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 381`
`34b0 : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`
`34b2 : c511 [ 3] cmp adrf`
	`3c5a : 68 [ 4] pla ;check flags`
	`3c5b : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3c5d : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`34b4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3c5f : f002 [ 3]> beq skip3404`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3c61 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3c62 : 2a > db test_num`
	`>`
	`3c63 : >skip3404`

	`3c63 : 28 [ 4] plp`

`34b6 : 28 [ 4] plp`
`; binary ADC / SBC abs,x`	`; binary ADC / SBC abs,x`
`34b7 : 08 [ 3] php ;save carry for subtract`
`34b8 : a50d [ 3] lda ad1`
`34ba : 7df501 [ 4] adc ada2-ad2,x ;perform add`
`34bd : 08 [ 3] php`
`34be : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`34c0 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`34c2 : 68 [ 4] pla ;check flags`	`3c64 : 08 [ 3] php ;save carry for subtract`
`34c3 : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`3c65 : a5b3 [ 3] lda ad1`
`34c5 : c511 [ 3] cmp adrf`	`3c67 : 7d4f01 [ 4] adc ada2-ad2,x ;perform add`
	`3c6a : 08 [ 3] php`
	`3c6b : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3c6d : f002 [ 3]> beq skip3406`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3c6f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3c70 : 2a > db test_num`
	`>`
	`3c71 : >skip3406`

	`3c71 : 68 [ 4] pla ;check flags`
	`3c72 : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3c74 : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`34c7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3c76 : f002 [ 3]> beq skip3408`
	`> trap ;failed equal (zero)`
`34c9 : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`34ca : 08 [ 3] php ;save carry for next add`	`3c78 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`34cb : a50d [ 3] lda ad1`	`3c79 : 2a > db test_num`
`34cd : fdf601 [ 4] sbc sba2-ad2,x ;perform subtract`	`>`
`34d0 : 08 [ 3] php`	`3c7a : >skip3408`
`34d1 : c50f [ 3] cmp adrl ;check result`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 250`	`3c7a : 28 [ 4] plp`
	`3c7b : 08 [ 3] php ;save carry for next add`
	`3c7c : a5b3 [ 3] lda ad1`
	`3c7e : fd5001 [ 4] sbc sba2-ad2,x ;perform subtract`
	`3c81 : 08 [ 3] php`
	`3c82 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3c84 : f002 [ 3]> beq skip3410`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3c86 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3c87 : 2a > db test_num`
	`>`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 382`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`trap_ne ;bad result`	`3c88 : >skip3410`
`34d3 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`34d5 : 68 [ 4] pla ;check flags`	`3c88 : 68 [ 4] pla ;check flags`
`34d6 : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`3c89 : 29c3 [ 2] and #$c3 ;mask NV----ZC`
`34d8 : c511 [ 3] cmp adrf`	`3c8b : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`34da : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3c8d : f002 [ 3]> beq skip3412`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3c8f : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3c90 : 2a > db test_num`
	`>`
	`3c91 : >skip3412`

	`3c91 : 28 [ 4] plp`

`34dc : 28 [ 4] plp`
`; binary ADC / SBC abs,y`	`; binary ADC / SBC abs,y`
`34dd : 08 [ 3] php ;save carry for subtract`
`34de : a50d [ 3] lda ad1`
`34e0 : 790401 [ 4] adc ada2-$ff,y ;perform add`
`34e3 : 08 [ 3] php`
`34e4 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`34e6 : d0fe [ 3]> bne * ;failed not equal (non zero)`

`34e8 : 68 [ 4] pla ;check flags`	`3c92 : 08 [ 3] php ;save carry for subtract`
`34e9 : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`3c93 : a5b3 [ 3] lda ad1`
`34eb : c511 [ 3] cmp adrf`	`3c95 : 790401 [ 4] adc ada2-$ff,y ;perform add`
	`3c98 : 08 [ 3] php`
	`3c99 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3c9b : f002 [ 3]> beq skip3414`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3c9d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3c9e : 2a > db test_num`
	`>`
	`3c9f : >skip3414`

	`3c9f : 68 [ 4] pla ;check flags`
	`3ca0 : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3ca2 : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`34ed : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3ca4 : f002 [ 3]> beq skip3416`
	`> trap ;failed equal (zero)`
`34ef : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`34f0 : 08 [ 3] php ;save carry for next add`	`3ca6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`34f1 : a50d [ 3] lda ad1`	`3ca7 : 2a > db test_num`
`34f3 : f90501 [ 4] sbc sba2-$ff,y ;perform subtract`	`>`
`34f6 : 08 [ 3] php`	`3ca8 : >skip3416`
`34f7 : c50f [ 3] cmp adrl ;check result`
	`3ca8 : 28 [ 4] plp`
	`3ca9 : 08 [ 3] php ;save carry for next add`
	`3caa : a5b3 [ 3] lda ad1`
	`3cac : f90501 [ 4] sbc sba2-$ff,y ;perform subtract`
	`3caf : 08 [ 3] php`
	`3cb0 : c5b5 [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`34f9 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3cb2 : f002 [ 3]> beq skip3418`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3cb4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 383`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`34fb : 68 [ 4] pla ;check flags`	`3cb5 : 2a > db test_num`
`34fc : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`>`
`34fe : c511 [ 3] cmp adrf`	`3cb6 : >skip3418`

	`3cb6 : 68 [ 4] pla ;check flags`
	`3cb7 : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3cb9 : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`3500 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3cbb : f002 [ 3]> beq skip3420`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3cbd : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3cbe : 2a > db test_num`
	`>`
	`3cbf : >skip3420`

	`3cbf : 28 [ 4] plp`

`3502 : 28 [ 4] plp`
`; binary ADC / SBC (zp,x)`	`; binary ADC / SBC (zp,x)`
`3503 : 08 [ 3] php ;save carry for subtract`
`3504 : a50d [ 3] lda ad1`
`3506 : 6144 [ 6] adc (lo adi2-ad2,x) ;perform add`
`3508 : 08 [ 3] php`
`3509 : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`350b : d0fe [ 3]> bne * ;failed not equal (non zero)`

`350d : 68 [ 4] pla ;check flags`	`3cc0 : 08 [ 3] php ;save carry for subtract`
`350e : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`3cc1 : a5b3 [ 3] lda ad1`
`3510 : c511 [ 3] cmp adrf`	`3cc3 : 6144 [ 6] adc (lo adi2-ad2,x) ;perform add`
	`3cc5 : 08 [ 3] php`
	`3cc6 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3cc8 : f002 [ 3]> beq skip3422`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3cca : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3ccb : 2a > db test_num`
	`>`
	`3ccc : >skip3422`

	`3ccc : 68 [ 4] pla ;check flags`
	`3ccd : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3ccf : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`3512 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3cd1 : f002 [ 3]> beq skip3424`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 251`	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3cd3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3cd4 : 2a > db test_num`
	`>`
	`3cd5 : >skip3424`

	`3cd5 : 28 [ 4] plp`
	`3cd6 : 08 [ 3] php ;save carry for next add`
	`3cd7 : a5b3 [ 3] lda ad1`
	`3cd9 : e146 [ 6] sbc (lo sbi2-ad2,x) ;perform subtract`
	`3cdb : 08 [ 3] php`
	`3cdc : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3cde : f002 [ 3]> beq skip3426`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 384`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3ce0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3ce1 : 2a > db test_num`
	`>`
	`3ce2 : >skip3426`

`3514 : 28 [ 4] plp`	`3ce2 : 68 [ 4] pla ;check flags`
`3515 : 08 [ 3] php ;save carry for next add`	`3ce3 : 29c3 [ 2] and #$c3 ;mask NV----ZC`
`3516 : a50d [ 3] lda ad1`	`3ce5 : c5b7 [ 3] cmp adrf`
`3518 : e146 [ 6] sbc (lo sbi2-ad2,x) ;perform subtract`
`351a : 08 [ 3] php`
`351b : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`351d : d0fe [ 3]> bne * ;failed not equal (non zero)`

`351f : 68 [ 4] pla ;check flags`
`3520 : 29c3 [ 2] and #$c3 ;mask NV----ZC`
`3522 : c511 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`3524 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3ce7 : f002 [ 3]> beq skip3428`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3ce9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3cea : 2a > db test_num`
	`>`
	`3ceb : >skip3428`

	`3ceb : 28 [ 4] plp`

`3526 : 28 [ 4] plp`
`; binary ADC / SBC (abs),y`	`; binary ADC / SBC (abs),y`
`3527 : 08 [ 3] php ;save carry for subtract`
`3528 : a50d [ 3] lda ad1`
`352a : 7156 [ 5] adc (adiy2),y ;perform add`
`352c : 08 [ 3] php`
`352d : c50f [ 3] cmp adrl ;check result`
`trap_ne ;bad result`
`352f : d0fe [ 3]> bne * ;failed not equal (non zero)`

`3531 : 68 [ 4] pla ;check flags`	`3cec : 08 [ 3] php ;save carry for subtract`
`3532 : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`3ced : a5b3 [ 3] lda ad1`
`3534 : c511 [ 3] cmp adrf`	`3cef : 71fc [ 5] adc (adiy2),y ;perform add`
	`3cf1 : 08 [ 3] php`
	`3cf2 : c5b5 [ 3] cmp adrl ;check result`
	`trap_ne ;bad result`
	`3cf4 : f002 [ 3]> beq skip3430`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3cf6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3cf7 : 2a > db test_num`
	`>`
	`3cf8 : >skip3430`

	`3cf8 : 68 [ 4] pla ;check flags`
	`3cf9 : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3cfb : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`3536 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3cfd : f002 [ 4]> beq skip3432`
	`> trap ;failed equal (zero)`
`3538 : 28 [ 4] plp`	`>; db $db ; M65C02/M65C02A SToP instruction`
`3539 : 08 [ 3] php ;save carry for next add`	`3cff : 00 [ 7]> brk ; Use BRK to return to the monitor`
`353a : a50d [ 3] lda ad1`	`3d00 : 2a > db test_num`
`353c : f158 [ 5] sbc (sbiy2),y ;perform subtract`	`>`
`353e : 08 [ 3] php`	`3d01 : >skip3432`
`353f : c50f [ 3] cmp adrl ;check result`
	`3d01 : 28 [ 4] plp`
	`3d02 : 08 [ 3] php ;save carry for next add`
	`3d03 : a5b3 [ 3] lda ad1`
	`3d05 : f1fe [ 5] sbc (sbiy2),y ;perform subtract`
	`3d07 : 08 [ 3] php`
	`3d08 : c5b5 [ 3] cmp adrl ;check result`
`trap_ne ;bad result`	`trap_ne ;bad result`
`3541 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 385`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`3543 : 68 [ 4] pla ;check flags`	`3d0a : f002 [ 3]> beq skip3434`
`3544 : 29c3 [ 2] and #$c3 ;mask NV----ZC`	`> trap ;failed equal (zero)`
`3546 : c511 [ 3] cmp adrf`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d0c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d0d : 2a > db test_num`
	`>`
	`3d0e : >skip3434`

	`3d0e : 68 [ 4] pla ;check flags`
	`3d0f : 29c3 [ 2] and #$c3 ;mask NV----ZC`
	`3d11 : c5b7 [ 3] cmp adrf`
`trap_ne ;bad flags`	`trap_ne ;bad flags`
`3548 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3d13 : f002 [ 3]> beq skip3436`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d15 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d16 : 2a > db test_num`
	`>`
	`3d17 : >skip3436`

`354a : 28 [ 4] plp`	`3d17 : 28 [ 4] plp`
`354b : 60 [ 6] rts`	`3d18 : 60 [ 6] rts`

`; target for the jump absolute test`	`; target for the jump absolute test`
`354c : 88 [ 2] dey`
`354d : 88 [ 2] dey`
`354e : test_far`
`354e : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 252`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`354f : 88 [ 2] dey`	`3d19 : 88 [ 2] dey`
`3550 : 88 [ 2] dey`	`3d1a : 88 [ 2] dey`
`3551 : 88 [ 2] dey`	`3d1b : test_far`
`3552 : 28 [ 4] plp`	`3d1b : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`
	`3d1c : 88 [ 2] dey`
	`3d1d : 88 [ 2] dey`
	`3d1e : 88 [ 2] dey`
	`3d1f : 28 [ 4] plp`
`trap_cs ;flags loaded?`	`trap_cs ;flags loaded?`
`3553 : b0fe [ 3]> bcs * ;failed carry set`	`3d20 : 9002 [ 3]> bcc skip3438`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d22 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d23 : 2a > db test_num`
	`>`
	`3d24 : >skip3438`

`trap_vs`	`trap_vs`
`3555 : 70fe [ 3]> bvs * ;failed overflow set`	`3d24 : 5002 [ 3]> bvc skip3440`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d26 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d27 : 2a > db test_num`
	`>`
	`3d28 : >skip3440`

`trap_mi`	`trap_mi`
`3557 : 30fe [ 3]> bmi * ;failed minus (bit 7 set)`	`3d28 : 1002 [ 3]> bpl skip3442`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 386`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3d2a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d2b : 2a > db test_num`
	`>`
	`3d2c : >skip3442`

`trap_eq`	`trap_eq`
`3559 : f0fe [ 3]> beq * ;failed equal (zero)`	`3d2c : d002 [ 3]> bne skip3444`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d2e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d2f : 2a > db test_num`
	`>`
	`3d30 : >skip3444`

`355b : c946 [ 2] cmp #'F' ;registers loaded?`	`3d30 : c946 [ 2] cmp #'F' ;registers loaded?`
`trap_ne`	`trap_ne`
`355d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3d32 : f002 [ 3]> beq skip3446`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d34 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d35 : 2a > db test_num`
	`>`
	`3d36 : >skip3446`

`355f : e041 [ 2] cpx #'A'`	`3d36 : e041 [ 2] cpx #'A'`
`trap_ne`	`trap_ne`
`3561 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3d38 : f002 [ 3]> beq skip3448`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d3a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d3b : 2a > db test_num`
	`>`
	`3d3c : >skip3448`

`3563 : c04f [ 2] cpy #('R'-3)`	`3d3c : c04f [ 2] cpy #('R'-3)`
`trap_ne`	`trap_ne`
`3565 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3d3e : f002 [ 3]> beq skip3450`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d40 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d41 : 2a > db test_num`
	`>`
	`3d42 : >skip3450`

`3567 : 48 [ 3] pha ;save a,x`	`3d42 : 48 [ 3] pha ;save a,x`
`3568 : 8a [ 2] txa`	`3d43 : 8a [ 2] txa`
`3569 : 48 [ 3] pha`	`3d44 : 48 [ 3] pha`
`356a : ba [ 2] tsx`	`3d45 : ba [ 2] tsx`
`356b : e0fd [ 2] cpx #$fd ;check SP`	`3d46 : e0fd [ 2] cpx #$fd ;check SP`
`trap_ne`	`trap_ne`
`356d : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3d48 : f002 [ 3]> beq skip3452`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d4a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d4b : 2a > db test_num`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 387`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`>`
	`3d4c : >skip3452`

`356f : 68 [ 4] pla ;restore x`	`3d4c : 68 [ 4] pla ;restore x`
`3570 : aa [ 2] tax`	`3d4d : aa [ 2] tax`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`3571 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3d4e : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`3573 : 48 [ 3]> pha ;use stack to load status`	`3d50 : 48 [ 3]> pha ;use stack to load status`
`3574 : 28 [ 4]> plp`	`3d51 : 28 [ 4]> plp`

`3575 : 68 [ 4] pla ;restore a`	`3d52 : 68 [ 4] pla ;restore a`
`3576 : e8 [ 2] inx ;return registers with modifications`	`3d53 : e8 [ 2] inx ;return registers with modifications`
`3577 : 49aa [ 2] eor #$aa ;N=1, V=1, Z=0, C=1`	`3d54 : 49aa [ 2] eor #$aa ;N=1, V=1, Z=0, C=1`
`3579 : 4cf707 [ 3] jmp far_ret`	`3d56 : 4ca808 [ 3] jmp far_ret`

`; target for the jump indirect test`	`; target for the jump indirect test`
`align`
`357c : 8535 ptr_tst_ind dw test_ind`
`357e : 4c08 ptr_ind_ret dw ind_ret`
`trap ;runover protection`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 253`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`3580 : 4c8035 [ 3]> jmp * ;failed anyway`	`3d59 : 00 align`

	`3d5a : 623d ptr_tst_ind dw test_ind`
	`3d5c : 1f09 ptr_ind_ret dw ind_ret`

`3583 : 88 [ 2] dey`	`trap ;runover protection`
`3584 : 88 [ 2] dey`	`>; db $db ; M65C02/M65C02A SToP instruction`
`3585 : test_ind`	`3d5e : 00 [ 7]> brk ; Use BRK to return to the monitor`
`3585 : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`	`3d5f : 2a > db test_num`
`3586 : 88 [ 2] dey`
`3587 : 88 [ 2] dey`	`3d60 : 88 [ 2] dey`
`3588 : 88 [ 2] dey`	`3d61 : 88 [ 2] dey`
`3589 : 28 [ 4] plp`	`3d62 : test_ind`
	`3d62 : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`
	`3d63 : 88 [ 2] dey`
	`3d64 : 88 [ 2] dey`
	`3d65 : 88 [ 2] dey`
	`3d66 : 28 [ 4] plp`
`trap_cs ;flags loaded?`	`trap_cs ;flags loaded?`
`358a : b0fe [ 3]> bcs * ;failed carry set`	`3d67 : 9002 [ 3]> bcc skip3457`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d69 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d6a : 2a > db test_num`
	`>`
	`3d6b : >skip3457`

`trap_vs`	`trap_vs`
`358c : 70fe [ 3]> bvs * ;failed overflow set`	`3d6b : 5002 [ 3]> bvc skip3459`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d6d : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d6e : 2a > db test_num`
	`>`
	`3d6f : >skip3459`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 388`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`trap_mi`	`trap_mi`
`358e : 30fe [ 3]> bmi * ;failed minus (bit 7 set)`	`3d6f : 1002 [ 3]> bpl skip3461`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d71 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d72 : 2a > db test_num`
	`>`
	`3d73 : >skip3461`

`trap_eq`	`trap_eq`
`3590 : f0fe [ 3]> beq * ;failed equal (zero)`	`3d73 : d002 [ 3]> bne skip3463`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d75 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d76 : 2a > db test_num`
	`>`
	`3d77 : >skip3463`

`3592 : c949 [ 2] cmp #'I' ;registers loaded?`	`3d77 : c949 [ 2] cmp #'I' ;registers loaded?`
`trap_ne`	`trap_ne`
`3594 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3d79 : f002 [ 3]> beq skip3465`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d7b : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d7c : 2a > db test_num`
	`>`
	`3d7d : >skip3465`

`3596 : e04e [ 2] cpx #'N'`	`3d7d : e04e [ 2] cpx #'N'`
`trap_ne`	`trap_ne`
`3598 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3d7f : f002 [ 3]> beq skip3467`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d81 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d82 : 2a > db test_num`
	`>`
	`3d83 : >skip3467`

`359a : c041 [ 2] cpy #('D'-3)`	`3d83 : c041 [ 2] cpy #('D'-3)`
`trap_ne`	`trap_ne`
`359c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3d85 : f002 [ 3]> beq skip3469`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d87 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d88 : 2a > db test_num`
	`>`
	`3d89 : >skip3469`

`359e : 48 [ 3] pha ;save a,x`	`3d89 : 48 [ 3] pha ;save a,x`
`359f : 8a [ 2] txa`	`3d8a : 8a [ 2] txa`
`35a0 : 48 [ 3] pha`	`3d8b : 48 [ 3] pha`
`35a1 : ba [ 2] tsx`	`3d8c : ba [ 2] tsx`
`35a2 : e0fd [ 2] cpx #$fd ;check SP`	`3d8d : e0fd [ 2] cpx #$fd ;check SP`
`trap_ne`	`trap_ne`
`35a4 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3d8f : f002 [ 3]> beq skip3471`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 389`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`35a6 : 68 [ 4] pla ;restore x`	`> trap ;failed equal (zero)`
`35a7 : aa [ 2] tax`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3d91 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3d92 : 2a > db test_num`
	`>`
	`3d93 : >skip3471`

	`3d93 : 68 [ 4] pla ;restore x`
	`3d94 : aa [ 2] tax`
`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`35a8 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3d95 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`35aa : 48 [ 3]> pha ;use stack to load status`	`3d97 : 48 [ 3]> pha ;use stack to load status`
`35ab : 28 [ 4]> plp`	`3d98 : 28 [ 4]> plp`

`35ac : 68 [ 4] pla ;restore a`
`35ad : e8 [ 2] inx ;return registers with modifications`
`35ae : 49aa [ 2] eor #$aa ;N=1, V=1, Z=0, C=1`
`35b0 : 6c7e35 [ 6] jmp (ptr_ind_ret)`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 254`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3d99 : 68 [ 4] pla ;restore a`
	`3d9a : e8 [ 2] inx ;return registers with modifications`
	`3d9b : 49aa [ 2] eor #$aa ;N=1, V=1, Z=0, C=1`
	`3d9d : 6c5c3d [ 6] jmp (ptr_ind_ret)`
`trap ;runover protection`	`trap ;runover protection`
`35b3 : 4cb335 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3da0 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3da1 : 2a > db test_num`


`; target for the jump subroutine test`	`; target for the jump subroutine test`
`35b6 : 88 [ 2] dey`
`35b7 : 88 [ 2] dey`	`3da2 : 88 [ 2] dey`
`35b8 : test_jsr`	`3da3 : 88 [ 2] dey`
`35b8 : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`	`3da4 : test_jsr`
`35b9 : 88 [ 2] dey`	`3da4 : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`
`35ba : 88 [ 2] dey`	`3da5 : 88 [ 2] dey`
`35bb : 88 [ 2] dey`	`3da6 : 88 [ 2] dey`
`35bc : 28 [ 4] plp`	`3da7 : 88 [ 2] dey`
	`3da8 : 28 [ 4] plp`
`trap_cs ;flags loaded?`	`trap_cs ;flags loaded?`
`35bd : b0fe [ 3]> bcs * ;failed carry set`	`3da9 : 9002 [ 3]> bcc skip3476`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3dab : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3dac : 2a > db test_num`
	`>`
	`3dad : >skip3476`

`trap_vs`	`trap_vs`
`35bf : 70fe [ 3]> bvs * ;failed overflow set`	`3dad : 5002 [ 3]> bvc skip3478`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3daf : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3db0 : 2a > db test_num`
	`>`
	`3db1 : >skip3478`

`trap_mi`	`trap_mi`
`35c1 : 30fe [ 3]> bmi * ;failed minus (bit 7 set)`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 390`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

	`3db1 : 1002 [ 3]> bpl skip3480`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3db3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3db4 : 2a > db test_num`
	`>`
	`3db5 : >skip3480`

`trap_eq`	`trap_eq`
`35c3 : f0fe [ 3]> beq * ;failed equal (zero)`	`3db5 : d002 [ 3]> bne skip3482`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3db7 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3db8 : 2a > db test_num`
	`>`
	`3db9 : >skip3482`

`35c5 : c94a [ 2] cmp #'J' ;registers loaded?`	`3db9 : c94a [ 2] cmp #'J' ;registers loaded?`
`trap_ne`	`trap_ne`
`35c7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3dbb : f002 [ 3]> beq skip3484`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3dbd : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3dbe : 2a > db test_num`
	`>`
	`3dbf : >skip3484`

`35c9 : e053 [ 2] cpx #'S'`	`3dbf : e053 [ 2] cpx #'S'`
`trap_ne`	`trap_ne`
`35cb : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3dc1 : f002 [ 3]> beq skip3486`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3dc3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3dc4 : 2a > db test_num`
	`>`
	`3dc5 : >skip3486`

`35cd : c04f [ 2] cpy #('R'-3)`	`3dc5 : c04f [ 2] cpy #('R'-3)`
`trap_ne`	`trap_ne`
`35cf : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3dc7 : f002 [ 3]> beq skip3488`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3dc9 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3dca : 2a > db test_num`
	`>`
	`3dcb : >skip3488`

`35d1 : 48 [ 3] pha ;save a,x`	`3dcb : 48 [ 3] pha ;save a,x`
`35d2 : 8a [ 2] txa`	`3dcc : 8a [ 2] txa`
`35d3 : 48 [ 3] pha`	`3dcd : 48 [ 3] pha`
`35d4 : ba [ 2] tsx ;sp -4? (return addr,a,x)`	`3dce : ba [ 2] tsx ;sp -4? (return addr,a,x)`
`35d5 : e0fb [ 2] cpx #$fb`	`3dcf : e0fb [ 2] cpx #$fb`
`trap_ne`	`trap_ne`
`35d7 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3dd1 : f002 [ 3]> beq skip3490`
	`> trap ;failed equal (zero)`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 391`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`35d9 : adff01 [ 4] lda $1ff ;propper return on stack`	`>; db $db ; M65C02/M65C02A SToP instruction`
`35dc : c908 [ 2] cmp #hi(jsr_ret)`	`3dd3 : 00 [ 7]> brk ; Use BRK to return to the monitor`
`trap_ne`	`3dd4 : 2a > db test_num`
`35de : d0fe [ 3]> bne * ;failed not equal (non zero)`	`>`
	`3dd5 : >skip3490`

`35e0 : adfe01 [ 4] lda $1fe`	`3dd5 : adff01 [ 4] lda $1ff ;propper return on stack`
`35e3 : c982 [ 2] cmp #lo(jsr_ret)`	`3dd8 : c909 [ 2] cmp #hi(jsr_ret)`
`trap_ne`	`trap_ne`
`35e5 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3dda : f002 [ 3]> beq skip3492`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3ddc : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3ddd : 2a > db test_num`
	`>`
	`3dde : >skip3492`

`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 255`	`3dde : adfe01 [ 4] lda $1fe`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`3de1 : c967 [ 2] cmp #lo(jsr_ret)`
	`trap_ne`
	`3de3 : f002 [ 3]> beq skip3494`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3de5 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3de6 : 2a > db test_num`
	`>`
	`3de7 : >skip3494`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`35e7 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3de7 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`35e9 : 48 [ 3]> pha ;use stack to load status`	`3de9 : 48 [ 3]> pha ;use stack to load status`
`35ea : 28 [ 4]> plp`	`3dea : 28 [ 4]> plp`

`35eb : 68 [ 4] pla ;pull x,a`	`3deb : 68 [ 4] pla ;pull x,a`
`35ec : aa [ 2] tax`	`3dec : aa [ 2] tax`
`35ed : 68 [ 4] pla`	`3ded : 68 [ 4] pla`
`35ee : e8 [ 2] inx ;return registers with modifications`	`3dee : e8 [ 2] inx ;return registers with modifications`
`35ef : 49aa [ 2] eor #$aa ;N=1, V=1, Z=0, C=1`	`3def : 49aa [ 2] eor #$aa ;N=1, V=1, Z=0, C=1`
`35f1 : 60 [ 6] rts`	`3df1 : 60 [ 6] rts`
`trap ;runover protection`	`trap ;runover protection`
`35f2 : 4cf235 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3df2 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3df3 : 2a > db test_num`


`;trap in case of unexpected IRQ, NMI, BRK, RESET - BRK test target`	`;trap in case of unexpected IRQ, NMI, BRK, RESET - BRK test target`
`35f5 : nmi_trap`
	`3df4 : nmi_trap`
`trap ;check stack for conditions at NMI`	`trap ;check stack for conditions at NMI`
`35f5 : 4cf535 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3df4 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3df5 : 2a > db test_num`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 392`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`35f8 : res_trap`	`3df6 : res_trap`
`trap ;unexpected RESET`	`trap ;unexpected RESET`
`35f8 : 4cf835 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3df6 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3df7 : 2a > db test_num`


	`3df8 : 88 [ 2] dey`
	`3df9 : 88 [ 2] dey`
	`3dfa : irq_trap ;BRK test or unextpected BRK or IRQ`
	`3dfa : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`
	`3dfb : 88 [ 2] dey`
	`3dfc : 88 [ 2] dey`
	`3dfd : 88 [ 2] dey`

`35fb : 88 [ 2] dey`
`35fc : 88 [ 2] dey`
`35fd : irq_trap ;BRK test or unextpected BRK or IRQ`
`35fd : 08 [ 3] php ;either SP or Y count will fail, if we do not hit`
`35fe : 88 [ 2] dey`
`35ff : 88 [ 2] dey`
`3600 : 88 [ 2] dey`
`;next 4 traps could be caused by unexpected BRK or IRQ`	`;next 4 traps could be caused by unexpected BRK or IRQ`
`;check stack for BREAK and originating location`	`;check stack for BREAK and originating location`
`;possible jump/branch into weeds (uninitialized space)`	`;possible jump/branch into weeds (uninitialized space)`
`3601 : c942 [ 2] cmp #'B' ;registers loaded?`
	`3dfe : c942 [ 2] cmp #'B' ;registers loaded?`
`trap_ne`	`trap_ne`
`3603 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3e00 : f002 [ 3]> beq skip3501`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3e02 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3e03 : 2a > db test_num`
	`>`
	`3e04 : >skip3501`

`3605 : e052 [ 2] cpx #'R'`	`3e04 : e052 [ 2] cpx #'R'`
`trap_ne`	`trap_ne`
`3607 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3e06 : f002 [ 3]> beq skip3503`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3e08 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3e09 : 2a > db test_num`
	`>`
	`3e0a : >skip3503`

`3609 : c048 [ 2] cpy #('K'-3)`	`3e0a : c048 [ 2] cpy #('K'-3)`
`trap_ne`	`trap_ne`
`360b : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3e0c : f002 [ 3]> beq skip3505`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3e0e : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3e0f : 2a > db test_num`
	`>`
	`3e10 : >skip3505`

`360d : 850a [ 3] sta irq_a ;save registers during break test`	`3e10 : 85b0 [ 3] sta irq_a ;save registers during break test`
`360f : 860b [ 3] stx irq_x`	`3e12 : 86b1 [ 3] stx irq_x`
`3611 : ba [ 2] tsx ;test break on stack`	`3e14 : ba [ 2] tsx ;test break on stack`
`3612 : bd0201 [ 4] lda $102,x`	`3e15 : bd0201 [ 4] lda $102,x`
`cmp_flag 0 ;break test should have B=1`	`cmp_flag 0 ;break test should have B=1`
`3615 : c930 [ 2]> cmp #(0 \|fao)&m8 ;expected flags + always on bits`	`3e18 : c930 [ 2]> cmp #(0 \|fao)&m8 ;expected flags + always on bits`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 256`	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 393`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`


`trap_ne ; - no break flag on stack`	`trap_ne ; - no break flag on stack`
`3617 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3e1a : f002 [ 3]> beq skip3508`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3e1c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3e1d : 2a > db test_num`
	`>`
	`3e1e : >skip3508`

`3619 : 68 [ 4] pla`	`3e1e : 68 [ 4] pla`
`361a : c934 [ 2] cmp #$34 ;should have added interrupt disable`	`3e1f : c934 [ 2] cmp #$34 ;should have added interrupt disable`
`trap_ne`	`trap_ne`
`361c : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3e21 : f002 [ 3]> beq skip3510`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3e23 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3e24 : 2a > db test_num`
	`>`
	`3e25 : >skip3510`

`361e : ba [ 2] tsx`	`3e25 : ba [ 2] tsx`
`361f : e0fc [ 2] cpx #$fc ;sp -3? (return addr, flags)`	`3e26 : e0fc [ 2] cpx #$fc ;sp -3? (return addr, flags)`
`trap_ne`	`trap_ne`
`3621 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3e28 : f002 [ 3]> beq skip3512`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3e2a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3e2b : 2a > db test_num`
	`>`
	`3e2c : >skip3512`

`3623 : adff01 [ 4] lda $1ff ;propper return on stack`	`3e2c : adff01 [ 4] lda $1ff ;propper return on stack`
`3626 : c908 [ 2] cmp #hi(brk_ret)`	`3e2f : c909 [ 2] cmp #hi(brk_ret)`
`trap_ne`	`trap_ne`
`3628 : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3e31 : f002 [ 3]> beq skip3514`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3e33 : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3e34 : 2a > db test_num`
	`>`
	`3e35 : >skip3514`

`362a : adfe01 [ 4] lda $1fe`	`3e35 : adfe01 [ 4] lda $1fe`
`; cmp #lo(brk_ret)`	`; cmp #lo(brk_ret)`
`362d : c9b8 [ 2] cmp #lo(brk_ret - 1) ; M65C02 treats JSR and traps (NMI, BRK/IRQ, RST) the same; add one to`	`3e38 : c9ba [ 2] cmp #lo(brk_ret - 1) ; M65C02 treats JSR and traps (NMI, BRK/IRQ, RST) the same; add one to`
`trap_ne`	`trap_ne`
`362f : d0fe [ 3]> bne * ;failed not equal (non zero)`	`3e3a : f002 [ 3]> beq skip3516`
	`> trap ;failed equal (zero)`
	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3e3c : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3e3d : 2a > db test_num`
	`>`
	`3e3e : >skip3516`

	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 394`
	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`set_stat $ff`	`set_stat $ff`
`> load_flag $ff`	`> load_flag $ff`
`3631 : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`	`3e3e : a9ff [ 2]> lda #$ff ;allow test to change I-flag (no mask)`
`>`	`>`
`3633 : 48 [ 3]> pha ;use stack to load status`	`3e40 : 48 [ 3]> pha ;use stack to load status`
`3634 : 28 [ 4]> plp`	`3e41 : 28 [ 4]> plp`

`3635 : a60b [ 3] ldx irq_x`	`3e42 : a6b1 [ 3] ldx irq_x`
`3637 : e8 [ 2] inx ;return registers with modifications`	`3e44 : e8 [ 2] inx ;return registers with modifications`
`3638 : a50a [ 3] lda irq_a`	`3e45 : a5b0 [ 3] lda irq_a`
`363a : 49aa [ 2] eor #$aa ;N=1, V=1, Z=0, C=1 but original flags should be restored`	`3e47 : 49aa [ 2] eor #$aa ;N=1, V=1, Z=0, C=1 but original flags should be restored`
`363c : 40 [ 6] rti`	`3e49 : 40 [ 6] rti`
`trap ;runover protection`	`trap ;runover protection`
`363d : 4c3d36 [ 3]> jmp * ;failed anyway`	`>; db $db ; M65C02/M65C02A SToP instruction`
	`3e4a : 00 [ 7]> brk ; Use BRK to return to the monitor`
	`3e4b : 2a > db test_num`


`;copy of data to initialize BSS segment`	`;copy of data to initialize BSS segment`

`if load_data_direct != 1`	`if load_data_direct != 1`
`zp_init`
`zp1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR`	`3e4c : zp_init`
`zp7f_ db $7f ;test pattern for compare`	`3e4c : c3824100 zp1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR`
	`3e50 : 7f zp7f_ db $7f ;test pattern for compare`

`;logical zeropage operands`	`;logical zeropage operands`
`zpOR_ db 0,$1f,$71,$80 ;test pattern for OR`
`zpAN_ db $0f,$ff,$7f,$80 ;test pattern for AND`	`3e51 : 001f7180 zpOR_ db 0,$1f,$71,$80 ;test pattern for OR`
`zpEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR`	`3e55 : 0fff7f80 zpAN_ db $0f,$ff,$7f,$80 ;test pattern for AND`
	`3e59 : ff0f8f8f zpEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR`

`;indirect addressing pointers`	`;indirect addressing pointers`
`ind1_ dw abs1 ;indirect pointer to pattern in absolute memory`
`dw abs1+1`	`3e5d : 0802 ind1_ dw abs1 ;indirect pointer to pattern in absolute memory`
`dw abs1+2`	`3e5f : 0902 dw abs1+1`
`dw abs1+3`	`3e61 : 0a02 dw abs1+2`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 257`	`3e63 : 0b02 dw abs1+3`
	`3e65 : 0c02 dw abs7f`
	`3e67 : 1001 inw1_ dw abs1-$f8 ;indirect pointer for wrap-test pattern`
	`3e69 : 0302 indt_ dw abst ;indirect pointer to store area in absolute memory`
	`3e6b : 0402 dw abst+1`
	`3e6d : 0502 dw abst+2`
	`3e6f : 0602 dw abst+3`
	`3e71 : 0b01 inwt_ dw abst-$f8 ;indirect pointer for wrap-test store`
	`3e73 : 3f02 indAN_ dw absAN ;indirect pointer to AND pattern in absolute memory`
	`3e75 : 4002 dw absAN+1`
	`3e77 : 4102 dw absAN+2`
	`3e79 : 4202 dw absAN+3`
	`3e7b : 4302 indEO_ dw absEO ;indirect pointer to EOR pattern in absolute memory`
	`3e7d : 4402 dw absEO+1`
	`3e7f : 4502 dw absEO+2`
	`3e81 : 4602 dw absEO+3`
	`3e83 : 3b02 indOR_ dw absOR ;indirect pointer to OR pattern in absolute memory`
	`3e85 : 3c02 dw absOR+1`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 395`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`dw abs7f`	`3e87 : 3d02 dw absOR+2`
`inw1_ dw abs1-$f8 ;indirect pointer for wrap-test pattern`	`3e89 : 3e02 dw absOR+3`
`indt_ dw abst ;indirect pointer to store area in absolute memory`
`dw abst+1`
`dw abst+2`
`dw abst+3`
`inwt_ dw abst-$f8 ;indirect pointer for wrap-test store`
`indAN_ dw absAN ;indirect pointer to AND pattern in absolute memory`
`dw absAN+1`
`dw absAN+2`
`dw absAN+3`
`indEO_ dw absEO ;indirect pointer to EOR pattern in absolute memory`
`dw absEO+1`
`dw absEO+2`
`dw absEO+3`
`indOR_ dw absOR ;indirect pointer to OR pattern in absolute memory`
`dw absOR+1`
`dw absOR+2`
`dw absOR+3`
`;add/subtract indirect pointers`	`;add/subtract indirect pointers`
`adi2_ dw ada2 ;indirect pointer to operand 2 in absolute memory`
`sbi2_ dw sba2 ;indirect pointer to complemented operand 2 (SBC)`	`3e8b : 0302 adi2_ dw ada2 ;indirect pointer to operand 2 in absolute memory`
`adiy2_ dw ada2-$ff ;with offset for indirect indexed`	`3e8d : 0402 sbi2_ dw sba2 ;indirect pointer to complemented operand 2 (SBC)`
`sbiy2_ dw sba2-$ff`	`3e8f : 0401 adiy2_ dw ada2-$ff ;with offset for indirect indexed`
`zp_end`	`3e91 : 0501 sbiy2_ dw sba2-$ff`
	`3e93 : zp_end`

`if (zp_end - zp_init) != (zp_bss_end - zp_bss)`	`if (zp_end - zp_init) != (zp_bss_end - zp_bss)`

`;force assembler error if size is different`	`;force assembler error if size is different`
`ERROR ERROR ERROR ;mismatch between bss and zeropage data`	`ERROR ERROR ERROR ;mismatch between bss and zeropage data`

`endif`	`endif`
`data_init`
`abs1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR`	`3e93 : data_init`
`abs7f_ db $7f ;test pattern for compare`	`3e93 : c3824100 abs1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR`
	`3e97 : 7f abs7f_ db $7f ;test pattern for compare`

`;loads`	`;loads`
`fLDx_ db fn,fn,0,fz ;expected flags for load`
	`3e98 : 80800002 fLDx_ db fn,fn,0,fz ;expected flags for load`

`;shifts`	`;shifts`
`rASL_ ;expected result ASL & ROL -carry`
`rROL_ db $86,$04,$82,0 ; "`	`3e9c : rASL_ ;expected result ASL & ROL -carry`
`rROLc_ db $87,$05,$83,1 ;expected result ROL +carry`	`3e9c : 86048200 rROL_ db $86,$04,$82,0 ; "`
`rLSR_ ;expected result LSR & ROR -carry`	`3ea0 : 87058301 rROLc_ db $87,$05,$83,1 ;expected result ROL +carry`
`rROR_ db $61,$41,$20,0 ; "`	`3ea4 : rLSR_ ;expected result LSR & ROR -carry`
`rRORc_ db $e1,$c1,$a0,$80 ;expected result ROR +carry`	`3ea4 : 61412000 rROR_ db $61,$41,$20,0 ; "`
`fASL_ ;expected flags for shifts`	`3ea8 : e1c1a080 rRORc_ db $e1,$c1,$a0,$80 ;expected result ROR +carry`
`fROL_ db fnc,fc,fn,fz ;no carry in`	`3eac : fASL_ ;expected flags for shifts`
`fROLc_ db fnc,fc,fn,0 ;carry in`	`3eac : 81018002 fROL_ db fnc,fc,fn,fz ;no carry in`
`fLSR_`	`3eb0 : 81018000 fROLc_ db fnc,fc,fn,0 ;carry in`
`fROR_ db fc,0,fc,fz ;no carry in`	`3eb4 : fLSR_`
`fRORc_ db fnc,fn,fnc,fn ;carry in`	`3eb4 : 01000102 fROR_ db fc,0,fc,fz ;no carry in`
	`3eb8 : 81808180 fRORc_ db fnc,fn,fnc,fn ;carry in`

`;increments (decrements)`	`;increments (decrements)`
`rINC_ db $7f,$80,$ff,0,1 ;expected result for INC/DEC`
`fINC_ db 0,fn,fn,fz,0 ;expected flags for INC/DEC`	`3ebc : 7f80ff0001 rINC_ db $7f,$80,$ff,0,1 ;expected result for INC/DEC`
	`3ec1 : 0080800200 fINC_ db 0,fn,fn,fz,0 ;expected flags for INC/DEC`

`;logical memory operand`	`;logical memory operand`
`absOR_ db 0,$1f,$71,$80 ;test pattern for OR`
`absAN_ db $0f,$ff,$7f,$80 ;test pattern for AND`	`3ec6 : 001f7180 absOR_ db 0,$1f,$71,$80 ;test pattern for OR`
`absEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR`	`3eca : 0fff7f80 absAN_ db $0f,$ff,$7f,$80 ;test pattern for AND`
	`3ece : ff0f8f8f absEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR`

`;logical accu operand`	`;logical accu operand`
`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 258`
	`3ed2 : 00f11f00 absORa_ db 0,$f1,$1f,0 ;test pattern for OR`
	`AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 396`
`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`	`---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------`

`absORa_ db 0,$f1,$1f,0 ;test pattern for OR`	`3ed6 : f0ffffff absANa_ db $f0,$ff,$ff,$ff ;test pattern for AND`
`absANa_ db $f0,$ff,$ff,$ff ;test pattern for AND`	`3eda : fff0f00f absEOa_ db $ff,$f0,$f0,$0f ;test pattern for EOR`
`absEOa_ db $ff,$f0,$f0,$0f ;test pattern for EOR`
`;logical results`	`;logical results`
`absrlo_ db 0,$ff,$7f,$80`
`absflo_ db fz,fn,0,fn`	`3ede : 00ff7f80 absrlo_ db 0,$ff,$7f,$80`
`data_end`	`3ee2 : 02800080 absflo_ db fz,fn,0,fn`

	`3ee6 : data_end`

`if (data_end - data_init) != (data_bss_end - data_bss)`	`if (data_end - data_init) != (data_bss_end - data_bss)`

`;force assembler error if size is different`	`;force assembler error if size is different`
`ERROR ERROR ERROR ;mismatch between bss and data`	`ERROR ERROR ERROR ;mismatch between bss and data`

`endif`	`endif`
	`code`
	`3ffa = org $3FFA`
	`3ffa : vec_init`
	`3ffa : f43d dw nmi_trap`
	`3ffc : f63d dw res_trap`
	`3ffe : fa3d dw irq_trap`
	`fffa = vec_bss equ $fffa`

	`endif ;end of RAM init data`

	`if (load_data_direct = 1) & (ROM_vectors = 1)`

	`org $fffa ;vectors`

`vec_init`
`dw nmi_trap`	`dw nmi_trap`
`dw res_trap`	`dw res_trap`
`dw irq_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 : f535 dw nmi_trap`
`fffc : f835 dw res_trap`
`fffe : fd35 dw irq_trap`
`endif`	`endif`

`fffa = end start`	`fffa = end start`

`No errors in pass 2.`	`No errors in pass 2.`
`Wrote binary from address $0000 through $ffff.`	`Wrote binary from address $0000 through $3fff.`
`Total size 65536 bytes.`	`Total size 16384 bytes.`
`Program start address is at $0400 (1024).`	`Program start address is at $0400 (1024).`

`No newline at end of file`	`No newline at end of file`

Browse

Tools

Subversion Repositories m65c02

[/] [m65c02/] [trunk/] [Src/] [M65C02-Test-Programs/] [Klaus2m5_Functional_Tests/] [65c02_ft.lst] - Diff between revs 2 and 3