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

Subversion Repositories m65c02

[/] [m65c02/] [trunk/] [Src/] [M65C02-Test-Programs/] [Klaus2m5_Functional_Tests/] [65c02_ft.lst] - Blame information for rev 3

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page    1
2
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3
 
4
---------------------------------------------------------- Symbol Table -----------------------------------------------------------
5
 
6
              Symbol   Value        Decimal
7
 
8
               absAN : $023f            575
9
              absANa : $024b            587
10 3 MichaelA
             absANa_ : $3ed6          16086
11
              absAN_ : $3eca          16074
12 2 MichaelA
               absEO : $0243            579
13
              absEOa : $024f            591
14 3 MichaelA
             absEOa_ : $3eda          16090
15
              absEO_ : $3ece          16078
16 2 MichaelA
              absflo : $0257            599
17 3 MichaelA
             absflo_ : $3ee2          16098
18 2 MichaelA
               absOR : $023b            571
19
              absORa : $0247            583
20 3 MichaelA
             absORa_ : $3ed2          16082
21
              absOR_ : $3ec6          16070
22 2 MichaelA
              absrlo : $0253            595
23 3 MichaelA
             absrlo_ : $3ede          16094
24 2 MichaelA
                abst : $0203            515
25
                abs1 : $0208            520
26 3 MichaelA
               abs1_ : $3e93          16019
27 2 MichaelA
               abs7f : $020c            524
28 3 MichaelA
              abs7f_ : $3e97          16023
29 2 MichaelA
                ada2 : $0203            515
30 3 MichaelA
                adfc : $00b2            178
31
               adiy2 : $00fc            252
32
              adiy2_ : $3e8f          16015
33
                adi2 : $00f8            248
34
               adi2_ : $3e8b          16011
35
                adrf : $00b7            183
36
                adrh : $00b6            182
37
                adrl : $00b5            181
38
                 ad1 : $00b3            179
39
                 ad2 : $00b4            180
40
            bin_test : $38fc          14588
41 2 MichaelA
               break : $0010             16
42 3 MichaelA
             brk_ret : $09bb           2491
43
                 br1 : $0613           1555
44
                br11 : $065d           1629
45
                br12 : $0661           1633
46
                br13 : $0665           1637
47
                br14 : $0671           1649
48
                 br2 : $0617           1559
49
                 br3 : $061b           1563
50
                 br4 : $0627           1575
51 2 MichaelA
               carry : $0001              1
52
           check_ram : 
53 3 MichaelA
              chkadd : $3b90          15248
54
              chkadi : $3c0b          15371   *
55
              chkdad : $3a1f          14879
56
             chkdadi : $3a82          14978   *
57
             chkdsbi : $3a9d          15005   *
58
              chksbi : $3c26          15398   *
59
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page    2
60
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
61
 
62
               ckad1 : $3ba5          15269
63 2 MichaelA
            cmp_flag : 
64
        code_segment : $0400           1024   *
65
            data_bss : $0208            520
66
        data_bss_end : $025b            603
67 3 MichaelA
            data_end : $3ee6          16102
68
           data_init : $3e93          16019
69 2 MichaelA
        data_segment : $0200            512   *
70
             decmode : $0008              8
71 3 MichaelA
            dec_test : $3968          14696
72 2 MichaelA
            eor_flag : 
73
                fASL : $0221            545
74 3 MichaelA
               fASL_ : $3eac          16044
75 2 MichaelA
                 fai : $0034             52
76
                 fao : $0030             48
77 3 MichaelA
             far_ret : $08a8           2216
78 2 MichaelA
                  fc : $0001              1
79
                fINC : $0236            566
80 3 MichaelA
               fINC_ : $3ec1          16065
81 2 MichaelA
                fLDx : $020d            525
82 3 MichaelA
               fLDx_ : $3e98          16024
83 2 MichaelA
                fLSR : $0229            553
84 3 MichaelA
               fLSR_ : $3eb4          16052
85 2 MichaelA
                  fn : $0080            128
86
                 fnc : $0081            129
87
                 fnv : $00c0            192
88
                 fnz : $0082            130
89
                fnzc : $0083            131
90
                fROL : $0221            545
91
               fROLc : $0225            549
92 3 MichaelA
              fROLc_ : $3eb0          16048
93
               fROL_ : $3eac          16044
94 2 MichaelA
                fROR : $0229            553
95
               fRORc : $022d            557
96 3 MichaelA
              fRORc_ : $3eb8          16056
97
               fROR_ : $3eb4          16052
98 2 MichaelA
                  fv : $0040             64
99
                 fvz : $0042             66
100
                  fz : $0002              2
101
                 fzc : $0003              3
102
              I_flag : $0003              3   *
103 3 MichaelA
               indAN : $00e0            224
104
              indAN_ : $3e73          15987
105
               indEO : $00e8            232
106
              indEO_ : $3e7b          15995
107
               indOR : $00f0            240
108
              indOR_ : $3e83          16003
109
                indt : $00d6            214
110
               indt_ : $3e69          15977
111
                ind1 : $00ca            202
112
               ind1_ : $3e5d          15965
113
             ind_ret : $091f           2335
114 2 MichaelA
              intdis : $0004              4
115 3 MichaelA
                inwt : $00de            222
116
               inwt_ : $3e71          15985
117
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page    3
118
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
119
 
120
                inw1 : $00d4            212
121
               inw1_ : $3e67          15975
122
               irq_a : $00b0            176
123
            irq_trap : $3dfa          15866
124
               irq_x : $00b1            177
125
             jsr_ret : $0967           2407   *
126
             ld_data : $0412           1042
127
               ld_zp : $0408           1032
128
    load_data_direct : $0000              0   *
129 2 MichaelA
           load_flag : 
130
               minus : $0080            128
131
                  m8 : $00ff            255
132
                 m8i : $00fb            251
133 3 MichaelA
                nbr1 : $061f           1567
134
               nbr11 : $0669           1641
135
               nbr12 : $066b           1643
136
               nbr13 : $066d           1645
137
               nbr14 : $066f           1647
138
                nbr2 : $0621           1569
139
                nbr3 : $0623           1571
140
                nbr4 : $0625           1573
141 2 MichaelA
           next_test : 
142 3 MichaelA
            nmi_trap : $3df4          15860
143 2 MichaelA
              overfl : $0040             64
144 3 MichaelA
         ptr_ind_ret : $3d5c          15708
145
         ptr_tst_ind : $3d5a          15706
146
         ROM_vectors : $0000              0   *
147 2 MichaelA
                rASL : $0211            529
148 3 MichaelA
               rASL_ : $3e9c          16028
149 2 MichaelA
           ram_chksm : $0201            513
150
             ram_top : $ffff             -1   *
151 3 MichaelA
           range_adr : $04bc           1212   *
152
           range_end : $0547           1351
153
            range_fw : $0433           1075
154
          range_loop : $042b           1067
155
            range_ok : $0540           1344
156
            range_op : $04bb           1211
157 2 MichaelA
              reserv : $0020             32
158 3 MichaelA
            res_trap : $3df6          15862
159 2 MichaelA
                rINC : $0231            561
160 3 MichaelA
               rINC_ : $3ebc          16060
161 2 MichaelA
                rLSR : $0219            537
162 3 MichaelA
               rLSR_ : $3ea4          16036
163 2 MichaelA
                rROL : $0211            529
164
               rROLc : $0215            533
165 3 MichaelA
              rROLc_ : $3ea0          16032
166
               rROL_ : $3e9c          16028
167 2 MichaelA
                rROR : $0219            537
168
               rRORc : $021d            541
169 3 MichaelA
              rRORc_ : $3ea8          16040
170
               rROR_ : $3ea4          16036
171 2 MichaelA
                sba2 : $0204            516
172 3 MichaelA
               sbiy2 : $00fe            254
173
              sbiy2_ : $3e91          16017
174
                sbi2 : $00fa            250
175
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page    4
176
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
177
 
178
               sbi2_ : $3e8d          16013
179
                 sb2 : $00b8            184
180 2 MichaelA
               set_a : 
181
             set_abs : 
182
            set_absx : 
183
              set_ax : 
184
              set_ay : 
185
            set_stat : 
186
               set_x : 
187
               set_y : 
188
               set_z : 
189
              set_zx : 
190 3 MichaelA
            skip0002 : $0424           1060
191
            skip0006 : $0550           1360
192
            skip0009 : $0563           1379
193
            skip0011 : $0567           1383
194
            skip0013 : $056b           1387
195
            skip0015 : $0571           1393
196
            skip0017 : $0575           1397
197
            skip0019 : $0579           1401
198
            skip0021 : $0580           1408
199
            skip0023 : $0584           1412
200
            skip0025 : $0588           1416
201
            skip0027 : $058e           1422
202
            skip0029 : $0592           1426
203
            skip0031 : $0596           1430
204
            skip0033 : $059d           1437
205
            skip0035 : $05a1           1441
206
            skip0037 : $05a5           1445
207
            skip0039 : $05ab           1451
208
            skip0041 : $05af           1455
209
            skip0043 : $05b3           1459
210
            skip0046 : $05bc           1468
211
            skip0048 : $05d1           1489
212
            skip0050 : $05d9           1497
213
            skip0052 : $05e0           1504
214
            skip0054 : $05e7           1511
215
            skip0056 : $05ee           1518
216
            skip0058 : $05f5           1525
217
            skip0061 : $05fe           1534
218
            skip0073 : $062f           1583
219
            skip0076 : $0636           1590
220
            skip0078 : $063d           1597
221
            skip0082 : $064d           1613
222
            skip0084 : $0651           1617
223
            skip0086 : $0655           1621
224
            skip0088 : $0659           1625
225
            skip0099 : $0679           1657
226
            skip0103 : $0681           1665
227
            skip0107 : $0689           1673
228
            skip0111 : $0691           1681
229
            skip0115 : $0699           1689
230
            skip0119 : $06a1           1697
231
            skip0123 : $06a9           1705
232
            skip0127 : $06b1           1713
233
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page    5
234
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
235
 
236
            skip0131 : $06b9           1721
237
            skip0134 : $06c2           1730
238
            skip0139 : $06da           1754
239
            skip0142 : $06e1           1761
240
            skip0147 : $06f1           1777
241
            skip0150 : $06f8           1784
242
            skip0155 : $0708           1800
243
            skip0158 : $070f           1807
244
            skip0163 : $071f           1823
245
            skip0166 : $0726           1830
246
            skip0171 : $0736           1846
247
            skip0174 : $073d           1853
248
            skip0179 : $074d           1869
249
            skip0182 : $0754           1876
250
            skip0187 : $0764           1892
251
            skip0190 : $076b           1899
252
            skip0195 : $077b           1915
253
            skip0198 : $0782           1922
254
            skip0203 : $0792           1938
255
            skip0206 : $0799           1945
256
            skip0211 : $07a9           1961
257
            skip0214 : $07b0           1968
258
            skip0219 : $07c0           1984
259
            skip0222 : $07c7           1991
260
            skip0227 : $07d7           2007
261
            skip0230 : $07de           2014
262
            skip0232 : $07e5           2021
263
            skip0234 : $07eb           2027
264
            skip0237 : $07f4           2036
265
            skip0242 : $0809           2057
266
            skip0245 : $0810           2064
267
            skip0250 : $0821           2081
268
            skip0253 : $0828           2088
269
            skip0256 : $0832           2098
270
            skip0261 : $084a           2122
271
            skip0264 : $0851           2129
272
            skip0266 : $0858           2136
273
            skip0268 : $085e           2142
274
            skip0273 : $0871           2161
275
            skip0276 : $0878           2168
276
            skip0278 : $087f           2175
277
            skip0280 : $0885           2181
278
            skip0283 : $088e           2190
279
            skip0287 : $08a6           2214
280
            skip0289 : $08ac           2220
281
            skip0291 : $08b0           2224
282
            skip0293 : $08b4           2228
283
            skip0295 : $08b8           2232
284
            skip0297 : $08be           2238
285
            skip0299 : $08c4           2244
286
            skip0301 : $08ca           2250
287
            skip0303 : $08d9           2265
288
            skip0305 : $08df           2271
289
            skip0307 : $08e3           2275
290
            skip0309 : $08e7           2279
291
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page    6
292
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
293
 
294
            skip0311 : $08eb           2283
295
            skip0313 : $08f1           2289
296
            skip0315 : $08f7           2295
297
            skip0317 : $08fd           2301
298
            skip0320 : $0906           2310
299
            skip0324 : $091d           2333
300
            skip0326 : $0928           2344
301
            skip0328 : $092c           2348
302
            skip0330 : $0930           2352
303
            skip0332 : $0934           2356
304
            skip0334 : $093a           2362
305
            skip0336 : $0940           2368
306
            skip0338 : $0946           2374
307
            skip0340 : $094d           2381
308
            skip0343 : $0956           2390
309
            skip0347 : $0971           2417
310
            skip0349 : $0975           2421
311
            skip0351 : $0979           2425
312
            skip0353 : $097d           2429
313
            skip0355 : $0983           2435
314
            skip0357 : $0989           2441
315
            skip0359 : $098f           2447
316
            skip0361 : $0996           2454
317
            skip0364 : $099f           2463
318
            skip0368 : $09c5           2501
319
            skip0370 : $09cb           2507
320
            skip0372 : $09d1           2513
321
            skip0375 : $09d8           2520
322
            skip0377 : $09df           2527
323
            skip0380 : $09e8           2536
324
            skip0386 : $09fb           2555
325
            skip0390 : $0a06           2566
326
            skip0394 : $0a11           2577
327
            skip0398 : $0a1c           2588
328
            skip0402 : $0a27           2599
329
            skip0406 : $0a32           2610
330
            skip0410 : $0a3d           2621
331
            skip0416 : $0a4b           2635
332
            skip0420 : $0a56           2646
333
            skip0424 : $0a61           2657
334
            skip0428 : $0a6c           2668
335
            skip0432 : $0a77           2679
336
            skip0436 : $0a82           2690
337
            skip0440 : $0a8d           2701
338
            skip0446 : $0a9b           2715
339
            skip0450 : $0aa6           2726
340
            skip0453 : $0ab0           2736
341
            skip0458 : $0ac4           2756
342
            skip0461 : $0acb           2763
343
            skip0464 : $0ad5           2773
344
            skip0467 : $0adc           2780
345
            skip0470 : $0ae6           2790
346
            skip0473 : $0aed           2797
347
            skip0476 : $0af7           2807
348
            skip0479 : $0afe           2814
349
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page    7
350
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
351
 
352
            skip0482 : $0b08           2824
353
            skip0485 : $0b0f           2831
354
            skip0490 : $0b1e           2846
355
            skip0493 : $0b25           2853
356
            skip0496 : $0b2f           2863
357
            skip0499 : $0b36           2870
358
            skip0502 : $0b40           2880
359
            skip0505 : $0b47           2887
360
            skip0508 : $0b51           2897
361
            skip0511 : $0b58           2904
362
            skip0514 : $0b62           2914
363
            skip0517 : $0b69           2921
364
            skip0522 : $0b79           2937
365
            skip0525 : $0b80           2944
366
            skip0528 : $0b8a           2954
367
            skip0531 : $0b91           2961
368
            skip0534 : $0b9b           2971
369
            skip0537 : $0ba2           2978
370
            skip0540 : $0bac           2988
371
            skip0543 : $0bb3           2995
372
            skip0546 : $0bbd           3005
373
            skip0549 : $0bc4           3012
374
            skip0554 : $0bd3           3027
375
            skip0557 : $0bda           3034
376
            skip0560 : $0be4           3044
377
            skip0563 : $0beb           3051
378
            skip0566 : $0bf5           3061
379
            skip0569 : $0bfc           3068
380
            skip0572 : $0c06           3078
381
            skip0575 : $0c0d           3085
382
            skip0578 : $0c17           3095
383
            skip0581 : $0c1e           3102
384
            skip0586 : $0c2e           3118
385
            skip0589 : $0c35           3125
386
            skip0592 : $0c42           3138
387
            skip0595 : $0c49           3145
388
            skip0598 : $0c56           3158
389
            skip0601 : $0c5d           3165
390
            skip0606 : $0c6b           3179
391
            skip0609 : $0c72           3186
392
            skip0612 : $0c7f           3199
393
            skip0615 : $0c86           3206
394
            skip0618 : $0c93           3219
395
            skip0621 : $0c9a           3226
396
            skip0626 : $0caa           3242
397
            skip0629 : $0cb1           3249
398
            skip0632 : $0cbe           3262
399
            skip0635 : $0cc5           3269
400
            skip0638 : $0cd2           3282
401
            skip0641 : $0cd9           3289
402
            skip0646 : $0ce7           3303
403
            skip0649 : $0cee           3310
404
            skip0652 : $0cfb           3323
405
            skip0655 : $0d02           3330
406
            skip0658 : $0d0f           3343
407
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page    8
408
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
409
 
410
            skip0661 : $0d16           3350
411
            skip0665 : $0d27           3367
412
            skip0668 : $0d2e           3374
413
            skip0671 : $0d3c           3388
414
            skip0674 : $0d43           3395
415
            skip0677 : $0d51           3409
416
            skip0680 : $0d58           3416
417
            skip0684 : $0d69           3433
418
            skip0687 : $0d70           3440
419
            skip0690 : $0d7e           3454
420
            skip0693 : $0d85           3461
421
            skip0696 : $0d93           3475
422
            skip0699 : $0d9a           3482
423
            skip0703 : $0dab           3499
424
            skip0706 : $0db2           3506
425
            skip0709 : $0dc0           3520
426
            skip0712 : $0dc7           3527
427
            skip0715 : $0dd5           3541
428
            skip0718 : $0ddc           3548
429
            skip0722 : $0ded           3565
430
            skip0725 : $0df4           3572
431
            skip0728 : $0e02           3586
432
            skip0731 : $0e09           3593
433
            skip0734 : $0e17           3607
434
            skip0737 : $0e1e           3614
435
            skip0740 : $0e28           3624
436
            skip0745 : $0e3e           3646
437
            skip0750 : $0e4d           3661
438
            skip0755 : $0e5d           3677
439
            skip0760 : $0e6c           3692
440
            skip0765 : $0e7c           3708
441
            skip0772 : $0e96           3734
442
            skip0775 : $0e9f           3743
443
            skip0779 : $0eab           3755
444
            skip0782 : $0eb4           3764
445
            skip0786 : $0ec0           3776
446
            skip0789 : $0ec9           3785
447
            skip0793 : $0ed8           3800
448
            skip0796 : $0ee1           3809
449
            skip0800 : $0eed           3821
450
            skip0803 : $0ef6           3830
451
            skip0807 : $0f02           3842
452
            skip0810 : $0f0b           3851
453
            skip0813 : $0f15           3861
454
            skip0817 : $0f34           3892
455
            skip0820 : $0f3e           3902
456
            skip0824 : $0f5b           3931
457
            skip0827 : $0f65           3941
458
            skip0831 : $0f83           3971
459
            skip0834 : $0f8d           3981
460
            skip0838 : $0fab           4011
461
            skip0841 : $0fb5           4021
462
            skip0843 : $0fc8           4040
463
            skip0845 : $0fd6           4054
464
            skip0848 : $0fe6           4070
465
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page    9
466
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
467
 
468
            skip0850 : $1012           4114
469
            skip0852 : $101e           4126
470
            skip0855 : $102e           4142
471
            skip0859 : $104d           4173
472
            skip0862 : $1057           4183
473
            skip0866 : $1074           4212
474
            skip0869 : $107e           4222
475
            skip0873 : $109b           4251
476
            skip0876 : $10a5           4261
477
            skip0880 : $10c2           4290
478
            skip0883 : $10cc           4300
479
            skip0885 : $10dd           4317
480
            skip0887 : $10eb           4331
481
            skip0890 : $10fb           4347
482
            skip0892 : $1125           4389
483
            skip0894 : $1131           4401
484
            skip0897 : $1141           4417
485
            skip0901 : $115f           4447
486
            skip0904 : $1169           4457
487
            skip0908 : $1182           4482
488
            skip0911 : $118c           4492
489
            skip0915 : $11a5           4517
490
            skip0918 : $11af           4527
491
            skip0922 : $11c8           4552
492
            skip0925 : $11d2           4562
493
            skip0929 : $11eb           4587
494
            skip0932 : $11f5           4597
495
            skip0936 : $120e           4622
496
            skip0939 : $1218           4632
497
            skip0943 : $1231           4657
498
            skip0946 : $123b           4667
499
            skip0950 : $1254           4692
500
            skip0953 : $125e           4702
501
            skip0957 : $1276           4726
502
            skip0960 : $1280           4736
503
            skip0964 : $1298           4760
504
            skip0967 : $12a2           4770
505
            skip0971 : $12ba           4794
506
            skip0974 : $12c4           4804
507
            skip0978 : $12dc           4828
508
            skip0981 : $12e6           4838
509
            skip0985 : $12ff           4863
510
            skip0988 : $1309           4873
511
            skip0992 : $1322           4898
512
            skip0995 : $132c           4908
513
            skip0999 : $1345           4933
514
            skip1002 : $134f           4943
515
            skip1006 : $1368           4968
516
            skip1009 : $1372           4978
517
            skip1013 : $1380           4992
518
            skip1016 : $138a           5002
519
            skip1020 : $1398           5016
520
            skip1023 : $13a2           5026
521
            skip1027 : $13b0           5040
522
            skip1030 : $13ba           5050
523
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   10
524
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
525
 
526
            skip1034 : $13c8           5064
527
            skip1037 : $13d2           5074
528
            skip1041 : $13e0           5088
529
            skip1044 : $13ea           5098
530
            skip1048 : $13f8           5112
531
            skip1051 : $1402           5122
532
            skip1055 : $1410           5136
533
            skip1058 : $141a           5146
534
            skip1062 : $1428           5160
535
            skip1065 : $1432           5170
536
            skip1067 : $143e           5182
537
            skip1069 : $144c           5196
538
            skip1071 : $1459           5209
539
            skip1073 : $1467           5223
540
            skip1075 : $1474           5236
541
            skip1077 : $1482           5250
542
            skip1079 : $148f           5263
543
            skip1081 : $149d           5277
544
            skip1084 : $14a9           5289
545
            skip1088 : $14c7           5319
546
            skip1091 : $14d1           5329
547
            skip1095 : $14ea           5354
548
            skip1098 : $14f4           5364
549
            skip1102 : $150d           5389
550
            skip1105 : $1517           5399
551
            skip1109 : $1530           5424
552
            skip1112 : $153a           5434
553
            skip1116 : $1553           5459
554
            skip1119 : $155d           5469
555
            skip1123 : $1576           5494
556
            skip1126 : $1580           5504
557
            skip1130 : $1599           5529
558
            skip1133 : $15a3           5539
559
            skip1137 : $15bc           5564
560
            skip1140 : $15c6           5574
561
            skip1144 : $15df           5599
562
            skip1147 : $15e9           5609
563
            skip1151 : $1602           5634
564
            skip1154 : $160c           5644
565
            skip1158 : $1625           5669
566
            skip1161 : $162f           5679
567
            skip1165 : $1648           5704
568
            skip1168 : $1652           5714
569
            skip1172 : $166b           5739
570
            skip1175 : $1675           5749
571
            skip1179 : $168e           5774
572
            skip1182 : $1698           5784
573
            skip1186 : $16b1           5809
574
            skip1189 : $16bb           5819
575
            skip1193 : $16d4           5844
576
            skip1196 : $16de           5854
577
            skip1200 : $16ec           5868
578
            skip1203 : $16f6           5878
579
            skip1207 : $1704           5892
580
            skip1210 : $170e           5902
581
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   11
582
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
583
 
584
            skip1214 : $171c           5916
585
            skip1217 : $1726           5926
586
            skip1221 : $1734           5940
587
            skip1224 : $173e           5950
588
            skip1228 : $174c           5964
589
            skip1231 : $1756           5974
590
            skip1235 : $1764           5988
591
            skip1238 : $176e           5998
592
            skip1242 : $177c           6012
593
            skip1245 : $1786           6022
594
            skip1249 : $1794           6036
595
            skip1252 : $179e           6046
596
            skip1254 : $17aa           6058
597
            skip1256 : $17b8           6072
598
            skip1258 : $17c5           6085
599
            skip1260 : $17d3           6099
600
            skip1262 : $17e0           6112
601
            skip1264 : $17ee           6126
602
            skip1266 : $17fb           6139
603
            skip1268 : $1809           6153
604
            skip1271 : $1815           6165
605
            skip1275 : $1833           6195
606
            skip1278 : $183d           6205
607
            skip1282 : $1859           6233
608
            skip1285 : $1863           6243
609
            skip1289 : $187e           6270
610
            skip1292 : $1888           6280
611
            skip1296 : $18a3           6307
612
            skip1299 : $18ad           6317
613
            skip1301 : $18be           6334
614
            skip1303 : $18cc           6348
615
            skip1306 : $18dc           6364
616
            skip1310 : $18fa           6394
617
            skip1313 : $1904           6404
618
            skip1317 : $1920           6432
619
            skip1320 : $192a           6442
620
            skip1322 : $193d           6461
621
            skip1326 : $195c           6492
622
            skip1329 : $1966           6502
623
            skip1333 : $1981           6529
624
            skip1336 : $198b           6539
625
            skip1338 : $199e           6558
626
            skip1342 : $19bf           6591
627
            skip1345 : $19c9           6601
628
            skip1349 : $19e8           6632
629
            skip1352 : $19f2           6642
630
            skip1354 : $1a07           6663
631
            skip1357 : $1a17           6679
632
            skip1359 : $1a40           6720
633
            skip1361 : $1a4c           6732
634
            skip1363 : $1a71           6769
635
            skip1365 : $1a92           6802
636
            skip1367 : $1ab6           6838
637
            skip1370 : $1ac6           6854
638
            skip1374 : $1ae1           6881
639
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   12
640
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
641
 
642
            skip1377 : $1aeb           6891
643
            skip1381 : $1b01           6913
644
            skip1384 : $1b0b           6923
645
            skip1388 : $1b21           6945
646
            skip1391 : $1b2b           6955
647
            skip1395 : $1b41           6977
648
            skip1398 : $1b4b           6987
649
            skip1402 : $1b61           7009
650
            skip1405 : $1b6b           7019
651
            skip1409 : $1b81           7041
652
            skip1412 : $1b8b           7051
653
            skip1416 : $1ba1           7073
654
            skip1419 : $1bab           7083
655
            skip1423 : $1bc1           7105
656
            skip1426 : $1bcb           7115
657
            skip1430 : $1be1           7137
658
            skip1433 : $1beb           7147
659
            skip1437 : $1c01           7169
660
            skip1440 : $1c0b           7179
661
            skip1444 : $1c21           7201
662
            skip1447 : $1c2b           7211
663
            skip1451 : $1c41           7233
664
            skip1454 : $1c4b           7243
665
            skip1458 : $1c61           7265
666
            skip1461 : $1c6b           7275
667
            skip1465 : $1c81           7297
668
            skip1468 : $1c8b           7307
669
            skip1472 : $1ca1           7329
670
            skip1475 : $1cab           7339
671
            skip1479 : $1cc1           7361
672
            skip1482 : $1ccb           7371
673
            skip1486 : $1cd9           7385
674
            skip1489 : $1ce3           7395
675
            skip1493 : $1cf1           7409
676
            skip1496 : $1cfb           7419
677
            skip1500 : $1d09           7433
678
            skip1503 : $1d13           7443
679
            skip1507 : $1d21           7457
680
            skip1510 : $1d2b           7467
681
            skip1514 : $1d39           7481
682
            skip1517 : $1d43           7491
683
            skip1521 : $1d51           7505
684
            skip1524 : $1d5b           7515
685
            skip1528 : $1d69           7529
686
            skip1531 : $1d73           7539
687
            skip1535 : $1d81           7553
688
            skip1538 : $1d8b           7563
689
            skip1540 : $1d97           7575
690
            skip1542 : $1da5           7589
691
            skip1544 : $1db2           7602
692
            skip1546 : $1dc0           7616
693
            skip1548 : $1dcd           7629
694
            skip1550 : $1ddb           7643
695
            skip1552 : $1de8           7656
696
            skip1554 : $1df6           7670
697
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   13
698
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
699
 
700
            skip1557 : $1e02           7682
701
            skip1562 : $1e17           7703
702
            skip1565 : $1e1e           7710
703
            skip1570 : $1e2f           7727
704
            skip1573 : $1e36           7734
705
            skip1578 : $1e47           7751
706
            skip1581 : $1e4e           7758
707
            skip1586 : $1e5f           7775
708
            skip1589 : $1e66           7782
709
            skip1594 : $1e77           7799
710
            skip1597 : $1e7e           7806
711
            skip1602 : $1e8f           7823
712
            skip1605 : $1e96           7830
713
            skip1610 : $1ea7           7847
714
            skip1613 : $1eae           7854
715
            skip1618 : $1ebf           7871
716
            skip1621 : $1ec6           7878
717
            skip1626 : $1ed8           7896
718
            skip1629 : $1edf           7903
719
            skip1634 : $1ef1           7921
720
            skip1637 : $1ef8           7928
721
            skip1642 : $1f0a           7946
722
            skip1645 : $1f11           7953
723
            skip1650 : $1f23           7971
724
            skip1653 : $1f2a           7978
725
            skip1658 : $1f3c           7996
726
            skip1661 : $1f43           8003
727
            skip1666 : $1f55           8021
728
            skip1669 : $1f5c           8028
729
            skip1674 : $1f6e           8046
730
            skip1677 : $1f75           8053
731
            skip1682 : $1f87           8071
732
            skip1685 : $1f8e           8078
733
            skip1688 : $1f98           8088
734
            skip1694 : $1fae           8110
735
            skip1698 : $1fbb           8123
736
            skip1701 : $1fc7           8135
737
            skip1704 : $1fce           8142
738
            skip1710 : $1fe0           8160
739
            skip1714 : $1fed           8173
740
            skip1717 : $1ff9           8185
741
            skip1720 : $2000           8192
742
            skip1726 : $2013           8211
743
            skip1730 : $2021           8225
744
            skip1733 : $202e           8238
745
            skip1736 : $2035           8245
746
            skip1742 : $2048           8264
747
            skip1746 : $2056           8278
748
            skip1749 : $2063           8291
749
            skip1752 : $206a           8298
750
            skip1758 : $207c           8316
751
            skip1762 : $2089           8329
752
            skip1765 : $2095           8341
753
            skip1768 : $209c           8348
754
            skip1774 : $20ae           8366
755
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   14
756
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
757
 
758
            skip1778 : $20bb           8379
759
            skip1781 : $20c7           8391
760
            skip1784 : $20ce           8398
761
            skip1787 : $20d8           8408
762
            skip1793 : $20ee           8430
763
            skip1797 : $20fb           8443
764
            skip1800 : $2107           8455
765
            skip1803 : $210e           8462
766
            skip1809 : $2120           8480
767
            skip1813 : $212d           8493
768
            skip1816 : $2139           8505
769
            skip1819 : $2140           8512
770
            skip1825 : $2153           8531
771
            skip1829 : $2161           8545
772
            skip1832 : $216e           8558
773
            skip1835 : $2175           8565
774
            skip1841 : $2188           8584
775
            skip1845 : $2196           8598
776
            skip1848 : $21a3           8611
777
            skip1851 : $21aa           8618
778
            skip1857 : $21bc           8636
779
            skip1861 : $21c9           8649
780
            skip1864 : $21d5           8661
781
            skip1867 : $21dc           8668
782
            skip1873 : $21ee           8686
783
            skip1877 : $21fb           8699
784
            skip1880 : $2207           8711
785
            skip1883 : $220e           8718
786
            skip1886 : $2218           8728
787
            skip1891 : $222d           8749
788
            skip1894 : $2234           8756
789
            skip1899 : $2245           8773
790
            skip1902 : $224c           8780
791
            skip1907 : $225d           8797
792
            skip1910 : $2264           8804
793
            skip1915 : $2275           8821
794
            skip1918 : $227c           8828
795
            skip1923 : $228d           8845
796
            skip1926 : $2294           8852
797
            skip1931 : $22a5           8869
798
            skip1934 : $22ac           8876
799
            skip1939 : $22be           8894
800
            skip1942 : $22c5           8901
801
            skip1947 : $22d7           8919
802
            skip1950 : $22de           8926
803
            skip1955 : $22f0           8944
804
            skip1958 : $22f7           8951
805
            skip1963 : $2309           8969
806
            skip1966 : $2310           8976
807
            skip1971 : $2322           8994
808
            skip1974 : $2329           9001
809
            skip1979 : $233b           9019
810
            skip1982 : $2342           9026
811
            skip1987 : $2353           9043
812
            skip1990 : $235a           9050
813
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   15
814
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
815
 
816
            skip1995 : $236b           9067
817
            skip1998 : $2372           9074
818
            skip2003 : $2383           9091
819
            skip2006 : $238a           9098
820
            skip2011 : $239b           9115
821
            skip2014 : $23a2           9122
822
            skip2019 : $23b3           9139
823
            skip2022 : $23ba           9146
824
            skip2027 : $23cb           9163
825
            skip2030 : $23d2           9170
826
            skip2035 : $23e5           9189
827
            skip2038 : $23ec           9196
828
            skip2043 : $23fd           9213
829
            skip2046 : $2404           9220
830
            skip2051 : $2415           9237
831
            skip2054 : $241c           9244
832
            skip2059 : $242d           9261
833
            skip2062 : $2434           9268
834
            skip2067 : $2445           9285
835
            skip2070 : $244c           9292
836
            skip2075 : $245d           9309
837
            skip2078 : $2464           9316
838
            skip2083 : $2476           9334
839
            skip2086 : $247d           9341
840
            skip2091 : $248f           9359
841
            skip2094 : $2496           9366
842
            skip2099 : $24a8           9384
843
            skip2102 : $24af           9391
844
            skip2107 : $24c1           9409
845
            skip2110 : $24c8           9416
846
            skip2115 : $24da           9434
847
            skip2118 : $24e1           9441
848
            skip2123 : $24f3           9459
849
            skip2126 : $24fa           9466
850
            skip2131 : $2510           9488
851
            skip2134 : $2517           9495
852
            skip2139 : $2529           9513
853
            skip2142 : $2530           9520
854
            skip2147 : $2542           9538
855
            skip2150 : $2549           9545
856
            skip2155 : $255b           9563
857
            skip2158 : $2562           9570
858
            skip2163 : $2574           9588
859
            skip2166 : $257b           9595
860
            skip2171 : $258d           9613
861
            skip2174 : $2594           9620
862
            skip2179 : $25a5           9637
863
            skip2182 : $25ac           9644
864
            skip2187 : $25bd           9661
865
            skip2190 : $25c4           9668
866
            skip2195 : $25d5           9685
867
            skip2198 : $25dc           9692
868
            skip2203 : $25ed           9709
869
            skip2206 : $25f4           9716
870
            skip2211 : $2605           9733
871
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   16
872
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
873
 
874
            skip2214 : $260c           9740
875
            skip2219 : $261d           9757
876
            skip2222 : $2624           9764
877
            skip2227 : $2635           9781
878
            skip2230 : $263c           9788
879
            skip2235 : $264d           9805
880
            skip2238 : $2654           9812
881
            skip2243 : $2665           9829
882
            skip2246 : $266c           9836
883
            skip2251 : $267d           9853
884
            skip2254 : $2684           9860
885
            skip2259 : $2695           9877
886
            skip2262 : $269c           9884
887
            skip2267 : $26ad           9901
888
            skip2270 : $26b4           9908
889
            skip2273 : $26be           9918
890
            skip2278 : $26d4           9940
891
            skip2281 : $26de           9950
892
            skip2286 : $26f2           9970
893
            skip2289 : $26fc           9980
894
            skip2294 : $2710          10000
895
            skip2297 : $271a          10010
896
            skip2302 : $272e          10030
897
            skip2305 : $2738          10040
898
            skip2310 : $274c          10060
899
            skip2313 : $2756          10070
900
            skip2318 : $276a          10090
901
            skip2321 : $2774          10100
902
            skip2326 : $2788          10120
903
            skip2329 : $2792          10130
904
            skip2334 : $27a6          10150
905
            skip2337 : $27b0          10160
906
            skip2342 : $27c4          10180
907
            skip2345 : $27ce          10190
908
            skip2350 : $27e2          10210
909
            skip2353 : $27ec          10220
910
            skip2358 : $2800          10240
911
            skip2361 : $280a          10250
912
            skip2366 : $281e          10270
913
            skip2369 : $2828          10280
914
            skip2372 : $2834          10292
915
            skip2377 : $284f          10319
916
            skip2380 : $2859          10329
917
            skip2385 : $2872          10354
918
            skip2388 : $287c          10364
919
            skip2393 : $2895          10389
920
            skip2396 : $289f          10399
921
            skip2401 : $28b8          10424
922
            skip2404 : $28c2          10434
923
            skip2409 : $28db          10459
924
            skip2412 : $28e5          10469
925
            skip2417 : $28fe          10494
926
            skip2420 : $2908          10504
927
            skip2425 : $2921          10529
928
            skip2428 : $292b          10539
929
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   17
930
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
931
 
932
            skip2433 : $2944          10564
933
            skip2436 : $294e          10574
934
            skip2441 : $2967          10599
935
            skip2444 : $2971          10609
936
            skip2449 : $298a          10634
937
            skip2452 : $2994          10644
938
            skip2457 : $29ad          10669
939
            skip2460 : $29b7          10679
940
            skip2465 : $29d0          10704
941
            skip2468 : $29da          10714
942
            skip2471 : $29e6          10726
943
            skip2476 : $2a04          10756
944
            skip2479 : $2a0e          10766
945
            skip2484 : $2a2a          10794
946
            skip2487 : $2a34          10804
947
            skip2492 : $2a50          10832
948
            skip2495 : $2a5a          10842
949
            skip2500 : $2a76          10870
950
            skip2503 : $2a80          10880
951
            skip2508 : $2a9c          10908
952
            skip2511 : $2aa6          10918
953
            skip2516 : $2ac2          10946
954
            skip2519 : $2acc          10956
955
            skip2524 : $2ae8          10984
956
            skip2527 : $2af2          10994
957
            skip2532 : $2b0e          11022
958
            skip2535 : $2b18          11032
959
            skip2540 : $2b34          11060
960
            skip2543 : $2b3e          11070
961
            skip2548 : $2b5a          11098
962
            skip2551 : $2b64          11108
963
            skip2556 : $2b80          11136
964
            skip2559 : $2b8a          11146
965
            skip2564 : $2ba6          11174
966
            skip2567 : $2bb0          11184
967
            skip2570 : $2bbc          11196
968
            skip2575 : $2bd7          11223
969
            skip2578 : $2be1          11233
970
            skip2583 : $2bfa          11258
971
            skip2586 : $2c04          11268
972
            skip2591 : $2c1d          11293
973
            skip2594 : $2c27          11303
974
            skip2599 : $2c40          11328
975
            skip2602 : $2c4a          11338
976
            skip2607 : $2c63          11363
977
            skip2610 : $2c6d          11373
978
            skip2615 : $2c86          11398
979
            skip2618 : $2c90          11408
980
            skip2623 : $2ca9          11433
981
            skip2626 : $2cb3          11443
982
            skip2631 : $2ccc          11468
983
            skip2634 : $2cd6          11478
984
            skip2639 : $2cef          11503
985
            skip2642 : $2cf9          11513
986
            skip2647 : $2d12          11538
987
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   18
988
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
989
 
990
            skip2650 : $2d1c          11548
991
            skip2655 : $2d35          11573
992
            skip2658 : $2d3f          11583
993
            skip2663 : $2d58          11608
994
            skip2666 : $2d62          11618
995
            skip2669 : $2d6e          11630
996
            skip2674 : $2d8c          11660
997
            skip2677 : $2d96          11670
998
            skip2682 : $2db2          11698
999
            skip2685 : $2dbc          11708
1000
            skip2690 : $2dd8          11736
1001
            skip2693 : $2de2          11746
1002
            skip2698 : $2dfe          11774
1003
            skip2701 : $2e08          11784
1004
            skip2706 : $2e24          11812
1005
            skip2709 : $2e2e          11822
1006
            skip2714 : $2e4a          11850
1007
            skip2717 : $2e54          11860
1008
            skip2722 : $2e70          11888
1009
            skip2725 : $2e7a          11898
1010
            skip2730 : $2e96          11926
1011
            skip2733 : $2ea0          11936
1012
            skip2738 : $2ebc          11964
1013
            skip2741 : $2ec6          11974
1014
            skip2746 : $2ee2          12002
1015
            skip2749 : $2eec          12012
1016
            skip2754 : $2f08          12040
1017
            skip2757 : $2f12          12050
1018
            skip2762 : $2f2e          12078
1019
            skip2765 : $2f38          12088
1020
            skip2768 : $2f44          12100
1021
            skip2773 : $2f5f          12127
1022
            skip2776 : $2f69          12137
1023
            skip2781 : $2f89          12169
1024
            skip2784 : $2f93          12179
1025
            skip2789 : $2fb6          12214
1026
            skip2792 : $2fc0          12224
1027
            skip2797 : $2fe0          12256
1028
            skip2800 : $2fea          12266
1029
            skip2803 : $3000          12288
1030
            skip2808 : $301e          12318
1031
            skip2811 : $3028          12328
1032
            skip2816 : $304c          12364
1033
            skip2819 : $3056          12374
1034
            skip2824 : $307d          12413
1035
            skip2827 : $3087          12423
1036
            skip2832 : $30ab          12459
1037
            skip2835 : $30b5          12469
1038
            skip2838 : $30cc          12492
1039
            skip2843 : $30e7          12519
1040
            skip2846 : $30f1          12529
1041
            skip2851 : $3113          12563
1042
            skip2854 : $311d          12573
1043
            skip2859 : $3140          12608
1044
            skip2862 : $314a          12618
1045
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   19
1046
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1047
 
1048
            skip2867 : $316c          12652
1049
            skip2870 : $3176          12662
1050
            skip2873 : $318c          12684
1051
            skip2878 : $31aa          12714
1052
            skip2881 : $31b4          12724
1053
            skip2886 : $31da          12762
1054
            skip2889 : $31e4          12772
1055
            skip2894 : $320b          12811
1056
            skip2897 : $3215          12821
1057
            skip2902 : $323b          12859
1058
            skip2905 : $3245          12869
1059
            skip2908 : $325c          12892
1060
            skip2913 : $3279          12921
1061
            skip2916 : $3283          12931
1062
            skip2921 : $329e          12958
1063
            skip2924 : $32a8          12968
1064
            skip2929 : $32c2          12994
1065
            skip2932 : $32cc          13004
1066
            skip2937 : $32e6          13030
1067
            skip2940 : $32f0          13040
1068
            skip2945 : $330c          13068
1069
            skip2948 : $3316          13078
1070
            skip2953 : $3332          13106
1071
            skip2956 : $333c          13116
1072
            skip2961 : $3352          13138
1073
            skip2964 : $335c          13148
1074
            skip2969 : $3372          13170
1075
            skip2972 : $337c          13180
1076
            skip2977 : $3393          13203
1077
            skip2980 : $339d          13213
1078
            skip2985 : $33b4          13236
1079
            skip2988 : $33be          13246
1080
            skip2993 : $33d5          13269
1081
            skip2996 : $33df          13279
1082
            skip3001 : $33f6          13302
1083
            skip3004 : $3400          13312
1084
            skip3009 : $3418          13336
1085
            skip3012 : $3422          13346
1086
            skip3017 : $343c          13372
1087
            skip3020 : $3446          13382
1088
            skip3025 : $345e          13406
1089
            skip3028 : $3468          13416
1090
            skip3033 : $347e          13438
1091
            skip3036 : $3488          13448
1092
            skip3039 : $3494          13460
1093
            skip3044 : $34b1          13489
1094
            skip3047 : $34bb          13499
1095
            skip3052 : $34d6          13526
1096
            skip3055 : $34e0          13536
1097
            skip3060 : $34fa          13562
1098
            skip3063 : $3504          13572
1099
            skip3068 : $351e          13598
1100
            skip3071 : $3528          13608
1101
            skip3076 : $3544          13636
1102
            skip3079 : $354e          13646
1103
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   20
1104
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1105
 
1106
            skip3084 : $356a          13674
1107
            skip3087 : $3574          13684
1108
            skip3092 : $358a          13706
1109
            skip3095 : $3594          13716
1110
            skip3100 : $35aa          13738
1111
            skip3103 : $35b4          13748
1112
            skip3108 : $35cb          13771
1113
            skip3111 : $35d5          13781
1114
            skip3116 : $35ec          13804
1115
            skip3119 : $35f6          13814
1116
            skip3124 : $360d          13837
1117
            skip3127 : $3617          13847
1118
            skip3132 : $362e          13870
1119
            skip3135 : $3638          13880
1120
            skip3140 : $3650          13904
1121
            skip3143 : $365a          13914
1122
            skip3148 : $3674          13940
1123
            skip3151 : $367e          13950
1124
            skip3156 : $3696          13974
1125
            skip3159 : $36a0          13984
1126
            skip3164 : $36b6          14006
1127
            skip3167 : $36c0          14016
1128
            skip3170 : $36cc          14028
1129
            skip3175 : $36e9          14057
1130
            skip3178 : $36f3          14067
1131
            skip3183 : $370e          14094
1132
            skip3186 : $3718          14104
1133
            skip3191 : $3732          14130
1134
            skip3194 : $373c          14140
1135
            skip3199 : $3756          14166
1136
            skip3202 : $3760          14176
1137
            skip3207 : $377c          14204
1138
            skip3210 : $3786          14214
1139
            skip3215 : $37a2          14242
1140
            skip3218 : $37ac          14252
1141
            skip3223 : $37c2          14274
1142
            skip3226 : $37cc          14284
1143
            skip3231 : $37e2          14306
1144
            skip3234 : $37ec          14316
1145
            skip3239 : $3803          14339
1146
            skip3242 : $380d          14349
1147
            skip3247 : $3824          14372
1148
            skip3250 : $382e          14382
1149
            skip3255 : $3845          14405
1150
            skip3258 : $384f          14415
1151
            skip3263 : $3866          14438
1152
            skip3266 : $3870          14448
1153
            skip3271 : $3888          14472
1154
            skip3274 : $3892          14482
1155
            skip3279 : $38ac          14508
1156
            skip3282 : $38b6          14518
1157
            skip3287 : $38ce          14542
1158
            skip3290 : $38d8          14552
1159
            skip3295 : $38ee          14574
1160
            skip3298 : $38f8          14584
1161
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   21
1162
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1163
 
1164
            skip3301 : $390a          14602
1165
            skip3304 : $3976          14710
1166
            skip3306 : $3a1d          14877
1167
            skip3310 : $3a2b          14891
1168
            skip3312 : $3a34          14900
1169
            skip3314 : $3a41          14913
1170
            skip3316 : $3a4a          14922
1171
            skip3318 : $3a58          14936
1172
            skip3320 : $3a61          14945
1173
            skip3322 : $3a6f          14959
1174
            skip3324 : $3a78          14968
1175
            skip3326 : $3a8a          14986
1176
            skip3328 : $3a93          14995
1177
            skip3330 : $3aa5          15013
1178
            skip3332 : $3aae          15022
1179
            skip3334 : $3abb          15035
1180
            skip3336 : $3ac4          15044
1181
            skip3338 : $3ad1          15057
1182
            skip3340 : $3ada          15066
1183
            skip3342 : $3ae8          15080
1184
            skip3344 : $3af1          15089
1185
            skip3346 : $3aff          15103
1186
            skip3348 : $3b08          15112
1187
            skip3350 : $3b16          15126
1188
            skip3352 : $3b1f          15135
1189
            skip3354 : $3b2d          15149
1190
            skip3356 : $3b36          15158
1191
            skip3358 : $3b43          15171
1192
            skip3360 : $3b4c          15180
1193
            skip3362 : $3b59          15193
1194
            skip3364 : $3b62          15202
1195
            skip3366 : $3b6f          15215
1196
            skip3368 : $3b78          15224
1197
            skip3370 : $3b85          15237
1198
            skip3372 : $3b8e          15246
1199
            skip3374 : $3bb4          15284
1200
            skip3376 : $3bbd          15293
1201
            skip3378 : $3bca          15306
1202
            skip3380 : $3bd3          15315
1203
            skip3382 : $3be1          15329
1204
            skip3384 : $3bea          15338
1205
            skip3386 : $3bf8          15352
1206
            skip3388 : $3c01          15361
1207
            skip3390 : $3c13          15379
1208
            skip3392 : $3c1c          15388
1209
            skip3394 : $3c2e          15406
1210
            skip3396 : $3c37          15415
1211
            skip3398 : $3c44          15428
1212
            skip3400 : $3c4d          15437
1213
            skip3402 : $3c5a          15450
1214
            skip3404 : $3c63          15459
1215
            skip3406 : $3c71          15473
1216
            skip3408 : $3c7a          15482
1217
            skip3410 : $3c88          15496
1218
            skip3412 : $3c91          15505
1219
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   22
1220
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1221
 
1222
            skip3414 : $3c9f          15519
1223
            skip3416 : $3ca8          15528
1224
            skip3418 : $3cb6          15542
1225
            skip3420 : $3cbf          15551
1226
            skip3422 : $3ccc          15564
1227
            skip3424 : $3cd5          15573
1228
            skip3426 : $3ce2          15586
1229
            skip3428 : $3ceb          15595
1230
            skip3430 : $3cf8          15608
1231
            skip3432 : $3d01          15617
1232
            skip3434 : $3d0e          15630
1233
            skip3436 : $3d17          15639
1234
            skip3438 : $3d24          15652
1235
            skip3440 : $3d28          15656
1236
            skip3442 : $3d2c          15660
1237
            skip3444 : $3d30          15664
1238
            skip3446 : $3d36          15670
1239
            skip3448 : $3d3c          15676
1240
            skip3450 : $3d42          15682
1241
            skip3452 : $3d4c          15692
1242
            skip3457 : $3d6b          15723
1243
            skip3459 : $3d6f          15727
1244
            skip3461 : $3d73          15731
1245
            skip3463 : $3d77          15735
1246
            skip3465 : $3d7d          15741
1247
            skip3467 : $3d83          15747
1248
            skip3469 : $3d89          15753
1249
            skip3471 : $3d93          15763
1250
            skip3476 : $3dad          15789
1251
            skip3478 : $3db1          15793
1252
            skip3480 : $3db5          15797
1253
            skip3482 : $3db9          15801
1254
            skip3484 : $3dbf          15807
1255
            skip3486 : $3dc5          15813
1256
            skip3488 : $3dcb          15819
1257
            skip3490 : $3dd5          15829
1258
            skip3492 : $3dde          15838
1259
            skip3494 : $3de7          15847
1260
            skip3501 : $3e04          15876
1261
            skip3503 : $3e0a          15882
1262
            skip3505 : $3e10          15888
1263
            skip3508 : $3e1e          15902
1264
            skip3510 : $3e25          15909
1265
            skip3512 : $3e2c          15916
1266
            skip3514 : $3e35          15925
1267
            skip3516 : $3e3e          15934
1268
       skip_bin_test : $0000              0   *
1269
       skip_dec_test : $0000              0   *
1270 2 MichaelA
         skip_part_1 : $0000              0   *
1271 3 MichaelA
           stack_top : $01ff            511   *
1272 2 MichaelA
               start : $0400           1024
1273 3 MichaelA
             success : 
1274
                tadd : $392e          14638
1275
               tadd1 : $3940          14656
1276
                tand : $3263          12899
1277
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   23
1278 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1279
 
1280 3 MichaelA
              tandi1 : $3270          12912
1281
              tandi2 : $3295          12949
1282
               tand1 : $3288          12936
1283
              tand10 : $33c3          13251
1284
              tand11 : $33e4          13284
1285
              tand12 : $3407          13319
1286
              tand13 : $342b          13355
1287
              tand14 : $344d          13389
1288
              tand15 : $346d          13421
1289
               tand2 : $32ad          12973
1290
               tand3 : $32d1          13009
1291
               tand4 : $32f5          13045
1292
               tand5 : $331b          13083
1293
               tand6 : $3341          13121
1294
               tand7 : $3361          13153
1295
               tand8 : $3381          13185
1296
               tand9 : $33a2          13218
1297
                tasl : $26c5           9925
1298
               tasl1 : $26e3           9955
1299
               tasl2 : $283b          10299
1300
               tasl3 : $285e          10334
1301
               tasl4 : $29ed          10733
1302
               tasl5 : $2a13          10771
1303
               tasl6 : $2bc3          11203
1304
               tasl7 : $2be6          11238
1305
               tasl8 : $2d75          11637
1306
               tasl9 : $2d9b          11675
1307
                tdad : $3998          14744
1308
               tdad1 : $39aa          14762
1309
               tdad2 : $39ba          14778
1310
               tdad3 : $39bc          14780
1311
               tdad4 : $39d6          14806
1312
               tdad5 : $39db          14811
1313
               tdad6 : $39ff          14847
1314
               tdad7 : $3a13          14867
1315
                tdec : $2f79          12153
1316
               tdec1 : $2fa0          12192
1317
              tdec10 : $2fd0          12240
1318
              tdec11 : $2ff7          12279
1319
              tdec12 : $3099          12441
1320
              tdec13 : $30c3          12483
1321
              tdec14 : $315a          12634
1322
              tdec15 : $3183          12675
1323
              tdec16 : $3226          12838
1324
              tdec17 : $3253          12883
1325
               tdec2 : $303a          12346
1326
               tdec3 : $3064          12388
1327
               tdec4 : $3101          12545
1328
               tdec5 : $312a          12586
1329
               tdec6 : $31c5          12741
1330
               tdec7 : $31f2          12786
1331
                teor : $349b          13467
1332
              teori1 : $34a8          13480
1333
              teori2 : $34cd          13517
1334
               teor1 : $34c0          13504
1335
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   24
1336 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1337
 
1338 3 MichaelA
              teor10 : $35fb          13819
1339
              teor11 : $361c          13852
1340
              teor12 : $363f          13887
1341
              teor13 : $3663          13923
1342
              teor14 : $3685          13957
1343
              teor15 : $36a5          13989
1344
               teor2 : $34e5          13541
1345
               teor3 : $3509          13577
1346
               teor4 : $352d          13613
1347
               teor5 : $3553          13651
1348
               teor6 : $3579          13689
1349
               teor7 : $3599          13721
1350
               teor8 : $35b9          13753
1351
               teor9 : $35da          13786
1352
            test_bne : $055b           1371
1353
           test_case : $0200            512
1354
            test_far : $3d1b          15643
1355
            test_ind : $3d62          15714
1356
            test_jsr : $3da4          15780
1357
           test_near : $08db           2267
1358 2 MichaelA
            test_num : $002a             42   *
1359 3 MichaelA
                tinc : $2f4f          12111
1360
               tinc1 : $2f72          12146
1361
              tinc10 : $2fa6          12198
1362
              tinc11 : $2fc9          12233
1363
              tinc12 : $306b          12395
1364
              tinc13 : $3091          12433
1365
              tinc14 : $312e          12590
1366
              tinc15 : $3153          12627
1367
              tinc16 : $31f6          12790
1368
              tinc17 : $321f          12831
1369
               tinc2 : $300c          12300
1370
               tinc3 : $3032          12338
1371
               tinc4 : $30d5          12501
1372
               tinc5 : $30fa          12538
1373
               tinc6 : $3195          12693
1374
               tinc7 : $31be          12734
1375
               tldax : $181c           6172
1376
              tldax1 : $1842           6210
1377
              tldax2 : $1868           6248
1378
              tldax3 : $188d           6285
1379
              tldax4 : $19a9           6569
1380
              tldax5 : $19d2           6610
1381
              tldax6 : $1a1e           6686
1382
              tldax7 : $1a2a           6698
1383
               tlday : $18e3           6371
1384
              tlday1 : $1909           6409
1385
              tlday2 : $1946           6470
1386
              tlday3 : $196b           6507
1387
              tlday4 : $1a57           6743
1388
              tlday5 : $1a7a           6778
1389
              tlday6 : $1a9d           6813
1390
                tldx : $0f1c           3868
1391
               tldx1 : $0f43           3907
1392
               tldx2 : $0f6a           3946
1393
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   25
1394 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1395
 
1396 3 MichaelA
               tldx3 : $0f92           3986
1397
               tldx4 : $0fed           4077
1398
               tldx5 : $0ffa           4090
1399
                tldy : $1035           4149
1400
               tldy1 : $105c           4188
1401
               tldy2 : $1083           4227
1402
               tldy3 : $10aa           4266
1403
               tldy4 : $1102           4354
1404
               tldy5 : $110f           4367
1405
                tlsr : $2701           9985
1406
               tlsr1 : $271f          10015
1407
               tlsr2 : $2881          10369
1408
               tlsr3 : $28a4          10404
1409
               tlsr4 : $2a39          10809
1410
               tlsr5 : $2a5f          10847
1411
               tlsr6 : $2c09          11273
1412
               tlsr7 : $2c2c          11308
1413
               tlsr8 : $2dc1          11713
1414
               tlsr9 : $2de7          11751
1415
                tora : $36d3          14035
1416
              torai1 : $36e0          14048
1417
              torai2 : $3705          14085
1418
               tora1 : $36f8          14072
1419
              tora10 : $3833          14387
1420
              tora11 : $3854          14420
1421
              tora12 : $3877          14455
1422
              tora13 : $389b          14491
1423
              tora14 : $38bd          14525
1424
              tora15 : $38dd          14557
1425
               tora2 : $371d          14109
1426
               tora3 : $3741          14145
1427
               tora4 : $3765          14181
1428
               tora5 : $378b          14219
1429
               tora6 : $37b1          14257
1430
               tora7 : $37d1          14289
1431
               tora8 : $37f1          14321
1432
               tora9 : $3812          14354
1433 2 MichaelA
                trap : 
1434
             trap_cc : 
1435
             trap_cs : 
1436
             trap_eq : 
1437
             trap_mi : 
1438
             trap_ne : 
1439
             trap_pl : 
1440
             trap_vc : 
1441
             trap_vs : 
1442 3 MichaelA
                trol : $273d          10045
1443
               trolc : $2779          10105
1444
              trolc1 : $2797          10135
1445
              trolc2 : $290d          10509
1446
              trolc3 : $2930          10544
1447
              trolc4 : $2ad1          10961
1448
              trolc5 : $2af7          10999
1449
              trolc6 : $2c95          11413
1450
              trolc7 : $2cb8          11448
1451
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   26
1452 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1453
 
1454 3 MichaelA
              trolc8 : $2e59          11865
1455
              trolc9 : $2e7f          11903
1456
               trol1 : $275b          10075
1457
               trol2 : $28c7          10439
1458
               trol3 : $28ea          10474
1459
               trol4 : $2a85          10885
1460
               trol5 : $2aab          10923
1461
               trol6 : $2c4f          11343
1462
               trol7 : $2c72          11378
1463
               trol8 : $2e0d          11789
1464
               trol9 : $2e33          11827
1465
                tror : $27b5          10165
1466
               trorc : $27f1          10225
1467
              trorc1 : $280f          10255
1468
              trorc2 : $2999          10649
1469
              trorc3 : $29bc          10684
1470
              trorc4 : $2b69          11113
1471
              trorc5 : $2b8f          11151
1472
              trorc6 : $2d21          11553
1473
              trorc7 : $2d44          11588
1474
              trorc8 : $2ef1          12017
1475
              trorc9 : $2f17          12055
1476
               tror1 : $27d3          10195
1477
               tror2 : $2953          10579
1478
               tror3 : $2976          10614
1479
               tror4 : $2b1d          11037
1480
               tror5 : $2b43          11075
1481
               tror6 : $2cdb          11483
1482
               tror7 : $2cfe          11518
1483
               tror8 : $2ea5          11941
1484
               tror9 : $2ecb          11979
1485
               tstax : $18b4           6324
1486
              tstax1 : $1a38           6712
1487
               tstay : $1931           6449
1488
              tstay1 : $1992           6546
1489
              tstay2 : $19fb           6651
1490
              tstay4 : $1a67           6759
1491
              tstay5 : $1a88           6792
1492
              tstay6 : $1aac           6828
1493
                tstx : $0fbc           4028
1494
               tstx1 : $1008           4104
1495
                tsty : $10d3           4307
1496
               tsty1 : $111d           4381
1497 2 MichaelA
               tst_a : 
1498
             tst_abs : 
1499
            tst_absx : 
1500
              tst_ax : 
1501
              tst_ay : 
1502
            tst_stat : 
1503
               tst_x : 
1504
               tst_y : 
1505
               tst_z : 
1506
              tst_zx : 
1507 3 MichaelA
             vec_bss : $fffa          65530
1508
            vec_init : $3ffa          16378
1509
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   27
1510
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1511
 
1512 2 MichaelA
                zero : $0002              2
1513 3 MichaelA
           zero_page : $00b0            176   *
1514
                zpAN : $00c2            194
1515
               zpAN_ : $3e55          15957
1516
                zpEO : $00c6            198
1517
               zpEO_ : $3e59          15961
1518
                zpOR : $00be            190
1519
               zpOR_ : $3e51          15953
1520
                 zpt : $00b2            178
1521
                 zp1 : $00b9            185
1522
                zp1_ : $3e4c          15948
1523
                zp7f : $00bd            189
1524
               zp7f_ : $3e50          15952
1525
              zp_bss : $00b9            185
1526
          zp_bss_end : $0100            256
1527
              zp_end : $3e93          16019
1528
             zp_init : $3e4c          15948
1529
            __6502__ : $0001              1
1530 2 MichaelA
 
1531 3 MichaelA
1409 labels used
1532 2 MichaelA
 
1533 3 MichaelA
5937 lines read, no errors in pass 1.
1534
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   28
1535 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1536
 
1537
                             ;
1538
                             ; 6 5 0 2   F U N C T I O N A L   T E S T
1539
                             ;
1540
                             ; Copyright (C) 2012-2013  Klaus Dormann
1541
                             ;
1542
                             ; This program is free software: you can redistribute it and/or modify
1543
                             ; it under the terms of the GNU General Public License as published by
1544
                             ; the Free Software Foundation, either version 3 of the License, or
1545
                             ; (at your option) any later version.
1546
                             ;
1547
                             ; This program is distributed in the hope that it will be useful,
1548
                             ; but WITHOUT ANY WARRANTY; without even the implied warranty of
1549
                             ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1550
                             ; GNU General Public License for more details.
1551
                             ;
1552
                             ; You should have received a copy of the GNU General Public License
1553
                             ; along with this program.  If not, see .
1554 3 MichaelA
                             ;
1555
                             ;
1556 2 MichaelA
                             ; This program is designed to test all opcodes of a 6502 emulator using all
1557
                             ; addressing modes with focus on propper setting of the processor status
1558
                             ; register bits.
1559
                             ;
1560
                             ; version 23-jul-2013
1561
                             ; contact info at http://2m5.de or email K@2m5.de
1562
                             ;
1563
                             ; assembled with AS65 from http://www.kingswood-consulting.co.uk/assemblers/
1564
                             ; command line switches: -l -m -s2 -w -h0
1565
                             ;                         |  |  |   |  no page headers in listing
1566
                             ;                         |  |  |   wide listing (133 char/col)
1567
                             ;                         |  |  write intel hex file instead of binary
1568
                             ;                         |  expand macros in listing
1569
                             ;                         generate pass2 listing
1570
                             ;
1571
                             ; No IO - should be run from a monitor with access to registers.
1572
                             ; To run load intel hex image with a load command, than alter PC to 400 hex
1573
                             ; (code_segment) and enter a go command.
1574
                             ; Loop on program counter determines error or successful completion of test.
1575
                             ; Check listing for relevant traps (jump/branch *).
1576
                             ; Please note that in early tests some instructions will have to be used before
1577
                             ; they are actually tested!
1578
                             ;
1579
                             ; RESET, NMI or IRQ should not occur and will be trapped if vectors are enabled.
1580
                             ; Tests documented behavior of the original NMOS 6502 only! No unofficial
1581
                             ; opcodes. Additional opcodes of newer versions of the CPU (65C02, 65816) will
1582
                             ; not be tested. Decimal ops will only be tested with valid BCD operands and
1583
                             ; N V Z flags will be ignored.
1584
                             ;
1585
                             ; Debugging hints:
1586
                             ;     Most of the code is written sequentially. if you hit a trap, check the
1587
                             ;   immediately preceeding code for the instruction to be tested. Results are
1588
                             ;   tested first, flags are checked second by pushing them onto the stack and
1589
                             ;   pulling them to the accumulator after the result was checked. The "real"
1590
                             ;   flags are no longer valid for the tested instruction at this time!
1591
                             ;     If the tested instruction was indexed, the relevant index (X or Y) must
1592 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   29
1593 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1594
 
1595
                             ;   also be checked. Opposed to the flags, X and Y registers are still valid.
1596
                             ;
1597
                             ; versions:
1598
                             ;   28-jul-2012  1st version distributed for testing
1599
                             ;   29-jul-2012  fixed references to location 0, now #0
1600
                             ;                added license - GPLv3
1601
                             ;   30-jul-2012  added configuration options
1602
                             ;   01-aug-2012  added trap macro to allow user to change error handling
1603
                             ;   01-dec-2012  fixed trap in branch field must be a branch
1604
                             ;   02-mar-2013  fixed PLA flags not tested
1605
                             ;   19-jul-2013  allowed ROM vectors to be loaded when load_data_direct = 0
1606
                             ;                added test sequence check to detect if tests jump their fence
1607
                             ;   23-jul-2013  added RAM integrity check
1608 3 MichaelA
                             ;
1609
                             ;   30-Aug-2013  Modified by Michael A. Morris to allow selection of tests
1610
                             ;   04-Jan-2014  Modified trap vectors to use sbc2oslite BRK handler for error
1611
                             ;                trapping. Enabled success macro, which returns to the monitor.
1612
                             ;                Disabled BRK trap test in order to trap out to the monitor.
1613
                             ;   30-Jan-2014  Modified success macro to issue brk instruction instead of rts.
1614
                             ;   27-Nov-2014  Modified success macro to use stp instruction instead of brk
1615
                             ;   07-Dec-2014  Modified success macro to use brk instruction instead of stp
1616
                             ;
1617 2 MichaelA
                             ; C O N F I G U R A T I O N
1618
                             ;
1619
                             ;ROM_vectors writable (0=no, 1=yes)
1620 3 MichaelA
                             ;
1621
                             ;   if ROM vectors can not be used interrupts will not be trapped
1622
                             ;   as a consequence BRK can not be tested but will be emulated to test RTI
1623
                             ;
1624
0000 =                       ROM_vectors = 0
1625
                             ;
1626 2 MichaelA
                             ;load_data_direct (0=move from code segment, 1=load directly)
1627
                             ;loading directly is preferred but may not be supported by your platform
1628
                             ;0 produces only consecutive object code, 1 is not suitable for a binary image
1629 3 MichaelA
                             ;
1630
0000 =                       load_data_direct = 0
1631
                             ;
1632 2 MichaelA
                             ;I_flag behavior (0=force enabled, 1=force disabled, 2=prohibit change, 3=allow
1633
                             ;change) 2 requires extra code and is not recommended. SEI & CLI can only be
1634
                             ;tested if you allow changing the interrupt status (I_flag = 3)
1635 3 MichaelA
                             ;
1636 2 MichaelA
0003 =                       I_flag = 3
1637 3 MichaelA
                             ;
1638 2 MichaelA
                             ;configure memory - try to stay away from memory used by the system
1639
                             ;zero_page memory start address, $50 (80) consecutive Bytes required
1640
                             ;                                add 2 if I_flag = 2
1641 3 MichaelA
                             ;
1642
00b0 =                       zero_page = $B0
1643
                             ;
1644 2 MichaelA
                             ;data_segment memory start address, $5B (91) consecutive Bytes required
1645 3 MichaelA
                             ;
1646 2 MichaelA
0200 =                       data_segment = $200
1647
                                 if (data_segment & $ff) != 0
1648
                                     ERROR ERROR ERROR low byte of data_segment MUST be $00 !!
1649
                                 endif
1650 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   30
1651
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1652
 
1653
                             ;
1654 2 MichaelA
                             ;code_segment memory start address, 13kB of consecutive space required
1655
                             ;                                   add 2.5 kB if I_flag = 2
1656
                             ;parts of the code are self modifying and must reside in RAM
1657 3 MichaelA
                             ;
1658 2 MichaelA
0400 =                       code_segment = $400
1659 3 MichaelA
                             ;
1660 2 MichaelA
                             ;RAM integrity test option. Checks for undesired RAM writes.
1661
                             ;set lowest non RAM or RAM mirror address page (-1=disable, 0=64k, $40=16k)
1662
                             ;leave disabled if a monitor, OS or background interrupt is allowed to alter RAM
1663 3 MichaelA
                             ;
1664 2 MichaelA
ffff =                       ram_top = -1
1665 3 MichaelA
                             ;ram_top = $40
1666 2 MichaelA
                             ;
1667 3 MichaelA
                             ;   Define the top of stack location
1668
                             ;
1669
01ff =                       stack_top = $1FF
1670
                             ;
1671 2 MichaelA
                             ;Skip to ADC/SBC tests
1672
                             ;
1673
0000 =                       skip_part_1  = 0
1674
                             ;
1675
                             ;Skip Binary or Decimal mode ADC/SBC instruction tests
1676
                             ;
1677 3 MichaelA
0000 =                       skip_bin_test = 0
1678
0000 =                       skip_dec_test = 0
1679
                             ;
1680 2 MichaelA
                                     noopt       ;do not take shortcuts
1681 3 MichaelA
                             ;
1682 2 MichaelA
                             ;macros for error & success traps to allow user modification
1683
                             ;example:
1684 3 MichaelA
                             ;
1685 2 MichaelA
                             ;trap    macro
1686
                             ;        jsr my_error_handler
1687
                             ;        endm
1688 3 MichaelA
                             ;
1689 2 MichaelA
                             ;trap_eq macro
1690
                             ;        bne skip\?
1691
                             ;        trap           ;failed equal (zero)
1692
                             ;skip\?
1693
                             ;        endm
1694
                             ;
1695
                             ; my_error_handler should pop the calling address from the stack and report it.
1696
                             ; putting larger portions of code (more than 3 bytes) inside the trap macro
1697
                             ; may lead to branch range problems for some tests.
1698 3 MichaelA
 
1699 2 MichaelA
                             trap    macro
1700 3 MichaelA
                             ;        db      $db         ; M65C02/M65C02A SToP instruction
1701
                                     brk                 ; Use BRK to return to the monitor
1702
                                     db      test_num
1703 2 MichaelA
                                     endm
1704 3 MichaelA
 
1705 2 MichaelA
                             trap_eq macro
1706 3 MichaelA
                                     bne skip\?
1707
                                     trap           ;failed equal (zero)
1708
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   31
1709
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1710
 
1711
                             skip\?
1712 2 MichaelA
                                     endm
1713 3 MichaelA
 
1714 2 MichaelA
                             trap_ne macro
1715 3 MichaelA
                                     beq skip\?
1716
                                     trap           ;failed equal (zero)
1717
                             skip\?
1718 2 MichaelA
                                     endm
1719 3 MichaelA
 
1720 2 MichaelA
                             trap_cs macro
1721 3 MichaelA
                                     bcc skip\?
1722
                                     trap           ;failed equal (zero)
1723
                             skip\?
1724 2 MichaelA
                                     endm
1725 3 MichaelA
 
1726 2 MichaelA
                             trap_cc macro
1727 3 MichaelA
                                     bcs skip\?
1728
                                     trap           ;failed equal (zero)
1729
                             skip\?
1730 2 MichaelA
                                     endm
1731 3 MichaelA
 
1732 2 MichaelA
                             trap_mi macro
1733 3 MichaelA
                                     bpl skip\?
1734
                                     trap           ;failed equal (zero)
1735
                             skip\?
1736 2 MichaelA
                                     endm
1737 3 MichaelA
 
1738 2 MichaelA
                             trap_pl macro
1739 3 MichaelA
                                     bmi skip\?
1740
                                     trap           ;failed equal (zero)
1741
                             skip\?
1742 2 MichaelA
                                     endm
1743 3 MichaelA
 
1744 2 MichaelA
                             trap_vs macro
1745 3 MichaelA
                                     bvc skip\?
1746
                                     trap           ;failed equal (zero)
1747
                             skip\?
1748 2 MichaelA
                                     endm
1749 3 MichaelA
 
1750 2 MichaelA
                             trap_vc macro
1751 3 MichaelA
                                     bvs skip\?
1752
                                     trap           ;failed equal (zero)
1753
                             skip\?
1754 2 MichaelA
                                     endm
1755 3 MichaelA
 
1756 2 MichaelA
                             success macro
1757 3 MichaelA
                                     brk
1758
                                     db      test_num+1
1759 2 MichaelA
                                     endm
1760
 
1761
0001 =                       carry   equ %00000001   ;flag bits in status
1762
0002 =                       zero    equ %00000010
1763
0004 =                       intdis  equ %00000100
1764
0008 =                       decmode equ %00001000
1765
0010 =                       break   equ %00010000
1766 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   32
1767
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1768
 
1769 2 MichaelA
0020 =                       reserv  equ %00100000
1770
0040 =                       overfl  equ %01000000
1771
0080 =                       minus   equ %10000000
1772
 
1773
0001 =                       fc      equ carry
1774
0002 =                       fz      equ zero
1775
0003 =                       fzc     equ carry+zero
1776
0040 =                       fv      equ overfl
1777
0042 =                       fvz     equ overfl+zero
1778
0080 =                       fn      equ minus
1779
0081 =                       fnc     equ minus+carry
1780
0082 =                       fnz     equ minus+zero
1781
0083 =                       fnzc    equ minus+zero+carry
1782
00c0 =                       fnv     equ minus+overfl
1783
 
1784
0030 =                       fao     equ break+reserv    ;bits always on after PHP, BRK
1785
0034 =                       fai     equ fao+intdis      ;+ forced interrupt disable
1786
00ff =                       m8      equ $ff             ;8 bit mask
1787
00fb =                       m8i     equ $ff&~intdis     ;8 bit mask - interrupt disable
1788
 
1789
                             ;macros to allow masking of status bits.
1790
                             ;masking of interrupt enable/disable on load and compare
1791
                             ;masking of always on bits after PHP or BRK (unused & break) on compare
1792 3 MichaelA
 
1793 2 MichaelA
                                     if I_flag = 0
1794 3 MichaelA
 
1795 2 MichaelA
                             load_flag   macro
1796
                                         lda #\1&m8i         ;force enable interrupts (mask I)
1797
                                         endm
1798 3 MichaelA
 
1799 2 MichaelA
                             cmp_flag    macro
1800
                                         cmp #(\1|fao)&m8i   ;I_flag is always enabled + always on bits
1801
                                         endm
1802 3 MichaelA
 
1803 2 MichaelA
                             eor_flag    macro
1804
                                         eor #(\1&m8i|fao)   ;mask I, invert expected flags + always on bits
1805
                                         endm
1806 3 MichaelA
 
1807 2 MichaelA
                                     endif
1808 3 MichaelA
 
1809 2 MichaelA
                                     if I_flag = 1
1810 3 MichaelA
 
1811 2 MichaelA
                             load_flag   macro
1812
                                         lda #\1|intdis      ;force disable interrupts
1813
                                         endm
1814 3 MichaelA
 
1815 2 MichaelA
                             cmp_flag    macro
1816
                                         cmp #(\1|fai)&m8    ;I_flag is always disabled + always on bits
1817
                                         endm
1818 3 MichaelA
 
1819 2 MichaelA
                             eor_flag    macro
1820
                                         eor #(\1|fai)       ;invert expected flags + always on bits + I
1821
                                         endm
1822 3 MichaelA
 
1823 2 MichaelA
                                     endif
1824 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   33
1825
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1826
 
1827
 
1828 2 MichaelA
                                     if I_flag = 2
1829 3 MichaelA
 
1830 2 MichaelA
                             load_flag   macro
1831
                                         lda #\1
1832
                                         ora flag_I_on       ;restore I-flag
1833
                                         and flag_I_off
1834
                                         endm
1835 3 MichaelA
 
1836 2 MichaelA
                             cmp_flag    macro
1837
                                         eor flag_I_on       ;I_flag is never changed
1838
                                         cmp #(\1|fao)&m8i   ;expected flags + always on bits, mask I
1839
                                         endm
1840 3 MichaelA
 
1841 2 MichaelA
                             eor_flag    macro
1842
                                         eor flag_I_on       ;I_flag is never changed
1843
                                         eor #(\1&m8i|fao)   ;mask I, invert expected flags + always on bits
1844
                                         endm
1845 3 MichaelA
 
1846 2 MichaelA
                                     endif
1847 3 MichaelA
 
1848 2 MichaelA
                                     if I_flag = 3
1849 3 MichaelA
 
1850 2 MichaelA
                             load_flag   macro
1851
                                         lda #\1             ;allow test to change I-flag (no mask)
1852
                                         endm
1853 3 MichaelA
 
1854 2 MichaelA
                             cmp_flag    macro
1855
                                         cmp #(\1|fao)&m8    ;expected flags + always on bits
1856
                                         endm
1857 3 MichaelA
 
1858 2 MichaelA
                             eor_flag    macro
1859
                                         eor #\1|fao         ;invert expected flags + always on bits
1860
                                         endm
1861 3 MichaelA
 
1862 2 MichaelA
                                     endif
1863
 
1864
                             ;macros to set (register|memory|zeropage) & status
1865 3 MichaelA
 
1866 2 MichaelA
                             set_stat    macro       ;setting flags in the processor status register
1867
                                         load_flag \1
1868
                                         pha         ;use stack to load status
1869
                                         plp
1870
                                         endm
1871
 
1872
                             set_a       macro       ;precharging accu & status
1873
                                         load_flag \2
1874
                                         pha         ;use stack to load status
1875
                                         lda #\1     ;precharge accu
1876
                                         plp
1877
                                         endm
1878
 
1879
                             set_x       macro       ;precharging index & status
1880
                                         load_flag \2
1881
                                         pha         ;use stack to load status
1882 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   34
1883
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1884
 
1885 2 MichaelA
                                         ldx #\1     ;precharge index x
1886
                                         plp
1887
                                         endm
1888
 
1889
                             set_y       macro       ;precharging index & status
1890
                                         load_flag \2
1891
                                         pha         ;use stack to load status
1892
                                         ldy #\1     ;precharge index y
1893
                                         plp
1894
                                         endm
1895
 
1896
                             set_ax      macro       ;precharging indexed accu & immediate status
1897
                                         load_flag \2
1898
                                         pha         ;use stack to load status
1899
                                         lda \1,x    ;precharge accu
1900
                                         plp
1901
                                         endm
1902
 
1903
                             set_ay      macro       ;precharging indexed accu & immediate status
1904
                                         load_flag \2
1905
                                         pha         ;use stack to load status
1906
                                         lda \1,y    ;precharge accu
1907
                                         plp
1908
                                         endm
1909
 
1910
                             set_z       macro       ;precharging indexed zp & immediate status
1911
                                         load_flag \2
1912
                                         pha         ;use stack to load status
1913
                                         lda \1,x    ;load to zeropage
1914
                                         sta zpt
1915
                                         plp
1916
                                         endm
1917
 
1918
                             set_zx      macro       ;precharging zp,x & immediate status
1919
                                         load_flag \2
1920
                                         pha         ;use stack to load status
1921
                                         lda \1,x    ;load to indexed zeropage
1922
                                         sta zpt,x
1923
                                         plp
1924
                                         endm
1925
 
1926
                             set_abs     macro       ;precharging indexed memory & immediate status
1927
                                         load_flag \2
1928
                                         pha         ;use stack to load status
1929
                                         lda \1,x    ;load to memory
1930
                                         sta abst
1931
                                         plp
1932
                                         endm
1933
 
1934
                             set_absx    macro       ;precharging abs,x & immediate status
1935
                                         load_flag \2
1936
                                         pha         ;use stack to load status
1937
                                         lda \1,x    ;load to indexed memory
1938
                                         sta abst,x
1939
                                         plp
1940 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   35
1941
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
1942
 
1943 2 MichaelA
                                         endm
1944
 
1945
                             ;macros to test (register|memory|zeropage) & status & (mask)
1946 3 MichaelA
 
1947 2 MichaelA
                             tst_stat    macro       ;testing flags in the processor status register
1948
                                         php         ;save status
1949
                                         php         ;use stack to retrieve status
1950
                                         pla
1951
                                         cmp_flag \1
1952
                                         trap_ne
1953
                                         plp         ;restore status
1954
                                         endm
1955
 
1956
                             tst_a       macro       ;testing result in accu & flags
1957
                                         php         ;save flags
1958
                                         php
1959
                                         cmp #\1     ;test result
1960
                                         trap_ne
1961
                                         pla         ;load status
1962
                                         cmp_flag \2
1963
                                         trap_ne
1964
                                         plp         ;restore status
1965
                                         endm
1966
 
1967
                             tst_x       macro       ;testing result in x index & flags
1968
                                         php         ;save flags
1969
                                         php
1970
                                         cpx #\1     ;test result
1971
                                         trap_ne
1972
                                         pla         ;load status
1973
                                         cmp_flag \2
1974
                                         trap_ne
1975
                                         plp         ;restore status
1976
                                         endm
1977
 
1978
                             tst_y       macro       ;testing result in y index & flags
1979
                                         php         ;save flags
1980
                                         php
1981
                                         cpy #\1     ;test result
1982
                                         trap_ne
1983
                                         pla         ;load status
1984
                                         cmp_flag \2
1985
                                         trap_ne
1986
                                         plp         ;restore status
1987
                                         endm
1988
 
1989
                             tst_ax      macro       ;indexed testing result in accu & flags
1990
                                         php         ;save flags
1991
                                         cmp \1,x    ;test result
1992
                                         trap_ne
1993
                                         pla         ;load status
1994
                                         eor_flag \3
1995
                                         cmp \2,x    ;test flags
1996
                                         trap_ne     ;
1997
                                         endm
1998 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   36
1999
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2000
 
2001 2 MichaelA
 
2002
                             tst_ay      macro       ;indexed testing result in accu & flags
2003
                                         php         ;save flags
2004
                                         cmp \1,y    ;test result
2005
                                         trap_ne     ;
2006
                                         pla         ;load status
2007
                                         eor_flag \3
2008
                                         cmp \2,y    ;test flags
2009
                                         trap_ne
2010
                                         endm
2011
 
2012
                             tst_z       macro       ;indexed testing result in zp & flags
2013
                                         php         ;save flags
2014
                                         lda zpt
2015
                                         cmp \1,x    ;test result
2016
                                         trap_ne
2017
                                         pla         ;load status
2018
                                         eor_flag \3
2019
                                         cmp \2,x    ;test flags
2020
                                         trap_ne
2021
                                         endm
2022
 
2023
                             tst_zx      macro       ;testing result in zp,x & flags
2024
                                         php         ;save flags
2025
                                         lda zpt,x
2026
                                         cmp \1,x    ;test result
2027
                                         trap_ne
2028
                                         pla         ;load status
2029
                                         eor_flag \3
2030
                                         cmp \2,x    ;test flags
2031
                                         trap_ne
2032
                                         endm
2033
 
2034
                             tst_abs     macro       ;indexed testing result in memory & flags
2035
                                         php         ;save flags
2036
                                         lda abst
2037
                                         cmp \1,x    ;test result
2038
                                         trap_ne
2039
                                         pla         ;load status
2040
                                         eor_flag \3
2041
                                         cmp \2,x    ;test flags
2042
                                         trap_ne
2043
                                         endm
2044
 
2045
                             tst_absx    macro       ;testing result in abs,x & flags
2046
                                         php         ;save flags
2047
                                         lda abst,x
2048
                                         cmp \1,x    ;test result
2049
                                         trap_ne
2050
                                         pla         ;load status
2051
                                         eor_flag \3
2052
                                         cmp \2,x    ;test flags
2053
                                         trap_ne
2054
                                         endm
2055
 
2056 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   37
2057
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2058
 
2059 2 MichaelA
                             ; RAM integrity test
2060
                             ;   verifies that none of the previous tests has altered RAM outside of the
2061
                             ;   designated write areas.
2062
                             ;   uses zpt word as indirect pointer, zpt+2 word as checksum
2063 3 MichaelA
 
2064 2 MichaelA
                                     if ram_top > -1
2065 3 MichaelA
 
2066 2 MichaelA
                             check_ram   macro
2067
                                         cld
2068
                                         lda #0
2069
                                         sta zpt         ;set low byte of indirect pointer
2070
                                         sta zpt+3       ;checksum high byte
2071
                                         sta range_adr   ;reset self modifying code
2072
                                         sta tandi1
2073
                                         sta tandi2
2074
                                         sta teori1
2075
                                         sta teori2
2076
                                         sta torai1
2077
                                         sta torai2
2078
                                         sta chkdadi
2079
                                         sta chkdsbi
2080
                                         sta chkadi
2081
                                         sta chksbi
2082
                                         clc
2083
                                         ldx #zp_bss-zero_page ;zeropage - write test area
2084
                             ccs3\?      adc zero_page,x
2085
                                         bcc ccs2\?
2086
                                         inc zpt+3       ;carry to high byte
2087
                                         clc
2088
                             ccs2\?      inx
2089
                                         bne ccs3\?
2090
                                         ldx #hi(data_segment) ;set high byte of indirect pointer
2091
                                         stx zpt+1
2092
                                         ldy #lo(data_bss) ;data after write test area
2093
                             ccs5\?      adc (zpt),y
2094
                                         bcc ccs4\?
2095
                                         inc zpt+3       ;carry to high byte
2096
                                         clc
2097
                             ccs4\?      iny
2098
                                         bne ccs5\?
2099
                                         inx             ;advance RAM high address
2100
                                         stx zpt+1
2101
                                         cpx #ram_top
2102
                                         bne ccs5\?
2103
                                         sta zpt+2       ;checksum low is
2104
                                         cmp ram_chksm   ;checksum low expected
2105
                                         trap_ne         ;checksum mismatch
2106
                                         lda zpt+3       ;checksum high is
2107
                                         cmp ram_chksm+1 ;checksum high expected
2108
                                         trap_ne         ;checksum mismatch
2109
                                         endm
2110 3 MichaelA
 
2111 2 MichaelA
                                     else
2112 3 MichaelA
 
2113 2 MichaelA
                             check_ram   macro
2114 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   38
2115
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2116
 
2117 2 MichaelA
                                         ;RAM check disabled - RAM size not set
2118
                                         endm
2119 3 MichaelA
 
2120 2 MichaelA
                                     endif
2121
 
2122
                             next_test   macro           ;make sure, tests don't jump the fence
2123
                                         lda test_case   ;previous test
2124
                                         cmp #test_num
2125
                                         trap_ne         ;test is out of sequence
2126
                             test_num = test_num + 1
2127
                                         lda #test_num   ;*** this tests' number
2128
                                         sta test_case
2129
                                         ;check_ram       ;uncomment to find altered RAM after each test
2130
                                         endm
2131
 
2132
                                 if load_data_direct = 1
2133 3 MichaelA
 
2134 2 MichaelA
                                     data
2135 3 MichaelA
 
2136 2 MichaelA
                                 else
2137 3 MichaelA
 
2138
                             ;        bss                 ;uninitialized segment, copy of data at end of code!
2139
                                     code
2140
0000 =                               org 0
2141
0000 : 00000000000000..              ds  zero_page
2142
 
2143 2 MichaelA
                                 endif
2144
                             ;
2145 3 MichaelA
00b0 =                               org zero_page
2146
                             ;
2147
                             ;        org 0
2148
                             ;        ds  zero_page
2149
                             ;
2150 2 MichaelA
                             ;break test interrupt save
2151 3 MichaelA
                             ;
2152
 
2153
00b0 : 00                    irq_a   ds  1               ;a register
2154
00b1 : 00                    irq_x   ds  1               ;x register
2155
 
2156 2 MichaelA
                                 if I_flag = 2
2157 3 MichaelA
 
2158 2 MichaelA
                             ;masking for I bit in status
2159 3 MichaelA
 
2160 2 MichaelA
                             flag_I_on   ds  1           ;or mask to load flags
2161
                             flag_I_off  ds  1           ;and mask to load flags
2162 3 MichaelA
 
2163 2 MichaelA
                                 endif
2164 3 MichaelA
 
2165
00b2 :                       zpt                         ;5 bytes store/modify test area
2166
 
2167 2 MichaelA
                             ;add/subtract operand generation and result/flag prediction
2168 3 MichaelA
 
2169
00b2 : 00                    adfc    ds  1               ;carry flag before op
2170
00b3 : 00                    ad1     ds  1               ;operand 1 - accumulator
2171
00b4 : 00                    ad2     ds  1               ;operand 2 - memory / immediate
2172
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   39
2173
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2174
 
2175
00b5 : 00                    adrl    ds  1               ;expected result bits 0-7
2176
00b6 : 00                    adrh    ds  1               ;expected result bit 8 (carry)
2177
00b7 : 00                    adrf    ds  1               ;expected flags NV0000ZC (-V in decimal mode)
2178
00b8 : 00                    sb2     ds  1               ;operand 2 complemented for subtract
2179
 
2180
00b9 :                       zp_bss
2181
 
2182
00b9 : c3824100              zp1     db  $c3,$82,$41,0   ;test patterns for LDx BIT ROL ROR ASL LSR
2183
00bd : 7f                    zp7f    db  $7f             ;test pattern for compare
2184
 
2185 2 MichaelA
                             ;logical zeropage operands
2186 3 MichaelA
 
2187
00be : 001f7180              zpOR    db  0,$1f,$71,$80   ;test pattern for OR
2188
00c2 : 0fff7f80              zpAN    db  $0f,$ff,$7f,$80 ;test pattern for AND
2189
00c6 : ff0f8f8f              zpEO    db  $ff,$0f,$8f,$8f ;test pattern for EOR
2190
 
2191 2 MichaelA
                             ;indirect addressing pointers
2192 3 MichaelA
 
2193
00ca : 0802                  ind1    dw  abs1            ;indirect pointer to pattern in absolute memory
2194
00cc : 0902                          dw  abs1+1
2195
00ce : 0a02                          dw  abs1+2
2196
00d0 : 0b02                          dw  abs1+3
2197
00d2 : 0c02                          dw  abs7f
2198
00d4 : 1001                  inw1    dw  abs1-$f8        ;indirect pointer for wrap-test pattern
2199
00d6 : 0302                  indt    dw  abst            ;indirect pointer to store area in absolute memory
2200
00d8 : 0402                          dw  abst+1
2201
00da : 0502                          dw  abst+2
2202
00dc : 0602                          dw  abst+3
2203
00de : 0b01                  inwt    dw  abst-$f8        ;indirect pointer for wrap-test store
2204
00e0 : 3f02                  indAN   dw  absAN           ;indirect pointer to AND pattern in absolute memory
2205
00e2 : 4002                          dw  absAN+1
2206
00e4 : 4102                          dw  absAN+2
2207
00e6 : 4202                          dw  absAN+3
2208
00e8 : 4302                  indEO   dw  absEO           ;indirect pointer to EOR pattern in absolute memory
2209
00ea : 4402                          dw  absEO+1
2210
00ec : 4502                          dw  absEO+2
2211
00ee : 4602                          dw  absEO+3
2212
00f0 : 3b02                  indOR   dw  absOR           ;indirect pointer to OR pattern in absolute memory
2213
00f2 : 3c02                          dw  absOR+1
2214
00f4 : 3d02                          dw  absOR+2
2215
00f6 : 3e02                          dw  absOR+3
2216
 
2217 2 MichaelA
                             ;add/subtract indirect pointers
2218 3 MichaelA
 
2219
00f8 : 0302                  adi2    dw  ada2            ;indirect pointer to operand 2 in absolute memory
2220
00fa : 0402                  sbi2    dw  sba2            ;indirect pointer to complemented operand 2 (SBC)
2221
00fc : 0401                  adiy2   dw  ada2-$ff        ;with offset for indirect indexed
2222
00fe : 0501                  sbiy2   dw  sba2-$ff
2223
 
2224
0100 :                       zp_bss_end
2225 2 MichaelA
 
2226
0200 =                               org data_segment
2227 3 MichaelA
 
2228 2 MichaelA
0200 : 00                    test_case   ds  1           ;current test number
2229
0201 : 0000                  ram_chksm   ds  2           ;checksum for RAM integrity test
2230 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   40
2231
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2232
 
2233
 
2234 2 MichaelA
                             ;add/subtract operand copy - abs tests write area
2235 3 MichaelA
 
2236 2 MichaelA
0203 :                       abst                        ;5 bytes store/modify test area
2237
0203 : 00                    ada2    ds  1               ;operand 2
2238
0204 : 00                    sba2    ds  1               ;operand 2 complemented for subtract
2239
0205 : 000000                        ds  3               ;fill remaining bytes
2240 3 MichaelA
 
2241 2 MichaelA
0208 :                       data_bss
2242 3 MichaelA
 
2243 2 MichaelA
0208 : c3824100              abs1    db  $c3,$82,$41,0   ;test patterns for LDx BIT ROL ROR ASL LSR
2244
020c : 7f                    abs7f   db  $7f             ;test pattern for compare
2245 3 MichaelA
 
2246 2 MichaelA
                             ;loads
2247 3 MichaelA
 
2248 2 MichaelA
020d : 80800002              fLDx    db  fn,fn,0,fz      ;expected flags for load
2249 3 MichaelA
 
2250 2 MichaelA
                             ;shifts
2251 3 MichaelA
 
2252 2 MichaelA
0211 :                       rASL                        ;expected result ASL & ROL -carry
2253
0211 : 86048200              rROL    db  $86,$04,$82,0   ; "
2254
0215 : 87058301              rROLc   db  $87,$05,$83,1   ;expected result ROL +carry
2255
0219 :                       rLSR                        ;expected result LSR & ROR -carry
2256
0219 : 61412000              rROR    db  $61,$41,$20,0   ; "
2257
021d : e1c1a080              rRORc   db  $e1,$c1,$a0,$80 ;expected result ROR +carry
2258
0221 :                       fASL                        ;expected flags for shifts
2259
0221 : 81018002              fROL    db  fnc,fc,fn,fz    ;no carry in
2260
0225 : 81018000              fROLc   db  fnc,fc,fn,0     ;carry in
2261
0229 :                       fLSR
2262
0229 : 01000102              fROR    db  fc,0,fc,fz      ;no carry in
2263
022d : 81808180              fRORc   db  fnc,fn,fnc,fn   ;carry in
2264 3 MichaelA
 
2265 2 MichaelA
                             ;increments (decrements)
2266 3 MichaelA
 
2267 2 MichaelA
0231 : 7f80ff0001            rINC    db  $7f,$80,$ff,0,1 ;expected result for INC/DEC
2268
0236 : 0080800200            fINC    db  0,fn,fn,fz,0    ;expected flags for INC/DEC
2269 3 MichaelA
 
2270 2 MichaelA
                             ;logical memory operand
2271 3 MichaelA
 
2272 2 MichaelA
023b : 001f7180              absOR   db  0,$1f,$71,$80   ;test pattern for OR
2273
023f : 0fff7f80              absAN   db  $0f,$ff,$7f,$80 ;test pattern for AND
2274
0243 : ff0f8f8f              absEO   db  $ff,$0f,$8f,$8f ;test pattern for EOR
2275 3 MichaelA
 
2276 2 MichaelA
                             ;logical accu operand
2277 3 MichaelA
 
2278 2 MichaelA
0247 : 00f11f00              absORa  db  0,$f1,$1f,0     ;test pattern for OR
2279
024b : f0ffffff              absANa  db  $f0,$ff,$ff,$ff ;test pattern for AND
2280
024f : fff0f00f              absEOa  db  $ff,$f0,$f0,$0f ;test pattern for EOR
2281 3 MichaelA
 
2282 2 MichaelA
                             ;logical results
2283 3 MichaelA
 
2284 2 MichaelA
0253 : 00ff7f80              absrlo  db  0,$ff,$7f,$80
2285
0257 : 02800080              absflo  db  fz,fn,0,fn
2286 3 MichaelA
 
2287 2 MichaelA
025b :                       data_bss_end
2288 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   41
2289
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2290
 
2291 2 MichaelA
 
2292
                                     code
2293
0400 =                               org code_segment
2294 3 MichaelA
 
2295 2 MichaelA
0400 : d8               [ 2] start   cld
2296
0401 : a900             [ 2]         lda #0          ;*** test 0 = initialize
2297
0403 : 8d0002           [ 4]         sta test_case
2298
0000 =                       test_num = 0
2299
 
2300
                             ;stop interrupts before initializing BSS
2301 3 MichaelA
 
2302 2 MichaelA
                                 if I_flag = 1
2303
                                     sei
2304
                                 endif
2305
 
2306
                             ;initialize BSS segment
2307 3 MichaelA
 
2308 2 MichaelA
                                 if load_data_direct != 1
2309 3 MichaelA
 
2310
0406 : a246             [ 2]         ldx #zp_end-zp_init-1
2311
0408 : bd4c3e           [ 4] ld_zp   lda zp_init,x
2312
040b : 95b9             [ 4]         sta zp_bss,x
2313
040d : ca               [ 2]         dex
2314
040e : 10f8             [ 3]         bpl ld_zp
2315
0410 : a252             [ 2]         ldx #data_end-data_init-1
2316
0412 : bd933e           [ 4] ld_data lda data_init,x
2317
0415 : 9d0802           [ 5]         sta data_bss,x
2318
0418 : ca               [ 2]         dex
2319
0419 : 10f7             [ 3]         bpl ld_data
2320
 
2321 2 MichaelA
                                   if ROM_vectors = 1
2322 3 MichaelA
 
2323 2 MichaelA
                                     ldx #5
2324
                             ld_vect lda vec_init,x
2325
                                     sta vec_bss,x
2326
                                     dex
2327
                                     bpl ld_vect
2328 3 MichaelA
 
2329 2 MichaelA
                                   endif
2330 3 MichaelA
 
2331 2 MichaelA
                                 endif
2332
 
2333
                             ;retain status of interrupt flag
2334 3 MichaelA
 
2335 2 MichaelA
                                 if I_flag = 2
2336 3 MichaelA
 
2337 2 MichaelA
                                     php
2338
                                     pla
2339
                                     and #4          ;isolate flag
2340
                                     sta flag_I_on   ;or mask
2341
                                     eor #lo(~4)     ;reverse
2342
                                     sta flag_I_off  ;and mask
2343 3 MichaelA
 
2344 2 MichaelA
                                 endif
2345
 
2346 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   42
2347
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2348
 
2349 2 MichaelA
                             ;generate checksum for RAM integrity test
2350 3 MichaelA
 
2351 2 MichaelA
                                 if ram_top > -1
2352 3 MichaelA
 
2353 2 MichaelA
                                     lda #0
2354
                                     sta zpt         ;set low byte of indirect pointer
2355
                                     sta ram_chksm+1 ;checksum high byte
2356
                                     sta range_adr   ;reset self modifying code
2357
                                     sta tandi1
2358
                                     sta tandi2
2359
                                     sta teori1
2360
                                     sta teori2
2361
                                     sta torai1
2362
                                     sta torai2
2363
                                     sta chkdadi
2364
                                     sta chkdsbi
2365
                                     sta chkadi
2366
                                     sta chksbi
2367
                                     clc
2368
                                     ldx #zp_bss-zero_page ;zeropage - write test area
2369
                             gcs3    adc zero_page,x
2370
                                     bcc gcs2
2371
                                     inc ram_chksm+1 ;carry to high byte
2372
                                     clc
2373
                             gcs2    inx
2374
                                     bne gcs3
2375
                                     ldx #hi(data_segment) ;set high byte of indirect pointer
2376
                                     stx zpt+1
2377
                                     ldy #lo(data_bss) ;data after write test area
2378
                             gcs5    adc (zpt),y
2379
                                     bcc gcs4
2380
                                     inc ram_chksm+1 ;carry to high byte
2381
                                     clc
2382
                             gcs4    iny
2383
                                     bne gcs5
2384
                                     inx             ;advance RAM high address
2385
                                     stx zpt+1
2386
                                     cpx #ram_top
2387
                                     bne gcs5
2388
                                     sta ram_chksm   ;checksum complete
2389 3 MichaelA
 
2390 2 MichaelA
                                 endif
2391
 
2392
                                 if skip_part_1 = 1
2393 3 MichaelA
 
2394 2 MichaelA
                                     jmp  bin_test
2395 3 MichaelA
 
2396 2 MichaelA
                                 endif
2397
 
2398
                                     next_test
2399 3 MichaelA
041b : ad0002           [ 4]>            lda test_case   ;previous test
2400
041e : c900             [ 2]>            cmp #test_num
2401 2 MichaelA
                            >            trap_ne         ;test is out of sequence
2402 3 MichaelA
0420 : f002             [ 3]>        beq skip0002
2403
                            >        trap           ;failed equal (zero)
2404
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   43
2405
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2406
 
2407
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2408
0422 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2409
0423 : 00                   >        db      test_num
2410 2 MichaelA
                            >
2411 3 MichaelA
0424 :                      >skip0002
2412
                            >
2413 2 MichaelA
0001 =                      >test_num = test_num + 1
2414 3 MichaelA
0424 : a901             [ 2]>            lda #test_num   ;*** this tests' number
2415
0426 : 8d0002           [ 4]>            sta test_case
2416 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
2417
 
2418
 
2419
                             ;testing relative addressing with BEQ
2420 3 MichaelA
 
2421
0429 : a0fe             [ 2]         ldy #$fe        ;testing maximum range, not -1/-2 (invalid/self adr)
2422
042b :                       range_loop
2423
042b : 88               [ 2]         dey             ;next relative address
2424
042c : 98               [ 2]         tya
2425
042d : aa               [ 2]         tax             ;precharge count to end of loop
2426
042e : 1003             [ 3]         bpl range_fw    ;calculate relative address
2427
0430 : 18               [ 2]         clc             ;avoid branch self or to relative address of branch
2428
0431 : 6902             [ 2]         adc #2
2429
0433 :                       range_fw
2430
0433 : 497f             [ 2]         eor #$7f        ;complement except sign
2431
0435 : 8dbc04           [ 4]         sta range_adr   ;load into test target
2432
0438 : a900             [ 2]         lda #0          ;should set zero flag in status register
2433
043a : 4cbb04           [ 3]         jmp range_op
2434 2 MichaelA
 
2435
                                     ;relative address target field with branch under test in the middle
2436 3 MichaelA
 
2437
043d : ca               [ 2]         dex             ;-128 - max backward
2438 2 MichaelA
043e : ca               [ 2]         dex
2439
043f : ca               [ 2]         dex
2440
0440 : ca               [ 2]         dex
2441
0441 : ca               [ 2]         dex
2442 3 MichaelA
0442 : ca               [ 2]         dex
2443 2 MichaelA
0443 : ca               [ 2]         dex
2444
0444 : ca               [ 2]         dex
2445 3 MichaelA
0445 : ca               [ 2]         dex             ;-120
2446 2 MichaelA
0446 : ca               [ 2]         dex
2447
0447 : ca               [ 2]         dex
2448
0448 : ca               [ 2]         dex
2449
0449 : ca               [ 2]         dex
2450
044a : ca               [ 2]         dex
2451
044b : ca               [ 2]         dex
2452 3 MichaelA
044c : ca               [ 2]         dex
2453 2 MichaelA
044d : ca               [ 2]         dex
2454
044e : ca               [ 2]         dex
2455 3 MichaelA
044f : ca               [ 2]         dex             ;-110
2456 2 MichaelA
0450 : ca               [ 2]         dex
2457
0451 : ca               [ 2]         dex
2458
0452 : ca               [ 2]         dex
2459
0453 : ca               [ 2]         dex
2460
0454 : ca               [ 2]         dex
2461
0455 : ca               [ 2]         dex
2462 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   44
2463
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2464
 
2465
0456 : ca               [ 2]         dex
2466 2 MichaelA
0457 : ca               [ 2]         dex
2467
0458 : ca               [ 2]         dex
2468 3 MichaelA
0459 : ca               [ 2]         dex             ;-100
2469 2 MichaelA
045a : ca               [ 2]         dex
2470
045b : ca               [ 2]         dex
2471
045c : ca               [ 2]         dex
2472
045d : ca               [ 2]         dex
2473
045e : ca               [ 2]         dex
2474
045f : ca               [ 2]         dex
2475 3 MichaelA
0460 : ca               [ 2]         dex
2476 2 MichaelA
0461 : ca               [ 2]         dex
2477
0462 : ca               [ 2]         dex
2478 3 MichaelA
0463 : ca               [ 2]         dex             ;-90
2479 2 MichaelA
0464 : ca               [ 2]         dex
2480
0465 : ca               [ 2]         dex
2481
0466 : ca               [ 2]         dex
2482
0467 : ca               [ 2]         dex
2483
0468 : ca               [ 2]         dex
2484
0469 : ca               [ 2]         dex
2485 3 MichaelA
046a : ca               [ 2]         dex
2486 2 MichaelA
046b : ca               [ 2]         dex
2487
046c : ca               [ 2]         dex
2488 3 MichaelA
046d : ca               [ 2]         dex             ;-80
2489 2 MichaelA
046e : ca               [ 2]         dex
2490
046f : ca               [ 2]         dex
2491
0470 : ca               [ 2]         dex
2492
0471 : ca               [ 2]         dex
2493
0472 : ca               [ 2]         dex
2494
0473 : ca               [ 2]         dex
2495 3 MichaelA
0474 : ca               [ 2]         dex
2496 2 MichaelA
0475 : ca               [ 2]         dex
2497
0476 : ca               [ 2]         dex
2498 3 MichaelA
0477 : ca               [ 2]         dex             ;-70
2499 2 MichaelA
0478 : ca               [ 2]         dex
2500
0479 : ca               [ 2]         dex
2501
047a : ca               [ 2]         dex
2502
047b : ca               [ 2]         dex
2503
047c : ca               [ 2]         dex
2504
047d : ca               [ 2]         dex
2505 3 MichaelA
047e : ca               [ 2]         dex
2506 2 MichaelA
047f : ca               [ 2]         dex
2507
0480 : ca               [ 2]         dex
2508 3 MichaelA
0481 : ca               [ 2]         dex             ;-60
2509 2 MichaelA
0482 : ca               [ 2]         dex
2510
0483 : ca               [ 2]         dex
2511
0484 : ca               [ 2]         dex
2512
0485 : ca               [ 2]         dex
2513
0486 : ca               [ 2]         dex
2514
0487 : ca               [ 2]         dex
2515 3 MichaelA
0488 : ca               [ 2]         dex
2516 2 MichaelA
0489 : ca               [ 2]         dex
2517
048a : ca               [ 2]         dex
2518 3 MichaelA
048b : ca               [ 2]         dex             ;-50
2519 2 MichaelA
048c : ca               [ 2]         dex
2520 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   45
2521
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2522
 
2523 2 MichaelA
048d : ca               [ 2]         dex
2524
048e : ca               [ 2]         dex
2525
048f : ca               [ 2]         dex
2526
0490 : ca               [ 2]         dex
2527
0491 : ca               [ 2]         dex
2528 3 MichaelA
0492 : ca               [ 2]         dex
2529 2 MichaelA
0493 : ca               [ 2]         dex
2530
0494 : ca               [ 2]         dex
2531 3 MichaelA
0495 : ca               [ 2]         dex             ;-40
2532 2 MichaelA
0496 : ca               [ 2]         dex
2533
0497 : ca               [ 2]         dex
2534
0498 : ca               [ 2]         dex
2535
0499 : ca               [ 2]         dex
2536
049a : ca               [ 2]         dex
2537
049b : ca               [ 2]         dex
2538 3 MichaelA
049c : ca               [ 2]         dex
2539 2 MichaelA
049d : ca               [ 2]         dex
2540
049e : ca               [ 2]         dex
2541 3 MichaelA
049f : ca               [ 2]         dex             ;-30
2542 2 MichaelA
04a0 : ca               [ 2]         dex
2543
04a1 : ca               [ 2]         dex
2544
04a2 : ca               [ 2]         dex
2545 3 MichaelA
04a3 : ca               [ 2]         dex
2546
04a4 : ca               [ 2]         dex
2547
04a5 : ca               [ 2]         dex
2548
04a6 : ca               [ 2]         dex
2549 2 MichaelA
04a7 : ca               [ 2]         dex
2550
04a8 : ca               [ 2]         dex
2551 3 MichaelA
04a9 : ca               [ 2]         dex             ;-20
2552 2 MichaelA
04aa : ca               [ 2]         dex
2553
04ab : ca               [ 2]         dex
2554
04ac : ca               [ 2]         dex
2555
04ad : ca               [ 2]         dex
2556
04ae : ca               [ 2]         dex
2557
04af : ca               [ 2]         dex
2558 3 MichaelA
04b0 : ca               [ 2]         dex
2559 2 MichaelA
04b1 : ca               [ 2]         dex
2560
04b2 : ca               [ 2]         dex
2561 3 MichaelA
04b3 : ca               [ 2]         dex             ;-10
2562 2 MichaelA
04b4 : ca               [ 2]         dex
2563
04b5 : ca               [ 2]         dex
2564
04b6 : ca               [ 2]         dex
2565
04b7 : ca               [ 2]         dex
2566
04b8 : ca               [ 2]         dex
2567
04b9 : ca               [ 2]         dex
2568 3 MichaelA
04ba : ca               [ 2]         dex             ;-3
2569
 
2570
04bb :                       range_op                ;test target with zero flag=0, z=1 if previous dex
2571
04bc =                       range_adr   = *+1       ;modifiable relative address
2572
 
2573
04bb : f03e             [ 3]         beq *+64        ;if called without modification
2574
04bd : ca               [ 2]         dex             ;+0
2575 2 MichaelA
04be : ca               [ 2]         dex
2576
04bf : ca               [ 2]         dex
2577
04c0 : ca               [ 2]         dex
2578 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   46
2579
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2580
 
2581 2 MichaelA
04c1 : ca               [ 2]         dex
2582
04c2 : ca               [ 2]         dex
2583
04c3 : ca               [ 2]         dex
2584 3 MichaelA
04c4 : ca               [ 2]         dex
2585 2 MichaelA
04c5 : ca               [ 2]         dex
2586
04c6 : ca               [ 2]         dex
2587 3 MichaelA
04c7 : ca               [ 2]         dex             ;+10
2588 2 MichaelA
04c8 : ca               [ 2]         dex
2589
04c9 : ca               [ 2]         dex
2590
04ca : ca               [ 2]         dex
2591
04cb : ca               [ 2]         dex
2592
04cc : ca               [ 2]         dex
2593
04cd : ca               [ 2]         dex
2594 3 MichaelA
04ce : ca               [ 2]         dex
2595 2 MichaelA
04cf : ca               [ 2]         dex
2596
04d0 : ca               [ 2]         dex
2597 3 MichaelA
04d1 : ca               [ 2]         dex             ;+20
2598 2 MichaelA
04d2 : ca               [ 2]         dex
2599
04d3 : ca               [ 2]         dex
2600
04d4 : ca               [ 2]         dex
2601
04d5 : ca               [ 2]         dex
2602
04d6 : ca               [ 2]         dex
2603
04d7 : ca               [ 2]         dex
2604 3 MichaelA
04d8 : ca               [ 2]         dex
2605 2 MichaelA
04d9 : ca               [ 2]         dex
2606
04da : ca               [ 2]         dex
2607 3 MichaelA
04db : ca               [ 2]         dex             ;+30
2608 2 MichaelA
04dc : ca               [ 2]         dex
2609
04dd : ca               [ 2]         dex
2610
04de : ca               [ 2]         dex
2611
04df : ca               [ 2]         dex
2612
04e0 : ca               [ 2]         dex
2613
04e1 : ca               [ 2]         dex
2614 3 MichaelA
04e2 : ca               [ 2]         dex
2615 2 MichaelA
04e3 : ca               [ 2]         dex
2616
04e4 : ca               [ 2]         dex
2617 3 MichaelA
04e5 : ca               [ 2]         dex             ;+40
2618 2 MichaelA
04e6 : ca               [ 2]         dex
2619
04e7 : ca               [ 2]         dex
2620
04e8 : ca               [ 2]         dex
2621
04e9 : ca               [ 2]         dex
2622
04ea : ca               [ 2]         dex
2623
04eb : ca               [ 2]         dex
2624 3 MichaelA
04ec : ca               [ 2]         dex
2625 2 MichaelA
04ed : ca               [ 2]         dex
2626
04ee : ca               [ 2]         dex
2627 3 MichaelA
04ef : ca               [ 2]         dex             ;+50
2628 2 MichaelA
04f0 : ca               [ 2]         dex
2629
04f1 : ca               [ 2]         dex
2630
04f2 : ca               [ 2]         dex
2631
04f3 : ca               [ 2]         dex
2632
04f4 : ca               [ 2]         dex
2633
04f5 : ca               [ 2]         dex
2634 3 MichaelA
04f6 : ca               [ 2]         dex
2635 2 MichaelA
04f7 : ca               [ 2]         dex
2636 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   47
2637
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2638
 
2639 2 MichaelA
04f8 : ca               [ 2]         dex
2640 3 MichaelA
04f9 : ca               [ 2]         dex             ;+60
2641 2 MichaelA
04fa : ca               [ 2]         dex
2642
04fb : ca               [ 2]         dex
2643
04fc : ca               [ 2]         dex
2644
04fd : ca               [ 2]         dex
2645
04fe : ca               [ 2]         dex
2646
04ff : ca               [ 2]         dex
2647 3 MichaelA
0500 : ca               [ 2]         dex
2648 2 MichaelA
0501 : ca               [ 2]         dex
2649
0502 : ca               [ 2]         dex
2650 3 MichaelA
0503 : ca               [ 2]         dex             ;+70
2651 2 MichaelA
0504 : ca               [ 2]         dex
2652
0505 : ca               [ 2]         dex
2653
0506 : ca               [ 2]         dex
2654
0507 : ca               [ 2]         dex
2655
0508 : ca               [ 2]         dex
2656
0509 : ca               [ 2]         dex
2657 3 MichaelA
050a : ca               [ 2]         dex
2658 2 MichaelA
050b : ca               [ 2]         dex
2659
050c : ca               [ 2]         dex
2660 3 MichaelA
050d : ca               [ 2]         dex             ;+80
2661 2 MichaelA
050e : ca               [ 2]         dex
2662
050f : ca               [ 2]         dex
2663
0510 : ca               [ 2]         dex
2664
0511 : ca               [ 2]         dex
2665
0512 : ca               [ 2]         dex
2666
0513 : ca               [ 2]         dex
2667 3 MichaelA
0514 : ca               [ 2]         dex
2668 2 MichaelA
0515 : ca               [ 2]         dex
2669
0516 : ca               [ 2]         dex
2670 3 MichaelA
0517 : ca               [ 2]         dex             ;+90
2671 2 MichaelA
0518 : ca               [ 2]         dex
2672
0519 : ca               [ 2]         dex
2673
051a : ca               [ 2]         dex
2674
051b : ca               [ 2]         dex
2675
051c : ca               [ 2]         dex
2676
051d : ca               [ 2]         dex
2677 3 MichaelA
051e : ca               [ 2]         dex
2678 2 MichaelA
051f : ca               [ 2]         dex
2679
0520 : ca               [ 2]         dex
2680 3 MichaelA
0521 : ca               [ 2]         dex             ;+100
2681 2 MichaelA
0522 : ca               [ 2]         dex
2682
0523 : ca               [ 2]         dex
2683
0524 : ca               [ 2]         dex
2684 3 MichaelA
0525 : ca               [ 2]         dex
2685
0526 : ca               [ 2]         dex
2686
0527 : ca               [ 2]         dex
2687
0528 : ca               [ 2]         dex
2688
0529 : ca               [ 2]         dex
2689
052a : ca               [ 2]         dex
2690
052b : ca               [ 2]         dex             ;+110
2691
052c : ca               [ 2]         dex
2692
052d : ca               [ 2]         dex
2693
052e : ca               [ 2]         dex
2694
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   48
2695
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2696
 
2697
052f : ca               [ 2]         dex
2698
0530 : ca               [ 2]         dex
2699
0531 : ca               [ 2]         dex
2700
0532 : ca               [ 2]         dex
2701
0533 : ca               [ 2]         dex
2702
0534 : ca               [ 2]         dex
2703
0535 : ca               [ 2]         dex             ;+120
2704
0536 : ca               [ 2]         dex
2705
0537 : ca               [ 2]         dex
2706
0538 : ca               [ 2]         dex
2707
0539 : ca               [ 2]         dex
2708
053a : ca               [ 2]         dex
2709
053b : ca               [ 2]         dex
2710
 
2711
053c : f002             [ 3]         beq range_ok    ;+127 - max forward
2712 2 MichaelA
                                     trap            ; bad range
2713 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2714
053e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2715
053f : 01                   >        db      test_num
2716 2 MichaelA
 
2717 3 MichaelA
 
2718
0540 :                       range_ok
2719
0540 : c000             [ 2]         cpy #0
2720
0542 : f003             [ 3]         beq range_end
2721
0544 : 4c2b04           [ 3]         jmp range_loop
2722
0547 :                       range_end               ;range test successful
2723 2 MichaelA
                                     next_test
2724 3 MichaelA
0547 : ad0002           [ 4]>            lda test_case   ;previous test
2725
054a : c901             [ 2]>            cmp #test_num
2726 2 MichaelA
                            >            trap_ne         ;test is out of sequence
2727 3 MichaelA
054c : f002             [ 3]>        beq skip0006
2728
                            >        trap           ;failed equal (zero)
2729
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2730
054e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2731
054f : 01                   >        db      test_num
2732 2 MichaelA
                            >
2733 3 MichaelA
0550 :                      >skip0006
2734
                            >
2735 2 MichaelA
0002 =                      >test_num = test_num + 1
2736 3 MichaelA
0550 : a902             [ 2]>            lda #test_num   ;*** this tests' number
2737
0552 : 8d0002           [ 4]>            sta test_case
2738 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
2739
 
2740
 
2741
                             ;partial test BNE & CMP, CPX, CPY immediate
2742 3 MichaelA
 
2743
0555 : c001             [ 2]         cpy #1          ;testing BNE true
2744
0557 : d002             [ 3]         bne test_bne
2745 2 MichaelA
                                     trap
2746 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2747
0559 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2748
055a : 02                   >        db      test_num
2749 2 MichaelA
 
2750 3 MichaelA
055b :                       test_bne
2751
055b : a900             [ 2]         lda #0
2752
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   49
2753 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2754
 
2755 3 MichaelA
055d : c900             [ 2]         cmp #0          ;test compare immediate
2756
                                     trap_ne
2757
055f : f002             [ 3]>        beq skip0009
2758
                            >        trap           ;failed equal (zero)
2759
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2760
0561 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2761
0562 : 02                   >        db      test_num
2762
                            >
2763
0563 :                      >skip0009
2764 2 MichaelA
 
2765
                                     trap_cc
2766 3 MichaelA
0563 : b002             [ 3]>        bcs skip0011
2767
                            >        trap           ;failed equal (zero)
2768
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2769
0565 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2770
0566 : 02                   >        db      test_num
2771
                            >
2772
0567 :                      >skip0011
2773 2 MichaelA
 
2774
                                     trap_mi
2775 3 MichaelA
0567 : 1002             [ 3]>        bpl skip0013
2776
                            >        trap           ;failed equal (zero)
2777
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2778
0569 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2779
056a : 02                   >        db      test_num
2780
                            >
2781
056b :                      >skip0013
2782 2 MichaelA
 
2783 3 MichaelA
056b : c901             [ 2]         cmp #1
2784 2 MichaelA
                                     trap_eq
2785 3 MichaelA
056d : d002             [ 3]>        bne skip0015
2786
                            >        trap           ;failed equal (zero)
2787
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2788
056f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2789
0570 : 02                   >        db      test_num
2790
                            >
2791
0571 :                      >skip0015
2792 2 MichaelA
 
2793
                                     trap_cs
2794 3 MichaelA
0571 : 9002             [ 3]>        bcc skip0017
2795
                            >        trap           ;failed equal (zero)
2796
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2797
0573 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2798
0574 : 02                   >        db      test_num
2799
                            >
2800
0575 :                      >skip0017
2801 2 MichaelA
 
2802
                                     trap_pl
2803 3 MichaelA
0575 : 3002             [ 3]>        bmi skip0019
2804
                            >        trap           ;failed equal (zero)
2805
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2806
0577 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2807
0578 : 02                   >        db      test_num
2808
                            >
2809
0579 :                      >skip0019
2810
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   50
2811
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2812
 
2813 2 MichaelA
 
2814 3 MichaelA
0579 : aa               [ 2]         tax
2815
057a : e000             [ 2]         cpx #0          ;test compare x immediate
2816 2 MichaelA
                                     trap_ne
2817 3 MichaelA
057c : f002             [ 3]>        beq skip0021
2818
                            >        trap           ;failed equal (zero)
2819
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2820
057e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2821
057f : 02                   >        db      test_num
2822
                            >
2823
0580 :                      >skip0021
2824 2 MichaelA
 
2825
                                     trap_cc
2826 3 MichaelA
0580 : b002             [ 3]>        bcs skip0023
2827
                            >        trap           ;failed equal (zero)
2828
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2829
0582 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2830
0583 : 02                   >        db      test_num
2831
                            >
2832
0584 :                      >skip0023
2833 2 MichaelA
 
2834
                                     trap_mi
2835 3 MichaelA
0584 : 1002             [ 3]>        bpl skip0025
2836
                            >        trap           ;failed equal (zero)
2837
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2838
0586 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2839
0587 : 02                   >        db      test_num
2840
                            >
2841
0588 :                      >skip0025
2842 2 MichaelA
 
2843 3 MichaelA
0588 : e001             [ 2]         cpx #1
2844 2 MichaelA
                                     trap_eq
2845 3 MichaelA
058a : d002             [ 3]>        bne skip0027
2846
                            >        trap           ;failed equal (zero)
2847
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2848
058c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2849
058d : 02                   >        db      test_num
2850
                            >
2851
058e :                      >skip0027
2852 2 MichaelA
 
2853
                                     trap_cs
2854 3 MichaelA
058e : 9002             [ 3]>        bcc skip0029
2855
                            >        trap           ;failed equal (zero)
2856
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2857
0590 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2858
0591 : 02                   >        db      test_num
2859
                            >
2860
0592 :                      >skip0029
2861 2 MichaelA
 
2862
                                     trap_pl
2863 3 MichaelA
0592 : 3002             [ 3]>        bmi skip0031
2864
                            >        trap           ;failed equal (zero)
2865
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2866
0594 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2867
0595 : 02                   >        db      test_num
2868
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   51
2869
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2870
 
2871
                            >
2872
0596 :                      >skip0031
2873 2 MichaelA
 
2874 3 MichaelA
0596 : a8               [ 2]         tay
2875
0597 : c000             [ 2]         cpy #0          ;test compare y immediate
2876 2 MichaelA
                                     trap_ne
2877 3 MichaelA
0599 : f002             [ 3]>        beq skip0033
2878
                            >        trap           ;failed equal (zero)
2879
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2880
059b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2881
059c : 02                   >        db      test_num
2882
                            >
2883
059d :                      >skip0033
2884 2 MichaelA
 
2885
                                     trap_cc
2886 3 MichaelA
059d : b002             [ 3]>        bcs skip0035
2887
                            >        trap           ;failed equal (zero)
2888
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2889
059f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2890
05a0 : 02                   >        db      test_num
2891
                            >
2892
05a1 :                      >skip0035
2893 2 MichaelA
 
2894
                                     trap_mi
2895 3 MichaelA
05a1 : 1002             [ 3]>        bpl skip0037
2896
                            >        trap           ;failed equal (zero)
2897
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2898
05a3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2899
05a4 : 02                   >        db      test_num
2900
                            >
2901
05a5 :                      >skip0037
2902 2 MichaelA
 
2903 3 MichaelA
05a5 : c001             [ 2]         cpy #1
2904 2 MichaelA
                                     trap_eq
2905 3 MichaelA
05a7 : d002             [ 3]>        bne skip0039
2906
                            >        trap           ;failed equal (zero)
2907
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2908
05a9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2909
05aa : 02                   >        db      test_num
2910
                            >
2911
05ab :                      >skip0039
2912 2 MichaelA
 
2913
                                     trap_cs
2914 3 MichaelA
05ab : 9002             [ 3]>        bcc skip0041
2915
                            >        trap           ;failed equal (zero)
2916
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2917
05ad : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2918
05ae : 02                   >        db      test_num
2919
                            >
2920
05af :                      >skip0041
2921
 
2922
                                     trap_pl
2923
05af : 3002             [ 3]>        bmi skip0043
2924
                            >        trap           ;failed equal (zero)
2925
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2926
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   52
2927 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2928
 
2929 3 MichaelA
05b1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2930
05b2 : 02                   >        db      test_num
2931
                            >
2932
05b3 :                      >skip0043
2933 2 MichaelA
 
2934
                                     next_test
2935 3 MichaelA
05b3 : ad0002           [ 4]>            lda test_case   ;previous test
2936
05b6 : c902             [ 2]>            cmp #test_num
2937 2 MichaelA
                            >            trap_ne         ;test is out of sequence
2938 3 MichaelA
05b8 : f002             [ 3]>        beq skip0046
2939
                            >        trap           ;failed equal (zero)
2940
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2941
05ba : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2942
05bb : 02                   >        db      test_num
2943 2 MichaelA
                            >
2944 3 MichaelA
05bc :                      >skip0046
2945
                            >
2946 2 MichaelA
0003 =                      >test_num = test_num + 1
2947 3 MichaelA
05bc : a903             [ 2]>            lda #test_num   ;*** this tests' number
2948
05be : 8d0002           [ 4]>            sta test_case
2949 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
2950
 
2951 3 MichaelA
 
2952 2 MichaelA
                             ;testing stack operations PHA PHP PLA PLP
2953
 
2954 3 MichaelA
05c1 : a2ff             [ 2]         ldx #$ff        ;initialize stack
2955
05c3 : 9a               [ 2]         txs
2956
05c4 : a955             [ 2]         lda #$55
2957
05c6 : 48               [ 3]         pha
2958
05c7 : a9aa             [ 2]         lda #$aa
2959
05c9 : 48               [ 3]         pha
2960
05ca : cdfe01           [ 4]         cmp $1fe        ;on stack ?
2961 2 MichaelA
                                     trap_ne
2962 3 MichaelA
05cd : f002             [ 3]>        beq skip0048
2963
                            >        trap           ;failed equal (zero)
2964
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2965
05cf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2966
05d0 : 03                   >        db      test_num
2967
                            >
2968
05d1 :                      >skip0048
2969 2 MichaelA
 
2970 3 MichaelA
05d1 : ba               [ 2]         tsx
2971
05d2 : 8a               [ 2]         txa             ;overwrite accu
2972
05d3 : c9fd             [ 2]         cmp #$fd        ;sp decremented?
2973 2 MichaelA
                                     trap_ne
2974 3 MichaelA
05d5 : f002             [ 3]>        beq skip0050
2975
                            >        trap           ;failed equal (zero)
2976
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2977
05d7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2978
05d8 : 03                   >        db      test_num
2979
                            >
2980
05d9 :                      >skip0050
2981 2 MichaelA
 
2982 3 MichaelA
05d9 : 68               [ 4]         pla
2983
05da : c9aa             [ 2]         cmp #$aa        ;successful retreived from stack?
2984
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   53
2985
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
2986
 
2987 2 MichaelA
                                     trap_ne
2988 3 MichaelA
05dc : f002             [ 3]>        beq skip0052
2989
                            >        trap           ;failed equal (zero)
2990
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
2991
05de : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
2992
05df : 03                   >        db      test_num
2993
                            >
2994
05e0 :                      >skip0052
2995 2 MichaelA
 
2996 3 MichaelA
05e0 : 68               [ 4]         pla
2997
05e1 : c955             [ 2]         cmp #$55
2998 2 MichaelA
                                     trap_ne
2999 3 MichaelA
05e3 : f002             [ 3]>        beq skip0054
3000
                            >        trap           ;failed equal (zero)
3001
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3002
05e5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3003
05e6 : 03                   >        db      test_num
3004
                            >
3005
05e7 :                      >skip0054
3006 2 MichaelA
 
3007 3 MichaelA
05e7 : cdff01           [ 4]         cmp $1ff        ;remains on stack?
3008 2 MichaelA
                                     trap_ne
3009 3 MichaelA
05ea : f002             [ 3]>        beq skip0056
3010
                            >        trap           ;failed equal (zero)
3011
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3012
05ec : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3013
05ed : 03                   >        db      test_num
3014
                            >
3015
05ee :                      >skip0056
3016 2 MichaelA
 
3017 3 MichaelA
05ee : ba               [ 2]         tsx
3018
05ef : e0ff             [ 2]         cpx #$ff        ;sp incremented?
3019 2 MichaelA
                                     trap_ne
3020 3 MichaelA
05f1 : f002             [ 3]>        beq skip0058
3021
                            >        trap           ;failed equal (zero)
3022
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3023
05f3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3024
05f4 : 03                   >        db      test_num
3025
                            >
3026
05f5 :                      >skip0058
3027 2 MichaelA
 
3028
                                     next_test
3029 3 MichaelA
05f5 : ad0002           [ 4]>            lda test_case   ;previous test
3030
05f8 : c903             [ 2]>            cmp #test_num
3031 2 MichaelA
                            >            trap_ne         ;test is out of sequence
3032 3 MichaelA
05fa : f002             [ 3]>        beq skip0061
3033
                            >        trap           ;failed equal (zero)
3034
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3035
05fc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3036
05fd : 03                   >        db      test_num
3037 2 MichaelA
                            >
3038 3 MichaelA
05fe :                      >skip0061
3039
                            >
3040 2 MichaelA
0004 =                      >test_num = test_num + 1
3041 3 MichaelA
05fe : a904             [ 2]>            lda #test_num   ;*** this tests' number
3042
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   54
3043
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3044
 
3045
0600 : 8d0002           [ 4]>            sta test_case
3046 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
3047
 
3048
 
3049
                             ;testing branch decisions BPL BMI BVC BVS BCC BCS BNE BEQ
3050 3 MichaelA
 
3051 2 MichaelA
                                     set_stat $ff    ;all on
3052
                            >            load_flag $ff
3053 3 MichaelA
0603 : a9ff             [ 2]>            lda #$ff                 ;allow test to change I-flag (no mask)
3054 2 MichaelA
                            >
3055 3 MichaelA
0605 : 48               [ 3]>            pha         ;use stack to load status
3056
0606 : 28               [ 4]>            plp
3057 2 MichaelA
 
3058 3 MichaelA
0607 : 1016             [ 3]         bpl nbr1        ;branches should not be taken
3059
0609 : 5016             [ 3]         bvc nbr2
3060
060b : 9016             [ 3]         bcc nbr3
3061
060d : d016             [ 3]         bne nbr4
3062
060f : 3002             [ 3]         bmi br1         ;branches should be taken
3063 2 MichaelA
                                     trap
3064 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3065
0611 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3066
0612 : 04                   >        db      test_num
3067 2 MichaelA
 
3068 3 MichaelA
0613 : 7002             [ 3] br1     bvs br2
3069 2 MichaelA
                                     trap
3070 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3071
0615 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3072
0616 : 04                   >        db      test_num
3073 2 MichaelA
 
3074 3 MichaelA
0617 : b002             [ 3] br2     bcs br3
3075 2 MichaelA
                                     trap
3076 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3077
0619 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3078
061a : 04                   >        db      test_num
3079 2 MichaelA
 
3080 3 MichaelA
061b : f00a             [ 3] br3     beq br4
3081 2 MichaelA
                                     trap
3082 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3083
061d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3084
061e : 04                   >        db      test_num
3085 2 MichaelA
 
3086 3 MichaelA
061f :                       nbr1
3087 2 MichaelA
                                     trap            ;previous bpl taken
3088 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3089
061f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3090
0620 : 04                   >        db      test_num
3091 2 MichaelA
 
3092 3 MichaelA
0621 :                       nbr2
3093 2 MichaelA
                                     trap            ;previous bvc taken
3094 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3095
0621 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3096
0622 : 04                   >        db      test_num
3097 2 MichaelA
 
3098 3 MichaelA
0623 :                       nbr3
3099 2 MichaelA
                                     trap            ;previous bcc taken
3100 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   55
3101
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3102
 
3103
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3104
0623 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3105
0624 : 04                   >        db      test_num
3106 2 MichaelA
 
3107 3 MichaelA
0625 :                       nbr4
3108 2 MichaelA
                                     trap            ;previous bne taken
3109 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3110
0625 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3111
0626 : 04                   >        db      test_num
3112 2 MichaelA
 
3113 3 MichaelA
0627 : 08               [ 3] br4     php
3114
0628 : ba               [ 2]         tsx
3115
0629 : e0fe             [ 2]         cpx #$fe        ;sp after php?
3116 2 MichaelA
                                     trap_ne
3117 3 MichaelA
062b : f002             [ 3]>        beq skip0073
3118
                            >        trap           ;failed equal (zero)
3119
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3120
062d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3121
062e : 04                   >        db      test_num
3122
                            >
3123
062f :                      >skip0073
3124 2 MichaelA
 
3125 3 MichaelA
062f : 68               [ 4]         pla
3126 2 MichaelA
                                     cmp_flag $ff    ;returned all flags on?
3127 3 MichaelA
0630 : c9ff             [ 2]>            cmp #($ff    |fao)&m8    ;expected flags + always on bits
3128 2 MichaelA
 
3129
                                     trap_ne
3130 3 MichaelA
0632 : f002             [ 3]>        beq skip0076
3131
                            >        trap           ;failed equal (zero)
3132
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3133
0634 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3134
0635 : 04                   >        db      test_num
3135
                            >
3136
0636 :                      >skip0076
3137 2 MichaelA
 
3138 3 MichaelA
0636 : ba               [ 2]         tsx
3139
0637 : e0ff             [ 2]         cpx #$ff        ;sp after php?
3140 2 MichaelA
                                     trap_ne
3141 3 MichaelA
0639 : f002             [ 3]>        beq skip0078
3142
                            >        trap           ;failed equal (zero)
3143
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3144
063b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3145
063c : 04                   >        db      test_num
3146
                            >
3147
063d :                      >skip0078
3148 2 MichaelA
 
3149
                                     set_stat 0      ;all off
3150
                            >            load_flag 0
3151 3 MichaelA
063d : a900             [ 2]>            lda #0                   ;allow test to change I-flag (no mask)
3152 2 MichaelA
                            >
3153 3 MichaelA
063f : 48               [ 3]>            pha         ;use stack to load status
3154
0640 : 28               [ 4]>            plp
3155 2 MichaelA
 
3156 3 MichaelA
0641 : 3026             [ 3]         bmi nbr11       ;branches should not be taken
3157
0643 : 7026             [ 3]         bvs nbr12
3158
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   56
3159
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3160
 
3161
0645 : b026             [ 3]         bcs nbr13
3162
0647 : f026             [ 3]         beq nbr14
3163 2 MichaelA
                                     trap_mi
3164 3 MichaelA
0649 : 1002             [ 3]>        bpl skip0082
3165
                            >        trap           ;failed equal (zero)
3166
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3167
064b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3168
064c : 04                   >        db      test_num
3169
                            >
3170
064d :                      >skip0082
3171 2 MichaelA
 
3172
                                     trap_vs
3173 3 MichaelA
064d : 5002             [ 3]>        bvc skip0084
3174
                            >        trap           ;failed equal (zero)
3175
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3176
064f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3177
0650 : 04                   >        db      test_num
3178
                            >
3179
0651 :                      >skip0084
3180 2 MichaelA
 
3181
                                     trap_cs
3182 3 MichaelA
0651 : 9002             [ 3]>        bcc skip0086
3183
                            >        trap           ;failed equal (zero)
3184
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3185
0653 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3186
0654 : 04                   >        db      test_num
3187
                            >
3188
0655 :                      >skip0086
3189 2 MichaelA
 
3190
                                     trap_eq
3191 3 MichaelA
0655 : d002             [ 3]>        bne skip0088
3192
                            >        trap           ;failed equal (zero)
3193
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3194
0657 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3195
0658 : 04                   >        db      test_num
3196
                            >
3197
0659 :                      >skip0088
3198 2 MichaelA
 
3199 3 MichaelA
0659 : 1002             [ 3]         bpl br11        ;branches should be taken
3200 2 MichaelA
                                     trap
3201 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3202
065b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3203
065c : 04                   >        db      test_num
3204 2 MichaelA
 
3205 3 MichaelA
065d : 5002             [ 3] br11    bvc br12
3206 2 MichaelA
                                     trap
3207 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3208
065f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3209
0660 : 04                   >        db      test_num
3210 2 MichaelA
 
3211 3 MichaelA
0661 : 9002             [ 3] br12    bcc br13
3212 2 MichaelA
                                     trap
3213 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3214
0663 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3215
0664 : 04                   >        db      test_num
3216
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   57
3217 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3218
 
3219
 
3220 3 MichaelA
0665 : d00a             [ 3] br13    bne br14
3221
                                     trap
3222
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3223
0667 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3224
0668 : 04                   >        db      test_num
3225
 
3226
0669 :                       nbr11
3227 2 MichaelA
                                     trap            ;previous bmi taken
3228 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3229
0669 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3230
066a : 04                   >        db      test_num
3231 2 MichaelA
 
3232 3 MichaelA
066b :                       nbr12
3233 2 MichaelA
                                     trap            ;previous bvs taken
3234 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3235
066b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3236
066c : 04                   >        db      test_num
3237 2 MichaelA
 
3238 3 MichaelA
066d :                       nbr13
3239 2 MichaelA
                                     trap            ;previous bcs taken
3240 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3241
066d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3242
066e : 04                   >        db      test_num
3243 2 MichaelA
 
3244 3 MichaelA
066f :                       nbr14
3245 2 MichaelA
                                     trap            ;previous beq taken
3246 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3247
066f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3248
0670 : 04                   >        db      test_num
3249 2 MichaelA
 
3250 3 MichaelA
0671 : 08               [ 3] br14    php
3251
0672 : 68               [ 4]         pla
3252 2 MichaelA
                                     cmp_flag 0      ;flags off except break (pushed by sw) + reserved?
3253 3 MichaelA
0673 : c930             [ 2]>            cmp #(0      |fao)&m8    ;expected flags + always on bits
3254 2 MichaelA
 
3255
                                     trap_ne
3256 3 MichaelA
0675 : f002             [ 3]>        beq skip0099
3257
                            >        trap           ;failed equal (zero)
3258
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3259
0677 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3260
0678 : 04                   >        db      test_num
3261
                            >
3262
0679 :                      >skip0099
3263 2 MichaelA
 
3264 3 MichaelA
 
3265 2 MichaelA
                                     ;crosscheck flags
3266 3 MichaelA
 
3267 2 MichaelA
                                     set_stat carry
3268
                            >            load_flag carry
3269 3 MichaelA
0679 : a901             [ 2]>            lda #carry             ;allow test to change I-flag (no mask)
3270 2 MichaelA
                            >
3271 3 MichaelA
067b : 48               [ 3]>            pha         ;use stack to load status
3272
067c : 28               [ 4]>            plp
3273 2 MichaelA
 
3274 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   58
3275
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3276
 
3277 2 MichaelA
                                     trap_cc
3278 3 MichaelA
067d : b002             [ 3]>        bcs skip0103
3279
                            >        trap           ;failed equal (zero)
3280
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3281
067f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3282
0680 : 04                   >        db      test_num
3283
                            >
3284
0681 :                      >skip0103
3285 2 MichaelA
 
3286
                                     set_stat zero
3287
                            >            load_flag zero
3288 3 MichaelA
0681 : a902             [ 2]>            lda #zero             ;allow test to change I-flag (no mask)
3289 2 MichaelA
                            >
3290 3 MichaelA
0683 : 48               [ 3]>            pha         ;use stack to load status
3291
0684 : 28               [ 4]>            plp
3292 2 MichaelA
 
3293
                                     trap_ne
3294 3 MichaelA
0685 : f002             [ 3]>        beq skip0107
3295
                            >        trap           ;failed equal (zero)
3296
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3297
0687 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3298
0688 : 04                   >        db      test_num
3299
                            >
3300
0689 :                      >skip0107
3301 2 MichaelA
 
3302
                                     set_stat overfl
3303
                            >            load_flag overfl
3304 3 MichaelA
0689 : a940             [ 2]>            lda #overfl             ;allow test to change I-flag (no mask)
3305 2 MichaelA
                            >
3306 3 MichaelA
068b : 48               [ 3]>            pha         ;use stack to load status
3307
068c : 28               [ 4]>            plp
3308 2 MichaelA
 
3309
                                     trap_vc
3310 3 MichaelA
068d : 7002             [ 3]>        bvs skip0111
3311
                            >        trap           ;failed equal (zero)
3312
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3313
068f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3314
0690 : 04                   >        db      test_num
3315
                            >
3316
0691 :                      >skip0111
3317 2 MichaelA
 
3318
                                     set_stat minus
3319
                            >            load_flag minus
3320 3 MichaelA
0691 : a980             [ 2]>            lda #minus             ;allow test to change I-flag (no mask)
3321 2 MichaelA
                            >
3322 3 MichaelA
0693 : 48               [ 3]>            pha         ;use stack to load status
3323
0694 : 28               [ 4]>            plp
3324 2 MichaelA
 
3325
                                     trap_pl
3326 3 MichaelA
0695 : 3002             [ 3]>        bmi skip0115
3327
                            >        trap           ;failed equal (zero)
3328
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3329
0697 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3330
0698 : 04                   >        db      test_num
3331
                            >
3332
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   59
3333
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3334
 
3335
0699 :                      >skip0115
3336 2 MichaelA
 
3337
                                     set_stat $ff-carry
3338
                            >            load_flag $ff-carry
3339 3 MichaelA
0699 : a9fe             [ 2]>            lda #$ff-carry             ;allow test to change I-flag (no mask)
3340 2 MichaelA
                            >
3341 3 MichaelA
069b : 48               [ 3]>            pha         ;use stack to load status
3342
069c : 28               [ 4]>            plp
3343 2 MichaelA
 
3344
                                     trap_cs
3345 3 MichaelA
069d : 9002             [ 3]>        bcc skip0119
3346
                            >        trap           ;failed equal (zero)
3347
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3348
069f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3349
06a0 : 04                   >        db      test_num
3350
                            >
3351
06a1 :                      >skip0119
3352 2 MichaelA
 
3353
                                     set_stat $ff-zero
3354
                            >            load_flag $ff-zero
3355 3 MichaelA
06a1 : a9fd             [ 2]>            lda #$ff-zero             ;allow test to change I-flag (no mask)
3356 2 MichaelA
                            >
3357 3 MichaelA
06a3 : 48               [ 3]>            pha         ;use stack to load status
3358
06a4 : 28               [ 4]>            plp
3359 2 MichaelA
 
3360
                                     trap_eq
3361 3 MichaelA
06a5 : d002             [ 3]>        bne skip0123
3362
                            >        trap           ;failed equal (zero)
3363
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3364
06a7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3365
06a8 : 04                   >        db      test_num
3366
                            >
3367
06a9 :                      >skip0123
3368 2 MichaelA
 
3369
                                     set_stat $ff-overfl
3370
                            >            load_flag $ff-overfl
3371 3 MichaelA
06a9 : a9bf             [ 2]>            lda #$ff-overfl             ;allow test to change I-flag (no mask)
3372 2 MichaelA
                            >
3373 3 MichaelA
06ab : 48               [ 3]>            pha         ;use stack to load status
3374
06ac : 28               [ 4]>            plp
3375 2 MichaelA
 
3376
                                     trap_vs
3377 3 MichaelA
06ad : 5002             [ 3]>        bvc skip0127
3378
                            >        trap           ;failed equal (zero)
3379
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3380
06af : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3381
06b0 : 04                   >        db      test_num
3382
                            >
3383
06b1 :                      >skip0127
3384 2 MichaelA
 
3385
                                     set_stat $ff-minus
3386
                            >            load_flag $ff-minus
3387 3 MichaelA
06b1 : a97f             [ 2]>            lda #$ff-minus             ;allow test to change I-flag (no mask)
3388 2 MichaelA
                            >
3389 3 MichaelA
06b3 : 48               [ 3]>            pha         ;use stack to load status
3390
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   60
3391
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3392
 
3393
06b4 : 28               [ 4]>            plp
3394 2 MichaelA
 
3395
                                     trap_mi
3396 3 MichaelA
06b5 : 1002             [ 3]>        bpl skip0131
3397
                            >        trap           ;failed equal (zero)
3398
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3399
06b7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3400
06b8 : 04                   >        db      test_num
3401
                            >
3402
06b9 :                      >skip0131
3403 2 MichaelA
 
3404
                                     next_test
3405 3 MichaelA
06b9 : ad0002           [ 4]>            lda test_case   ;previous test
3406
06bc : c904             [ 2]>            cmp #test_num
3407 2 MichaelA
                            >            trap_ne         ;test is out of sequence
3408 3 MichaelA
06be : f002             [ 3]>        beq skip0134
3409
                            >        trap           ;failed equal (zero)
3410
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3411
06c0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3412
06c1 : 04                   >        db      test_num
3413 2 MichaelA
                            >
3414 3 MichaelA
06c2 :                      >skip0134
3415
                            >
3416 2 MichaelA
0005 =                      >test_num = test_num + 1
3417 3 MichaelA
06c2 : a905             [ 2]>            lda #test_num   ;*** this tests' number
3418
06c4 : 8d0002           [ 4]>            sta test_case
3419 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
3420
 
3421
 
3422
                             ; test PHA does not alter flags or accumulator but PLA does
3423 3 MichaelA
 
3424
06c7 : a255             [ 2]         ldx #$55        ;x & y protected
3425
06c9 : a0aa             [ 2]         ldy #$aa
3426 2 MichaelA
                                     set_a 1,$ff     ;push
3427
                            >            load_flag $ff
3428 3 MichaelA
06cb : a9ff             [ 2]>            lda #$ff                  ;allow test to change I-flag (no mask)
3429 2 MichaelA
                            >
3430 3 MichaelA
06cd : 48               [ 3]>            pha         ;use stack to load status
3431
06ce : a901             [ 2]>            lda #1     ;precharge accu
3432
06d0 : 28               [ 4]>            plp
3433 2 MichaelA
 
3434 3 MichaelA
06d1 : 48               [ 3]         pha
3435 2 MichaelA
                                     tst_a 1,$ff
3436 3 MichaelA
06d2 : 08               [ 3]>            php         ;save flags
3437
06d3 : 08               [ 3]>            php
3438
06d4 : c901             [ 2]>            cmp #1     ;test result
3439 2 MichaelA
                            >            trap_ne
3440 3 MichaelA
06d6 : f002             [ 3]>        beq skip0139
3441
                            >        trap           ;failed equal (zero)
3442
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3443
06d8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3444
06d9 : 05                   >        db      test_num
3445 2 MichaelA
                            >
3446 3 MichaelA
06da :                      >skip0139
3447
                            >
3448
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   61
3449
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3450
 
3451
06da : 68               [ 4]>            pla         ;load status
3452 2 MichaelA
                            >            cmp_flag $ff
3453 3 MichaelA
06db : c9ff             [ 2]>            cmp #($ff|fao)&m8    ;expected flags + always on bits
3454 2 MichaelA
                            >
3455
                            >            trap_ne
3456 3 MichaelA
06dd : f002             [ 3]>        beq skip0142
3457
                            >        trap           ;failed equal (zero)
3458
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3459
06df : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3460
06e0 : 05                   >        db      test_num
3461 2 MichaelA
                            >
3462 3 MichaelA
06e1 :                      >skip0142
3463
                            >
3464
06e1 : 28               [ 4]>            plp         ;restore status
3465 2 MichaelA
 
3466
                                     set_a 0,0
3467
                            >            load_flag 0
3468 3 MichaelA
06e2 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
3469 2 MichaelA
                            >
3470 3 MichaelA
06e4 : 48               [ 3]>            pha         ;use stack to load status
3471
06e5 : a900             [ 2]>            lda #0     ;precharge accu
3472
06e7 : 28               [ 4]>            plp
3473 2 MichaelA
 
3474 3 MichaelA
06e8 : 48               [ 3]         pha
3475 2 MichaelA
                                     tst_a 0,0
3476 3 MichaelA
06e9 : 08               [ 3]>            php         ;save flags
3477
06ea : 08               [ 3]>            php
3478
06eb : c900             [ 2]>            cmp #0     ;test result
3479 2 MichaelA
                            >            trap_ne
3480 3 MichaelA
06ed : f002             [ 3]>        beq skip0147
3481
                            >        trap           ;failed equal (zero)
3482
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3483
06ef : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3484
06f0 : 05                   >        db      test_num
3485 2 MichaelA
                            >
3486 3 MichaelA
06f1 :                      >skip0147
3487
                            >
3488
06f1 : 68               [ 4]>            pla         ;load status
3489 2 MichaelA
                            >            cmp_flag 0
3490 3 MichaelA
06f2 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
3491 2 MichaelA
                            >
3492
                            >            trap_ne
3493 3 MichaelA
06f4 : f002             [ 3]>        beq skip0150
3494
                            >        trap           ;failed equal (zero)
3495
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3496
06f6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3497
06f7 : 05                   >        db      test_num
3498 2 MichaelA
                            >
3499 3 MichaelA
06f8 :                      >skip0150
3500
                            >
3501
06f8 : 28               [ 4]>            plp         ;restore status
3502 2 MichaelA
 
3503
                                     set_a $ff,$ff
3504
                            >            load_flag $ff
3505 3 MichaelA
06f9 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
3506
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   62
3507
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3508
 
3509 2 MichaelA
                            >
3510 3 MichaelA
06fb : 48               [ 3]>            pha         ;use stack to load status
3511
06fc : a9ff             [ 2]>            lda #$ff     ;precharge accu
3512
06fe : 28               [ 4]>            plp
3513 2 MichaelA
 
3514 3 MichaelA
06ff : 48               [ 3]         pha
3515 2 MichaelA
                                     tst_a $ff,$ff
3516 3 MichaelA
0700 : 08               [ 3]>            php         ;save flags
3517
0701 : 08               [ 3]>            php
3518
0702 : c9ff             [ 2]>            cmp #$ff     ;test result
3519 2 MichaelA
                            >            trap_ne
3520 3 MichaelA
0704 : f002             [ 3]>        beq skip0155
3521
                            >        trap           ;failed equal (zero)
3522
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3523
0706 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3524
0707 : 05                   >        db      test_num
3525 2 MichaelA
                            >
3526 3 MichaelA
0708 :                      >skip0155
3527
                            >
3528
0708 : 68               [ 4]>            pla         ;load status
3529 2 MichaelA
                            >            cmp_flag $ff
3530 3 MichaelA
0709 : c9ff             [ 2]>            cmp #($ff|fao)&m8    ;expected flags + always on bits
3531 2 MichaelA
                            >
3532
                            >            trap_ne
3533 3 MichaelA
070b : f002             [ 3]>        beq skip0158
3534
                            >        trap           ;failed equal (zero)
3535
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3536
070d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3537
070e : 05                   >        db      test_num
3538 2 MichaelA
                            >
3539 3 MichaelA
070f :                      >skip0158
3540
                            >
3541
070f : 28               [ 4]>            plp         ;restore status
3542 2 MichaelA
 
3543
                                     set_a 1,0
3544
                            >            load_flag 0
3545 3 MichaelA
0710 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
3546 2 MichaelA
                            >
3547 3 MichaelA
0712 : 48               [ 3]>            pha         ;use stack to load status
3548
0713 : a901             [ 2]>            lda #1     ;precharge accu
3549
0715 : 28               [ 4]>            plp
3550 2 MichaelA
 
3551 3 MichaelA
0716 : 48               [ 3]         pha
3552 2 MichaelA
                                     tst_a 1,0
3553 3 MichaelA
0717 : 08               [ 3]>            php         ;save flags
3554
0718 : 08               [ 3]>            php
3555
0719 : c901             [ 2]>            cmp #1     ;test result
3556 2 MichaelA
                            >            trap_ne
3557 3 MichaelA
071b : f002             [ 3]>        beq skip0163
3558
                            >        trap           ;failed equal (zero)
3559
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3560
071d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3561
071e : 05                   >        db      test_num
3562 2 MichaelA
                            >
3563 3 MichaelA
071f :                      >skip0163
3564
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   63
3565
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3566
 
3567
                            >
3568
071f : 68               [ 4]>            pla         ;load status
3569 2 MichaelA
                            >            cmp_flag 0
3570 3 MichaelA
0720 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
3571 2 MichaelA
                            >
3572
                            >            trap_ne
3573 3 MichaelA
0722 : f002             [ 3]>        beq skip0166
3574
                            >        trap           ;failed equal (zero)
3575
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3576
0724 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3577
0725 : 05                   >        db      test_num
3578 2 MichaelA
                            >
3579 3 MichaelA
0726 :                      >skip0166
3580
                            >
3581
0726 : 28               [ 4]>            plp         ;restore status
3582 2 MichaelA
 
3583
                                     set_a 0,$ff
3584
                            >            load_flag $ff
3585 3 MichaelA
0727 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
3586 2 MichaelA
                            >
3587 3 MichaelA
0729 : 48               [ 3]>            pha         ;use stack to load status
3588
072a : a900             [ 2]>            lda #0     ;precharge accu
3589
072c : 28               [ 4]>            plp
3590 2 MichaelA
 
3591 3 MichaelA
072d : 48               [ 3]         pha
3592 2 MichaelA
                                     tst_a 0,$ff
3593 3 MichaelA
072e : 08               [ 3]>            php         ;save flags
3594
072f : 08               [ 3]>            php
3595
0730 : c900             [ 2]>            cmp #0     ;test result
3596 2 MichaelA
                            >            trap_ne
3597 3 MichaelA
0732 : f002             [ 3]>        beq skip0171
3598
                            >        trap           ;failed equal (zero)
3599
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3600
0734 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3601
0735 : 05                   >        db      test_num
3602 2 MichaelA
                            >
3603 3 MichaelA
0736 :                      >skip0171
3604
                            >
3605
0736 : 68               [ 4]>            pla         ;load status
3606 2 MichaelA
                            >            cmp_flag $ff
3607 3 MichaelA
0737 : c9ff             [ 2]>            cmp #($ff|fao)&m8    ;expected flags + always on bits
3608 2 MichaelA
                            >
3609
                            >            trap_ne
3610 3 MichaelA
0739 : f002             [ 3]>        beq skip0174
3611
                            >        trap           ;failed equal (zero)
3612
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3613
073b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3614
073c : 05                   >        db      test_num
3615 2 MichaelA
                            >
3616 3 MichaelA
073d :                      >skip0174
3617
                            >
3618
073d : 28               [ 4]>            plp         ;restore status
3619 2 MichaelA
 
3620
                                     set_a $ff,0
3621
                            >            load_flag 0
3622 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   64
3623
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3624
 
3625
073e : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
3626 2 MichaelA
                            >
3627 3 MichaelA
0740 : 48               [ 3]>            pha         ;use stack to load status
3628
0741 : a9ff             [ 2]>            lda #$ff     ;precharge accu
3629
0743 : 28               [ 4]>            plp
3630 2 MichaelA
 
3631 3 MichaelA
0744 : 48               [ 3]         pha
3632 2 MichaelA
                                     tst_a $ff,0
3633 3 MichaelA
0745 : 08               [ 3]>            php         ;save flags
3634
0746 : 08               [ 3]>            php
3635
0747 : c9ff             [ 2]>            cmp #$ff     ;test result
3636 2 MichaelA
                            >            trap_ne
3637 3 MichaelA
0749 : f002             [ 3]>        beq skip0179
3638
                            >        trap           ;failed equal (zero)
3639
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3640
074b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3641
074c : 05                   >        db      test_num
3642 2 MichaelA
                            >
3643 3 MichaelA
074d :                      >skip0179
3644
                            >
3645
074d : 68               [ 4]>            pla         ;load status
3646 2 MichaelA
                            >            cmp_flag 0
3647 3 MichaelA
074e : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
3648 2 MichaelA
                            >
3649
                            >            trap_ne
3650 3 MichaelA
0750 : f002             [ 3]>        beq skip0182
3651
                            >        trap           ;failed equal (zero)
3652
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3653
0752 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3654
0753 : 05                   >        db      test_num
3655 2 MichaelA
                            >
3656 3 MichaelA
0754 :                      >skip0182
3657
                            >
3658
0754 : 28               [ 4]>            plp         ;restore status
3659 2 MichaelA
 
3660
                                     set_a 0,$ff     ;pull
3661
                            >            load_flag $ff
3662 3 MichaelA
0755 : a9ff             [ 2]>            lda #$ff                  ;allow test to change I-flag (no mask)
3663 2 MichaelA
                            >
3664 3 MichaelA
0757 : 48               [ 3]>            pha         ;use stack to load status
3665
0758 : a900             [ 2]>            lda #0     ;precharge accu
3666
075a : 28               [ 4]>            plp
3667 2 MichaelA
 
3668 3 MichaelA
075b : 68               [ 4]         pla
3669 2 MichaelA
                                     tst_a $ff,$ff-zero
3670 3 MichaelA
075c : 08               [ 3]>            php         ;save flags
3671
075d : 08               [ 3]>            php
3672
075e : c9ff             [ 2]>            cmp #$ff     ;test result
3673 2 MichaelA
                            >            trap_ne
3674 3 MichaelA
0760 : f002             [ 3]>        beq skip0187
3675
                            >        trap           ;failed equal (zero)
3676
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3677
0762 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3678
0763 : 05                   >        db      test_num
3679 2 MichaelA
                            >
3680 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   65
3681
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3682
 
3683
0764 :                      >skip0187
3684
                            >
3685
0764 : 68               [ 4]>            pla         ;load status
3686 2 MichaelA
                            >            cmp_flag $ff-zero
3687 3 MichaelA
0765 : c9fd             [ 2]>            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
3688 2 MichaelA
                            >
3689
                            >            trap_ne
3690 3 MichaelA
0767 : f002             [ 3]>        beq skip0190
3691
                            >        trap           ;failed equal (zero)
3692
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3693
0769 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3694
076a : 05                   >        db      test_num
3695 2 MichaelA
                            >
3696 3 MichaelA
076b :                      >skip0190
3697
                            >
3698
076b : 28               [ 4]>            plp         ;restore status
3699 2 MichaelA
 
3700
                                     set_a $ff,0
3701
                            >            load_flag 0
3702 3 MichaelA
076c : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
3703 2 MichaelA
                            >
3704 3 MichaelA
076e : 48               [ 3]>            pha         ;use stack to load status
3705
076f : a9ff             [ 2]>            lda #$ff     ;precharge accu
3706
0771 : 28               [ 4]>            plp
3707 2 MichaelA
 
3708 3 MichaelA
0772 : 68               [ 4]         pla
3709 2 MichaelA
                                     tst_a 0,zero
3710 3 MichaelA
0773 : 08               [ 3]>            php         ;save flags
3711
0774 : 08               [ 3]>            php
3712
0775 : c900             [ 2]>            cmp #0     ;test result
3713 2 MichaelA
                            >            trap_ne
3714 3 MichaelA
0777 : f002             [ 3]>        beq skip0195
3715
                            >        trap           ;failed equal (zero)
3716
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3717
0779 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3718
077a : 05                   >        db      test_num
3719 2 MichaelA
                            >
3720 3 MichaelA
077b :                      >skip0195
3721
                            >
3722
077b : 68               [ 4]>            pla         ;load status
3723 2 MichaelA
                            >            cmp_flag zero
3724 3 MichaelA
077c : c932             [ 2]>            cmp #(zero|fao)&m8    ;expected flags + always on bits
3725 2 MichaelA
                            >
3726
                            >            trap_ne
3727 3 MichaelA
077e : f002             [ 3]>        beq skip0198
3728
                            >        trap           ;failed equal (zero)
3729
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3730
0780 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3731
0781 : 05                   >        db      test_num
3732 2 MichaelA
                            >
3733 3 MichaelA
0782 :                      >skip0198
3734
                            >
3735
0782 : 28               [ 4]>            plp         ;restore status
3736 2 MichaelA
 
3737
                                     set_a $fe,$ff
3738 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   66
3739
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3740
 
3741 2 MichaelA
                            >            load_flag $ff
3742 3 MichaelA
0783 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
3743 2 MichaelA
                            >
3744 3 MichaelA
0785 : 48               [ 3]>            pha         ;use stack to load status
3745
0786 : a9fe             [ 2]>            lda #$fe     ;precharge accu
3746
0788 : 28               [ 4]>            plp
3747 2 MichaelA
 
3748 3 MichaelA
0789 : 68               [ 4]         pla
3749 2 MichaelA
                                     tst_a 1,$ff-zero-minus
3750 3 MichaelA
078a : 08               [ 3]>            php         ;save flags
3751
078b : 08               [ 3]>            php
3752
078c : c901             [ 2]>            cmp #1     ;test result
3753 2 MichaelA
                            >            trap_ne
3754 3 MichaelA
078e : f002             [ 3]>        beq skip0203
3755
                            >        trap           ;failed equal (zero)
3756
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3757
0790 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3758
0791 : 05                   >        db      test_num
3759 2 MichaelA
                            >
3760 3 MichaelA
0792 :                      >skip0203
3761
                            >
3762
0792 : 68               [ 4]>            pla         ;load status
3763 2 MichaelA
                            >            cmp_flag $ff-zero-minus
3764 3 MichaelA
0793 : c97d             [ 2]>            cmp #($ff-zero-minus|fao)&m8    ;expected flags + always on bits
3765 2 MichaelA
                            >
3766
                            >            trap_ne
3767 3 MichaelA
0795 : f002             [ 3]>        beq skip0206
3768
                            >        trap           ;failed equal (zero)
3769
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3770
0797 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3771
0798 : 05                   >        db      test_num
3772 2 MichaelA
                            >
3773 3 MichaelA
0799 :                      >skip0206
3774
                            >
3775
0799 : 28               [ 4]>            plp         ;restore status
3776 2 MichaelA
 
3777
                                     set_a 0,0
3778
                            >            load_flag 0
3779 3 MichaelA
079a : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
3780 2 MichaelA
                            >
3781 3 MichaelA
079c : 48               [ 3]>            pha         ;use stack to load status
3782
079d : a900             [ 2]>            lda #0     ;precharge accu
3783
079f : 28               [ 4]>            plp
3784 2 MichaelA
 
3785 3 MichaelA
07a0 : 68               [ 4]         pla
3786 2 MichaelA
                                     tst_a $ff,minus
3787 3 MichaelA
07a1 : 08               [ 3]>            php         ;save flags
3788
07a2 : 08               [ 3]>            php
3789
07a3 : c9ff             [ 2]>            cmp #$ff     ;test result
3790 2 MichaelA
                            >            trap_ne
3791 3 MichaelA
07a5 : f002             [ 3]>        beq skip0211
3792
                            >        trap           ;failed equal (zero)
3793
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3794
07a7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3795
07a8 : 05                   >        db      test_num
3796
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   67
3797
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3798
 
3799 2 MichaelA
                            >
3800 3 MichaelA
07a9 :                      >skip0211
3801
                            >
3802
07a9 : 68               [ 4]>            pla         ;load status
3803 2 MichaelA
                            >            cmp_flag minus
3804 3 MichaelA
07aa : c9b0             [ 2]>            cmp #(minus|fao)&m8    ;expected flags + always on bits
3805 2 MichaelA
                            >
3806
                            >            trap_ne
3807 3 MichaelA
07ac : f002             [ 3]>        beq skip0214
3808
                            >        trap           ;failed equal (zero)
3809
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3810
07ae : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3811
07af : 05                   >        db      test_num
3812 2 MichaelA
                            >
3813 3 MichaelA
07b0 :                      >skip0214
3814
                            >
3815
07b0 : 28               [ 4]>            plp         ;restore status
3816 2 MichaelA
 
3817
                                     set_a $ff,$ff
3818
                            >            load_flag $ff
3819 3 MichaelA
07b1 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
3820 2 MichaelA
                            >
3821 3 MichaelA
07b3 : 48               [ 3]>            pha         ;use stack to load status
3822
07b4 : a9ff             [ 2]>            lda #$ff     ;precharge accu
3823
07b6 : 28               [ 4]>            plp
3824 2 MichaelA
 
3825 3 MichaelA
07b7 : 68               [ 4]         pla
3826 2 MichaelA
                                     tst_a 0,$ff-minus
3827 3 MichaelA
07b8 : 08               [ 3]>            php         ;save flags
3828
07b9 : 08               [ 3]>            php
3829
07ba : c900             [ 2]>            cmp #0     ;test result
3830 2 MichaelA
                            >            trap_ne
3831 3 MichaelA
07bc : f002             [ 3]>        beq skip0219
3832
                            >        trap           ;failed equal (zero)
3833
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3834
07be : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3835
07bf : 05                   >        db      test_num
3836 2 MichaelA
                            >
3837 3 MichaelA
07c0 :                      >skip0219
3838
                            >
3839
07c0 : 68               [ 4]>            pla         ;load status
3840 2 MichaelA
                            >            cmp_flag $ff-minus
3841 3 MichaelA
07c1 : c97f             [ 2]>            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
3842 2 MichaelA
                            >
3843
                            >            trap_ne
3844 3 MichaelA
07c3 : f002             [ 3]>        beq skip0222
3845
                            >        trap           ;failed equal (zero)
3846
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3847
07c5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3848
07c6 : 05                   >        db      test_num
3849 2 MichaelA
                            >
3850 3 MichaelA
07c7 :                      >skip0222
3851
                            >
3852
07c7 : 28               [ 4]>            plp         ;restore status
3853 2 MichaelA
 
3854 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   68
3855
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3856
 
3857 2 MichaelA
                                     set_a $fe,0
3858
                            >            load_flag 0
3859 3 MichaelA
07c8 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
3860 2 MichaelA
                            >
3861 3 MichaelA
07ca : 48               [ 3]>            pha         ;use stack to load status
3862
07cb : a9fe             [ 2]>            lda #$fe     ;precharge accu
3863
07cd : 28               [ 4]>            plp
3864 2 MichaelA
 
3865 3 MichaelA
07ce : 68               [ 4]         pla
3866 2 MichaelA
                                     tst_a 1,0
3867 3 MichaelA
07cf : 08               [ 3]>            php         ;save flags
3868
07d0 : 08               [ 3]>            php
3869
07d1 : c901             [ 2]>            cmp #1     ;test result
3870 2 MichaelA
                            >            trap_ne
3871 3 MichaelA
07d3 : f002             [ 3]>        beq skip0227
3872
                            >        trap           ;failed equal (zero)
3873
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3874
07d5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3875
07d6 : 05                   >        db      test_num
3876 2 MichaelA
                            >
3877 3 MichaelA
07d7 :                      >skip0227
3878
                            >
3879
07d7 : 68               [ 4]>            pla         ;load status
3880 2 MichaelA
                            >            cmp_flag 0
3881 3 MichaelA
07d8 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
3882 2 MichaelA
                            >
3883
                            >            trap_ne
3884 3 MichaelA
07da : f002             [ 3]>        beq skip0230
3885
                            >        trap           ;failed equal (zero)
3886
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3887
07dc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3888
07dd : 05                   >        db      test_num
3889 2 MichaelA
                            >
3890 3 MichaelA
07de :                      >skip0230
3891
                            >
3892
07de : 28               [ 4]>            plp         ;restore status
3893 2 MichaelA
 
3894 3 MichaelA
07df : e055             [ 2]         cpx #$55        ;x & y unchanged?
3895 2 MichaelA
                                     trap_ne
3896 3 MichaelA
07e1 : f002             [ 3]>        beq skip0232
3897
                            >        trap           ;failed equal (zero)
3898
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3899
07e3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3900
07e4 : 05                   >        db      test_num
3901
                            >
3902
07e5 :                      >skip0232
3903 2 MichaelA
 
3904 3 MichaelA
07e5 : c0aa             [ 2]         cpy #$aa
3905 2 MichaelA
                                     trap_ne
3906 3 MichaelA
07e7 : f002             [ 3]>        beq skip0234
3907
                            >        trap           ;failed equal (zero)
3908
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3909
07e9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3910
07ea : 05                   >        db      test_num
3911
                            >
3912
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   69
3913
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3914
 
3915
07eb :                      >skip0234
3916 2 MichaelA
 
3917
                                     next_test
3918 3 MichaelA
07eb : ad0002           [ 4]>            lda test_case   ;previous test
3919
07ee : c905             [ 2]>            cmp #test_num
3920 2 MichaelA
                            >            trap_ne         ;test is out of sequence
3921 3 MichaelA
07f0 : f002             [ 3]>        beq skip0237
3922
                            >        trap           ;failed equal (zero)
3923
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3924
07f2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3925
07f3 : 05                   >        db      test_num
3926 2 MichaelA
                            >
3927 3 MichaelA
07f4 :                      >skip0237
3928
                            >
3929 2 MichaelA
0006 =                      >test_num = test_num + 1
3930 3 MichaelA
07f4 : a906             [ 2]>            lda #test_num   ;*** this tests' number
3931
07f6 : 8d0002           [ 4]>            sta test_case
3932 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
3933
 
3934
 
3935
                             ; partial pretest EOR #
3936 3 MichaelA
 
3937 2 MichaelA
                                     set_a $3c,0
3938
                            >            load_flag 0
3939 3 MichaelA
07f9 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
3940 2 MichaelA
                            >
3941 3 MichaelA
07fb : 48               [ 3]>            pha         ;use stack to load status
3942
07fc : a93c             [ 2]>            lda #$3c     ;precharge accu
3943
07fe : 28               [ 4]>            plp
3944 2 MichaelA
 
3945 3 MichaelA
07ff : 49c3             [ 2]         eor #$c3
3946 2 MichaelA
                                     tst_a $ff,fn
3947 3 MichaelA
0801 : 08               [ 3]>            php         ;save flags
3948
0802 : 08               [ 3]>            php
3949
0803 : c9ff             [ 2]>            cmp #$ff     ;test result
3950 2 MichaelA
                            >            trap_ne
3951 3 MichaelA
0805 : f002             [ 3]>        beq skip0242
3952
                            >        trap           ;failed equal (zero)
3953
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3954
0807 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3955
0808 : 06                   >        db      test_num
3956 2 MichaelA
                            >
3957 3 MichaelA
0809 :                      >skip0242
3958
                            >
3959
0809 : 68               [ 4]>            pla         ;load status
3960 2 MichaelA
                            >            cmp_flag fn
3961 3 MichaelA
080a : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
3962 2 MichaelA
                            >
3963
                            >            trap_ne
3964 3 MichaelA
080c : f002             [ 3]>        beq skip0245
3965
                            >        trap           ;failed equal (zero)
3966
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3967
080e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3968
080f : 06                   >        db      test_num
3969 2 MichaelA
                            >
3970 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   70
3971
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
3972
 
3973
0810 :                      >skip0245
3974
                            >
3975
0810 : 28               [ 4]>            plp         ;restore status
3976 2 MichaelA
 
3977
                                     set_a $c3,0
3978
                            >            load_flag 0
3979 3 MichaelA
0811 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
3980 2 MichaelA
                            >
3981 3 MichaelA
0813 : 48               [ 3]>            pha         ;use stack to load status
3982
0814 : a9c3             [ 2]>            lda #$c3     ;precharge accu
3983
0816 : 28               [ 4]>            plp
3984 2 MichaelA
 
3985 3 MichaelA
0817 : 49c3             [ 2]         eor #$c3
3986 2 MichaelA
                                     tst_a 0,fz
3987 3 MichaelA
0819 : 08               [ 3]>            php         ;save flags
3988
081a : 08               [ 3]>            php
3989
081b : c900             [ 2]>            cmp #0     ;test result
3990 2 MichaelA
                            >            trap_ne
3991 3 MichaelA
081d : f002             [ 3]>        beq skip0250
3992
                            >        trap           ;failed equal (zero)
3993
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
3994
081f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
3995
0820 : 06                   >        db      test_num
3996 2 MichaelA
                            >
3997 3 MichaelA
0821 :                      >skip0250
3998
                            >
3999
0821 : 68               [ 4]>            pla         ;load status
4000 2 MichaelA
                            >            cmp_flag fz
4001 3 MichaelA
0822 : c932             [ 2]>            cmp #(fz|fao)&m8    ;expected flags + always on bits
4002 2 MichaelA
                            >
4003
                            >            trap_ne
4004 3 MichaelA
0824 : f002             [ 3]>        beq skip0253
4005
                            >        trap           ;failed equal (zero)
4006
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4007
0826 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4008
0827 : 06                   >        db      test_num
4009 2 MichaelA
                            >
4010 3 MichaelA
0828 :                      >skip0253
4011
                            >
4012
0828 : 28               [ 4]>            plp         ;restore status
4013 2 MichaelA
 
4014
                                     next_test
4015 3 MichaelA
0829 : ad0002           [ 4]>            lda test_case   ;previous test
4016
082c : c906             [ 2]>            cmp #test_num
4017 2 MichaelA
                            >            trap_ne         ;test is out of sequence
4018 3 MichaelA
082e : f002             [ 3]>        beq skip0256
4019
                            >        trap           ;failed equal (zero)
4020
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4021
0830 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4022
0831 : 06                   >        db      test_num
4023 2 MichaelA
                            >
4024 3 MichaelA
0832 :                      >skip0256
4025
                            >
4026 2 MichaelA
0007 =                      >test_num = test_num + 1
4027 3 MichaelA
0832 : a907             [ 2]>            lda #test_num   ;*** this tests' number
4028
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   71
4029
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4030
 
4031
0834 : 8d0002           [ 4]>            sta test_case
4032 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
4033
 
4034
 
4035
                             ; PC modifying instructions except branches (NOP, JMP, JSR, RTS, BRK, RTI)
4036
                             ; testing NOP
4037 3 MichaelA
 
4038
0837 : a224             [ 2]         ldx #$24
4039
0839 : a042             [ 2]         ldy #$42
4040 2 MichaelA
                                     set_a $18,0
4041
                            >            load_flag 0
4042 3 MichaelA
083b : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
4043 2 MichaelA
                            >
4044 3 MichaelA
083d : 48               [ 3]>            pha         ;use stack to load status
4045
083e : a918             [ 2]>            lda #$18     ;precharge accu
4046
0840 : 28               [ 4]>            plp
4047 2 MichaelA
 
4048 3 MichaelA
0841 : ea               [ 2]         nop
4049 2 MichaelA
                                     tst_a $18,0
4050 3 MichaelA
0842 : 08               [ 3]>            php         ;save flags
4051
0843 : 08               [ 3]>            php
4052
0844 : c918             [ 2]>            cmp #$18     ;test result
4053 2 MichaelA
                            >            trap_ne
4054 3 MichaelA
0846 : f002             [ 3]>        beq skip0261
4055
                            >        trap           ;failed equal (zero)
4056
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4057
0848 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4058
0849 : 07                   >        db      test_num
4059 2 MichaelA
                            >
4060 3 MichaelA
084a :                      >skip0261
4061
                            >
4062
084a : 68               [ 4]>            pla         ;load status
4063 2 MichaelA
                            >            cmp_flag 0
4064 3 MichaelA
084b : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
4065 2 MichaelA
                            >
4066
                            >            trap_ne
4067 3 MichaelA
084d : f002             [ 3]>        beq skip0264
4068
                            >        trap           ;failed equal (zero)
4069
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4070
084f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4071
0850 : 07                   >        db      test_num
4072 2 MichaelA
                            >
4073 3 MichaelA
0851 :                      >skip0264
4074
                            >
4075
0851 : 28               [ 4]>            plp         ;restore status
4076 2 MichaelA
 
4077 3 MichaelA
0852 : e024             [ 2]         cpx #$24
4078 2 MichaelA
                                     trap_ne
4079 3 MichaelA
0854 : f002             [ 3]>        beq skip0266
4080
                            >        trap           ;failed equal (zero)
4081
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4082
0856 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4083
0857 : 07                   >        db      test_num
4084
                            >
4085
0858 :                      >skip0266
4086
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   72
4087
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4088
 
4089 2 MichaelA
 
4090 3 MichaelA
0858 : c042             [ 2]         cpy #$42
4091 2 MichaelA
                                     trap_ne
4092 3 MichaelA
085a : f002             [ 3]>        beq skip0268
4093
                            >        trap           ;failed equal (zero)
4094
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4095
085c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4096
085d : 07                   >        db      test_num
4097
                            >
4098
085e :                      >skip0268
4099 2 MichaelA
 
4100 3 MichaelA
085e : a2db             [ 2]         ldx #$db
4101
0860 : a0bd             [ 2]         ldy #$bd
4102 2 MichaelA
                                     set_a $e7,$ff
4103
                            >            load_flag $ff
4104 3 MichaelA
0862 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
4105 2 MichaelA
                            >
4106 3 MichaelA
0864 : 48               [ 3]>            pha         ;use stack to load status
4107
0865 : a9e7             [ 2]>            lda #$e7     ;precharge accu
4108
0867 : 28               [ 4]>            plp
4109 2 MichaelA
 
4110 3 MichaelA
0868 : ea               [ 2]         nop
4111 2 MichaelA
                                     tst_a $e7,$ff
4112 3 MichaelA
0869 : 08               [ 3]>            php         ;save flags
4113
086a : 08               [ 3]>            php
4114
086b : c9e7             [ 2]>            cmp #$e7     ;test result
4115 2 MichaelA
                            >            trap_ne
4116 3 MichaelA
086d : f002             [ 3]>        beq skip0273
4117
                            >        trap           ;failed equal (zero)
4118
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4119
086f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4120
0870 : 07                   >        db      test_num
4121 2 MichaelA
                            >
4122 3 MichaelA
0871 :                      >skip0273
4123
                            >
4124
0871 : 68               [ 4]>            pla         ;load status
4125 2 MichaelA
                            >            cmp_flag $ff
4126 3 MichaelA
0872 : c9ff             [ 2]>            cmp #($ff|fao)&m8    ;expected flags + always on bits
4127 2 MichaelA
                            >
4128
                            >            trap_ne
4129 3 MichaelA
0874 : f002             [ 3]>        beq skip0276
4130
                            >        trap           ;failed equal (zero)
4131
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4132
0876 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4133
0877 : 07                   >        db      test_num
4134 2 MichaelA
                            >
4135 3 MichaelA
0878 :                      >skip0276
4136
                            >
4137
0878 : 28               [ 4]>            plp         ;restore status
4138 2 MichaelA
 
4139 3 MichaelA
0879 : e0db             [ 2]         cpx #$db
4140 2 MichaelA
                                     trap_ne
4141 3 MichaelA
087b : f002             [ 3]>        beq skip0278
4142
                            >        trap           ;failed equal (zero)
4143
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4144
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   73
4145
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4146
 
4147
087d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4148
087e : 07                   >        db      test_num
4149
                            >
4150
087f :                      >skip0278
4151 2 MichaelA
 
4152 3 MichaelA
087f : c0bd             [ 2]         cpy #$bd
4153 2 MichaelA
                                     trap_ne
4154 3 MichaelA
0881 : f002             [ 3]>        beq skip0280
4155
                            >        trap           ;failed equal (zero)
4156
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4157
0883 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4158
0884 : 07                   >        db      test_num
4159
                            >
4160
0885 :                      >skip0280
4161 2 MichaelA
 
4162
                                     next_test
4163 3 MichaelA
0885 : ad0002           [ 4]>            lda test_case   ;previous test
4164
0888 : c907             [ 2]>            cmp #test_num
4165 2 MichaelA
                            >            trap_ne         ;test is out of sequence
4166 3 MichaelA
088a : f002             [ 3]>        beq skip0283
4167
                            >        trap           ;failed equal (zero)
4168
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4169
088c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4170
088d : 07                   >        db      test_num
4171 2 MichaelA
                            >
4172 3 MichaelA
088e :                      >skip0283
4173
                            >
4174 2 MichaelA
0008 =                      >test_num = test_num + 1
4175 3 MichaelA
088e : a908             [ 2]>            lda #test_num   ;*** this tests' number
4176
0890 : 8d0002           [ 4]>            sta test_case
4177 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
4178
 
4179
 
4180
                             ; jump absolute
4181 3 MichaelA
 
4182 2 MichaelA
                                     set_stat $0
4183
                            >            load_flag $0
4184 3 MichaelA
0893 : a900             [ 2]>            lda #$0             ;allow test to change I-flag (no mask)
4185 2 MichaelA
                            >
4186 3 MichaelA
0895 : 48               [ 3]>            pha         ;use stack to load status
4187
0896 : 28               [ 4]>            plp
4188 2 MichaelA
 
4189 3 MichaelA
0897 : a946             [ 2]         lda #'F'
4190
0899 : a241             [ 2]         ldx #'A'
4191
089b : a052             [ 2]         ldy #'R'        ;N=0, V=0, Z=0, C=0
4192
089d : 4c1b3d           [ 3]         jmp test_far
4193
08a0 : ea               [ 2]         nop
4194
08a1 : ea               [ 2]         nop
4195 2 MichaelA
                                     trap_ne         ;runover protection
4196 3 MichaelA
08a2 : f002             [ 3]>        beq skip0287
4197
                            >        trap           ;failed equal (zero)
4198
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4199
08a4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4200
08a5 : 08                   >        db      test_num
4201
                            >
4202
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   74
4203 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4204
 
4205 3 MichaelA
08a6 :                      >skip0287
4206
 
4207
08a6 : e8               [ 2]         inx
4208
08a7 : e8               [ 2]         inx
4209
08a8 :                       far_ret
4210 2 MichaelA
                                     trap_eq         ;returned flags OK?
4211 3 MichaelA
08a8 : d002             [ 3]>        bne skip0289
4212
                            >        trap           ;failed equal (zero)
4213
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4214
08aa : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4215
08ab : 08                   >        db      test_num
4216
                            >
4217
08ac :                      >skip0289
4218 2 MichaelA
 
4219
                                     trap_pl
4220 3 MichaelA
08ac : 3002             [ 3]>        bmi skip0291
4221
                            >        trap           ;failed equal (zero)
4222
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4223
08ae : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4224
08af : 08                   >        db      test_num
4225
                            >
4226
08b0 :                      >skip0291
4227 2 MichaelA
 
4228
                                     trap_cc
4229 3 MichaelA
08b0 : b002             [ 3]>        bcs skip0293
4230
                            >        trap           ;failed equal (zero)
4231
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4232
08b2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4233
08b3 : 08                   >        db      test_num
4234
                            >
4235
08b4 :                      >skip0293
4236 2 MichaelA
 
4237
                                     trap_vc
4238 3 MichaelA
08b4 : 7002             [ 3]>        bvs skip0295
4239
                            >        trap           ;failed equal (zero)
4240
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4241
08b6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4242
08b7 : 08                   >        db      test_num
4243
                            >
4244
08b8 :                      >skip0295
4245 2 MichaelA
 
4246 3 MichaelA
08b8 : c9ec             [ 2]         cmp #('F'^$aa)  ;returned registers OK?
4247 2 MichaelA
                                     trap_ne
4248 3 MichaelA
08ba : f002             [ 3]>        beq skip0297
4249
                            >        trap           ;failed equal (zero)
4250
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4251
08bc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4252
08bd : 08                   >        db      test_num
4253
                            >
4254
08be :                      >skip0297
4255 2 MichaelA
 
4256 3 MichaelA
08be : e042             [ 2]         cpx #('A'+1)
4257 2 MichaelA
                                     trap_ne
4258 3 MichaelA
08c0 : f002             [ 3]>        beq skip0299
4259
                            >        trap           ;failed equal (zero)
4260
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   75
4261
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4262
 
4263
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4264
08c2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4265
08c3 : 08                   >        db      test_num
4266
                            >
4267
08c4 :                      >skip0299
4268 2 MichaelA
 
4269 3 MichaelA
08c4 : c04f             [ 2]         cpy #('R'-3)
4270 2 MichaelA
                                     trap_ne
4271 3 MichaelA
08c6 : f002             [ 3]>        beq skip0301
4272
                            >        trap           ;failed equal (zero)
4273
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4274
08c8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4275
08c9 : 08                   >        db      test_num
4276
                            >
4277
08ca :                      >skip0301
4278 2 MichaelA
 
4279 3 MichaelA
08ca : ca               [ 2]         dex
4280
08cb : c8               [ 2]         iny
4281
08cc : c8               [ 2]         iny
4282
08cd : c8               [ 2]         iny
4283
08ce : 49aa             [ 2]         eor #$aa        ;N=0, V=1, Z=0, C=1
4284
08d0 : 4cdb08           [ 3]         jmp test_near
4285
08d3 : ea               [ 2]         nop
4286
08d4 : ea               [ 2]         nop
4287 2 MichaelA
                                     trap_ne         ;runover protection
4288 3 MichaelA
08d5 : f002             [ 3]>        beq skip0303
4289
                            >        trap           ;failed equal (zero)
4290
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4291
08d7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4292
08d8 : 08                   >        db      test_num
4293
                            >
4294
08d9 :                      >skip0303
4295 2 MichaelA
 
4296 3 MichaelA
08d9 : e8               [ 2]         inx
4297
08da : e8               [ 2]         inx
4298
08db :                       test_near
4299 2 MichaelA
                                     trap_eq         ;passed flags OK?
4300 3 MichaelA
08db : d002             [ 3]>        bne skip0305
4301
                            >        trap           ;failed equal (zero)
4302
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4303
08dd : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4304
08de : 08                   >        db      test_num
4305
                            >
4306
08df :                      >skip0305
4307 2 MichaelA
 
4308
                                     trap_mi
4309 3 MichaelA
08df : 1002             [ 3]>        bpl skip0307
4310
                            >        trap           ;failed equal (zero)
4311
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4312
08e1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4313
08e2 : 08                   >        db      test_num
4314
                            >
4315
08e3 :                      >skip0307
4316 2 MichaelA
 
4317
                                     trap_cc
4318 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   76
4319
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4320
 
4321
08e3 : b002             [ 3]>        bcs skip0309
4322
                            >        trap           ;failed equal (zero)
4323
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4324
08e5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4325
08e6 : 08                   >        db      test_num
4326
                            >
4327
08e7 :                      >skip0309
4328 2 MichaelA
 
4329
                                     trap_vc
4330 3 MichaelA
08e7 : 7002             [ 3]>        bvs skip0311
4331
                            >        trap           ;failed equal (zero)
4332
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4333
08e9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4334
08ea : 08                   >        db      test_num
4335
                            >
4336
08eb :                      >skip0311
4337 2 MichaelA
 
4338 3 MichaelA
08eb : c946             [ 2]         cmp #'F'        ;passed registers OK?
4339 2 MichaelA
                                     trap_ne
4340 3 MichaelA
08ed : f002             [ 3]>        beq skip0313
4341
                            >        trap           ;failed equal (zero)
4342
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4343
08ef : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4344
08f0 : 08                   >        db      test_num
4345
                            >
4346
08f1 :                      >skip0313
4347 2 MichaelA
 
4348 3 MichaelA
08f1 : e041             [ 2]         cpx #'A'
4349 2 MichaelA
                                     trap_ne
4350 3 MichaelA
08f3 : f002             [ 3]>        beq skip0315
4351
                            >        trap           ;failed equal (zero)
4352
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4353
08f5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4354
08f6 : 08                   >        db      test_num
4355
                            >
4356
08f7 :                      >skip0315
4357 2 MichaelA
 
4358 3 MichaelA
08f7 : c052             [ 2]         cpy #'R'
4359 2 MichaelA
                                     trap_ne
4360 3 MichaelA
08f9 : f002             [ 3]>        beq skip0317
4361
                            >        trap           ;failed equal (zero)
4362
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4363
08fb : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4364
08fc : 08                   >        db      test_num
4365
                            >
4366
08fd :                      >skip0317
4367 2 MichaelA
 
4368
                                     next_test
4369 3 MichaelA
08fd : ad0002           [ 4]>            lda test_case   ;previous test
4370
0900 : c908             [ 2]>            cmp #test_num
4371 2 MichaelA
                            >            trap_ne         ;test is out of sequence
4372 3 MichaelA
0902 : f002             [ 3]>        beq skip0320
4373
                            >        trap           ;failed equal (zero)
4374
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4375
0904 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4376
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   77
4377
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4378
 
4379
0905 : 08                   >        db      test_num
4380 2 MichaelA
                            >
4381 3 MichaelA
0906 :                      >skip0320
4382
                            >
4383 2 MichaelA
0009 =                      >test_num = test_num + 1
4384 3 MichaelA
0906 : a909             [ 2]>            lda #test_num   ;*** this tests' number
4385
0908 : 8d0002           [ 4]>            sta test_case
4386 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
4387
 
4388
 
4389
                             ; jump indirect
4390 3 MichaelA
 
4391 2 MichaelA
                                     set_stat 0
4392
                            >            load_flag 0
4393 3 MichaelA
090b : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
4394 2 MichaelA
                            >
4395 3 MichaelA
090d : 48               [ 3]>            pha         ;use stack to load status
4396
090e : 28               [ 4]>            plp
4397 2 MichaelA
 
4398 3 MichaelA
090f : a949             [ 2]         lda #'I'
4399
0911 : a24e             [ 2]         ldx #'N'
4400
0913 : a044             [ 2]         ldy #'D'        ;N=0, V=0, Z=0, C=0
4401
0915 : 6c5a3d           [ 6]         jmp (ptr_tst_ind)
4402
0918 : ea               [ 2]         nop
4403 2 MichaelA
                                     trap_ne         ;runover protection
4404 3 MichaelA
0919 : f002             [ 3]>        beq skip0324
4405
                            >        trap           ;failed equal (zero)
4406
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4407
091b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4408
091c : 09                   >        db      test_num
4409
                            >
4410
091d :                      >skip0324
4411 2 MichaelA
 
4412 3 MichaelA
091d : 88               [ 2]         dey
4413
091e : 88               [ 2]         dey
4414
091f :                       ind_ret
4415
091f : 08               [ 3]         php             ;either SP or Y count will fail, if we do not hit
4416
0920 : 88               [ 2]         dey
4417
0921 : 88               [ 2]         dey
4418
0922 : 88               [ 2]         dey
4419
0923 : 28               [ 4]         plp
4420 2 MichaelA
                                     trap_eq         ;returned flags OK?
4421 3 MichaelA
0924 : d002             [ 3]>        bne skip0326
4422
                            >        trap           ;failed equal (zero)
4423
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4424
0926 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4425
0927 : 09                   >        db      test_num
4426
                            >
4427
0928 :                      >skip0326
4428 2 MichaelA
 
4429
                                     trap_pl
4430 3 MichaelA
0928 : 3002             [ 3]>        bmi skip0328
4431
                            >        trap           ;failed equal (zero)
4432
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4433
092a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4434
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   78
4435
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4436
 
4437
092b : 09                   >        db      test_num
4438
                            >
4439
092c :                      >skip0328
4440 2 MichaelA
 
4441
                                     trap_cc
4442 3 MichaelA
092c : b002             [ 3]>        bcs skip0330
4443
                            >        trap           ;failed equal (zero)
4444
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4445
092e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4446
092f : 09                   >        db      test_num
4447
                            >
4448
0930 :                      >skip0330
4449 2 MichaelA
 
4450
                                     trap_vc
4451 3 MichaelA
0930 : 7002             [ 3]>        bvs skip0332
4452
                            >        trap           ;failed equal (zero)
4453
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4454
0932 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4455
0933 : 09                   >        db      test_num
4456
                            >
4457
0934 :                      >skip0332
4458 2 MichaelA
 
4459 3 MichaelA
0934 : c9e3             [ 2]         cmp #('I'^$aa)  ;returned registers OK?
4460 2 MichaelA
                                     trap_ne
4461 3 MichaelA
0936 : f002             [ 3]>        beq skip0334
4462
                            >        trap           ;failed equal (zero)
4463
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4464
0938 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4465
0939 : 09                   >        db      test_num
4466
                            >
4467
093a :                      >skip0334
4468 2 MichaelA
 
4469 3 MichaelA
093a : e04f             [ 2]         cpx #('N'+1)
4470 2 MichaelA
                                     trap_ne
4471 3 MichaelA
093c : f002             [ 3]>        beq skip0336
4472
                            >        trap           ;failed equal (zero)
4473
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4474
093e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4475
093f : 09                   >        db      test_num
4476
                            >
4477
0940 :                      >skip0336
4478 2 MichaelA
 
4479 3 MichaelA
0940 : c03e             [ 2]         cpy #('D'-6)
4480 2 MichaelA
                                     trap_ne
4481 3 MichaelA
0942 : f002             [ 3]>        beq skip0338
4482
                            >        trap           ;failed equal (zero)
4483
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4484
0944 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4485
0945 : 09                   >        db      test_num
4486
                            >
4487
0946 :                      >skip0338
4488 2 MichaelA
 
4489 3 MichaelA
0946 : ba               [ 2]         tsx             ;SP check
4490
0947 : e0ff             [ 2]         cpx #$ff
4491 2 MichaelA
                                     trap_ne
4492 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   79
4493
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4494
 
4495
0949 : f002             [ 3]>        beq skip0340
4496
                            >        trap           ;failed equal (zero)
4497
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4498
094b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4499
094c : 09                   >        db      test_num
4500
                            >
4501
094d :                      >skip0340
4502 2 MichaelA
 
4503
                                     next_test
4504 3 MichaelA
094d : ad0002           [ 4]>            lda test_case   ;previous test
4505
0950 : c909             [ 2]>            cmp #test_num
4506 2 MichaelA
                            >            trap_ne         ;test is out of sequence
4507 3 MichaelA
0952 : f002             [ 3]>        beq skip0343
4508
                            >        trap           ;failed equal (zero)
4509
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4510
0954 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4511
0955 : 09                   >        db      test_num
4512 2 MichaelA
                            >
4513 3 MichaelA
0956 :                      >skip0343
4514
                            >
4515 2 MichaelA
000a =                      >test_num = test_num + 1
4516 3 MichaelA
0956 : a90a             [ 2]>            lda #test_num   ;*** this tests' number
4517
0958 : 8d0002           [ 4]>            sta test_case
4518 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
4519
 
4520
 
4521
                             ; jump subroutine & return from subroutine
4522 3 MichaelA
 
4523 2 MichaelA
                                     set_stat 0
4524
                            >            load_flag 0
4525 3 MichaelA
095b : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
4526 2 MichaelA
                            >
4527 3 MichaelA
095d : 48               [ 3]>            pha         ;use stack to load status
4528
095e : 28               [ 4]>            plp
4529 2 MichaelA
 
4530 3 MichaelA
095f : a94a             [ 2]         lda #'J'
4531
0961 : a253             [ 2]         ldx #'S'
4532
0963 : a052             [ 2]         ldy #'R'        ;N=0, V=0, Z=0, C=0
4533
0965 : 20a43d           [ 6]         jsr test_jsr
4534
0967 =                       jsr_ret = *-1           ;last address of jsr = return address
4535
0968 : 08               [ 3]         php             ;either SP or Y count will fail, if we do not hit
4536
0969 : 88               [ 2]         dey
4537
096a : 88               [ 2]         dey
4538
096b : 88               [ 2]         dey
4539
096c : 28               [ 4]         plp
4540 2 MichaelA
                                     trap_eq         ;returned flags OK?
4541 3 MichaelA
096d : d002             [ 3]>        bne skip0347
4542
                            >        trap           ;failed equal (zero)
4543
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4544
096f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4545
0970 : 0a                   >        db      test_num
4546
                            >
4547
0971 :                      >skip0347
4548 2 MichaelA
 
4549
                                     trap_pl
4550 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   80
4551 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4552
 
4553 3 MichaelA
0971 : 3002             [ 3]>        bmi skip0349
4554
                            >        trap           ;failed equal (zero)
4555
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4556
0973 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4557
0974 : 0a                   >        db      test_num
4558
                            >
4559
0975 :                      >skip0349
4560 2 MichaelA
 
4561
                                     trap_cc
4562 3 MichaelA
0975 : b002             [ 3]>        bcs skip0351
4563
                            >        trap           ;failed equal (zero)
4564
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4565
0977 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4566
0978 : 0a                   >        db      test_num
4567
                            >
4568
0979 :                      >skip0351
4569 2 MichaelA
 
4570
                                     trap_vc
4571 3 MichaelA
0979 : 7002             [ 3]>        bvs skip0353
4572
                            >        trap           ;failed equal (zero)
4573
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4574
097b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4575
097c : 0a                   >        db      test_num
4576
                            >
4577
097d :                      >skip0353
4578 2 MichaelA
 
4579 3 MichaelA
097d : c9e0             [ 2]         cmp #('J'^$aa)  ;returned registers OK?
4580 2 MichaelA
                                     trap_ne
4581 3 MichaelA
097f : f002             [ 3]>        beq skip0355
4582
                            >        trap           ;failed equal (zero)
4583
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4584
0981 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4585
0982 : 0a                   >        db      test_num
4586
                            >
4587
0983 :                      >skip0355
4588 2 MichaelA
 
4589 3 MichaelA
0983 : e054             [ 2]         cpx #('S'+1)
4590 2 MichaelA
                                     trap_ne
4591 3 MichaelA
0985 : f002             [ 3]>        beq skip0357
4592
                            >        trap           ;failed equal (zero)
4593
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4594
0987 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4595
0988 : 0a                   >        db      test_num
4596
                            >
4597
0989 :                      >skip0357
4598 2 MichaelA
 
4599 3 MichaelA
0989 : c04c             [ 2]         cpy #('R'-6)
4600 2 MichaelA
                                     trap_ne
4601 3 MichaelA
098b : f002             [ 3]>        beq skip0359
4602
                            >        trap           ;failed equal (zero)
4603
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4604
098d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4605
098e : 0a                   >        db      test_num
4606
                            >
4607
098f :                      >skip0359
4608
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   81
4609
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4610
 
4611 2 MichaelA
 
4612 3 MichaelA
098f : ba               [ 2]         tsx             ;sp?
4613
0990 : e0ff             [ 2]         cpx #$ff
4614 2 MichaelA
                                     trap_ne
4615 3 MichaelA
0992 : f002             [ 3]>        beq skip0361
4616
                            >        trap           ;failed equal (zero)
4617
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4618
0994 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4619
0995 : 0a                   >        db      test_num
4620
                            >
4621
0996 :                      >skip0361
4622 2 MichaelA
 
4623
                                     next_test
4624 3 MichaelA
0996 : ad0002           [ 4]>            lda test_case   ;previous test
4625
0999 : c90a             [ 2]>            cmp #test_num
4626 2 MichaelA
                            >            trap_ne         ;test is out of sequence
4627 3 MichaelA
099b : f002             [ 3]>        beq skip0364
4628
                            >        trap           ;failed equal (zero)
4629
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4630
099d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4631
099e : 0a                   >        db      test_num
4632 2 MichaelA
                            >
4633 3 MichaelA
099f :                      >skip0364
4634
                            >
4635 2 MichaelA
000b =                      >test_num = test_num + 1
4636 3 MichaelA
099f : a90b             [ 2]>            lda #test_num   ;*** this tests' number
4637
09a1 : 8d0002           [ 4]>            sta test_case
4638 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
4639
 
4640
 
4641
                             ; break & return from interrupt
4642 3 MichaelA
 
4643 2 MichaelA
                                 if ROM_vectors = 1
4644 3 MichaelA
 
4645 2 MichaelA
                                     set_stat 0
4646 3 MichaelA
                                     lda #'B'
4647
                                     ldx #'R'
4648
                                     ldy #'K'        ;N=0, V=0, Z=0, C=0
4649
                                     brk
4650
 
4651
                                 else
4652
 
4653
09a4 : a909             [ 2]         lda #hi(brk_ret) ;emulated break
4654
09a6 : 48               [ 3]         pha
4655
09a7 : a9ba             [ 2]         lda #lo(brk_ret-1) ; M65C02 pushes BRK+1 not BRK+2
4656
09a9 : 48               [ 3]         pha
4657
09aa : a930             [ 2]         lda #fao        ;set break & unused on stack
4658
09ac : 48               [ 3]         pha
4659
                                     set_stat intdis
4660
                            >            load_flag intdis
4661
09ad : a904             [ 2]>            lda #intdis             ;allow test to change I-flag (no mask)
4662 2 MichaelA
                            >
4663 3 MichaelA
09af : 48               [ 3]>            pha         ;use stack to load status
4664
09b0 : 28               [ 4]>            plp
4665 2 MichaelA
 
4666 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   82
4667 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4668
 
4669 3 MichaelA
09b1 : a942             [ 2]         lda #'B'
4670
09b3 : a252             [ 2]         ldx #'R'
4671
09b5 : a04b             [ 2]         ldy #'K'        ;N=0, V=0, Z=0, C=0
4672
09b7 : 4cfa3d           [ 3]         jmp irq_trap
4673
 
4674 2 MichaelA
                                 endif
4675 3 MichaelA
 
4676
09ba : 88               [ 2]         dey             ;should not be executed
4677
09bb :                       brk_ret                 ;address of break return
4678
09bb : 08               [ 3]         php             ;either SP or Y count will fail, if we do not hit
4679
09bc : 88               [ 2]         dey
4680
09bd : 88               [ 2]         dey
4681
09be : 88               [ 2]         dey
4682
09bf : c9e8             [ 2]         cmp #('B'^$aa)  ;returned registers OK?
4683 2 MichaelA
                                     trap_ne
4684 3 MichaelA
09c1 : f002             [ 3]>        beq skip0368
4685
                            >        trap           ;failed equal (zero)
4686
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4687
09c3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4688
09c4 : 0b                   >        db      test_num
4689
                            >
4690
09c5 :                      >skip0368
4691 2 MichaelA
 
4692 3 MichaelA
09c5 : e053             [ 2]         cpx #('R'+1)
4693 2 MichaelA
                                     trap_ne
4694 3 MichaelA
09c7 : f002             [ 3]>        beq skip0370
4695
                            >        trap           ;failed equal (zero)
4696
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4697
09c9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4698
09ca : 0b                   >        db      test_num
4699
                            >
4700
09cb :                      >skip0370
4701 2 MichaelA
 
4702 3 MichaelA
09cb : c045             [ 2]         cpy #('K'-6)
4703 2 MichaelA
                                     trap_ne
4704 3 MichaelA
09cd : f002             [ 3]>        beq skip0372
4705
                            >        trap           ;failed equal (zero)
4706
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4707
09cf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4708
09d0 : 0b                   >        db      test_num
4709
                            >
4710
09d1 :                      >skip0372
4711 2 MichaelA
 
4712 3 MichaelA
09d1 : 68               [ 4]         pla             ;returned flags OK (unchanged)?
4713 2 MichaelA
                                     cmp_flag 0
4714 3 MichaelA
09d2 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
4715 2 MichaelA
 
4716
                                     trap_ne
4717 3 MichaelA
09d4 : f002             [ 3]>        beq skip0375
4718
                            >        trap           ;failed equal (zero)
4719
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4720
09d6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4721
09d7 : 0b                   >        db      test_num
4722
                            >
4723
09d8 :                      >skip0375
4724
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   83
4725
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4726
 
4727 2 MichaelA
 
4728 3 MichaelA
09d8 : ba               [ 2]         tsx             ;sp?
4729
09d9 : e0ff             [ 2]         cpx #$ff
4730 2 MichaelA
                                     trap_ne
4731 3 MichaelA
09db : f002             [ 3]>        beq skip0377
4732
                            >        trap           ;failed equal (zero)
4733
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4734
09dd : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4735
09de : 0b                   >        db      test_num
4736
                            >
4737
09df :                      >skip0377
4738 2 MichaelA
 
4739
                                     next_test
4740 3 MichaelA
09df : ad0002           [ 4]>            lda test_case   ;previous test
4741
09e2 : c90b             [ 2]>            cmp #test_num
4742 2 MichaelA
                            >            trap_ne         ;test is out of sequence
4743 3 MichaelA
09e4 : f002             [ 3]>        beq skip0380
4744
                            >        trap           ;failed equal (zero)
4745
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4746
09e6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4747
09e7 : 0b                   >        db      test_num
4748 2 MichaelA
                            >
4749 3 MichaelA
09e8 :                      >skip0380
4750
                            >
4751 2 MichaelA
000c =                      >test_num = test_num + 1
4752 3 MichaelA
09e8 : a90c             [ 2]>            lda #test_num   ;*** this tests' number
4753
09ea : 8d0002           [ 4]>            sta test_case
4754 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
4755
 
4756
 
4757
                             ; test set and clear flags CLC CLI CLD CLV SEC SEI SED
4758 3 MichaelA
 
4759 2 MichaelA
                                     set_stat $ff
4760
                            >            load_flag $ff
4761 3 MichaelA
09ed : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
4762 2 MichaelA
                            >
4763 3 MichaelA
09ef : 48               [ 3]>            pha         ;use stack to load status
4764
09f0 : 28               [ 4]>            plp
4765 2 MichaelA
 
4766 3 MichaelA
09f1 : 18               [ 2]         clc
4767 2 MichaelA
                                     tst_stat $ff-carry
4768 3 MichaelA
09f2 : 08               [ 3]>            php         ;save status
4769
09f3 : 08               [ 3]>            php         ;use stack to retrieve status
4770
09f4 : 68               [ 4]>            pla
4771 2 MichaelA
                            >            cmp_flag $ff-carry
4772 3 MichaelA
09f5 : c9fe             [ 2]>            cmp #($ff-carry|fao)&m8    ;expected flags + always on bits
4773 2 MichaelA
                            >
4774
                            >            trap_ne
4775 3 MichaelA
09f7 : f002             [ 3]>        beq skip0386
4776
                            >        trap           ;failed equal (zero)
4777
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4778
09f9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4779
09fa : 0c                   >        db      test_num
4780 2 MichaelA
                            >
4781 3 MichaelA
09fb :                      >skip0386
4782
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   84
4783
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4784
 
4785
                            >
4786
09fb : 28               [ 4]>            plp         ;restore status
4787 2 MichaelA
 
4788 3 MichaelA
09fc : 38               [ 2]         sec
4789 2 MichaelA
                                     tst_stat $ff
4790 3 MichaelA
09fd : 08               [ 3]>            php         ;save status
4791
09fe : 08               [ 3]>            php         ;use stack to retrieve status
4792
09ff : 68               [ 4]>            pla
4793 2 MichaelA
                            >            cmp_flag $ff
4794 3 MichaelA
0a00 : c9ff             [ 2]>            cmp #($ff|fao)&m8    ;expected flags + always on bits
4795 2 MichaelA
                            >
4796
                            >            trap_ne
4797 3 MichaelA
0a02 : f002             [ 3]>        beq skip0390
4798
                            >        trap           ;failed equal (zero)
4799
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4800
0a04 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4801
0a05 : 0c                   >        db      test_num
4802 2 MichaelA
                            >
4803 3 MichaelA
0a06 :                      >skip0390
4804
                            >
4805
0a06 : 28               [ 4]>            plp         ;restore status
4806 2 MichaelA
 
4807 3 MichaelA
 
4808 2 MichaelA
                                 if I_flag = 3
4809 3 MichaelA
 
4810
0a07 : 58               [ 2]         cli
4811 2 MichaelA
                                     tst_stat $ff-intdis
4812 3 MichaelA
0a08 : 08               [ 3]>            php         ;save status
4813
0a09 : 08               [ 3]>            php         ;use stack to retrieve status
4814
0a0a : 68               [ 4]>            pla
4815 2 MichaelA
                            >            cmp_flag $ff-intdis
4816 3 MichaelA
0a0b : c9fb             [ 2]>            cmp #($ff-intdis|fao)&m8    ;expected flags + always on bits
4817 2 MichaelA
                            >
4818
                            >            trap_ne
4819 3 MichaelA
0a0d : f002             [ 3]>        beq skip0394
4820
                            >        trap           ;failed equal (zero)
4821
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4822
0a0f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4823
0a10 : 0c                   >        db      test_num
4824 2 MichaelA
                            >
4825 3 MichaelA
0a11 :                      >skip0394
4826
                            >
4827
0a11 : 28               [ 4]>            plp         ;restore status
4828 2 MichaelA
 
4829 3 MichaelA
0a12 : 78               [ 2]         sei
4830 2 MichaelA
                                     tst_stat $ff
4831 3 MichaelA
0a13 : 08               [ 3]>            php         ;save status
4832
0a14 : 08               [ 3]>            php         ;use stack to retrieve status
4833
0a15 : 68               [ 4]>            pla
4834 2 MichaelA
                            >            cmp_flag $ff
4835 3 MichaelA
0a16 : c9ff             [ 2]>            cmp #($ff|fao)&m8    ;expected flags + always on bits
4836 2 MichaelA
                            >
4837
                            >            trap_ne
4838 3 MichaelA
0a18 : f002             [ 3]>        beq skip0398
4839
                            >        trap           ;failed equal (zero)
4840
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   85
4841
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4842
 
4843
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4844
0a1a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4845
0a1b : 0c                   >        db      test_num
4846 2 MichaelA
                            >
4847 3 MichaelA
0a1c :                      >skip0398
4848
                            >
4849
0a1c : 28               [ 4]>            plp         ;restore status
4850 2 MichaelA
 
4851 3 MichaelA
 
4852 2 MichaelA
                                 endif
4853 3 MichaelA
 
4854
0a1d : d8               [ 2]         cld
4855 2 MichaelA
                                     tst_stat $ff-decmode
4856 3 MichaelA
0a1e : 08               [ 3]>            php         ;save status
4857
0a1f : 08               [ 3]>            php         ;use stack to retrieve status
4858
0a20 : 68               [ 4]>            pla
4859 2 MichaelA
                            >            cmp_flag $ff-decmode
4860 3 MichaelA
0a21 : c9f7             [ 2]>            cmp #($ff-decmode|fao)&m8    ;expected flags + always on bits
4861 2 MichaelA
                            >
4862
                            >            trap_ne
4863 3 MichaelA
0a23 : f002             [ 3]>        beq skip0402
4864
                            >        trap           ;failed equal (zero)
4865
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4866
0a25 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4867
0a26 : 0c                   >        db      test_num
4868 2 MichaelA
                            >
4869 3 MichaelA
0a27 :                      >skip0402
4870
                            >
4871
0a27 : 28               [ 4]>            plp         ;restore status
4872 2 MichaelA
 
4873 3 MichaelA
0a28 : f8               [ 2]         sed
4874 2 MichaelA
                                     tst_stat $ff
4875 3 MichaelA
0a29 : 08               [ 3]>            php         ;save status
4876
0a2a : 08               [ 3]>            php         ;use stack to retrieve status
4877
0a2b : 68               [ 4]>            pla
4878 2 MichaelA
                            >            cmp_flag $ff
4879 3 MichaelA
0a2c : c9ff             [ 2]>            cmp #($ff|fao)&m8    ;expected flags + always on bits
4880 2 MichaelA
                            >
4881
                            >            trap_ne
4882 3 MichaelA
0a2e : f002             [ 3]>        beq skip0406
4883
                            >        trap           ;failed equal (zero)
4884
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4885
0a30 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4886
0a31 : 0c                   >        db      test_num
4887 2 MichaelA
                            >
4888 3 MichaelA
0a32 :                      >skip0406
4889
                            >
4890
0a32 : 28               [ 4]>            plp         ;restore status
4891 2 MichaelA
 
4892 3 MichaelA
0a33 : b8               [ 2]         clv
4893 2 MichaelA
                                     tst_stat $ff-overfl
4894 3 MichaelA
0a34 : 08               [ 3]>            php         ;save status
4895
0a35 : 08               [ 3]>            php         ;use stack to retrieve status
4896
0a36 : 68               [ 4]>            pla
4897 2 MichaelA
                            >            cmp_flag $ff-overfl
4898 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   86
4899
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4900
 
4901
0a37 : c9bf             [ 2]>            cmp #($ff-overfl|fao)&m8    ;expected flags + always on bits
4902 2 MichaelA
                            >
4903
                            >            trap_ne
4904 3 MichaelA
0a39 : f002             [ 3]>        beq skip0410
4905
                            >        trap           ;failed equal (zero)
4906
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4907
0a3b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4908
0a3c : 0c                   >        db      test_num
4909 2 MichaelA
                            >
4910 3 MichaelA
0a3d :                      >skip0410
4911
                            >
4912
0a3d : 28               [ 4]>            plp         ;restore status
4913 2 MichaelA
 
4914
                                     set_stat 0
4915
                            >            load_flag 0
4916 3 MichaelA
0a3e : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
4917 2 MichaelA
                            >
4918 3 MichaelA
0a40 : 48               [ 3]>            pha         ;use stack to load status
4919
0a41 : 28               [ 4]>            plp
4920 2 MichaelA
 
4921
                                     tst_stat 0
4922 3 MichaelA
0a42 : 08               [ 3]>            php         ;save status
4923
0a43 : 08               [ 3]>            php         ;use stack to retrieve status
4924
0a44 : 68               [ 4]>            pla
4925 2 MichaelA
                            >            cmp_flag 0
4926 3 MichaelA
0a45 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
4927 2 MichaelA
                            >
4928
                            >            trap_ne
4929 3 MichaelA
0a47 : f002             [ 3]>        beq skip0416
4930
                            >        trap           ;failed equal (zero)
4931
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4932
0a49 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4933
0a4a : 0c                   >        db      test_num
4934 2 MichaelA
                            >
4935 3 MichaelA
0a4b :                      >skip0416
4936
                            >
4937
0a4b : 28               [ 4]>            plp         ;restore status
4938 2 MichaelA
 
4939 3 MichaelA
0a4c : 38               [ 2]         sec
4940 2 MichaelA
                                     tst_stat carry
4941 3 MichaelA
0a4d : 08               [ 3]>            php         ;save status
4942
0a4e : 08               [ 3]>            php         ;use stack to retrieve status
4943
0a4f : 68               [ 4]>            pla
4944 2 MichaelA
                            >            cmp_flag carry
4945 3 MichaelA
0a50 : c931             [ 2]>            cmp #(carry|fao)&m8    ;expected flags + always on bits
4946 2 MichaelA
                            >
4947
                            >            trap_ne
4948 3 MichaelA
0a52 : f002             [ 3]>        beq skip0420
4949
                            >        trap           ;failed equal (zero)
4950
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4951
0a54 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4952
0a55 : 0c                   >        db      test_num
4953 2 MichaelA
                            >
4954 3 MichaelA
0a56 :                      >skip0420
4955
                            >
4956
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   87
4957
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
4958
 
4959
0a56 : 28               [ 4]>            plp         ;restore status
4960 2 MichaelA
 
4961 3 MichaelA
0a57 : 18               [ 2]         clc
4962 2 MichaelA
                                     tst_stat 0
4963 3 MichaelA
0a58 : 08               [ 3]>            php         ;save status
4964
0a59 : 08               [ 3]>            php         ;use stack to retrieve status
4965
0a5a : 68               [ 4]>            pla
4966 2 MichaelA
                            >            cmp_flag 0
4967 3 MichaelA
0a5b : c930             [ 2]>            cmp #(0  |fao)&m8    ;expected flags + always on bits
4968 2 MichaelA
                            >
4969
                            >            trap_ne
4970 3 MichaelA
0a5d : f002             [ 3]>        beq skip0424
4971
                            >        trap           ;failed equal (zero)
4972
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4973
0a5f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4974
0a60 : 0c                   >        db      test_num
4975 2 MichaelA
                            >
4976 3 MichaelA
0a61 :                      >skip0424
4977
                            >
4978
0a61 : 28               [ 4]>            plp         ;restore status
4979 2 MichaelA
 
4980 3 MichaelA
 
4981 2 MichaelA
                                 if I_flag = 3
4982 3 MichaelA
 
4983
0a62 : 78               [ 2]         sei
4984 2 MichaelA
                                     tst_stat intdis
4985 3 MichaelA
0a63 : 08               [ 3]>            php         ;save status
4986
0a64 : 08               [ 3]>            php         ;use stack to retrieve status
4987
0a65 : 68               [ 4]>            pla
4988 2 MichaelA
                            >            cmp_flag intdis
4989 3 MichaelA
0a66 : c934             [ 2]>            cmp #(intdis|fao)&m8    ;expected flags + always on bits
4990 2 MichaelA
                            >
4991
                            >            trap_ne
4992 3 MichaelA
0a68 : f002             [ 3]>        beq skip0428
4993
                            >        trap           ;failed equal (zero)
4994
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
4995
0a6a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
4996
0a6b : 0c                   >        db      test_num
4997 2 MichaelA
                            >
4998 3 MichaelA
0a6c :                      >skip0428
4999
                            >
5000
0a6c : 28               [ 4]>            plp         ;restore status
5001 2 MichaelA
 
5002 3 MichaelA
0a6d : 58               [ 2]         cli
5003 2 MichaelA
                                     tst_stat 0
5004 3 MichaelA
0a6e : 08               [ 3]>            php         ;save status
5005
0a6f : 08               [ 3]>            php         ;use stack to retrieve status
5006
0a70 : 68               [ 4]>            pla
5007 2 MichaelA
                            >            cmp_flag 0
5008 3 MichaelA
0a71 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
5009 2 MichaelA
                            >
5010
                            >            trap_ne
5011 3 MichaelA
0a73 : f002             [ 3]>        beq skip0432
5012
                            >        trap           ;failed equal (zero)
5013
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5014
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   88
5015 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5016
 
5017 3 MichaelA
0a75 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5018
0a76 : 0c                   >        db      test_num
5019
                            >
5020
0a77 :                      >skip0432
5021
                            >
5022
0a77 : 28               [ 4]>            plp         ;restore status
5023 2 MichaelA
 
5024 3 MichaelA
 
5025 2 MichaelA
                                 endif
5026 3 MichaelA
 
5027
0a78 : f8               [ 2]         sed
5028 2 MichaelA
                                     tst_stat decmode
5029 3 MichaelA
0a79 : 08               [ 3]>            php         ;save status
5030
0a7a : 08               [ 3]>            php         ;use stack to retrieve status
5031
0a7b : 68               [ 4]>            pla
5032 2 MichaelA
                            >            cmp_flag decmode
5033 3 MichaelA
0a7c : c938             [ 2]>            cmp #(decmode|fao)&m8    ;expected flags + always on bits
5034 2 MichaelA
                            >
5035
                            >            trap_ne
5036 3 MichaelA
0a7e : f002             [ 3]>        beq skip0436
5037
                            >        trap           ;failed equal (zero)
5038
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5039
0a80 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5040
0a81 : 0c                   >        db      test_num
5041 2 MichaelA
                            >
5042 3 MichaelA
0a82 :                      >skip0436
5043
                            >
5044
0a82 : 28               [ 4]>            plp         ;restore status
5045 2 MichaelA
 
5046 3 MichaelA
0a83 : d8               [ 2]         cld
5047 2 MichaelA
                                     tst_stat 0
5048 3 MichaelA
0a84 : 08               [ 3]>            php         ;save status
5049
0a85 : 08               [ 3]>            php         ;use stack to retrieve status
5050
0a86 : 68               [ 4]>            pla
5051 2 MichaelA
                            >            cmp_flag 0
5052 3 MichaelA
0a87 : c930             [ 2]>            cmp #(0  |fao)&m8    ;expected flags + always on bits
5053 2 MichaelA
                            >
5054
                            >            trap_ne
5055 3 MichaelA
0a89 : f002             [ 3]>        beq skip0440
5056
                            >        trap           ;failed equal (zero)
5057
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5058
0a8b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5059
0a8c : 0c                   >        db      test_num
5060 2 MichaelA
                            >
5061 3 MichaelA
0a8d :                      >skip0440
5062
                            >
5063
0a8d : 28               [ 4]>            plp         ;restore status
5064 2 MichaelA
 
5065
                                     set_stat overfl
5066
                            >            load_flag overfl
5067 3 MichaelA
0a8e : a940             [ 2]>            lda #overfl             ;allow test to change I-flag (no mask)
5068 2 MichaelA
                            >
5069 3 MichaelA
0a90 : 48               [ 3]>            pha         ;use stack to load status
5070
0a91 : 28               [ 4]>            plp
5071 2 MichaelA
 
5072 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   89
5073
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5074
 
5075 2 MichaelA
                                     tst_stat overfl
5076 3 MichaelA
0a92 : 08               [ 3]>            php         ;save status
5077
0a93 : 08               [ 3]>            php         ;use stack to retrieve status
5078
0a94 : 68               [ 4]>            pla
5079 2 MichaelA
                            >            cmp_flag overfl
5080 3 MichaelA
0a95 : c970             [ 2]>            cmp #(overfl|fao)&m8    ;expected flags + always on bits
5081 2 MichaelA
                            >
5082
                            >            trap_ne
5083 3 MichaelA
0a97 : f002             [ 3]>        beq skip0446
5084
                            >        trap           ;failed equal (zero)
5085
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5086
0a99 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5087
0a9a : 0c                   >        db      test_num
5088 2 MichaelA
                            >
5089 3 MichaelA
0a9b :                      >skip0446
5090
                            >
5091
0a9b : 28               [ 4]>            plp         ;restore status
5092 2 MichaelA
 
5093 3 MichaelA
0a9c : b8               [ 2]         clv
5094 2 MichaelA
                                     tst_stat 0
5095 3 MichaelA
0a9d : 08               [ 3]>            php         ;save status
5096
0a9e : 08               [ 3]>            php         ;use stack to retrieve status
5097
0a9f : 68               [ 4]>            pla
5098 2 MichaelA
                            >            cmp_flag 0
5099 3 MichaelA
0aa0 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
5100 2 MichaelA
                            >
5101
                            >            trap_ne
5102 3 MichaelA
0aa2 : f002             [ 3]>        beq skip0450
5103
                            >        trap           ;failed equal (zero)
5104
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5105
0aa4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5106
0aa5 : 0c                   >        db      test_num
5107 2 MichaelA
                            >
5108 3 MichaelA
0aa6 :                      >skip0450
5109
                            >
5110
0aa6 : 28               [ 4]>            plp         ;restore status
5111 2 MichaelA
 
5112
                                     next_test
5113 3 MichaelA
0aa7 : ad0002           [ 4]>            lda test_case   ;previous test
5114
0aaa : c90c             [ 2]>            cmp #test_num
5115 2 MichaelA
                            >            trap_ne         ;test is out of sequence
5116 3 MichaelA
0aac : f002             [ 3]>        beq skip0453
5117
                            >        trap           ;failed equal (zero)
5118
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5119
0aae : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5120
0aaf : 0c                   >        db      test_num
5121 2 MichaelA
                            >
5122 3 MichaelA
0ab0 :                      >skip0453
5123
                            >
5124 2 MichaelA
000d =                      >test_num = test_num + 1
5125 3 MichaelA
0ab0 : a90d             [ 2]>            lda #test_num   ;*** this tests' number
5126
0ab2 : 8d0002           [ 4]>            sta test_case
5127 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
5128
 
5129 3 MichaelA
 
5130
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   90
5131
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5132
 
5133 2 MichaelA
                             ; testing index register increment/decrement and transfer
5134
                             ; INX INY DEX DEY TAX TXA TAY TYA
5135 3 MichaelA
 
5136
0ab5 : a2fe             [ 2]         ldx #$fe
5137 2 MichaelA
                                     set_stat $ff
5138
                            >            load_flag $ff
5139 3 MichaelA
0ab7 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
5140 2 MichaelA
                            >
5141 3 MichaelA
0ab9 : 48               [ 3]>            pha         ;use stack to load status
5142
0aba : 28               [ 4]>            plp
5143 2 MichaelA
 
5144 3 MichaelA
0abb : e8               [ 2]         inx             ;ff
5145 2 MichaelA
                                     tst_x $ff,$ff-zero
5146 3 MichaelA
0abc : 08               [ 3]>            php         ;save flags
5147
0abd : 08               [ 3]>            php
5148
0abe : e0ff             [ 2]>            cpx #$ff     ;test result
5149 2 MichaelA
                            >            trap_ne
5150 3 MichaelA
0ac0 : f002             [ 3]>        beq skip0458
5151
                            >        trap           ;failed equal (zero)
5152
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5153
0ac2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5154
0ac3 : 0d                   >        db      test_num
5155 2 MichaelA
                            >
5156 3 MichaelA
0ac4 :                      >skip0458
5157
                            >
5158
0ac4 : 68               [ 4]>            pla         ;load status
5159 2 MichaelA
                            >            cmp_flag $ff-zero
5160 3 MichaelA
0ac5 : c9fd             [ 2]>            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
5161 2 MichaelA
                            >
5162
                            >            trap_ne
5163 3 MichaelA
0ac7 : f002             [ 3]>        beq skip0461
5164
                            >        trap           ;failed equal (zero)
5165
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5166
0ac9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5167
0aca : 0d                   >        db      test_num
5168 2 MichaelA
                            >
5169 3 MichaelA
0acb :                      >skip0461
5170
                            >
5171
0acb : 28               [ 4]>            plp         ;restore status
5172 2 MichaelA
 
5173 3 MichaelA
0acc : e8               [ 2]         inx             ;00
5174 2 MichaelA
                                     tst_x 0,$ff-minus
5175 3 MichaelA
0acd : 08               [ 3]>            php         ;save flags
5176
0ace : 08               [ 3]>            php
5177
0acf : e000             [ 2]>            cpx #0     ;test result
5178 2 MichaelA
                            >            trap_ne
5179 3 MichaelA
0ad1 : f002             [ 3]>        beq skip0464
5180
                            >        trap           ;failed equal (zero)
5181
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5182
0ad3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5183
0ad4 : 0d                   >        db      test_num
5184 2 MichaelA
                            >
5185 3 MichaelA
0ad5 :                      >skip0464
5186
                            >
5187
0ad5 : 68               [ 4]>            pla         ;load status
5188
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   91
5189 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5190
 
5191 3 MichaelA
                            >            cmp_flag $ff-minus
5192
0ad6 : c97f             [ 2]>            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
5193 2 MichaelA
                            >
5194
                            >            trap_ne
5195 3 MichaelA
0ad8 : f002             [ 3]>        beq skip0467
5196
                            >        trap           ;failed equal (zero)
5197
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5198
0ada : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5199
0adb : 0d                   >        db      test_num
5200 2 MichaelA
                            >
5201 3 MichaelA
0adc :                      >skip0467
5202
                            >
5203
0adc : 28               [ 4]>            plp         ;restore status
5204 2 MichaelA
 
5205 3 MichaelA
0add : e8               [ 2]         inx             ;01
5206 2 MichaelA
                                     tst_x 1,$ff-minus-zero
5207 3 MichaelA
0ade : 08               [ 3]>            php         ;save flags
5208
0adf : 08               [ 3]>            php
5209
0ae0 : e001             [ 2]>            cpx #1     ;test result
5210 2 MichaelA
                            >            trap_ne
5211 3 MichaelA
0ae2 : f002             [ 3]>        beq skip0470
5212
                            >        trap           ;failed equal (zero)
5213
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5214
0ae4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5215
0ae5 : 0d                   >        db      test_num
5216 2 MichaelA
                            >
5217 3 MichaelA
0ae6 :                      >skip0470
5218
                            >
5219
0ae6 : 68               [ 4]>            pla         ;load status
5220 2 MichaelA
                            >            cmp_flag $ff-minus-zero
5221 3 MichaelA
0ae7 : c97d             [ 2]>            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
5222 2 MichaelA
                            >
5223
                            >            trap_ne
5224 3 MichaelA
0ae9 : f002             [ 3]>        beq skip0473
5225
                            >        trap           ;failed equal (zero)
5226
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5227
0aeb : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5228
0aec : 0d                   >        db      test_num
5229 2 MichaelA
                            >
5230 3 MichaelA
0aed :                      >skip0473
5231
                            >
5232
0aed : 28               [ 4]>            plp         ;restore status
5233 2 MichaelA
 
5234 3 MichaelA
0aee : ca               [ 2]         dex             ;00
5235 2 MichaelA
                                     tst_x 0,$ff-minus
5236 3 MichaelA
0aef : 08               [ 3]>            php         ;save flags
5237
0af0 : 08               [ 3]>            php
5238
0af1 : e000             [ 2]>            cpx #0     ;test result
5239 2 MichaelA
                            >            trap_ne
5240 3 MichaelA
0af3 : f002             [ 3]>        beq skip0476
5241
                            >        trap           ;failed equal (zero)
5242
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5243
0af5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5244
0af6 : 0d                   >        db      test_num
5245 2 MichaelA
                            >
5246 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   92
5247
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5248
 
5249
0af7 :                      >skip0476
5250
                            >
5251
0af7 : 68               [ 4]>            pla         ;load status
5252 2 MichaelA
                            >            cmp_flag $ff-minus
5253 3 MichaelA
0af8 : c97f             [ 2]>            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
5254 2 MichaelA
                            >
5255
                            >            trap_ne
5256 3 MichaelA
0afa : f002             [ 3]>        beq skip0479
5257
                            >        trap           ;failed equal (zero)
5258
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5259
0afc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5260
0afd : 0d                   >        db      test_num
5261 2 MichaelA
                            >
5262 3 MichaelA
0afe :                      >skip0479
5263
                            >
5264
0afe : 28               [ 4]>            plp         ;restore status
5265 2 MichaelA
 
5266 3 MichaelA
0aff : ca               [ 2]         dex             ;ff
5267 2 MichaelA
                                     tst_x $ff,$ff-zero
5268 3 MichaelA
0b00 : 08               [ 3]>            php         ;save flags
5269
0b01 : 08               [ 3]>            php
5270
0b02 : e0ff             [ 2]>            cpx #$ff     ;test result
5271 2 MichaelA
                            >            trap_ne
5272 3 MichaelA
0b04 : f002             [ 3]>        beq skip0482
5273
                            >        trap           ;failed equal (zero)
5274
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5275
0b06 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5276
0b07 : 0d                   >        db      test_num
5277 2 MichaelA
                            >
5278 3 MichaelA
0b08 :                      >skip0482
5279
                            >
5280
0b08 : 68               [ 4]>            pla         ;load status
5281 2 MichaelA
                            >            cmp_flag $ff-zero
5282 3 MichaelA
0b09 : c9fd             [ 2]>            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
5283 2 MichaelA
                            >
5284
                            >            trap_ne
5285 3 MichaelA
0b0b : f002             [ 3]>        beq skip0485
5286
                            >        trap           ;failed equal (zero)
5287
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5288
0b0d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5289
0b0e : 0d                   >        db      test_num
5290 2 MichaelA
                            >
5291 3 MichaelA
0b0f :                      >skip0485
5292
                            >
5293
0b0f : 28               [ 4]>            plp         ;restore status
5294 2 MichaelA
 
5295 3 MichaelA
0b10 : ca               [ 2]         dex             ;fe
5296 2 MichaelA
                                     set_stat 0
5297
                            >            load_flag 0
5298 3 MichaelA
0b11 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
5299 2 MichaelA
                            >
5300 3 MichaelA
0b13 : 48               [ 3]>            pha         ;use stack to load status
5301
0b14 : 28               [ 4]>            plp
5302 2 MichaelA
 
5303 3 MichaelA
0b15 : e8               [ 2]         inx             ;ff
5304
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   93
5305
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5306
 
5307 2 MichaelA
                                     tst_x $ff,minus
5308 3 MichaelA
0b16 : 08               [ 3]>            php         ;save flags
5309
0b17 : 08               [ 3]>            php
5310
0b18 : e0ff             [ 2]>            cpx #$ff     ;test result
5311 2 MichaelA
                            >            trap_ne
5312 3 MichaelA
0b1a : f002             [ 3]>        beq skip0490
5313
                            >        trap           ;failed equal (zero)
5314
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5315
0b1c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5316
0b1d : 0d                   >        db      test_num
5317 2 MichaelA
                            >
5318 3 MichaelA
0b1e :                      >skip0490
5319
                            >
5320
0b1e : 68               [ 4]>            pla         ;load status
5321 2 MichaelA
                            >            cmp_flag minus
5322 3 MichaelA
0b1f : c9b0             [ 2]>            cmp #(minus|fao)&m8    ;expected flags + always on bits
5323 2 MichaelA
                            >
5324
                            >            trap_ne
5325 3 MichaelA
0b21 : f002             [ 3]>        beq skip0493
5326
                            >        trap           ;failed equal (zero)
5327
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5328
0b23 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5329
0b24 : 0d                   >        db      test_num
5330 2 MichaelA
                            >
5331 3 MichaelA
0b25 :                      >skip0493
5332
                            >
5333
0b25 : 28               [ 4]>            plp         ;restore status
5334 2 MichaelA
 
5335 3 MichaelA
0b26 : e8               [ 2]         inx             ;00
5336 2 MichaelA
                                     tst_x 0,zero
5337 3 MichaelA
0b27 : 08               [ 3]>            php         ;save flags
5338
0b28 : 08               [ 3]>            php
5339
0b29 : e000             [ 2]>            cpx #0     ;test result
5340 2 MichaelA
                            >            trap_ne
5341 3 MichaelA
0b2b : f002             [ 3]>        beq skip0496
5342
                            >        trap           ;failed equal (zero)
5343
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5344
0b2d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5345
0b2e : 0d                   >        db      test_num
5346 2 MichaelA
                            >
5347 3 MichaelA
0b2f :                      >skip0496
5348
                            >
5349
0b2f : 68               [ 4]>            pla         ;load status
5350 2 MichaelA
                            >            cmp_flag zero
5351 3 MichaelA
0b30 : c932             [ 2]>            cmp #(zero|fao)&m8    ;expected flags + always on bits
5352 2 MichaelA
                            >
5353
                            >            trap_ne
5354 3 MichaelA
0b32 : f002             [ 3]>        beq skip0499
5355
                            >        trap           ;failed equal (zero)
5356
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5357
0b34 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5358
0b35 : 0d                   >        db      test_num
5359 2 MichaelA
                            >
5360 3 MichaelA
0b36 :                      >skip0499
5361
                            >
5362
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   94
5363
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5364
 
5365
0b36 : 28               [ 4]>            plp         ;restore status
5366 2 MichaelA
 
5367 3 MichaelA
0b37 : e8               [ 2]         inx             ;01
5368 2 MichaelA
                                     tst_x 1,0
5369 3 MichaelA
0b38 : 08               [ 3]>            php         ;save flags
5370
0b39 : 08               [ 3]>            php
5371
0b3a : e001             [ 2]>            cpx #1     ;test result
5372 2 MichaelA
                            >            trap_ne
5373 3 MichaelA
0b3c : f002             [ 3]>        beq skip0502
5374
                            >        trap           ;failed equal (zero)
5375
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5376
0b3e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5377
0b3f : 0d                   >        db      test_num
5378 2 MichaelA
                            >
5379 3 MichaelA
0b40 :                      >skip0502
5380
                            >
5381
0b40 : 68               [ 4]>            pla         ;load status
5382 2 MichaelA
                            >            cmp_flag 0
5383 3 MichaelA
0b41 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
5384 2 MichaelA
                            >
5385
                            >            trap_ne
5386 3 MichaelA
0b43 : f002             [ 3]>        beq skip0505
5387
                            >        trap           ;failed equal (zero)
5388
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5389
0b45 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5390
0b46 : 0d                   >        db      test_num
5391 2 MichaelA
                            >
5392 3 MichaelA
0b47 :                      >skip0505
5393
                            >
5394
0b47 : 28               [ 4]>            plp         ;restore status
5395 2 MichaelA
 
5396 3 MichaelA
0b48 : ca               [ 2]         dex             ;00
5397 2 MichaelA
                                     tst_x 0,zero
5398 3 MichaelA
0b49 : 08               [ 3]>            php         ;save flags
5399
0b4a : 08               [ 3]>            php
5400
0b4b : e000             [ 2]>            cpx #0     ;test result
5401 2 MichaelA
                            >            trap_ne
5402 3 MichaelA
0b4d : f002             [ 3]>        beq skip0508
5403
                            >        trap           ;failed equal (zero)
5404
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5405
0b4f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5406
0b50 : 0d                   >        db      test_num
5407 2 MichaelA
                            >
5408 3 MichaelA
0b51 :                      >skip0508
5409
                            >
5410
0b51 : 68               [ 4]>            pla         ;load status
5411 2 MichaelA
                            >            cmp_flag zero
5412 3 MichaelA
0b52 : c932             [ 2]>            cmp #(zero|fao)&m8    ;expected flags + always on bits
5413 2 MichaelA
                            >
5414
                            >            trap_ne
5415 3 MichaelA
0b54 : f002             [ 3]>        beq skip0511
5416
                            >        trap           ;failed equal (zero)
5417
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5418
0b56 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5419
0b57 : 0d                   >        db      test_num
5420
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   95
5421
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5422
 
5423 2 MichaelA
                            >
5424 3 MichaelA
0b58 :                      >skip0511
5425
                            >
5426
0b58 : 28               [ 4]>            plp         ;restore status
5427 2 MichaelA
 
5428 3 MichaelA
0b59 : ca               [ 2]         dex             ;ff
5429 2 MichaelA
                                     tst_x $ff,minus
5430 3 MichaelA
0b5a : 08               [ 3]>            php         ;save flags
5431
0b5b : 08               [ 3]>            php
5432
0b5c : e0ff             [ 2]>            cpx #$ff     ;test result
5433 2 MichaelA
                            >            trap_ne
5434 3 MichaelA
0b5e : f002             [ 3]>        beq skip0514
5435
                            >        trap           ;failed equal (zero)
5436
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5437
0b60 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5438
0b61 : 0d                   >        db      test_num
5439 2 MichaelA
                            >
5440 3 MichaelA
0b62 :                      >skip0514
5441
                            >
5442
0b62 : 68               [ 4]>            pla         ;load status
5443 2 MichaelA
                            >            cmp_flag minus
5444 3 MichaelA
0b63 : c9b0             [ 2]>            cmp #(minus|fao)&m8    ;expected flags + always on bits
5445 2 MichaelA
                            >
5446
                            >            trap_ne
5447 3 MichaelA
0b65 : f002             [ 3]>        beq skip0517
5448
                            >        trap           ;failed equal (zero)
5449
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5450
0b67 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5451
0b68 : 0d                   >        db      test_num
5452 2 MichaelA
                            >
5453 3 MichaelA
0b69 :                      >skip0517
5454
                            >
5455
0b69 : 28               [ 4]>            plp         ;restore status
5456 2 MichaelA
 
5457
 
5458 3 MichaelA
0b6a : a0fe             [ 2]         ldy #$fe
5459 2 MichaelA
                                     set_stat $ff
5460
                            >            load_flag $ff
5461 3 MichaelA
0b6c : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
5462 2 MichaelA
                            >
5463 3 MichaelA
0b6e : 48               [ 3]>            pha         ;use stack to load status
5464
0b6f : 28               [ 4]>            plp
5465 2 MichaelA
 
5466 3 MichaelA
0b70 : c8               [ 2]         iny             ;ff
5467 2 MichaelA
                                     tst_y $ff,$ff-zero
5468 3 MichaelA
0b71 : 08               [ 3]>            php         ;save flags
5469
0b72 : 08               [ 3]>            php
5470
0b73 : c0ff             [ 2]>            cpy #$ff     ;test result
5471 2 MichaelA
                            >            trap_ne
5472 3 MichaelA
0b75 : f002             [ 3]>        beq skip0522
5473
                            >        trap           ;failed equal (zero)
5474
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5475
0b77 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5476
0b78 : 0d                   >        db      test_num
5477
                            >
5478
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   96
5479 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5480
 
5481 3 MichaelA
0b79 :                      >skip0522
5482 2 MichaelA
                            >
5483 3 MichaelA
0b79 : 68               [ 4]>            pla         ;load status
5484 2 MichaelA
                            >            cmp_flag $ff-zero
5485 3 MichaelA
0b7a : c9fd             [ 2]>            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
5486 2 MichaelA
                            >
5487
                            >            trap_ne
5488 3 MichaelA
0b7c : f002             [ 3]>        beq skip0525
5489
                            >        trap           ;failed equal (zero)
5490
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5491
0b7e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5492
0b7f : 0d                   >        db      test_num
5493 2 MichaelA
                            >
5494 3 MichaelA
0b80 :                      >skip0525
5495
                            >
5496
0b80 : 28               [ 4]>            plp         ;restore status
5497 2 MichaelA
 
5498 3 MichaelA
0b81 : c8               [ 2]         iny             ;00
5499 2 MichaelA
                                     tst_y 0,$ff-minus
5500 3 MichaelA
0b82 : 08               [ 3]>            php         ;save flags
5501
0b83 : 08               [ 3]>            php
5502
0b84 : c000             [ 2]>            cpy #0     ;test result
5503 2 MichaelA
                            >            trap_ne
5504 3 MichaelA
0b86 : f002             [ 3]>        beq skip0528
5505
                            >        trap           ;failed equal (zero)
5506
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5507
0b88 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5508
0b89 : 0d                   >        db      test_num
5509 2 MichaelA
                            >
5510 3 MichaelA
0b8a :                      >skip0528
5511
                            >
5512
0b8a : 68               [ 4]>            pla         ;load status
5513 2 MichaelA
                            >            cmp_flag $ff-minus
5514 3 MichaelA
0b8b : c97f             [ 2]>            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
5515 2 MichaelA
                            >
5516
                            >            trap_ne
5517 3 MichaelA
0b8d : f002             [ 3]>        beq skip0531
5518
                            >        trap           ;failed equal (zero)
5519
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5520
0b8f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5521
0b90 : 0d                   >        db      test_num
5522 2 MichaelA
                            >
5523 3 MichaelA
0b91 :                      >skip0531
5524
                            >
5525
0b91 : 28               [ 4]>            plp         ;restore status
5526 2 MichaelA
 
5527 3 MichaelA
0b92 : c8               [ 2]         iny             ;01
5528 2 MichaelA
                                     tst_y 1,$ff-minus-zero
5529 3 MichaelA
0b93 : 08               [ 3]>            php         ;save flags
5530
0b94 : 08               [ 3]>            php
5531
0b95 : c001             [ 2]>            cpy #1     ;test result
5532 2 MichaelA
                            >            trap_ne
5533 3 MichaelA
0b97 : f002             [ 3]>        beq skip0534
5534
                            >        trap           ;failed equal (zero)
5535
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5536
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   97
5537
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5538
 
5539
0b99 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5540
0b9a : 0d                   >        db      test_num
5541 2 MichaelA
                            >
5542 3 MichaelA
0b9b :                      >skip0534
5543
                            >
5544
0b9b : 68               [ 4]>            pla         ;load status
5545 2 MichaelA
                            >            cmp_flag $ff-minus-zero
5546 3 MichaelA
0b9c : c97d             [ 2]>            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
5547 2 MichaelA
                            >
5548
                            >            trap_ne
5549 3 MichaelA
0b9e : f002             [ 3]>        beq skip0537
5550
                            >        trap           ;failed equal (zero)
5551
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5552
0ba0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5553
0ba1 : 0d                   >        db      test_num
5554 2 MichaelA
                            >
5555 3 MichaelA
0ba2 :                      >skip0537
5556
                            >
5557
0ba2 : 28               [ 4]>            plp         ;restore status
5558 2 MichaelA
 
5559 3 MichaelA
0ba3 : 88               [ 2]         dey             ;00
5560 2 MichaelA
                                     tst_y 0,$ff-minus
5561 3 MichaelA
0ba4 : 08               [ 3]>            php         ;save flags
5562
0ba5 : 08               [ 3]>            php
5563
0ba6 : c000             [ 2]>            cpy #0     ;test result
5564 2 MichaelA
                            >            trap_ne
5565 3 MichaelA
0ba8 : f002             [ 3]>        beq skip0540
5566
                            >        trap           ;failed equal (zero)
5567
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5568
0baa : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5569
0bab : 0d                   >        db      test_num
5570 2 MichaelA
                            >
5571 3 MichaelA
0bac :                      >skip0540
5572
                            >
5573
0bac : 68               [ 4]>            pla         ;load status
5574 2 MichaelA
                            >            cmp_flag $ff-minus
5575 3 MichaelA
0bad : c97f             [ 2]>            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
5576 2 MichaelA
                            >
5577
                            >            trap_ne
5578 3 MichaelA
0baf : f002             [ 3]>        beq skip0543
5579
                            >        trap           ;failed equal (zero)
5580
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5581
0bb1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5582
0bb2 : 0d                   >        db      test_num
5583 2 MichaelA
                            >
5584 3 MichaelA
0bb3 :                      >skip0543
5585
                            >
5586
0bb3 : 28               [ 4]>            plp         ;restore status
5587 2 MichaelA
 
5588 3 MichaelA
0bb4 : 88               [ 2]         dey             ;ff
5589 2 MichaelA
                                     tst_y $ff,$ff-zero
5590 3 MichaelA
0bb5 : 08               [ 3]>            php         ;save flags
5591
0bb6 : 08               [ 3]>            php
5592
0bb7 : c0ff             [ 2]>            cpy #$ff     ;test result
5593 2 MichaelA
                            >            trap_ne
5594 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   98
5595
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5596
 
5597
0bb9 : f002             [ 3]>        beq skip0546
5598
                            >        trap           ;failed equal (zero)
5599
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5600
0bbb : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5601
0bbc : 0d                   >        db      test_num
5602 2 MichaelA
                            >
5603 3 MichaelA
0bbd :                      >skip0546
5604
                            >
5605
0bbd : 68               [ 4]>            pla         ;load status
5606 2 MichaelA
                            >            cmp_flag $ff-zero
5607 3 MichaelA
0bbe : c9fd             [ 2]>            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
5608 2 MichaelA
                            >
5609
                            >            trap_ne
5610 3 MichaelA
0bc0 : f002             [ 3]>        beq skip0549
5611
                            >        trap           ;failed equal (zero)
5612
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5613
0bc2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5614
0bc3 : 0d                   >        db      test_num
5615 2 MichaelA
                            >
5616 3 MichaelA
0bc4 :                      >skip0549
5617
                            >
5618
0bc4 : 28               [ 4]>            plp         ;restore status
5619 2 MichaelA
 
5620 3 MichaelA
0bc5 : 88               [ 2]         dey             ;fe
5621 2 MichaelA
                                     set_stat 0
5622
                            >            load_flag 0
5623 3 MichaelA
0bc6 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
5624 2 MichaelA
                            >
5625 3 MichaelA
0bc8 : 48               [ 3]>            pha         ;use stack to load status
5626
0bc9 : 28               [ 4]>            plp
5627 2 MichaelA
 
5628 3 MichaelA
0bca : c8               [ 2]         iny             ;ff
5629 2 MichaelA
                                     tst_y $ff,0+minus
5630 3 MichaelA
0bcb : 08               [ 3]>            php         ;save flags
5631
0bcc : 08               [ 3]>            php
5632
0bcd : c0ff             [ 2]>            cpy #$ff     ;test result
5633 2 MichaelA
                            >            trap_ne
5634 3 MichaelA
0bcf : f002             [ 3]>        beq skip0554
5635
                            >        trap           ;failed equal (zero)
5636
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5637
0bd1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5638
0bd2 : 0d                   >        db      test_num
5639 2 MichaelA
                            >
5640 3 MichaelA
0bd3 :                      >skip0554
5641
                            >
5642
0bd3 : 68               [ 4]>            pla         ;load status
5643 2 MichaelA
                            >            cmp_flag 0+minus
5644 3 MichaelA
0bd4 : c9b0             [ 2]>            cmp #(0+minus|fao)&m8    ;expected flags + always on bits
5645 2 MichaelA
                            >
5646
                            >            trap_ne
5647 3 MichaelA
0bd6 : f002             [ 3]>        beq skip0557
5648
                            >        trap           ;failed equal (zero)
5649
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5650
0bd8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5651
0bd9 : 0d                   >        db      test_num
5652
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page   99
5653
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5654
 
5655 2 MichaelA
                            >
5656 3 MichaelA
0bda :                      >skip0557
5657
                            >
5658
0bda : 28               [ 4]>            plp         ;restore status
5659 2 MichaelA
 
5660 3 MichaelA
0bdb : c8               [ 2]         iny             ;00
5661 2 MichaelA
                                     tst_y 0,zero
5662 3 MichaelA
0bdc : 08               [ 3]>            php         ;save flags
5663
0bdd : 08               [ 3]>            php
5664
0bde : c000             [ 2]>            cpy #0     ;test result
5665 2 MichaelA
                            >            trap_ne
5666 3 MichaelA
0be0 : f002             [ 3]>        beq skip0560
5667
                            >        trap           ;failed equal (zero)
5668
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5669
0be2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5670
0be3 : 0d                   >        db      test_num
5671 2 MichaelA
                            >
5672 3 MichaelA
0be4 :                      >skip0560
5673
                            >
5674
0be4 : 68               [ 4]>            pla         ;load status
5675 2 MichaelA
                            >            cmp_flag zero
5676 3 MichaelA
0be5 : c932             [ 2]>            cmp #(zero|fao)&m8    ;expected flags + always on bits
5677 2 MichaelA
                            >
5678
                            >            trap_ne
5679 3 MichaelA
0be7 : f002             [ 3]>        beq skip0563
5680
                            >        trap           ;failed equal (zero)
5681
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5682
0be9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5683
0bea : 0d                   >        db      test_num
5684 2 MichaelA
                            >
5685 3 MichaelA
0beb :                      >skip0563
5686
                            >
5687
0beb : 28               [ 4]>            plp         ;restore status
5688 2 MichaelA
 
5689 3 MichaelA
0bec : c8               [ 2]         iny             ;01
5690 2 MichaelA
                                     tst_y 1,0
5691 3 MichaelA
0bed : 08               [ 3]>            php         ;save flags
5692
0bee : 08               [ 3]>            php
5693
0bef : c001             [ 2]>            cpy #1     ;test result
5694 2 MichaelA
                            >            trap_ne
5695 3 MichaelA
0bf1 : f002             [ 3]>        beq skip0566
5696
                            >        trap           ;failed equal (zero)
5697
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5698
0bf3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5699
0bf4 : 0d                   >        db      test_num
5700 2 MichaelA
                            >
5701 3 MichaelA
0bf5 :                      >skip0566
5702
                            >
5703
0bf5 : 68               [ 4]>            pla         ;load status
5704 2 MichaelA
                            >            cmp_flag 0
5705 3 MichaelA
0bf6 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
5706 2 MichaelA
                            >
5707
                            >            trap_ne
5708 3 MichaelA
0bf8 : f002             [ 3]>        beq skip0569
5709
                            >        trap           ;failed equal (zero)
5710
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  100
5711
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5712
 
5713
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5714
0bfa : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5715
0bfb : 0d                   >        db      test_num
5716 2 MichaelA
                            >
5717 3 MichaelA
0bfc :                      >skip0569
5718
                            >
5719
0bfc : 28               [ 4]>            plp         ;restore status
5720 2 MichaelA
 
5721 3 MichaelA
0bfd : 88               [ 2]         dey             ;00
5722 2 MichaelA
                                     tst_y 0,zero
5723 3 MichaelA
0bfe : 08               [ 3]>            php         ;save flags
5724
0bff : 08               [ 3]>            php
5725
0c00 : c000             [ 2]>            cpy #0     ;test result
5726 2 MichaelA
                            >            trap_ne
5727 3 MichaelA
0c02 : f002             [ 3]>        beq skip0572
5728
                            >        trap           ;failed equal (zero)
5729
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5730
0c04 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5731
0c05 : 0d                   >        db      test_num
5732 2 MichaelA
                            >
5733 3 MichaelA
0c06 :                      >skip0572
5734
                            >
5735
0c06 : 68               [ 4]>            pla         ;load status
5736 2 MichaelA
                            >            cmp_flag zero
5737 3 MichaelA
0c07 : c932             [ 2]>            cmp #(zero|fao)&m8    ;expected flags + always on bits
5738 2 MichaelA
                            >
5739
                            >            trap_ne
5740 3 MichaelA
0c09 : f002             [ 3]>        beq skip0575
5741
                            >        trap           ;failed equal (zero)
5742
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5743
0c0b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5744
0c0c : 0d                   >        db      test_num
5745 2 MichaelA
                            >
5746 3 MichaelA
0c0d :                      >skip0575
5747
                            >
5748
0c0d : 28               [ 4]>            plp         ;restore status
5749 2 MichaelA
 
5750 3 MichaelA
0c0e : 88               [ 2]         dey             ;ff
5751 2 MichaelA
                                     tst_y $ff,minus
5752 3 MichaelA
0c0f : 08               [ 3]>            php         ;save flags
5753
0c10 : 08               [ 3]>            php
5754
0c11 : c0ff             [ 2]>            cpy #$ff     ;test result
5755 2 MichaelA
                            >            trap_ne
5756 3 MichaelA
0c13 : f002             [ 3]>        beq skip0578
5757
                            >        trap           ;failed equal (zero)
5758
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5759
0c15 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5760
0c16 : 0d                   >        db      test_num
5761 2 MichaelA
                            >
5762 3 MichaelA
0c17 :                      >skip0578
5763
                            >
5764
0c17 : 68               [ 4]>            pla         ;load status
5765 2 MichaelA
                            >            cmp_flag minus
5766 3 MichaelA
0c18 : c9b0             [ 2]>            cmp #(minus|fao)&m8    ;expected flags + always on bits
5767
                            >
5768
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  101
5769 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5770
 
5771
                            >            trap_ne
5772 3 MichaelA
0c1a : f002             [ 3]>        beq skip0581
5773
                            >        trap           ;failed equal (zero)
5774
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5775
0c1c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5776
0c1d : 0d                   >        db      test_num
5777 2 MichaelA
                            >
5778 3 MichaelA
0c1e :                      >skip0581
5779
                            >
5780
0c1e : 28               [ 4]>            plp         ;restore status
5781 2 MichaelA
 
5782
 
5783 3 MichaelA
0c1f : a2ff             [ 2]         ldx #$ff
5784 2 MichaelA
                                     set_stat $ff
5785
                            >            load_flag $ff
5786 3 MichaelA
0c21 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
5787 2 MichaelA
                            >
5788 3 MichaelA
0c23 : 48               [ 3]>            pha         ;use stack to load status
5789
0c24 : 28               [ 4]>            plp
5790 2 MichaelA
 
5791 3 MichaelA
0c25 : 8a               [ 2]         txa
5792 2 MichaelA
                                     tst_a $ff,$ff-zero
5793 3 MichaelA
0c26 : 08               [ 3]>            php         ;save flags
5794
0c27 : 08               [ 3]>            php
5795
0c28 : c9ff             [ 2]>            cmp #$ff     ;test result
5796 2 MichaelA
                            >            trap_ne
5797 3 MichaelA
0c2a : f002             [ 3]>        beq skip0586
5798
                            >        trap           ;failed equal (zero)
5799
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5800
0c2c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5801
0c2d : 0d                   >        db      test_num
5802 2 MichaelA
                            >
5803 3 MichaelA
0c2e :                      >skip0586
5804
                            >
5805
0c2e : 68               [ 4]>            pla         ;load status
5806 2 MichaelA
                            >            cmp_flag $ff-zero
5807 3 MichaelA
0c2f : c9fd             [ 2]>            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
5808 2 MichaelA
                            >
5809
                            >            trap_ne
5810 3 MichaelA
0c31 : f002             [ 3]>        beq skip0589
5811
                            >        trap           ;failed equal (zero)
5812
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5813
0c33 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5814
0c34 : 0d                   >        db      test_num
5815 2 MichaelA
                            >
5816 3 MichaelA
0c35 :                      >skip0589
5817
                            >
5818
0c35 : 28               [ 4]>            plp         ;restore status
5819 2 MichaelA
 
5820 3 MichaelA
0c36 : 08               [ 3]         php
5821
0c37 : e8               [ 2]         inx             ;00
5822
0c38 : 28               [ 4]         plp
5823
0c39 : 8a               [ 2]         txa
5824 2 MichaelA
                                     tst_a 0,$ff-minus
5825 3 MichaelA
0c3a : 08               [ 3]>            php         ;save flags
5826
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  102
5827
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5828
 
5829
0c3b : 08               [ 3]>            php
5830
0c3c : c900             [ 2]>            cmp #0     ;test result
5831 2 MichaelA
                            >            trap_ne
5832 3 MichaelA
0c3e : f002             [ 3]>        beq skip0592
5833
                            >        trap           ;failed equal (zero)
5834
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5835
0c40 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5836
0c41 : 0d                   >        db      test_num
5837 2 MichaelA
                            >
5838 3 MichaelA
0c42 :                      >skip0592
5839
                            >
5840
0c42 : 68               [ 4]>            pla         ;load status
5841 2 MichaelA
                            >            cmp_flag $ff-minus
5842 3 MichaelA
0c43 : c97f             [ 2]>            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
5843 2 MichaelA
                            >
5844
                            >            trap_ne
5845 3 MichaelA
0c45 : f002             [ 3]>        beq skip0595
5846
                            >        trap           ;failed equal (zero)
5847
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5848
0c47 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5849
0c48 : 0d                   >        db      test_num
5850 2 MichaelA
                            >
5851 3 MichaelA
0c49 :                      >skip0595
5852
                            >
5853
0c49 : 28               [ 4]>            plp         ;restore status
5854 2 MichaelA
 
5855 3 MichaelA
0c4a : 08               [ 3]         php
5856
0c4b : e8               [ 2]         inx             ;01
5857
0c4c : 28               [ 4]         plp
5858
0c4d : 8a               [ 2]         txa
5859 2 MichaelA
                                     tst_a 1,$ff-minus-zero
5860 3 MichaelA
0c4e : 08               [ 3]>            php         ;save flags
5861
0c4f : 08               [ 3]>            php
5862
0c50 : c901             [ 2]>            cmp #1     ;test result
5863 2 MichaelA
                            >            trap_ne
5864 3 MichaelA
0c52 : f002             [ 3]>        beq skip0598
5865
                            >        trap           ;failed equal (zero)
5866
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5867
0c54 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5868
0c55 : 0d                   >        db      test_num
5869 2 MichaelA
                            >
5870 3 MichaelA
0c56 :                      >skip0598
5871
                            >
5872
0c56 : 68               [ 4]>            pla         ;load status
5873 2 MichaelA
                            >            cmp_flag $ff-minus-zero
5874 3 MichaelA
0c57 : c97d             [ 2]>            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
5875 2 MichaelA
                            >
5876
                            >            trap_ne
5877 3 MichaelA
0c59 : f002             [ 3]>        beq skip0601
5878
                            >        trap           ;failed equal (zero)
5879
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5880
0c5b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5881
0c5c : 0d                   >        db      test_num
5882 2 MichaelA
                            >
5883 3 MichaelA
0c5d :                      >skip0601
5884
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  103
5885
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5886
 
5887
                            >
5888
0c5d : 28               [ 4]>            plp         ;restore status
5889 2 MichaelA
 
5890
                                     set_stat 0
5891
                            >            load_flag 0
5892 3 MichaelA
0c5e : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
5893 2 MichaelA
                            >
5894 3 MichaelA
0c60 : 48               [ 3]>            pha         ;use stack to load status
5895
0c61 : 28               [ 4]>            plp
5896 2 MichaelA
 
5897 3 MichaelA
0c62 : 8a               [ 2]         txa
5898 2 MichaelA
                                     tst_a 1,0
5899 3 MichaelA
0c63 : 08               [ 3]>            php         ;save flags
5900
0c64 : 08               [ 3]>            php
5901
0c65 : c901             [ 2]>            cmp #1     ;test result
5902 2 MichaelA
                            >            trap_ne
5903 3 MichaelA
0c67 : f002             [ 3]>        beq skip0606
5904
                            >        trap           ;failed equal (zero)
5905
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5906
0c69 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5907
0c6a : 0d                   >        db      test_num
5908 2 MichaelA
                            >
5909 3 MichaelA
0c6b :                      >skip0606
5910
                            >
5911
0c6b : 68               [ 4]>            pla         ;load status
5912 2 MichaelA
                            >            cmp_flag 0
5913 3 MichaelA
0c6c : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
5914 2 MichaelA
                            >
5915
                            >            trap_ne
5916 3 MichaelA
0c6e : f002             [ 3]>        beq skip0609
5917
                            >        trap           ;failed equal (zero)
5918
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5919
0c70 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5920
0c71 : 0d                   >        db      test_num
5921 2 MichaelA
                            >
5922 3 MichaelA
0c72 :                      >skip0609
5923
                            >
5924
0c72 : 28               [ 4]>            plp         ;restore status
5925 2 MichaelA
 
5926 3 MichaelA
0c73 : 08               [ 3]         php
5927
0c74 : ca               [ 2]         dex             ;00
5928
0c75 : 28               [ 4]         plp
5929
0c76 : 8a               [ 2]         txa
5930 2 MichaelA
                                     tst_a 0,zero
5931 3 MichaelA
0c77 : 08               [ 3]>            php         ;save flags
5932
0c78 : 08               [ 3]>            php
5933
0c79 : c900             [ 2]>            cmp #0     ;test result
5934 2 MichaelA
                            >            trap_ne
5935 3 MichaelA
0c7b : f002             [ 3]>        beq skip0612
5936
                            >        trap           ;failed equal (zero)
5937
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5938
0c7d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5939
0c7e : 0d                   >        db      test_num
5940 2 MichaelA
                            >
5941 3 MichaelA
0c7f :                      >skip0612
5942
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  104
5943 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
5944
 
5945
                            >
5946 3 MichaelA
0c7f : 68               [ 4]>            pla         ;load status
5947
                            >            cmp_flag zero
5948
0c80 : c932             [ 2]>            cmp #(zero|fao)&m8    ;expected flags + always on bits
5949
                            >
5950 2 MichaelA
                            >            trap_ne
5951 3 MichaelA
0c82 : f002             [ 3]>        beq skip0615
5952
                            >        trap           ;failed equal (zero)
5953
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5954
0c84 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5955
0c85 : 0d                   >        db      test_num
5956 2 MichaelA
                            >
5957 3 MichaelA
0c86 :                      >skip0615
5958
                            >
5959
0c86 : 28               [ 4]>            plp         ;restore status
5960 2 MichaelA
 
5961 3 MichaelA
0c87 : 08               [ 3]         php
5962
0c88 : ca               [ 2]         dex             ;ff
5963
0c89 : 28               [ 4]         plp
5964
0c8a : 8a               [ 2]         txa
5965 2 MichaelA
                                     tst_a $ff,minus
5966 3 MichaelA
0c8b : 08               [ 3]>            php         ;save flags
5967
0c8c : 08               [ 3]>            php
5968
0c8d : c9ff             [ 2]>            cmp #$ff     ;test result
5969 2 MichaelA
                            >            trap_ne
5970 3 MichaelA
0c8f : f002             [ 3]>        beq skip0618
5971
                            >        trap           ;failed equal (zero)
5972
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5973
0c91 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5974
0c92 : 0d                   >        db      test_num
5975 2 MichaelA
                            >
5976 3 MichaelA
0c93 :                      >skip0618
5977
                            >
5978
0c93 : 68               [ 4]>            pla         ;load status
5979 2 MichaelA
                            >            cmp_flag minus
5980 3 MichaelA
0c94 : c9b0             [ 2]>            cmp #(minus|fao)&m8    ;expected flags + always on bits
5981 2 MichaelA
                            >
5982
                            >            trap_ne
5983 3 MichaelA
0c96 : f002             [ 3]>        beq skip0621
5984
                            >        trap           ;failed equal (zero)
5985
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
5986
0c98 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
5987
0c99 : 0d                   >        db      test_num
5988 2 MichaelA
                            >
5989 3 MichaelA
0c9a :                      >skip0621
5990
                            >
5991
0c9a : 28               [ 4]>            plp         ;restore status
5992 2 MichaelA
 
5993
 
5994 3 MichaelA
0c9b : a0ff             [ 2]         ldy #$ff
5995 2 MichaelA
                                     set_stat $ff
5996
                            >            load_flag $ff
5997 3 MichaelA
0c9d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
5998 2 MichaelA
                            >
5999 3 MichaelA
0c9f : 48               [ 3]>            pha         ;use stack to load status
6000
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  105
6001
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6002
 
6003
0ca0 : 28               [ 4]>            plp
6004 2 MichaelA
 
6005 3 MichaelA
0ca1 : 98               [ 2]         tya
6006 2 MichaelA
                                     tst_a $ff,$ff-zero
6007 3 MichaelA
0ca2 : 08               [ 3]>            php         ;save flags
6008
0ca3 : 08               [ 3]>            php
6009
0ca4 : c9ff             [ 2]>            cmp #$ff     ;test result
6010 2 MichaelA
                            >            trap_ne
6011 3 MichaelA
0ca6 : f002             [ 3]>        beq skip0626
6012
                            >        trap           ;failed equal (zero)
6013
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6014
0ca8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6015
0ca9 : 0d                   >        db      test_num
6016 2 MichaelA
                            >
6017 3 MichaelA
0caa :                      >skip0626
6018
                            >
6019
0caa : 68               [ 4]>            pla         ;load status
6020 2 MichaelA
                            >            cmp_flag $ff-zero
6021 3 MichaelA
0cab : c9fd             [ 2]>            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
6022 2 MichaelA
                            >
6023
                            >            trap_ne
6024 3 MichaelA
0cad : f002             [ 3]>        beq skip0629
6025
                            >        trap           ;failed equal (zero)
6026
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6027
0caf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6028
0cb0 : 0d                   >        db      test_num
6029 2 MichaelA
                            >
6030 3 MichaelA
0cb1 :                      >skip0629
6031
                            >
6032
0cb1 : 28               [ 4]>            plp         ;restore status
6033 2 MichaelA
 
6034 3 MichaelA
0cb2 : 08               [ 3]         php
6035
0cb3 : c8               [ 2]         iny             ;00
6036
0cb4 : 28               [ 4]         plp
6037
0cb5 : 98               [ 2]         tya
6038 2 MichaelA
                                     tst_a 0,$ff-minus
6039 3 MichaelA
0cb6 : 08               [ 3]>            php         ;save flags
6040
0cb7 : 08               [ 3]>            php
6041
0cb8 : c900             [ 2]>            cmp #0     ;test result
6042 2 MichaelA
                            >            trap_ne
6043 3 MichaelA
0cba : f002             [ 3]>        beq skip0632
6044
                            >        trap           ;failed equal (zero)
6045
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6046
0cbc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6047
0cbd : 0d                   >        db      test_num
6048 2 MichaelA
                            >
6049 3 MichaelA
0cbe :                      >skip0632
6050
                            >
6051
0cbe : 68               [ 4]>            pla         ;load status
6052 2 MichaelA
                            >            cmp_flag $ff-minus
6053 3 MichaelA
0cbf : c97f             [ 2]>            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
6054 2 MichaelA
                            >
6055
                            >            trap_ne
6056 3 MichaelA
0cc1 : f002             [ 3]>        beq skip0635
6057
                            >        trap           ;failed equal (zero)
6058
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  106
6059
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6060
 
6061
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6062
0cc3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6063
0cc4 : 0d                   >        db      test_num
6064 2 MichaelA
                            >
6065 3 MichaelA
0cc5 :                      >skip0635
6066
                            >
6067
0cc5 : 28               [ 4]>            plp         ;restore status
6068 2 MichaelA
 
6069 3 MichaelA
0cc6 : 08               [ 3]         php
6070
0cc7 : c8               [ 2]         iny             ;01
6071
0cc8 : 28               [ 4]         plp
6072
0cc9 : 98               [ 2]         tya
6073 2 MichaelA
                                     tst_a 1,$ff-minus-zero
6074 3 MichaelA
0cca : 08               [ 3]>            php         ;save flags
6075
0ccb : 08               [ 3]>            php
6076
0ccc : c901             [ 2]>            cmp #1     ;test result
6077 2 MichaelA
                            >            trap_ne
6078 3 MichaelA
0cce : f002             [ 3]>        beq skip0638
6079
                            >        trap           ;failed equal (zero)
6080
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6081
0cd0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6082
0cd1 : 0d                   >        db      test_num
6083 2 MichaelA
                            >
6084 3 MichaelA
0cd2 :                      >skip0638
6085
                            >
6086
0cd2 : 68               [ 4]>            pla         ;load status
6087 2 MichaelA
                            >            cmp_flag $ff-minus-zero
6088 3 MichaelA
0cd3 : c97d             [ 2]>            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
6089 2 MichaelA
                            >
6090
                            >            trap_ne
6091 3 MichaelA
0cd5 : f002             [ 3]>        beq skip0641
6092
                            >        trap           ;failed equal (zero)
6093
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6094
0cd7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6095
0cd8 : 0d                   >        db      test_num
6096 2 MichaelA
                            >
6097 3 MichaelA
0cd9 :                      >skip0641
6098
                            >
6099
0cd9 : 28               [ 4]>            plp         ;restore status
6100 2 MichaelA
 
6101
                                     set_stat 0
6102
                            >            load_flag 0
6103 3 MichaelA
0cda : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
6104 2 MichaelA
                            >
6105 3 MichaelA
0cdc : 48               [ 3]>            pha         ;use stack to load status
6106
0cdd : 28               [ 4]>            plp
6107 2 MichaelA
 
6108 3 MichaelA
0cde : 98               [ 2]         tya
6109 2 MichaelA
                                     tst_a 1,0
6110 3 MichaelA
0cdf : 08               [ 3]>            php         ;save flags
6111
0ce0 : 08               [ 3]>            php
6112
0ce1 : c901             [ 2]>            cmp #1     ;test result
6113 2 MichaelA
                            >            trap_ne
6114 3 MichaelA
0ce3 : f002             [ 3]>        beq skip0646
6115
                            >        trap           ;failed equal (zero)
6116
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  107
6117 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6118
 
6119 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6120
0ce5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6121
0ce6 : 0d                   >        db      test_num
6122 2 MichaelA
                            >
6123 3 MichaelA
0ce7 :                      >skip0646
6124
                            >
6125
0ce7 : 68               [ 4]>            pla         ;load status
6126
                            >            cmp_flag 0
6127
0ce8 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
6128
                            >
6129 2 MichaelA
                            >            trap_ne
6130 3 MichaelA
0cea : f002             [ 3]>        beq skip0649
6131
                            >        trap           ;failed equal (zero)
6132
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6133
0cec : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6134
0ced : 0d                   >        db      test_num
6135 2 MichaelA
                            >
6136 3 MichaelA
0cee :                      >skip0649
6137
                            >
6138
0cee : 28               [ 4]>            plp         ;restore status
6139 2 MichaelA
 
6140 3 MichaelA
0cef : 08               [ 3]         php
6141
0cf0 : 88               [ 2]         dey             ;00
6142
0cf1 : 28               [ 4]         plp
6143
0cf2 : 98               [ 2]         tya
6144 2 MichaelA
                                     tst_a 0,zero
6145 3 MichaelA
0cf3 : 08               [ 3]>            php         ;save flags
6146
0cf4 : 08               [ 3]>            php
6147
0cf5 : c900             [ 2]>            cmp #0     ;test result
6148 2 MichaelA
                            >            trap_ne
6149 3 MichaelA
0cf7 : f002             [ 3]>        beq skip0652
6150
                            >        trap           ;failed equal (zero)
6151
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6152
0cf9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6153
0cfa : 0d                   >        db      test_num
6154 2 MichaelA
                            >
6155 3 MichaelA
0cfb :                      >skip0652
6156
                            >
6157
0cfb : 68               [ 4]>            pla         ;load status
6158 2 MichaelA
                            >            cmp_flag zero
6159 3 MichaelA
0cfc : c932             [ 2]>            cmp #(zero|fao)&m8    ;expected flags + always on bits
6160 2 MichaelA
                            >
6161
                            >            trap_ne
6162 3 MichaelA
0cfe : f002             [ 4]>        beq skip0655
6163
                            >        trap           ;failed equal (zero)
6164
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6165
0d00 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6166
0d01 : 0d                   >        db      test_num
6167 2 MichaelA
                            >
6168 3 MichaelA
0d02 :                      >skip0655
6169
                            >
6170
0d02 : 28               [ 4]>            plp         ;restore status
6171 2 MichaelA
 
6172 3 MichaelA
0d03 : 08               [ 3]         php
6173
0d04 : 88               [ 2]         dey             ;ff
6174
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  108
6175
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6176
 
6177
0d05 : 28               [ 4]         plp
6178
0d06 : 98               [ 2]         tya
6179 2 MichaelA
                                     tst_a $ff,minus
6180 3 MichaelA
0d07 : 08               [ 3]>            php         ;save flags
6181
0d08 : 08               [ 3]>            php
6182
0d09 : c9ff             [ 2]>            cmp #$ff     ;test result
6183 2 MichaelA
                            >            trap_ne
6184 3 MichaelA
0d0b : f002             [ 3]>        beq skip0658
6185
                            >        trap           ;failed equal (zero)
6186
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6187
0d0d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6188
0d0e : 0d                   >        db      test_num
6189 2 MichaelA
                            >
6190 3 MichaelA
0d0f :                      >skip0658
6191
                            >
6192
0d0f : 68               [ 4]>            pla         ;load status
6193 2 MichaelA
                            >            cmp_flag minus
6194 3 MichaelA
0d10 : c9b0             [ 2]>            cmp #(minus|fao)&m8    ;expected flags + always on bits
6195 2 MichaelA
                            >
6196
                            >            trap_ne
6197 3 MichaelA
0d12 : f002             [ 3]>        beq skip0661
6198
                            >        trap           ;failed equal (zero)
6199
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6200
0d14 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6201
0d15 : 0d                   >        db      test_num
6202 2 MichaelA
                            >
6203 3 MichaelA
0d16 :                      >skip0661
6204
                            >
6205
0d16 : 28               [ 4]>            plp         ;restore status
6206 2 MichaelA
 
6207
 
6208
                                     load_flag $ff
6209 3 MichaelA
0d17 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
6210 2 MichaelA
 
6211 3 MichaelA
0d19 : 48               [ 3]         pha
6212
0d1a : a2ff             [ 2]         ldx #$ff        ;ff
6213
0d1c : 8a               [ 2]         txa
6214
0d1d : 28               [ 4]         plp
6215
0d1e : a8               [ 2]         tay
6216 2 MichaelA
                                     tst_y $ff,$ff-zero
6217 3 MichaelA
0d1f : 08               [ 3]>            php         ;save flags
6218
0d20 : 08               [ 3]>            php
6219
0d21 : c0ff             [ 2]>            cpy #$ff     ;test result
6220 2 MichaelA
                            >            trap_ne
6221 3 MichaelA
0d23 : f002             [ 3]>        beq skip0665
6222
                            >        trap           ;failed equal (zero)
6223
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6224
0d25 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6225
0d26 : 0d                   >        db      test_num
6226 2 MichaelA
                            >
6227 3 MichaelA
0d27 :                      >skip0665
6228
                            >
6229
0d27 : 68               [ 4]>            pla         ;load status
6230 2 MichaelA
                            >            cmp_flag $ff-zero
6231 3 MichaelA
0d28 : c9fd             [ 2]>            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
6232
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  109
6233
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6234
 
6235 2 MichaelA
                            >
6236
                            >            trap_ne
6237 3 MichaelA
0d2a : f002             [ 3]>        beq skip0668
6238
                            >        trap           ;failed equal (zero)
6239
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6240
0d2c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6241
0d2d : 0d                   >        db      test_num
6242 2 MichaelA
                            >
6243 3 MichaelA
0d2e :                      >skip0668
6244
                            >
6245
0d2e : 28               [ 4]>            plp         ;restore status
6246 2 MichaelA
 
6247 3 MichaelA
0d2f : 08               [ 3]         php
6248
0d30 : e8               [ 2]         inx             ;00
6249
0d31 : 8a               [ 2]         txa
6250
0d32 : 28               [ 4]         plp
6251
0d33 : a8               [ 2]         tay
6252 2 MichaelA
                                     tst_y 0,$ff-minus
6253 3 MichaelA
0d34 : 08               [ 3]>            php         ;save flags
6254
0d35 : 08               [ 3]>            php
6255
0d36 : c000             [ 2]>            cpy #0     ;test result
6256 2 MichaelA
                            >            trap_ne
6257 3 MichaelA
0d38 : f002             [ 3]>        beq skip0671
6258
                            >        trap           ;failed equal (zero)
6259
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6260
0d3a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6261
0d3b : 0d                   >        db      test_num
6262 2 MichaelA
                            >
6263 3 MichaelA
0d3c :                      >skip0671
6264
                            >
6265
0d3c : 68               [ 4]>            pla         ;load status
6266 2 MichaelA
                            >            cmp_flag $ff-minus
6267 3 MichaelA
0d3d : c97f             [ 2]>            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
6268 2 MichaelA
                            >
6269
                            >            trap_ne
6270 3 MichaelA
0d3f : f002             [ 3]>        beq skip0674
6271
                            >        trap           ;failed equal (zero)
6272
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6273
0d41 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6274
0d42 : 0d                   >        db      test_num
6275 2 MichaelA
                            >
6276 3 MichaelA
0d43 :                      >skip0674
6277
                            >
6278
0d43 : 28               [ 4]>            plp         ;restore status
6279 2 MichaelA
 
6280 3 MichaelA
0d44 : 08               [ 3]         php
6281
0d45 : e8               [ 2]         inx             ;01
6282
0d46 : 8a               [ 2]         txa
6283
0d47 : 28               [ 4]         plp
6284
0d48 : a8               [ 2]         tay
6285 2 MichaelA
                                     tst_y 1,$ff-minus-zero
6286 3 MichaelA
0d49 : 08               [ 3]>            php         ;save flags
6287
0d4a : 08               [ 3]>            php
6288
0d4b : c001             [ 2]>            cpy #1     ;test result
6289 2 MichaelA
                            >            trap_ne
6290 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  110
6291
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6292
 
6293
0d4d : f002             [ 3]>        beq skip0677
6294
                            >        trap           ;failed equal (zero)
6295
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6296
0d4f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6297
0d50 : 0d                   >        db      test_num
6298 2 MichaelA
                            >
6299 3 MichaelA
0d51 :                      >skip0677
6300
                            >
6301
0d51 : 68               [ 4]>            pla         ;load status
6302 2 MichaelA
                            >            cmp_flag $ff-minus-zero
6303 3 MichaelA
0d52 : c97d             [ 2]>            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
6304 2 MichaelA
                            >
6305
                            >            trap_ne
6306 3 MichaelA
0d54 : f002             [ 3]>        beq skip0680
6307
                            >        trap           ;failed equal (zero)
6308
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6309
0d56 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6310
0d57 : 0d                   >        db      test_num
6311 2 MichaelA
                            >
6312 3 MichaelA
0d58 :                      >skip0680
6313
                            >
6314
0d58 : 28               [ 4]>            plp         ;restore status
6315 2 MichaelA
 
6316
                                     load_flag 0
6317 3 MichaelA
0d59 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
6318 2 MichaelA
 
6319 3 MichaelA
0d5b : 48               [ 3]         pha
6320
0d5c : a900             [ 2]         lda #0
6321
0d5e : 8a               [ 2]         txa
6322
0d5f : 28               [ 4]         plp
6323
0d60 : a8               [ 2]         tay
6324 2 MichaelA
                                     tst_y 1,0
6325 3 MichaelA
0d61 : 08               [ 3]>            php         ;save flags
6326
0d62 : 08               [ 3]>            php
6327
0d63 : c001             [ 2]>            cpy #1     ;test result
6328 2 MichaelA
                            >            trap_ne
6329 3 MichaelA
0d65 : f002             [ 3]>        beq skip0684
6330
                            >        trap           ;failed equal (zero)
6331
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6332
0d67 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6333
0d68 : 0d                   >        db      test_num
6334 2 MichaelA
                            >
6335 3 MichaelA
0d69 :                      >skip0684
6336
                            >
6337
0d69 : 68               [ 4]>            pla         ;load status
6338 2 MichaelA
                            >            cmp_flag 0
6339 3 MichaelA
0d6a : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
6340 2 MichaelA
                            >
6341
                            >            trap_ne
6342 3 MichaelA
0d6c : f002             [ 3]>        beq skip0687
6343
                            >        trap           ;failed equal (zero)
6344
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6345
0d6e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6346
0d6f : 0d                   >        db      test_num
6347 2 MichaelA
                            >
6348 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  111
6349
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6350
 
6351
0d70 :                      >skip0687
6352
                            >
6353
0d70 : 28               [ 4]>            plp         ;restore status
6354 2 MichaelA
 
6355 3 MichaelA
0d71 : 08               [ 3]         php
6356
0d72 : ca               [ 2]         dex             ;00
6357
0d73 : 8a               [ 2]         txa
6358
0d74 : 28               [ 4]         plp
6359
0d75 : a8               [ 2]         tay
6360 2 MichaelA
                                     tst_y 0,zero
6361 3 MichaelA
0d76 : 08               [ 3]>            php         ;save flags
6362
0d77 : 08               [ 3]>            php
6363
0d78 : c000             [ 2]>            cpy #0     ;test result
6364 2 MichaelA
                            >            trap_ne
6365 3 MichaelA
0d7a : f002             [ 3]>        beq skip0690
6366
                            >        trap           ;failed equal (zero)
6367
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6368
0d7c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6369
0d7d : 0d                   >        db      test_num
6370 2 MichaelA
                            >
6371 3 MichaelA
0d7e :                      >skip0690
6372
                            >
6373
0d7e : 68               [ 4]>            pla         ;load status
6374 2 MichaelA
                            >            cmp_flag zero
6375 3 MichaelA
0d7f : c932             [ 2]>            cmp #(zero|fao)&m8    ;expected flags + always on bits
6376 2 MichaelA
                            >
6377
                            >            trap_ne
6378 3 MichaelA
0d81 : f002             [ 3]>        beq skip0693
6379
                            >        trap           ;failed equal (zero)
6380
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6381
0d83 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6382
0d84 : 0d                   >        db      test_num
6383 2 MichaelA
                            >
6384 3 MichaelA
0d85 :                      >skip0693
6385
                            >
6386
0d85 : 28               [ 4]>            plp         ;restore status
6387 2 MichaelA
 
6388 3 MichaelA
0d86 : 08               [ 3]         php
6389
0d87 : ca               [ 2]         dex             ;ff
6390
0d88 : 8a               [ 2]         txa
6391
0d89 : 28               [ 4]         plp
6392
0d8a : a8               [ 2]         tay
6393 2 MichaelA
                                     tst_y $ff,minus
6394 3 MichaelA
0d8b : 08               [ 3]>            php         ;save flags
6395
0d8c : 08               [ 3]>            php
6396
0d8d : c0ff             [ 2]>            cpy #$ff     ;test result
6397
                            >            trap_ne
6398
0d8f : f002             [ 3]>        beq skip0696
6399
                            >        trap           ;failed equal (zero)
6400
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6401
0d91 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6402
0d92 : 0d                   >        db      test_num
6403
                            >
6404
0d93 :                      >skip0696
6405
                            >
6406
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  112
6407 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6408
 
6409 3 MichaelA
0d93 : 68               [ 4]>            pla         ;load status
6410 2 MichaelA
                            >            cmp_flag minus
6411 3 MichaelA
0d94 : c9b0             [ 2]>            cmp #(minus|fao)&m8    ;expected flags + always on bits
6412 2 MichaelA
                            >
6413
                            >            trap_ne
6414 3 MichaelA
0d96 : f002             [ 3]>        beq skip0699
6415
                            >        trap           ;failed equal (zero)
6416
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6417
0d98 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6418
0d99 : 0d                   >        db      test_num
6419 2 MichaelA
                            >
6420 3 MichaelA
0d9a :                      >skip0699
6421
                            >
6422
0d9a : 28               [ 4]>            plp         ;restore status
6423 2 MichaelA
 
6424
 
6425
 
6426
                                     load_flag $ff
6427 3 MichaelA
0d9b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
6428 2 MichaelA
 
6429 3 MichaelA
0d9d : 48               [ 3]         pha
6430
0d9e : a0ff             [ 2]         ldy #$ff        ;ff
6431
0da0 : 98               [ 2]         tya
6432
0da1 : 28               [ 4]         plp
6433
0da2 : aa               [ 2]         tax
6434 2 MichaelA
                                     tst_x $ff,$ff-zero
6435 3 MichaelA
0da3 : 08               [ 3]>            php         ;save flags
6436
0da4 : 08               [ 3]>            php
6437
0da5 : e0ff             [ 2]>            cpx #$ff     ;test result
6438 2 MichaelA
                            >            trap_ne
6439 3 MichaelA
0da7 : f002             [ 3]>        beq skip0703
6440
                            >        trap           ;failed equal (zero)
6441
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6442
0da9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6443
0daa : 0d                   >        db      test_num
6444 2 MichaelA
                            >
6445 3 MichaelA
0dab :                      >skip0703
6446
                            >
6447
0dab : 68               [ 4]>            pla         ;load status
6448 2 MichaelA
                            >            cmp_flag $ff-zero
6449 3 MichaelA
0dac : c9fd             [ 2]>            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
6450 2 MichaelA
                            >
6451
                            >            trap_ne
6452 3 MichaelA
0dae : f002             [ 3]>        beq skip0706
6453
                            >        trap           ;failed equal (zero)
6454
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6455
0db0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6456
0db1 : 0d                   >        db      test_num
6457 2 MichaelA
                            >
6458 3 MichaelA
0db2 :                      >skip0706
6459
                            >
6460
0db2 : 28               [ 4]>            plp         ;restore status
6461 2 MichaelA
 
6462 3 MichaelA
0db3 : 08               [ 3]         php
6463
0db4 : c8               [ 2]         iny             ;00
6464
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  113
6465
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6466
 
6467
0db5 : 98               [ 2]         tya
6468
0db6 : 28               [ 4]         plp
6469
0db7 : aa               [ 2]         tax
6470 2 MichaelA
                                     tst_x 0,$ff-minus
6471 3 MichaelA
0db8 : 08               [ 3]>            php         ;save flags
6472
0db9 : 08               [ 3]>            php
6473
0dba : e000             [ 2]>            cpx #0     ;test result
6474 2 MichaelA
                            >            trap_ne
6475 3 MichaelA
0dbc : f002             [ 3]>        beq skip0709
6476
                            >        trap           ;failed equal (zero)
6477
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6478
0dbe : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6479
0dbf : 0d                   >        db      test_num
6480 2 MichaelA
                            >
6481 3 MichaelA
0dc0 :                      >skip0709
6482
                            >
6483
0dc0 : 68               [ 4]>            pla         ;load status
6484 2 MichaelA
                            >            cmp_flag $ff-minus
6485 3 MichaelA
0dc1 : c97f             [ 2]>            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
6486 2 MichaelA
                            >
6487
                            >            trap_ne
6488 3 MichaelA
0dc3 : f002             [ 3]>        beq skip0712
6489
                            >        trap           ;failed equal (zero)
6490
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6491
0dc5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6492
0dc6 : 0d                   >        db      test_num
6493 2 MichaelA
                            >
6494 3 MichaelA
0dc7 :                      >skip0712
6495
                            >
6496
0dc7 : 28               [ 4]>            plp         ;restore status
6497 2 MichaelA
 
6498 3 MichaelA
0dc8 : 08               [ 3]         php
6499
0dc9 : c8               [ 2]         iny             ;01
6500
0dca : 98               [ 2]         tya
6501
0dcb : 28               [ 4]         plp
6502
0dcc : aa               [ 2]         tax
6503 2 MichaelA
                                     tst_x 1,$ff-minus-zero
6504 3 MichaelA
0dcd : 08               [ 3]>            php         ;save flags
6505
0dce : 08               [ 3]>            php
6506
0dcf : e001             [ 2]>            cpx #1     ;test result
6507 2 MichaelA
                            >            trap_ne
6508 3 MichaelA
0dd1 : f002             [ 3]>        beq skip0715
6509
                            >        trap           ;failed equal (zero)
6510
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6511
0dd3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6512
0dd4 : 0d                   >        db      test_num
6513 2 MichaelA
                            >
6514 3 MichaelA
0dd5 :                      >skip0715
6515
                            >
6516
0dd5 : 68               [ 4]>            pla         ;load status
6517 2 MichaelA
                            >            cmp_flag $ff-minus-zero
6518 3 MichaelA
0dd6 : c97d             [ 2]>            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
6519 2 MichaelA
                            >
6520
                            >            trap_ne
6521 3 MichaelA
0dd8 : f002             [ 3]>        beq skip0718
6522
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  114
6523
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6524
 
6525
                            >        trap           ;failed equal (zero)
6526
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6527
0dda : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6528
0ddb : 0d                   >        db      test_num
6529 2 MichaelA
                            >
6530 3 MichaelA
0ddc :                      >skip0718
6531
                            >
6532
0ddc : 28               [ 4]>            plp         ;restore status
6533 2 MichaelA
 
6534
                                     load_flag 0
6535 3 MichaelA
0ddd : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
6536 2 MichaelA
 
6537 3 MichaelA
0ddf : 48               [ 3]         pha
6538
0de0 : a900             [ 2]         lda #0          ;preset status
6539
0de2 : 98               [ 2]         tya
6540
0de3 : 28               [ 4]         plp
6541
0de4 : aa               [ 2]         tax
6542 2 MichaelA
                                     tst_x 1,0
6543 3 MichaelA
0de5 : 08               [ 3]>            php         ;save flags
6544
0de6 : 08               [ 3]>            php
6545
0de7 : e001             [ 2]>            cpx #1     ;test result
6546 2 MichaelA
                            >            trap_ne
6547 3 MichaelA
0de9 : f002             [ 3]>        beq skip0722
6548
                            >        trap           ;failed equal (zero)
6549
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6550
0deb : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6551
0dec : 0d                   >        db      test_num
6552 2 MichaelA
                            >
6553 3 MichaelA
0ded :                      >skip0722
6554
                            >
6555
0ded : 68               [ 4]>            pla         ;load status
6556 2 MichaelA
                            >            cmp_flag 0
6557 3 MichaelA
0dee : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
6558 2 MichaelA
                            >
6559
                            >            trap_ne
6560 3 MichaelA
0df0 : f002             [ 3]>        beq skip0725
6561
                            >        trap           ;failed equal (zero)
6562
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6563
0df2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6564
0df3 : 0d                   >        db      test_num
6565 2 MichaelA
                            >
6566 3 MichaelA
0df4 :                      >skip0725
6567
                            >
6568
0df4 : 28               [ 4]>            plp         ;restore status
6569 2 MichaelA
 
6570 3 MichaelA
0df5 : 08               [ 3]         php
6571
0df6 : 88               [ 2]         dey             ;00
6572
0df7 : 98               [ 2]         tya
6573
0df8 : 28               [ 4]         plp
6574
0df9 : aa               [ 2]         tax
6575
                                     tst_x 0,zero
6576
0dfa : 08               [ 3]>            php         ;save flags
6577
0dfb : 08               [ 3]>            php
6578
0dfc : e000             [ 2]>            cpx #0     ;test result
6579
                            >            trap_ne
6580
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  115
6581 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6582
 
6583 3 MichaelA
0dfe : f002             [ 4]>        beq skip0728
6584
                            >        trap           ;failed equal (zero)
6585
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6586
0e00 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6587
0e01 : 0d                   >        db      test_num
6588 2 MichaelA
                            >
6589 3 MichaelA
0e02 :                      >skip0728
6590
                            >
6591
0e02 : 68               [ 4]>            pla         ;load status
6592 2 MichaelA
                            >            cmp_flag zero
6593 3 MichaelA
0e03 : c932             [ 2]>            cmp #(zero|fao)&m8    ;expected flags + always on bits
6594 2 MichaelA
                            >
6595
                            >            trap_ne
6596 3 MichaelA
0e05 : f002             [ 3]>        beq skip0731
6597
                            >        trap           ;failed equal (zero)
6598
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6599
0e07 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6600
0e08 : 0d                   >        db      test_num
6601 2 MichaelA
                            >
6602 3 MichaelA
0e09 :                      >skip0731
6603
                            >
6604
0e09 : 28               [ 4]>            plp         ;restore status
6605 2 MichaelA
 
6606 3 MichaelA
0e0a : 08               [ 3]         php
6607
0e0b : 88               [ 2]         dey             ;ff
6608
0e0c : 98               [ 2]         tya
6609
0e0d : 28               [ 4]         plp
6610
0e0e : aa               [ 2]         tax
6611 2 MichaelA
                                     tst_x $ff,minus
6612 3 MichaelA
0e0f : 08               [ 3]>            php         ;save flags
6613
0e10 : 08               [ 3]>            php
6614
0e11 : e0ff             [ 2]>            cpx #$ff     ;test result
6615 2 MichaelA
                            >            trap_ne
6616 3 MichaelA
0e13 : f002             [ 3]>        beq skip0734
6617
                            >        trap           ;failed equal (zero)
6618
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6619
0e15 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6620
0e16 : 0d                   >        db      test_num
6621 2 MichaelA
                            >
6622 3 MichaelA
0e17 :                      >skip0734
6623
                            >
6624
0e17 : 68               [ 4]>            pla         ;load status
6625 2 MichaelA
                            >            cmp_flag minus
6626 3 MichaelA
0e18 : c9b0             [ 2]>            cmp #(minus|fao)&m8    ;expected flags + always on bits
6627 2 MichaelA
                            >
6628
                            >            trap_ne
6629 3 MichaelA
0e1a : f002             [ 3]>        beq skip0737
6630
                            >        trap           ;failed equal (zero)
6631
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6632
0e1c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6633
0e1d : 0d                   >        db      test_num
6634 2 MichaelA
                            >
6635 3 MichaelA
0e1e :                      >skip0737
6636
                            >
6637
0e1e : 28               [ 4]>            plp         ;restore status
6638
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  116
6639
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6640
 
6641 2 MichaelA
 
6642
                                     next_test
6643 3 MichaelA
0e1f : ad0002           [ 4]>            lda test_case   ;previous test
6644
0e22 : c90d             [ 2]>            cmp #test_num
6645 2 MichaelA
                            >            trap_ne         ;test is out of sequence
6646 3 MichaelA
0e24 : f002             [ 3]>        beq skip0740
6647
                            >        trap           ;failed equal (zero)
6648
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6649
0e26 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6650
0e27 : 0d                   >        db      test_num
6651 2 MichaelA
                            >
6652 3 MichaelA
0e28 :                      >skip0740
6653
                            >
6654 2 MichaelA
000e =                      >test_num = test_num + 1
6655 3 MichaelA
0e28 : a90e             [ 2]>            lda #test_num   ;*** this tests' number
6656
0e2a : 8d0002           [ 4]>            sta test_case
6657 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
6658
 
6659
 
6660
                             ;TSX sets NZ - TXS does not
6661 3 MichaelA
 
6662
0e2d : a201             [ 2]         ldx #1          ;01
6663 2 MichaelA
                                     set_stat $ff
6664
                            >            load_flag $ff
6665 3 MichaelA
0e2f : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
6666 2 MichaelA
                            >
6667 3 MichaelA
0e31 : 48               [ 3]>            pha         ;use stack to load status
6668
0e32 : 28               [ 4]>            plp
6669 2 MichaelA
 
6670 3 MichaelA
0e33 : 9a               [ 2]         txs
6671
0e34 : 08               [ 3]         php
6672
0e35 : ad0101           [ 4]         lda $101
6673 2 MichaelA
                                     cmp_flag $ff
6674 3 MichaelA
0e38 : c9ff             [ 2]>            cmp #($ff|fao)&m8    ;expected flags + always on bits
6675 2 MichaelA
 
6676
                                     trap_ne
6677 3 MichaelA
0e3a : f002             [ 3]>        beq skip0745
6678
                            >        trap           ;failed equal (zero)
6679
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6680
0e3c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6681
0e3d : 0e                   >        db      test_num
6682
                            >
6683
0e3e :                      >skip0745
6684 2 MichaelA
 
6685
                                     set_stat 0
6686
                            >            load_flag 0
6687 3 MichaelA
0e3e : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
6688 2 MichaelA
                            >
6689 3 MichaelA
0e40 : 48               [ 3]>            pha         ;use stack to load status
6690
0e41 : 28               [ 4]>            plp
6691 2 MichaelA
 
6692 3 MichaelA
0e42 : 9a               [ 2]         txs
6693
0e43 : 08               [ 3]         php
6694
0e44 : ad0101           [ 4]         lda $101
6695 2 MichaelA
                                     cmp_flag 0
6696 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  117
6697
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6698
 
6699
0e47 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
6700 2 MichaelA
 
6701
                                     trap_ne
6702 3 MichaelA
0e49 : f002             [ 3]>        beq skip0750
6703
                            >        trap           ;failed equal (zero)
6704
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6705
0e4b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6706
0e4c : 0e                   >        db      test_num
6707
                            >
6708
0e4d :                      >skip0750
6709 2 MichaelA
 
6710 3 MichaelA
0e4d : ca               [ 2]         dex             ;00
6711 2 MichaelA
                                     set_stat $ff
6712
                            >            load_flag $ff
6713 3 MichaelA
0e4e : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
6714 2 MichaelA
                            >
6715 3 MichaelA
0e50 : 48               [ 3]>            pha         ;use stack to load status
6716
0e51 : 28               [ 4]>            plp
6717 2 MichaelA
 
6718 3 MichaelA
0e52 : 9a               [ 2]         txs
6719
0e53 : 08               [ 3]         php
6720
0e54 : ad0001           [ 4]         lda $100
6721 2 MichaelA
                                     cmp_flag $ff
6722 3 MichaelA
0e57 : c9ff             [ 2]>            cmp #($ff|fao)&m8    ;expected flags + always on bits
6723 2 MichaelA
 
6724
                                     trap_ne
6725 3 MichaelA
0e59 : f002             [ 3]>        beq skip0755
6726
                            >        trap           ;failed equal (zero)
6727
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6728
0e5b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6729
0e5c : 0e                   >        db      test_num
6730
                            >
6731
0e5d :                      >skip0755
6732 2 MichaelA
 
6733
                                     set_stat 0
6734
                            >            load_flag 0
6735 3 MichaelA
0e5d : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
6736 2 MichaelA
                            >
6737 3 MichaelA
0e5f : 48               [ 3]>            pha         ;use stack to load status
6738
0e60 : 28               [ 4]>            plp
6739 2 MichaelA
 
6740 3 MichaelA
0e61 : 9a               [ 2]         txs
6741
0e62 : 08               [ 3]         php
6742
0e63 : ad0001           [ 4]         lda $100
6743 2 MichaelA
                                     cmp_flag 0
6744 3 MichaelA
0e66 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
6745 2 MichaelA
 
6746
                                     trap_ne
6747 3 MichaelA
0e68 : f002             [ 3]>        beq skip0760
6748
                            >        trap           ;failed equal (zero)
6749
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6750
0e6a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6751
0e6b : 0e                   >        db      test_num
6752
                            >
6753
0e6c :                      >skip0760
6754
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  118
6755
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6756
 
6757 2 MichaelA
 
6758 3 MichaelA
0e6c : ca               [ 2]         dex             ;ff
6759 2 MichaelA
                                     set_stat $ff
6760
                            >            load_flag $ff
6761 3 MichaelA
0e6d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
6762 2 MichaelA
                            >
6763 3 MichaelA
0e6f : 48               [ 3]>            pha         ;use stack to load status
6764
0e70 : 28               [ 4]>            plp
6765 2 MichaelA
 
6766 3 MichaelA
0e71 : 9a               [ 2]         txs
6767
0e72 : 08               [ 3]         php
6768
0e73 : adff01           [ 4]         lda $1ff
6769 2 MichaelA
                                     cmp_flag $ff
6770 3 MichaelA
0e76 : c9ff             [ 2]>            cmp #($ff|fao)&m8    ;expected flags + always on bits
6771 2 MichaelA
 
6772
                                     trap_ne
6773 3 MichaelA
0e78 : f002             [ 3]>        beq skip0765
6774
                            >        trap           ;failed equal (zero)
6775
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6776
0e7a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6777
0e7b : 0e                   >        db      test_num
6778
                            >
6779
0e7c :                      >skip0765
6780 2 MichaelA
 
6781
                                     set_stat 0
6782
                            >            load_flag 0
6783 3 MichaelA
0e7c : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
6784 2 MichaelA
                            >
6785 3 MichaelA
0e7e : 48               [ 3]>            pha         ;use stack to load status
6786
0e7f : 28               [ 4]>            plp
6787 2 MichaelA
 
6788 3 MichaelA
0e80 : 9a               [ 2]         txs
6789
0e81 : 08               [ 3]         php
6790
0e82 : adff01           [ 4]         lda $1ff
6791 2 MichaelA
                                     cmp_flag 0
6792 3 MichaelA
0e85 : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
6793 2 MichaelA
 
6794
 
6795 3 MichaelA
0e87 : a201             [ 2]         ldx #1
6796
0e89 : 9a               [ 2]         txs             ;sp=01
6797 2 MichaelA
                                     set_stat $ff
6798
                            >            load_flag $ff
6799 3 MichaelA
0e8a : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
6800 2 MichaelA
                            >
6801 3 MichaelA
0e8c : 48               [ 3]>            pha         ;use stack to load status
6802
0e8d : 28               [ 4]>            plp
6803 2 MichaelA
 
6804 3 MichaelA
0e8e : ba               [ 2]         tsx             ;clears Z, N
6805
0e8f : 08               [ 3]         php             ;sp=00
6806
0e90 : e001             [ 2]         cpx #1
6807 2 MichaelA
                                     trap_ne
6808 3 MichaelA
0e92 : f002             [ 3]>        beq skip0772
6809
                            >        trap           ;failed equal (zero)
6810
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6811
0e94 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6812
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  119
6813 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6814
 
6815 3 MichaelA
0e95 : 0e                   >        db      test_num
6816
                            >
6817
0e96 :                      >skip0772
6818
 
6819
0e96 : ad0101           [ 4]         lda $101
6820 2 MichaelA
                                     cmp_flag $ff-minus-zero
6821 3 MichaelA
0e99 : c97d             [ 2]>            cmp #($ff-minus-zero|fao)&m8    ;expected flags + always on bits
6822 2 MichaelA
 
6823
                                     trap_ne
6824 3 MichaelA
0e9b : f002             [ 3]>        beq skip0775
6825
                            >        trap           ;failed equal (zero)
6826
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6827
0e9d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6828
0e9e : 0e                   >        db      test_num
6829
                            >
6830
0e9f :                      >skip0775
6831 2 MichaelA
 
6832
                                     set_stat $ff
6833
                            >            load_flag $ff
6834 3 MichaelA
0e9f : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
6835 2 MichaelA
                            >
6836 3 MichaelA
0ea1 : 48               [ 3]>            pha         ;use stack to load status
6837
0ea2 : 28               [ 4]>            plp
6838 2 MichaelA
 
6839 3 MichaelA
0ea3 : ba               [ 2]         tsx             ;clears N, sets Z
6840
0ea4 : 08               [ 3]         php             ;sp=ff
6841
0ea5 : e000             [ 2]         cpx #0
6842 2 MichaelA
                                     trap_ne
6843 3 MichaelA
0ea7 : f002             [ 3]>        beq skip0779
6844
                            >        trap           ;failed equal (zero)
6845
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6846
0ea9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6847
0eaa : 0e                   >        db      test_num
6848
                            >
6849
0eab :                      >skip0779
6850 2 MichaelA
 
6851 3 MichaelA
0eab : ad0001           [ 4]         lda $100
6852 2 MichaelA
                                     cmp_flag $ff-minus
6853 3 MichaelA
0eae : c97f             [ 2]>            cmp #($ff-minus|fao)&m8    ;expected flags + always on bits
6854 2 MichaelA
 
6855
                                     trap_ne
6856 3 MichaelA
0eb0 : f002             [ 3]>        beq skip0782
6857
                            >        trap           ;failed equal (zero)
6858
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6859
0eb2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6860
0eb3 : 0e                   >        db      test_num
6861
                            >
6862
0eb4 :                      >skip0782
6863 2 MichaelA
 
6864
                                     set_stat $ff
6865
                            >            load_flag $ff
6866 3 MichaelA
0eb4 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
6867 2 MichaelA
                            >
6868 3 MichaelA
0eb6 : 48               [ 3]>            pha         ;use stack to load status
6869
0eb7 : 28               [ 4]>            plp
6870
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  120
6871
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6872
 
6873 2 MichaelA
 
6874 3 MichaelA
0eb8 : ba               [ 2]         tsx             ;clears N, sets Z
6875
0eb9 : 08               [ 3]         php             ;sp=fe
6876
0eba : e0ff             [ 2]         cpx #$ff
6877 2 MichaelA
                                     trap_ne
6878 3 MichaelA
0ebc : f002             [ 3]>        beq skip0786
6879
                            >        trap           ;failed equal (zero)
6880
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6881
0ebe : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6882
0ebf : 0e                   >        db      test_num
6883
                            >
6884
0ec0 :                      >skip0786
6885 2 MichaelA
 
6886 3 MichaelA
0ec0 : adff01           [ 4]         lda $1ff
6887 2 MichaelA
                                     cmp_flag $ff-zero
6888 3 MichaelA
0ec3 : c9fd             [ 2]>            cmp #($ff-zero|fao)&m8    ;expected flags + always on bits
6889 2 MichaelA
 
6890
                                     trap_ne
6891 3 MichaelA
0ec5 : f002             [ 3]>        beq skip0789
6892
                            >        trap           ;failed equal (zero)
6893
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6894
0ec7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6895
0ec8 : 0e                   >        db      test_num
6896
                            >
6897
0ec9 :                      >skip0789
6898 2 MichaelA
 
6899
 
6900 3 MichaelA
0ec9 : a201             [ 2]         ldx #1
6901
0ecb : 9a               [ 2]         txs             ;sp=01
6902 2 MichaelA
                                     set_stat 0
6903
                            >            load_flag 0
6904 3 MichaelA
0ecc : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
6905 2 MichaelA
                            >
6906 3 MichaelA
0ece : 48               [ 3]>            pha         ;use stack to load status
6907
0ecf : 28               [ 4]>            plp
6908 2 MichaelA
 
6909 3 MichaelA
0ed0 : ba               [ 2]         tsx             ;clears Z, N
6910
0ed1 : 08               [ 3]         php             ;sp=00
6911
0ed2 : e001             [ 2]         cpx #1
6912 2 MichaelA
                                     trap_ne
6913 3 MichaelA
0ed4 : f002             [ 3]>        beq skip0793
6914
                            >        trap           ;failed equal (zero)
6915
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6916
0ed6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6917
0ed7 : 0e                   >        db      test_num
6918
                            >
6919
0ed8 :                      >skip0793
6920 2 MichaelA
 
6921 3 MichaelA
0ed8 : ad0101           [ 4]         lda $101
6922 2 MichaelA
                                     cmp_flag 0
6923 3 MichaelA
0edb : c930             [ 2]>            cmp #(0|fao)&m8    ;expected flags + always on bits
6924 2 MichaelA
 
6925
                                     trap_ne
6926 3 MichaelA
0edd : f002             [ 3]>        beq skip0796
6927
                            >        trap           ;failed equal (zero)
6928
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  121
6929
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6930
 
6931
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6932
0edf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6933
0ee0 : 0e                   >        db      test_num
6934
                            >
6935
0ee1 :                      >skip0796
6936 2 MichaelA
 
6937
                                     set_stat 0
6938
                            >            load_flag 0
6939 3 MichaelA
0ee1 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
6940 2 MichaelA
                            >
6941 3 MichaelA
0ee3 : 48               [ 3]>            pha         ;use stack to load status
6942
0ee4 : 28               [ 4]>            plp
6943 2 MichaelA
 
6944 3 MichaelA
0ee5 : ba               [ 2]         tsx             ;clears N, sets Z
6945
0ee6 : 08               [ 3]         php             ;sp=ff
6946
0ee7 : e000             [ 2]         cpx #0
6947 2 MichaelA
                                     trap_ne
6948 3 MichaelA
0ee9 : f002             [ 3]>        beq skip0800
6949
                            >        trap           ;failed equal (zero)
6950
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6951
0eeb : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6952
0eec : 0e                   >        db      test_num
6953
                            >
6954
0eed :                      >skip0800
6955 2 MichaelA
 
6956 3 MichaelA
0eed : ad0001           [ 4]         lda $100
6957 2 MichaelA
                                     cmp_flag zero
6958 3 MichaelA
0ef0 : c932             [ 2]>            cmp #(zero|fao)&m8    ;expected flags + always on bits
6959 2 MichaelA
 
6960
                                     trap_ne
6961 3 MichaelA
0ef2 : f002             [ 3]>        beq skip0803
6962
                            >        trap           ;failed equal (zero)
6963
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6964
0ef4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6965
0ef5 : 0e                   >        db      test_num
6966
                            >
6967
0ef6 :                      >skip0803
6968 2 MichaelA
 
6969
                                     set_stat 0
6970
                            >            load_flag 0
6971 3 MichaelA
0ef6 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
6972 2 MichaelA
                            >
6973 3 MichaelA
0ef8 : 48               [ 3]>            pha         ;use stack to load status
6974
0ef9 : 28               [ 4]>            plp
6975 2 MichaelA
 
6976 3 MichaelA
0efa : ba               [ 2]         tsx             ;clears N, sets Z
6977
0efb : 08               [ 3]         php             ;sp=fe
6978
0efc : e0ff             [ 2]         cpx #$ff
6979 2 MichaelA
                                     trap_ne
6980 3 MichaelA
0efe : f002             [ 4]>        beq skip0807
6981
                            >        trap           ;failed equal (zero)
6982
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6983
0f00 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
6984
0f01 : 0e                   >        db      test_num
6985
                            >
6986
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  122
6987
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
6988
 
6989
0f02 :                      >skip0807
6990 2 MichaelA
 
6991 3 MichaelA
0f02 : adff01           [ 4]         lda $1ff
6992 2 MichaelA
                                     cmp_flag minus
6993 3 MichaelA
0f05 : c9b0             [ 2]>            cmp #(minus|fao)&m8    ;expected flags + always on bits
6994 2 MichaelA
 
6995
                                     trap_ne
6996 3 MichaelA
0f07 : f002             [ 3]>        beq skip0810
6997
                            >        trap           ;failed equal (zero)
6998
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
6999
0f09 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7000
0f0a : 0e                   >        db      test_num
7001
                            >
7002
0f0b :                      >skip0810
7003 2 MichaelA
 
7004 3 MichaelA
0f0b : 68               [ 4]         pla             ;sp=ff
7005 2 MichaelA
                                     next_test
7006 3 MichaelA
0f0c : ad0002           [ 4]>            lda test_case   ;previous test
7007
0f0f : c90e             [ 2]>            cmp #test_num
7008 2 MichaelA
                            >            trap_ne         ;test is out of sequence
7009 3 MichaelA
0f11 : f002             [ 3]>        beq skip0813
7010
                            >        trap           ;failed equal (zero)
7011
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7012
0f13 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7013
0f14 : 0e                   >        db      test_num
7014 2 MichaelA
                            >
7015 3 MichaelA
0f15 :                      >skip0813
7016
                            >
7017 2 MichaelA
000f =                      >test_num = test_num + 1
7018 3 MichaelA
0f15 : a90f             [ 2]>            lda #test_num   ;*** this tests' number
7019
0f17 : 8d0002           [ 4]>            sta test_case
7020 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
7021
 
7022
 
7023
                             ; testing index register load & store LDY LDX STY STX all addressing modes
7024
                             ; LDX / STX - zp,y / abs,y
7025 3 MichaelA
 
7026
0f1a : a003             [ 2]         ldy #3
7027
0f1c :                       tldx
7028 2 MichaelA
                                     set_stat 0
7029
                            >            load_flag 0
7030 3 MichaelA
0f1c : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
7031 2 MichaelA
                            >
7032 3 MichaelA
0f1e : 48               [ 3]>            pha         ;use stack to load status
7033
0f1f : 28               [ 4]>            plp
7034 2 MichaelA
 
7035 3 MichaelA
0f20 : b6b9             [ 4]         ldx zp1,y
7036
0f22 : 08               [ 3]         php         ;test stores do not alter flags
7037
0f23 : 8a               [ 2]         txa
7038
0f24 : 49c3             [ 2]         eor #$c3
7039
0f26 : 28               [ 4]         plp
7040
0f27 : 990302           [ 5]         sta abst,y
7041
0f2a : 08               [ 3]         php         ;flags after load/store sequence
7042
0f2b : 49c3             [ 2]         eor #$c3
7043
0f2d : d90802           [ 4]         cmp abs1,y  ;test result
7044
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  123
7045
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7046
 
7047 2 MichaelA
                                     trap_ne
7048 3 MichaelA
0f30 : f002             [ 3]>        beq skip0817
7049
                            >        trap           ;failed equal (zero)
7050
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7051
0f32 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7052
0f33 : 0f                   >        db      test_num
7053
                            >
7054
0f34 :                      >skip0817
7055 2 MichaelA
 
7056 3 MichaelA
0f34 : 68               [ 4]         pla         ;load status
7057 2 MichaelA
                                     eor_flag 0
7058 3 MichaelA
0f35 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
7059 2 MichaelA
 
7060 3 MichaelA
0f37 : d90d02           [ 4]         cmp fLDx,y  ;test flags
7061 2 MichaelA
                                     trap_ne
7062 3 MichaelA
0f3a : f002             [ 3]>        beq skip0820
7063
                            >        trap           ;failed equal (zero)
7064
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7065
0f3c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7066
0f3d : 0f                   >        db      test_num
7067
                            >
7068
0f3e :                      >skip0820
7069 2 MichaelA
 
7070 3 MichaelA
0f3e : 88               [ 2]         dey
7071
0f3f : 10db             [ 3]         bpl tldx
7072 2 MichaelA
 
7073 3 MichaelA
0f41 : a003             [ 2]         ldy #3
7074
0f43 :                       tldx1
7075 2 MichaelA
                                     set_stat $ff
7076
                            >            load_flag $ff
7077 3 MichaelA
0f43 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
7078 2 MichaelA
                            >
7079 3 MichaelA
0f45 : 48               [ 3]>            pha         ;use stack to load status
7080
0f46 : 28               [ 4]>            plp
7081 2 MichaelA
 
7082 3 MichaelA
0f47 : b6b9             [ 4]         ldx zp1,y
7083
0f49 : 08               [ 3]         php         ;test stores do not alter flags
7084
0f4a : 8a               [ 2]         txa
7085
0f4b : 49c3             [ 2]         eor #$c3
7086
0f4d : 28               [ 4]         plp
7087
0f4e : 990302           [ 5]         sta abst,y
7088
0f51 : 08               [ 3]         php         ;flags after load/store sequence
7089
0f52 : 49c3             [ 2]         eor #$c3
7090
0f54 : d90802           [ 4]         cmp abs1,y  ;test result
7091 2 MichaelA
                                     trap_ne
7092 3 MichaelA
0f57 : f002             [ 3]>        beq skip0824
7093
                            >        trap           ;failed equal (zero)
7094
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7095
0f59 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7096
0f5a : 0f                   >        db      test_num
7097
                            >
7098
0f5b :                      >skip0824
7099 2 MichaelA
 
7100 3 MichaelA
0f5b : 68               [ 4]         pla         ;load status
7101 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
7102 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  124
7103
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7104
 
7105
0f5c : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
7106 2 MichaelA
 
7107 3 MichaelA
0f5e : d90d02           [ 4]         cmp fLDx,y  ;test flags
7108 2 MichaelA
                                     trap_ne
7109 3 MichaelA
0f61 : f002             [ 3]>        beq skip0827
7110
                            >        trap           ;failed equal (zero)
7111
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7112
0f63 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7113
0f64 : 0f                   >        db      test_num
7114
                            >
7115
0f65 :                      >skip0827
7116 2 MichaelA
 
7117 3 MichaelA
0f65 : 88               [ 2]         dey
7118
0f66 : 10db             [ 3]         bpl tldx1
7119 2 MichaelA
 
7120 3 MichaelA
0f68 : a003             [ 2]         ldy #3
7121
0f6a :                       tldx2
7122 2 MichaelA
                                     set_stat 0
7123
                            >            load_flag 0
7124 3 MichaelA
0f6a : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
7125 2 MichaelA
                            >
7126 3 MichaelA
0f6c : 48               [ 3]>            pha         ;use stack to load status
7127
0f6d : 28               [ 4]>            plp
7128 2 MichaelA
 
7129 3 MichaelA
0f6e : be0802           [ 4]         ldx abs1,y
7130
0f71 : 08               [ 3]         php         ;test stores do not alter flags
7131
0f72 : 8a               [ 2]         txa
7132
0f73 : 49c3             [ 2]         eor #$c3
7133
0f75 : aa               [ 2]         tax
7134
0f76 : 28               [ 4]         plp
7135
0f77 : 96b2             [ 4]         stx zpt,y
7136
0f79 : 08               [ 3]         php         ;flags after load/store sequence
7137
0f7a : 49c3             [ 2]         eor #$c3
7138
0f7c : d9b900           [ 4]         cmp zp1,y   ;test result
7139 2 MichaelA
                                     trap_ne
7140 3 MichaelA
0f7f : f002             [ 3]>        beq skip0831
7141
                            >        trap           ;failed equal (zero)
7142
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7143
0f81 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7144
0f82 : 0f                   >        db      test_num
7145
                            >
7146
0f83 :                      >skip0831
7147 2 MichaelA
 
7148 3 MichaelA
0f83 : 68               [ 4]         pla         ;load status
7149 2 MichaelA
                                     eor_flag 0
7150 3 MichaelA
0f84 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
7151 2 MichaelA
 
7152 3 MichaelA
0f86 : d90d02           [ 4]         cmp fLDx,y  ;test flags
7153 2 MichaelA
                                     trap_ne
7154 3 MichaelA
0f89 : f002             [ 3]>        beq skip0834
7155
                            >        trap           ;failed equal (zero)
7156
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7157
0f8b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7158
0f8c : 0f                   >        db      test_num
7159
                            >
7160
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  125
7161 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7162
 
7163 3 MichaelA
0f8d :                      >skip0834
7164 2 MichaelA
 
7165 3 MichaelA
0f8d : 88               [ 2]         dey
7166
0f8e : 10da             [ 3]         bpl tldx2
7167
 
7168
0f90 : a003             [ 2]         ldy #3
7169
0f92 :                       tldx3
7170 2 MichaelA
                                     set_stat $ff
7171
                            >            load_flag $ff
7172 3 MichaelA
0f92 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
7173 2 MichaelA
                            >
7174 3 MichaelA
0f94 : 48               [ 3]>            pha         ;use stack to load status
7175
0f95 : 28               [ 4]>            plp
7176 2 MichaelA
 
7177 3 MichaelA
0f96 : be0802           [ 4]         ldx abs1,y
7178
0f99 : 08               [ 3]         php         ;test stores do not alter flags
7179
0f9a : 8a               [ 2]         txa
7180
0f9b : 49c3             [ 2]         eor #$c3
7181
0f9d : aa               [ 2]         tax
7182
0f9e : 28               [ 4]         plp
7183
0f9f : 96b2             [ 4]         stx zpt,y
7184
0fa1 : 08               [ 3]         php         ;flags after load/store sequence
7185
0fa2 : 49c3             [ 2]         eor #$c3
7186
0fa4 : d9b900           [ 4]         cmp zp1,y   ;test result
7187 2 MichaelA
                                     trap_ne
7188 3 MichaelA
0fa7 : f002             [ 3]>        beq skip0838
7189
                            >        trap           ;failed equal (zero)
7190
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7191
0fa9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7192
0faa : 0f                   >        db      test_num
7193
                            >
7194
0fab :                      >skip0838
7195 2 MichaelA
 
7196 3 MichaelA
0fab : 68               [ 4]         pla         ;load status
7197 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
7198 3 MichaelA
0fac : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
7199 2 MichaelA
 
7200 3 MichaelA
0fae : d90d02           [ 4]         cmp fLDx,y  ;test flags
7201 2 MichaelA
                                     trap_ne
7202 3 MichaelA
0fb1 : f002             [ 3]>        beq skip0841
7203
                            >        trap           ;failed equal (zero)
7204
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7205
0fb3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7206
0fb4 : 0f                   >        db      test_num
7207
                            >
7208
0fb5 :                      >skip0841
7209 2 MichaelA
 
7210 3 MichaelA
0fb5 : 88               [ 2]         dey
7211
0fb6 : 10da             [ 3]         bpl tldx3
7212 2 MichaelA
 
7213 3 MichaelA
0fb8 : a003             [ 2]         ldy #3      ;testing store result
7214
0fba : a200             [ 2]         ldx #0
7215
0fbc : b9b200           [ 4] tstx    lda zpt,y
7216
0fbf : 49c3             [ 2]         eor #$c3
7217
0fc1 : d9b900           [ 4]         cmp zp1,y
7218
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  126
7219
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7220
 
7221 2 MichaelA
                                     trap_ne     ;store to zp data
7222 3 MichaelA
0fc4 : f002             [ 3]>        beq skip0843
7223
                            >        trap           ;failed equal (zero)
7224
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7225
0fc6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7226
0fc7 : 0f                   >        db      test_num
7227
                            >
7228
0fc8 :                      >skip0843
7229 2 MichaelA
 
7230 3 MichaelA
0fc8 : 96b2             [ 4]         stx zpt,y   ;clear
7231
0fca : b90302           [ 4]         lda abst,y
7232
0fcd : 49c3             [ 2]         eor #$c3
7233
0fcf : d90802           [ 4]         cmp abs1,y
7234 2 MichaelA
                                     trap_ne     ;store to abs data
7235 3 MichaelA
0fd2 : f002             [ 3]>        beq skip0845
7236
                            >        trap           ;failed equal (zero)
7237
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7238
0fd4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7239
0fd5 : 0f                   >        db      test_num
7240
                            >
7241
0fd6 :                      >skip0845
7242 2 MichaelA
 
7243 3 MichaelA
0fd6 : 8a               [ 2]         txa
7244
0fd7 : 990302           [ 5]         sta abst,y  ;clear
7245
0fda : 88               [ 2]         dey
7246
0fdb : 10df             [ 3]         bpl tstx
7247 2 MichaelA
                                     next_test
7248 3 MichaelA
0fdd : ad0002           [ 4]>            lda test_case   ;previous test
7249
0fe0 : c90f             [ 2]>            cmp #test_num
7250 2 MichaelA
                            >            trap_ne         ;test is out of sequence
7251 3 MichaelA
0fe2 : f002             [ 3]>        beq skip0848
7252
                            >        trap           ;failed equal (zero)
7253
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7254
0fe4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7255
0fe5 : 0f                   >        db      test_num
7256 2 MichaelA
                            >
7257 3 MichaelA
0fe6 :                      >skip0848
7258
                            >
7259 2 MichaelA
0010 =                      >test_num = test_num + 1
7260 3 MichaelA
0fe6 : a910             [ 2]>            lda #test_num   ;*** this tests' number
7261
0fe8 : 8d0002           [ 4]>            sta test_case
7262 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
7263
 
7264
 
7265
                             ; indexed wraparound test (only zp should wrap)
7266 3 MichaelA
 
7267
0feb : a0fd             [ 2]         ldy #3+$fa
7268
0fed : b6bf             [ 4] tldx4   ldx zp1-$fa&$ff,y   ;wrap on indexed zp
7269
0fef : 8a               [ 2]         txa
7270
0ff0 : 990901           [ 5]         sta abst-$fa,y      ;no STX abs,y!
7271
0ff3 : 88               [ 2]         dey
7272
0ff4 : c0fa             [ 2]         cpy #$fa
7273
0ff6 : b0f5             [ 3]         bcs tldx4
7274
0ff8 : a0fd             [ 2]         ldy #3+$fa
7275
0ffa : be0e01           [ 4] tldx5   ldx abs1-$fa,y      ;no wrap on indexed abs
7276
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  127
7277
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7278
 
7279
0ffd : 96b8             [ 4]         stx zpt-$fa&$ff,y
7280
0fff : 88               [ 2]         dey
7281
1000 : c0fa             [ 2]         cpy #$fa
7282
1002 : b0f6             [ 4]         bcs tldx5
7283
1004 : a003             [ 2]         ldy #3      ;testing wraparound result
7284
1006 : a200             [ 2]         ldx #0
7285
1008 : b9b200           [ 4] tstx1   lda zpt,y
7286
100b : d9b900           [ 4]         cmp zp1,y
7287 2 MichaelA
                                     trap_ne     ;store to zp data
7288 3 MichaelA
100e : f002             [ 3]>        beq skip0850
7289
                            >        trap           ;failed equal (zero)
7290
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7291
1010 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7292
1011 : 10                   >        db      test_num
7293
                            >
7294
1012 :                      >skip0850
7295 2 MichaelA
 
7296 3 MichaelA
1012 : 96b2             [ 4]         stx zpt,y   ;clear
7297
1014 : b90302           [ 4]         lda abst,y
7298
1017 : d90802           [ 4]         cmp abs1,y
7299 2 MichaelA
                                     trap_ne     ;store to abs data
7300 3 MichaelA
101a : f002             [ 3]>        beq skip0852
7301
                            >        trap           ;failed equal (zero)
7302
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7303
101c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7304
101d : 10                   >        db      test_num
7305
                            >
7306
101e :                      >skip0852
7307 2 MichaelA
 
7308 3 MichaelA
101e : 8a               [ 2]         txa
7309
101f : 990302           [ 5]         sta abst,y  ;clear
7310
1022 : 88               [ 2]         dey
7311
1023 : 10e3             [ 3]         bpl tstx1
7312 2 MichaelA
                                     next_test
7313 3 MichaelA
1025 : ad0002           [ 4]>            lda test_case   ;previous test
7314
1028 : c910             [ 2]>            cmp #test_num
7315 2 MichaelA
                            >            trap_ne         ;test is out of sequence
7316 3 MichaelA
102a : f002             [ 3]>        beq skip0855
7317
                            >        trap           ;failed equal (zero)
7318
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7319
102c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7320
102d : 10                   >        db      test_num
7321 2 MichaelA
                            >
7322 3 MichaelA
102e :                      >skip0855
7323
                            >
7324 2 MichaelA
0011 =                      >test_num = test_num + 1
7325 3 MichaelA
102e : a911             [ 2]>            lda #test_num   ;*** this tests' number
7326
1030 : 8d0002           [ 4]>            sta test_case
7327 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
7328
 
7329
 
7330
                             ; LDY / STY - zp,x / abs,x
7331 3 MichaelA
 
7332
1033 : a203             [ 2]         ldx #3
7333
1035 :                       tldy
7334
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  128
7335 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7336
 
7337
                                     set_stat 0
7338
                            >            load_flag 0
7339 3 MichaelA
1035 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
7340 2 MichaelA
                            >
7341 3 MichaelA
1037 : 48               [ 3]>            pha         ;use stack to load status
7342
1038 : 28               [ 4]>            plp
7343 2 MichaelA
 
7344 3 MichaelA
1039 : b4b9             [ 4]         ldy zp1,x
7345
103b : 08               [ 3]         php         ;test stores do not alter flags
7346
103c : 98               [ 2]         tya
7347
103d : 49c3             [ 2]         eor #$c3
7348
103f : 28               [ 4]         plp
7349
1040 : 9d0302           [ 5]         sta abst,x
7350
1043 : 08               [ 3]         php         ;flags after load/store sequence
7351
1044 : 49c3             [ 2]         eor #$c3
7352
1046 : dd0802           [ 4]         cmp abs1,x  ;test result
7353 2 MichaelA
                                     trap_ne
7354 3 MichaelA
1049 : f002             [ 3]>        beq skip0859
7355
                            >        trap           ;failed equal (zero)
7356
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7357
104b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7358
104c : 11                   >        db      test_num
7359
                            >
7360
104d :                      >skip0859
7361 2 MichaelA
 
7362 3 MichaelA
104d : 68               [ 4]         pla         ;load status
7363 2 MichaelA
                                     eor_flag 0
7364 3 MichaelA
104e : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
7365 2 MichaelA
 
7366 3 MichaelA
1050 : dd0d02           [ 4]         cmp fLDx,x  ;test flags
7367 2 MichaelA
                                     trap_ne
7368 3 MichaelA
1053 : f002             [ 3]>        beq skip0862
7369
                            >        trap           ;failed equal (zero)
7370
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7371
1055 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7372
1056 : 11                   >        db      test_num
7373
                            >
7374
1057 :                      >skip0862
7375 2 MichaelA
 
7376 3 MichaelA
1057 : ca               [ 2]         dex
7377
1058 : 10db             [ 3]         bpl tldy
7378 2 MichaelA
 
7379 3 MichaelA
105a : a203             [ 2]         ldx #3
7380
105c :                       tldy1
7381 2 MichaelA
                                     set_stat $ff
7382
                            >            load_flag $ff
7383 3 MichaelA
105c : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
7384 2 MichaelA
                            >
7385 3 MichaelA
105e : 48               [ 3]>            pha         ;use stack to load status
7386
105f : 28               [ 4]>            plp
7387 2 MichaelA
 
7388 3 MichaelA
1060 : b4b9             [ 4]         ldy zp1,x
7389
1062 : 08               [ 3]         php         ;test stores do not alter flags
7390
1063 : 98               [ 2]         tya
7391
1064 : 49c3             [ 2]         eor #$c3
7392
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  129
7393
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7394
 
7395
1066 : 28               [ 4]         plp
7396
1067 : 9d0302           [ 5]         sta abst,x
7397
106a : 08               [ 3]         php         ;flags after load/store sequence
7398
106b : 49c3             [ 2]         eor #$c3
7399
106d : dd0802           [ 4]         cmp abs1,x  ;test result
7400 2 MichaelA
                                     trap_ne
7401 3 MichaelA
1070 : f002             [ 3]>        beq skip0866
7402
                            >        trap           ;failed equal (zero)
7403
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7404
1072 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7405
1073 : 11                   >        db      test_num
7406
                            >
7407
1074 :                      >skip0866
7408 2 MichaelA
 
7409 3 MichaelA
1074 : 68               [ 4]         pla         ;load status
7410 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
7411 3 MichaelA
1075 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
7412 2 MichaelA
 
7413 3 MichaelA
1077 : dd0d02           [ 4]         cmp fLDx,x  ;test flags
7414 2 MichaelA
                                     trap_ne
7415 3 MichaelA
107a : f002             [ 3]>        beq skip0869
7416
                            >        trap           ;failed equal (zero)
7417
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7418
107c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7419
107d : 11                   >        db      test_num
7420
                            >
7421
107e :                      >skip0869
7422 2 MichaelA
 
7423 3 MichaelA
107e : ca               [ 2]         dex
7424
107f : 10db             [ 3]         bpl tldy1
7425 2 MichaelA
 
7426 3 MichaelA
1081 : a203             [ 2]         ldx #3
7427
1083 :                       tldy2
7428 2 MichaelA
                                     set_stat 0
7429
                            >            load_flag 0
7430 3 MichaelA
1083 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
7431 2 MichaelA
                            >
7432 3 MichaelA
1085 : 48               [ 3]>            pha         ;use stack to load status
7433
1086 : 28               [ 4]>            plp
7434 2 MichaelA
 
7435 3 MichaelA
1087 : bc0802           [ 4]         ldy abs1,x
7436
108a : 08               [ 3]         php         ;test stores do not alter flags
7437
108b : 98               [ 2]         tya
7438
108c : 49c3             [ 2]         eor #$c3
7439
108e : a8               [ 2]         tay
7440
108f : 28               [ 4]         plp
7441
1090 : 94b2             [ 4]         sty zpt,x
7442
1092 : 08               [ 3]         php         ;flags after load/store sequence
7443
1093 : 49c3             [ 2]         eor #$c3
7444
1095 : d5b9             [ 4]         cmp zp1,x   ;test result
7445 2 MichaelA
                                     trap_ne
7446 3 MichaelA
1097 : f002             [ 3]>        beq skip0873
7447
                            >        trap           ;failed equal (zero)
7448
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7449
1099 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7450
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  130
7451
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7452
 
7453
109a : 11                   >        db      test_num
7454
                            >
7455
109b :                      >skip0873
7456 2 MichaelA
 
7457 3 MichaelA
109b : 68               [ 4]         pla         ;load status
7458 2 MichaelA
                                     eor_flag 0
7459 3 MichaelA
109c : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
7460 2 MichaelA
 
7461 3 MichaelA
109e : dd0d02           [ 4]         cmp fLDx,x  ;test flags
7462 2 MichaelA
                                     trap_ne
7463 3 MichaelA
10a1 : f002             [ 3]>        beq skip0876
7464
                            >        trap           ;failed equal (zero)
7465
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7466
10a3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7467
10a4 : 11                   >        db      test_num
7468
                            >
7469
10a5 :                      >skip0876
7470 2 MichaelA
 
7471 3 MichaelA
10a5 : ca               [ 2]         dex
7472
10a6 : 10db             [ 3]         bpl tldy2
7473 2 MichaelA
 
7474 3 MichaelA
10a8 : a203             [ 2]         ldx #3
7475
10aa :                       tldy3
7476 2 MichaelA
                                     set_stat $ff
7477
                            >            load_flag $ff
7478 3 MichaelA
10aa : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
7479 2 MichaelA
                            >
7480 3 MichaelA
10ac : 48               [ 3]>            pha         ;use stack to load status
7481
10ad : 28               [ 4]>            plp
7482 2 MichaelA
 
7483 3 MichaelA
10ae : bc0802           [ 4]         ldy abs1,x
7484
10b1 : 08               [ 3]         php         ;test stores do not alter flags
7485
10b2 : 98               [ 2]         tya
7486
10b3 : 49c3             [ 2]         eor #$c3
7487
10b5 : a8               [ 2]         tay
7488
10b6 : 28               [ 4]         plp
7489
10b7 : 94b2             [ 4]         sty zpt,x
7490
10b9 : 08               [ 3]         php         ;flags after load/store sequence
7491
10ba : 49c3             [ 2]         eor #$c3
7492
10bc : d5b9             [ 4]         cmp zp1,x   ;test result
7493 2 MichaelA
                                     trap_ne
7494 3 MichaelA
10be : f002             [ 3]>        beq skip0880
7495
                            >        trap           ;failed equal (zero)
7496
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7497
10c0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7498
10c1 : 11                   >        db      test_num
7499
                            >
7500
10c2 :                      >skip0880
7501 2 MichaelA
 
7502 3 MichaelA
10c2 : 68               [ 4]         pla         ;load status
7503 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
7504 3 MichaelA
10c3 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
7505 2 MichaelA
 
7506 3 MichaelA
10c5 : dd0d02           [ 4]         cmp fLDx,x  ;test flags
7507 2 MichaelA
                                     trap_ne
7508 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  131
7509
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7510
 
7511
10c8 : f002             [ 3]>        beq skip0883
7512
                            >        trap           ;failed equal (zero)
7513
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7514
10ca : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7515
10cb : 11                   >        db      test_num
7516
                            >
7517
10cc :                      >skip0883
7518 2 MichaelA
 
7519 3 MichaelA
10cc : ca               [ 2]         dex
7520
10cd : 10db             [ 3]         bpl tldy3
7521 2 MichaelA
 
7522 3 MichaelA
10cf : a203             [ 2]         ldx #3      ;testing store result
7523
10d1 : a000             [ 2]         ldy #0
7524
10d3 : b5b2             [ 4] tsty    lda zpt,x
7525
10d5 : 49c3             [ 2]         eor #$c3
7526
10d7 : d5b9             [ 4]         cmp zp1,x
7527 2 MichaelA
                                     trap_ne     ;store to zp,x data
7528 3 MichaelA
10d9 : f002             [ 3]>        beq skip0885
7529
                            >        trap           ;failed equal (zero)
7530
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7531
10db : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7532
10dc : 11                   >        db      test_num
7533
                            >
7534
10dd :                      >skip0885
7535 2 MichaelA
 
7536 3 MichaelA
10dd : 94b2             [ 4]         sty zpt,x   ;clear
7537
10df : bd0302           [ 4]         lda abst,x
7538
10e2 : 49c3             [ 2]         eor #$c3
7539
10e4 : dd0802           [ 4]         cmp abs1,x
7540 2 MichaelA
                                     trap_ne     ;store to abs,x data
7541 3 MichaelA
10e7 : f002             [ 3]>        beq skip0887
7542
                            >        trap           ;failed equal (zero)
7543
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7544
10e9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7545
10ea : 11                   >        db      test_num
7546
                            >
7547
10eb :                      >skip0887
7548 2 MichaelA
 
7549 3 MichaelA
10eb : 8a               [ 2]         txa
7550
10ec : 9d0302           [ 5]         sta abst,x  ;clear
7551
10ef : ca               [ 2]         dex
7552
10f0 : 10e1             [ 3]         bpl tsty
7553 2 MichaelA
                                     next_test
7554 3 MichaelA
10f2 : ad0002           [ 4]>            lda test_case   ;previous test
7555
10f5 : c911             [ 2]>            cmp #test_num
7556 2 MichaelA
                            >            trap_ne         ;test is out of sequence
7557 3 MichaelA
10f7 : f002             [ 3]>        beq skip0890
7558
                            >        trap           ;failed equal (zero)
7559
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7560
10f9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7561
10fa : 11                   >        db      test_num
7562 2 MichaelA
                            >
7563 3 MichaelA
10fb :                      >skip0890
7564
                            >
7565 2 MichaelA
0012 =                      >test_num = test_num + 1
7566 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  132
7567
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7568
 
7569
10fb : a912             [ 2]>            lda #test_num   ;*** this tests' number
7570
10fd : 8d0002           [ 4]>            sta test_case
7571 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
7572
 
7573
 
7574
                             ; indexed wraparound test (only zp should wrap)
7575 3 MichaelA
 
7576
1100 : a2fd             [ 2]         ldx #3+$fa
7577
1102 : b4bf             [ 4] tldy4   ldy zp1-$fa&$ff,x   ;wrap on indexed zp
7578
1104 : 98               [ 2]         tya
7579
1105 : 9d0901           [ 5]         sta abst-$fa,x      ;no STX abs,x!
7580
1108 : ca               [ 2]         dex
7581
1109 : e0fa             [ 2]         cpx #$fa
7582
110b : b0f5             [ 3]         bcs tldy4
7583
110d : a2fd             [ 2]         ldx #3+$fa
7584
110f : bc0e01           [ 4] tldy5   ldy abs1-$fa,x      ;no wrap on indexed abs
7585
1112 : 94b8             [ 4]         sty zpt-$fa&$ff,x
7586
1114 : ca               [ 2]         dex
7587
1115 : e0fa             [ 2]         cpx #$fa
7588
1117 : b0f6             [ 3]         bcs tldy5
7589
1119 : a203             [ 2]         ldx #3      ;testing wraparound result
7590
111b : a000             [ 2]         ldy #0
7591
111d : b5b2             [ 4] tsty1   lda zpt,x
7592
111f : d5b9             [ 4]         cmp zp1,x
7593 2 MichaelA
                                     trap_ne     ;store to zp,x data
7594 3 MichaelA
1121 : f002             [ 3]>        beq skip0892
7595
                            >        trap           ;failed equal (zero)
7596
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7597
1123 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7598
1124 : 12                   >        db      test_num
7599
                            >
7600
1125 :                      >skip0892
7601 2 MichaelA
 
7602 3 MichaelA
1125 : 94b2             [ 4]         sty zpt,x   ;clear
7603
1127 : bd0302           [ 4]         lda abst,x
7604
112a : dd0802           [ 4]         cmp abs1,x
7605 2 MichaelA
                                     trap_ne     ;store to abs,x data
7606 3 MichaelA
112d : f002             [ 3]>        beq skip0894
7607
                            >        trap           ;failed equal (zero)
7608
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7609
112f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7610
1130 : 12                   >        db      test_num
7611
                            >
7612
1131 :                      >skip0894
7613 2 MichaelA
 
7614 3 MichaelA
1131 : 8a               [ 2]         txa
7615
1132 : 9d0302           [ 5]         sta abst,x  ;clear
7616
1135 : ca               [ 2]         dex
7617
1136 : 10e5             [ 3]         bpl tsty1
7618 2 MichaelA
                                     next_test
7619 3 MichaelA
1138 : ad0002           [ 4]>            lda test_case   ;previous test
7620
113b : c912             [ 2]>            cmp #test_num
7621 2 MichaelA
                            >            trap_ne         ;test is out of sequence
7622 3 MichaelA
113d : f002             [ 3]>        beq skip0897
7623
                            >        trap           ;failed equal (zero)
7624
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  133
7625
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7626
 
7627
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7628
113f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7629
1140 : 12                   >        db      test_num
7630 2 MichaelA
                            >
7631 3 MichaelA
1141 :                      >skip0897
7632
                            >
7633 2 MichaelA
0013 =                      >test_num = test_num + 1
7634 3 MichaelA
1141 : a913             [ 2]>            lda #test_num   ;*** this tests' number
7635
1143 : 8d0002           [ 4]>            sta test_case
7636 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
7637
 
7638
 
7639
                             ; LDX / STX - zp / abs / #
7640 3 MichaelA
 
7641 2 MichaelA
                                     set_stat 0
7642
                            >            load_flag 0
7643 3 MichaelA
1146 : a900             [ 2]>            lda #0               ;allow test to change I-flag (no mask)
7644 2 MichaelA
                            >
7645 3 MichaelA
1148 : 48               [ 3]>            pha         ;use stack to load status
7646
1149 : 28               [ 4]>            plp
7647 2 MichaelA
 
7648 3 MichaelA
114a : a6b9             [ 3]         ldx zp1
7649
114c : 08               [ 3]         php         ;test stores do not alter flags
7650
114d : 8a               [ 2]         txa
7651
114e : 49c3             [ 2]         eor #$c3
7652
1150 : aa               [ 2]         tax
7653
1151 : 28               [ 4]         plp
7654
1152 : 8e0302           [ 4]         stx abst
7655
1155 : 08               [ 3]         php         ;flags after load/store sequence
7656
1156 : 49c3             [ 2]         eor #$c3
7657
1158 : aa               [ 2]         tax
7658
1159 : e0c3             [ 2]         cpx #$c3    ;test result
7659 2 MichaelA
                                     trap_ne
7660 3 MichaelA
115b : f002             [ 3]>        beq skip0901
7661
                            >        trap           ;failed equal (zero)
7662
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7663
115d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7664
115e : 13                   >        db      test_num
7665
                            >
7666
115f :                      >skip0901
7667 2 MichaelA
 
7668 3 MichaelA
115f : 68               [ 4]         pla         ;load status
7669 2 MichaelA
                                     eor_flag 0
7670 3 MichaelA
1160 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
7671 2 MichaelA
 
7672 3 MichaelA
1162 : cd0d02           [ 4]         cmp fLDx    ;test flags
7673 2 MichaelA
                                     trap_ne
7674 3 MichaelA
1165 : f002             [ 3]>        beq skip0904
7675
                            >        trap           ;failed equal (zero)
7676
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7677
1167 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7678
1168 : 13                   >        db      test_num
7679
                            >
7680
1169 :                      >skip0904
7681 2 MichaelA
 
7682 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  134
7683
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7684
 
7685 2 MichaelA
                                     set_stat 0
7686
                            >            load_flag 0
7687 3 MichaelA
1169 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
7688 2 MichaelA
                            >
7689 3 MichaelA
116b : 48               [ 3]>            pha         ;use stack to load status
7690
116c : 28               [ 4]>            plp
7691 2 MichaelA
 
7692 3 MichaelA
116d : a6ba             [ 3]         ldx zp1+1
7693
116f : 08               [ 3]         php         ;test stores do not alter flags
7694
1170 : 8a               [ 2]         txa
7695
1171 : 49c3             [ 2]         eor #$c3
7696
1173 : aa               [ 2]         tax
7697
1174 : 28               [ 4]         plp
7698
1175 : 8e0402           [ 4]         stx abst+1
7699
1178 : 08               [ 3]         php         ;flags after load/store sequence
7700
1179 : 49c3             [ 2]         eor #$c3
7701
117b : aa               [ 2]         tax
7702
117c : e082             [ 2]         cpx #$82    ;test result
7703 2 MichaelA
                                     trap_ne
7704 3 MichaelA
117e : f002             [ 3]>        beq skip0908
7705
                            >        trap           ;failed equal (zero)
7706
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7707
1180 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7708
1181 : 13                   >        db      test_num
7709
                            >
7710
1182 :                      >skip0908
7711 2 MichaelA
 
7712 3 MichaelA
1182 : 68               [ 4]         pla         ;load status
7713 2 MichaelA
                                     eor_flag 0
7714 3 MichaelA
1183 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
7715 2 MichaelA
 
7716 3 MichaelA
1185 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
7717 2 MichaelA
                                     trap_ne
7718 3 MichaelA
1188 : f002             [ 3]>        beq skip0911
7719
                            >        trap           ;failed equal (zero)
7720
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7721
118a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7722
118b : 13                   >        db      test_num
7723
                            >
7724
118c :                      >skip0911
7725 2 MichaelA
 
7726
                                     set_stat 0
7727
                            >            load_flag 0
7728 3 MichaelA
118c : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
7729 2 MichaelA
                            >
7730 3 MichaelA
118e : 48               [ 3]>            pha         ;use stack to load status
7731
118f : 28               [ 4]>            plp
7732 2 MichaelA
 
7733 3 MichaelA
1190 : a6bb             [ 3]         ldx zp1+2
7734
1192 : 08               [ 3]         php         ;test stores do not alter flags
7735
1193 : 8a               [ 2]         txa
7736
1194 : 49c3             [ 2]         eor #$c3
7737
1196 : aa               [ 2]         tax
7738
1197 : 28               [ 4]         plp
7739
1198 : 8e0502           [ 4]         stx abst+2
7740
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  135
7741 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7742
 
7743 3 MichaelA
119b : 08               [ 3]         php         ;flags after load/store sequence
7744
119c : 49c3             [ 2]         eor #$c3
7745
119e : aa               [ 2]         tax
7746
119f : e041             [ 2]         cpx #$41    ;test result
7747 2 MichaelA
                                     trap_ne
7748 3 MichaelA
11a1 : f002             [ 3]>        beq skip0915
7749
                            >        trap           ;failed equal (zero)
7750
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7751
11a3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7752
11a4 : 13                   >        db      test_num
7753
                            >
7754
11a5 :                      >skip0915
7755 2 MichaelA
 
7756 3 MichaelA
11a5 : 68               [ 4]         pla         ;load status
7757 2 MichaelA
                                     eor_flag 0
7758 3 MichaelA
11a6 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
7759 2 MichaelA
 
7760 3 MichaelA
11a8 : cd0f02           [ 4]         cmp fLDx+2  ;test flags
7761 2 MichaelA
                                     trap_ne
7762 3 MichaelA
11ab : f002             [ 3]>        beq skip0918
7763
                            >        trap           ;failed equal (zero)
7764
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7765
11ad : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7766
11ae : 13                   >        db      test_num
7767
                            >
7768
11af :                      >skip0918
7769 2 MichaelA
 
7770
                                     set_stat 0
7771
                            >            load_flag 0
7772 3 MichaelA
11af : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
7773 2 MichaelA
                            >
7774 3 MichaelA
11b1 : 48               [ 3]>            pha         ;use stack to load status
7775
11b2 : 28               [ 4]>            plp
7776 2 MichaelA
 
7777 3 MichaelA
11b3 : a6bc             [ 3]         ldx zp1+3
7778
11b5 : 08               [ 3]         php         ;test stores do not alter flags
7779
11b6 : 8a               [ 2]         txa
7780
11b7 : 49c3             [ 2]         eor #$c3
7781
11b9 : aa               [ 2]         tax
7782
11ba : 28               [ 4]         plp
7783
11bb : 8e0602           [ 4]         stx abst+3
7784
11be : 08               [ 3]         php         ;flags after load/store sequence
7785
11bf : 49c3             [ 2]         eor #$c3
7786
11c1 : aa               [ 2]         tax
7787
11c2 : e000             [ 2]         cpx #0      ;test result
7788 2 MichaelA
                                     trap_ne
7789 3 MichaelA
11c4 : f002             [ 3]>        beq skip0922
7790
                            >        trap           ;failed equal (zero)
7791
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7792
11c6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7793
11c7 : 13                   >        db      test_num
7794
                            >
7795
11c8 :                      >skip0922
7796 2 MichaelA
 
7797 3 MichaelA
11c8 : 68               [ 4]         pla         ;load status
7798
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  136
7799
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7800
 
7801 2 MichaelA
                                     eor_flag 0
7802 3 MichaelA
11c9 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
7803 2 MichaelA
 
7804 3 MichaelA
11cb : cd1002           [ 4]         cmp fLDx+3  ;test flags
7805 2 MichaelA
                                     trap_ne
7806 3 MichaelA
11ce : f002             [ 3]>        beq skip0925
7807
                            >        trap           ;failed equal (zero)
7808
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7809
11d0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7810
11d1 : 13                   >        db      test_num
7811
                            >
7812
11d2 :                      >skip0925
7813 2 MichaelA
 
7814
 
7815
                                     set_stat $ff
7816
                            >            load_flag $ff
7817 3 MichaelA
11d2 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
7818 2 MichaelA
                            >
7819 3 MichaelA
11d4 : 48               [ 3]>            pha         ;use stack to load status
7820
11d5 : 28               [ 4]>            plp
7821 2 MichaelA
 
7822 3 MichaelA
11d6 : a6b9             [ 3]         ldx zp1
7823
11d8 : 08               [ 3]         php         ;test stores do not alter flags
7824
11d9 : 8a               [ 2]         txa
7825
11da : 49c3             [ 2]         eor #$c3
7826
11dc : aa               [ 2]         tax
7827
11dd : 28               [ 4]         plp
7828
11de : 8e0302           [ 4]         stx abst
7829
11e1 : 08               [ 3]         php         ;flags after load/store sequence
7830
11e2 : 49c3             [ 2]         eor #$c3
7831
11e4 : aa               [ 2]         tax
7832
11e5 : e0c3             [ 2]         cpx #$c3    ;test result
7833 2 MichaelA
                                     trap_ne     ;
7834 3 MichaelA
11e7 : f002             [ 3]>        beq skip0929
7835
                            >        trap           ;failed equal (zero)
7836
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7837
11e9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7838
11ea : 13                   >        db      test_num
7839
                            >
7840
11eb :                      >skip0929
7841 2 MichaelA
 
7842 3 MichaelA
11eb : 68               [ 4]         pla         ;load status
7843 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
7844 3 MichaelA
11ec : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
7845 2 MichaelA
 
7846 3 MichaelA
11ee : cd0d02           [ 4]         cmp fLDx    ;test flags
7847 2 MichaelA
                                     trap_ne
7848 3 MichaelA
11f1 : f002             [ 3]>        beq skip0932
7849
                            >        trap           ;failed equal (zero)
7850
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7851
11f3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7852
11f4 : 13                   >        db      test_num
7853
                            >
7854
11f5 :                      >skip0932
7855 2 MichaelA
 
7856 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  137
7857
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7858
 
7859 2 MichaelA
                                     set_stat $ff
7860
                            >            load_flag $ff
7861 3 MichaelA
11f5 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
7862 2 MichaelA
                            >
7863 3 MichaelA
11f7 : 48               [ 3]>            pha         ;use stack to load status
7864
11f8 : 28               [ 4]>            plp
7865 2 MichaelA
 
7866 3 MichaelA
11f9 : a6ba             [ 3]         ldx zp1+1
7867
11fb : 08               [ 3]         php         ;test stores do not alter flags
7868
11fc : 8a               [ 2]         txa
7869
11fd : 49c3             [ 2]         eor #$c3
7870
11ff : aa               [ 2]         tax
7871
1200 : 28               [ 4]         plp
7872
1201 : 8e0402           [ 4]         stx abst+1
7873
1204 : 08               [ 3]         php         ;flags after load/store sequence
7874
1205 : 49c3             [ 2]         eor #$c3
7875
1207 : aa               [ 2]         tax
7876
1208 : e082             [ 2]         cpx #$82    ;test result
7877 2 MichaelA
                                     trap_ne
7878 3 MichaelA
120a : f002             [ 3]>        beq skip0936
7879
                            >        trap           ;failed equal (zero)
7880
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7881
120c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7882
120d : 13                   >        db      test_num
7883
                            >
7884
120e :                      >skip0936
7885 2 MichaelA
 
7886 3 MichaelA
120e : 68               [ 4]         pla         ;load status
7887 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
7888 3 MichaelA
120f : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
7889 2 MichaelA
 
7890 3 MichaelA
1211 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
7891 2 MichaelA
                                     trap_ne
7892 3 MichaelA
1214 : f002             [ 3]>        beq skip0939
7893
                            >        trap           ;failed equal (zero)
7894
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7895
1216 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7896
1217 : 13                   >        db      test_num
7897
                            >
7898
1218 :                      >skip0939
7899 2 MichaelA
 
7900
                                     set_stat $ff
7901
                            >            load_flag $ff
7902 3 MichaelA
1218 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
7903 2 MichaelA
                            >
7904 3 MichaelA
121a : 48               [ 3]>            pha         ;use stack to load status
7905
121b : 28               [ 4]>            plp
7906
 
7907
121c : a6bb             [ 3]         ldx zp1+2
7908
121e : 08               [ 3]         php         ;test stores do not alter flags
7909
121f : 8a               [ 2]         txa
7910
1220 : 49c3             [ 2]         eor #$c3
7911
1222 : aa               [ 2]         tax
7912
1223 : 28               [ 4]         plp
7913
1224 : 8e0502           [ 4]         stx abst+2
7914
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  138
7915 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7916
 
7917 3 MichaelA
1227 : 08               [ 3]         php         ;flags after load/store sequence
7918
1228 : 49c3             [ 2]         eor #$c3
7919
122a : aa               [ 2]         tax
7920
122b : e041             [ 2]         cpx #$41    ;test result
7921 2 MichaelA
                                     trap_ne     ;
7922 3 MichaelA
122d : f002             [ 3]>        beq skip0943
7923
                            >        trap           ;failed equal (zero)
7924
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7925
122f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7926
1230 : 13                   >        db      test_num
7927
                            >
7928
1231 :                      >skip0943
7929 2 MichaelA
 
7930 3 MichaelA
1231 : 68               [ 4]         pla         ;load status
7931 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
7932 3 MichaelA
1232 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
7933 2 MichaelA
 
7934 3 MichaelA
1234 : cd0f02           [ 4]         cmp fLDx+2  ;test flags
7935 2 MichaelA
                                     trap_ne
7936 3 MichaelA
1237 : f002             [ 3]>        beq skip0946
7937
                            >        trap           ;failed equal (zero)
7938
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7939
1239 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7940
123a : 13                   >        db      test_num
7941
                            >
7942
123b :                      >skip0946
7943 2 MichaelA
 
7944
                                     set_stat $ff
7945
                            >            load_flag $ff
7946 3 MichaelA
123b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
7947 2 MichaelA
                            >
7948 3 MichaelA
123d : 48               [ 3]>            pha         ;use stack to load status
7949
123e : 28               [ 4]>            plp
7950 2 MichaelA
 
7951 3 MichaelA
123f : a6bc             [ 3]         ldx zp1+3
7952
1241 : 08               [ 3]         php         ;test stores do not alter flags
7953
1242 : 8a               [ 2]         txa
7954
1243 : 49c3             [ 2]         eor #$c3
7955
1245 : aa               [ 2]         tax
7956
1246 : 28               [ 4]         plp
7957
1247 : 8e0602           [ 4]         stx abst+3
7958
124a : 08               [ 3]         php         ;flags after load/store sequence
7959
124b : 49c3             [ 2]         eor #$c3
7960
124d : aa               [ 2]         tax
7961
124e : e000             [ 2]         cpx #0      ;test result
7962 2 MichaelA
                                     trap_ne
7963 3 MichaelA
1250 : f002             [ 3]>        beq skip0950
7964
                            >        trap           ;failed equal (zero)
7965
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7966
1252 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7967
1253 : 13                   >        db      test_num
7968
                            >
7969
1254 :                      >skip0950
7970 2 MichaelA
 
7971 3 MichaelA
1254 : 68               [ 4]         pla         ;load status
7972
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  139
7973
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
7974
 
7975 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
7976 3 MichaelA
1255 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
7977 2 MichaelA
 
7978 3 MichaelA
1257 : cd1002           [ 4]         cmp fLDx+3  ;test flags
7979 2 MichaelA
                                     trap_ne
7980 3 MichaelA
125a : f002             [ 3]>        beq skip0953
7981
                            >        trap           ;failed equal (zero)
7982
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
7983
125c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
7984
125d : 13                   >        db      test_num
7985
                            >
7986
125e :                      >skip0953
7987 2 MichaelA
 
7988
 
7989
                                     set_stat 0
7990
                            >            load_flag 0
7991 3 MichaelA
125e : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
7992 2 MichaelA
                            >
7993 3 MichaelA
1260 : 48               [ 3]>            pha         ;use stack to load status
7994
1261 : 28               [ 4]>            plp
7995 2 MichaelA
 
7996 3 MichaelA
1262 : ae0802           [ 4]         ldx abs1
7997
1265 : 08               [ 3]         php         ;test stores do not alter flags
7998
1266 : 8a               [ 2]         txa
7999
1267 : 49c3             [ 2]         eor #$c3
8000
1269 : aa               [ 2]         tax
8001
126a : 28               [ 4]         plp
8002
126b : 86b2             [ 3]         stx zpt
8003
126d : 08               [ 3]         php         ;flags after load/store sequence
8004
126e : 49c3             [ 2]         eor #$c3
8005
1270 : c5b9             [ 3]         cmp zp1     ;test result
8006 2 MichaelA
                                     trap_ne
8007 3 MichaelA
1272 : f002             [ 3]>        beq skip0957
8008
                            >        trap           ;failed equal (zero)
8009
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8010
1274 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8011
1275 : 13                   >        db      test_num
8012
                            >
8013
1276 :                      >skip0957
8014 2 MichaelA
 
8015 3 MichaelA
1276 : 68               [ 4]         pla         ;load status
8016 2 MichaelA
                                     eor_flag 0
8017 3 MichaelA
1277 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
8018 2 MichaelA
 
8019 3 MichaelA
1279 : cd0d02           [ 4]         cmp fLDx    ;test flags
8020 2 MichaelA
                                     trap_ne
8021 3 MichaelA
127c : f002             [ 3]>        beq skip0960
8022
                            >        trap           ;failed equal (zero)
8023
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8024
127e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8025
127f : 13                   >        db      test_num
8026
                            >
8027
1280 :                      >skip0960
8028 2 MichaelA
 
8029
                                     set_stat 0
8030 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  140
8031
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8032
 
8033 2 MichaelA
                            >            load_flag 0
8034 3 MichaelA
1280 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
8035 2 MichaelA
                            >
8036 3 MichaelA
1282 : 48               [ 3]>            pha         ;use stack to load status
8037
1283 : 28               [ 4]>            plp
8038 2 MichaelA
 
8039 3 MichaelA
1284 : ae0902           [ 4]         ldx abs1+1
8040
1287 : 08               [ 3]         php         ;test stores do not alter flags
8041
1288 : 8a               [ 2]         txa
8042
1289 : 49c3             [ 2]         eor #$c3
8043
128b : aa               [ 2]         tax
8044
128c : 28               [ 4]         plp
8045
128d : 86b3             [ 3]         stx zpt+1
8046
128f : 08               [ 3]         php         ;flags after load/store sequence
8047
1290 : 49c3             [ 2]         eor #$c3
8048
1292 : c5ba             [ 3]         cmp zp1+1   ;test result
8049 2 MichaelA
                                     trap_ne
8050 3 MichaelA
1294 : f002             [ 3]>        beq skip0964
8051
                            >        trap           ;failed equal (zero)
8052
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8053
1296 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8054
1297 : 13                   >        db      test_num
8055
                            >
8056
1298 :                      >skip0964
8057 2 MichaelA
 
8058 3 MichaelA
1298 : 68               [ 4]         pla         ;load status
8059 2 MichaelA
                                     eor_flag 0
8060 3 MichaelA
1299 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
8061 2 MichaelA
 
8062 3 MichaelA
129b : cd0e02           [ 4]         cmp fLDx+1  ;test flags
8063 2 MichaelA
                                     trap_ne
8064 3 MichaelA
129e : f002             [ 3]>        beq skip0967
8065
                            >        trap           ;failed equal (zero)
8066
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8067
12a0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8068
12a1 : 13                   >        db      test_num
8069
                            >
8070
12a2 :                      >skip0967
8071 2 MichaelA
 
8072
                                     set_stat 0
8073
                            >            load_flag 0
8074 3 MichaelA
12a2 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
8075 2 MichaelA
                            >
8076 3 MichaelA
12a4 : 48               [ 3]>            pha         ;use stack to load status
8077
12a5 : 28               [ 4]>            plp
8078 2 MichaelA
 
8079 3 MichaelA
12a6 : ae0a02           [ 4]         ldx abs1+2
8080
12a9 : 08               [ 3]         php         ;test stores do not alter flags
8081
12aa : 8a               [ 2]         txa
8082
12ab : 49c3             [ 2]         eor #$c3
8083
12ad : aa               [ 2]         tax
8084
12ae : 28               [ 4]         plp
8085
12af : 86b4             [ 3]         stx zpt+2
8086
12b1 : 08               [ 3]         php         ;flags after load/store sequence
8087
12b2 : 49c3             [ 2]         eor #$c3
8088
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  141
8089
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8090
 
8091
12b4 : c5bb             [ 3]         cmp zp1+2   ;test result
8092 2 MichaelA
                                     trap_ne
8093 3 MichaelA
12b6 : f002             [ 3]>        beq skip0971
8094
                            >        trap           ;failed equal (zero)
8095
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8096
12b8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8097
12b9 : 13                   >        db      test_num
8098
                            >
8099
12ba :                      >skip0971
8100 2 MichaelA
 
8101 3 MichaelA
12ba : 68               [ 4]         pla         ;load status
8102 2 MichaelA
                                     eor_flag 0
8103 3 MichaelA
12bb : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
8104 2 MichaelA
 
8105 3 MichaelA
12bd : cd0f02           [ 4]         cmp fLDx+2  ;test flags
8106 2 MichaelA
                                     trap_ne
8107 3 MichaelA
12c0 : f002             [ 3]>        beq skip0974
8108
                            >        trap           ;failed equal (zero)
8109
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8110
12c2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8111
12c3 : 13                   >        db      test_num
8112
                            >
8113
12c4 :                      >skip0974
8114 2 MichaelA
 
8115
                                     set_stat 0
8116
                            >            load_flag 0
8117 3 MichaelA
12c4 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
8118 2 MichaelA
                            >
8119 3 MichaelA
12c6 : 48               [ 3]>            pha         ;use stack to load status
8120
12c7 : 28               [ 4]>            plp
8121 2 MichaelA
 
8122 3 MichaelA
12c8 : ae0b02           [ 4]         ldx abs1+3
8123
12cb : 08               [ 3]         php         ;test stores do not alter flags
8124
12cc : 8a               [ 2]         txa
8125
12cd : 49c3             [ 2]         eor #$c3
8126
12cf : aa               [ 2]         tax
8127
12d0 : 28               [ 4]         plp
8128
12d1 : 86b5             [ 3]         stx zpt+3
8129
12d3 : 08               [ 3]         php         ;flags after load/store sequence
8130
12d4 : 49c3             [ 2]         eor #$c3
8131
12d6 : c5bc             [ 3]         cmp zp1+3   ;test result
8132 2 MichaelA
                                     trap_ne
8133 3 MichaelA
12d8 : f002             [ 3]>        beq skip0978
8134
                            >        trap           ;failed equal (zero)
8135
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8136
12da : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8137
12db : 13                   >        db      test_num
8138
                            >
8139
12dc :                      >skip0978
8140 2 MichaelA
 
8141 3 MichaelA
12dc : 68               [ 4]         pla         ;load status
8142 2 MichaelA
                                     eor_flag 0
8143 3 MichaelA
12dd : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
8144 2 MichaelA
 
8145 3 MichaelA
12df : cd1002           [ 4]         cmp fLDx+3  ;test flags
8146
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  142
8147 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8148
 
8149 3 MichaelA
                                     trap_ne
8150
12e2 : f002             [ 3]>        beq skip0981
8151
                            >        trap           ;failed equal (zero)
8152
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8153
12e4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8154
12e5 : 13                   >        db      test_num
8155
                            >
8156
12e6 :                      >skip0981
8157 2 MichaelA
 
8158 3 MichaelA
 
8159 2 MichaelA
                                     set_stat $ff
8160
                            >            load_flag $ff
8161 3 MichaelA
12e6 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
8162 2 MichaelA
                            >
8163 3 MichaelA
12e8 : 48               [ 3]>            pha         ;use stack to load status
8164
12e9 : 28               [ 4]>            plp
8165 2 MichaelA
 
8166 3 MichaelA
12ea : ae0802           [ 4]         ldx abs1
8167
12ed : 08               [ 3]         php         ;test stores do not alter flags
8168
12ee : 8a               [ 2]         txa
8169
12ef : 49c3             [ 2]         eor #$c3
8170
12f1 : aa               [ 2]         tax
8171
12f2 : 28               [ 4]         plp
8172
12f3 : 86b2             [ 3]         stx zpt
8173
12f5 : 08               [ 3]         php         ;flags after load/store sequence
8174
12f6 : 49c3             [ 2]         eor #$c3
8175
12f8 : aa               [ 2]         tax
8176
12f9 : e4b9             [ 3]         cpx zp1     ;test result
8177 2 MichaelA
                                     trap_ne
8178 3 MichaelA
12fb : f002             [ 3]>        beq skip0985
8179
                            >        trap           ;failed equal (zero)
8180
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8181
12fd : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8182
12fe : 13                   >        db      test_num
8183
                            >
8184
12ff :                      >skip0985
8185 2 MichaelA
 
8186 3 MichaelA
12ff : 68               [ 4]         pla         ;load status
8187 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
8188 3 MichaelA
1300 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
8189 2 MichaelA
 
8190 3 MichaelA
1302 : cd0d02           [ 4]         cmp fLDx    ;test flags
8191 2 MichaelA
                                     trap_ne
8192 3 MichaelA
1305 : f002             [ 3]>        beq skip0988
8193
                            >        trap           ;failed equal (zero)
8194
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8195
1307 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8196
1308 : 13                   >        db      test_num
8197
                            >
8198
1309 :                      >skip0988
8199 2 MichaelA
 
8200
                                     set_stat $ff
8201
                            >            load_flag $ff
8202 3 MichaelA
1309 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
8203 2 MichaelA
                            >
8204 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  143
8205
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8206
 
8207
130b : 48               [ 3]>            pha         ;use stack to load status
8208
130c : 28               [ 4]>            plp
8209 2 MichaelA
 
8210 3 MichaelA
130d : ae0902           [ 4]         ldx abs1+1
8211
1310 : 08               [ 3]         php         ;test stores do not alter flags
8212
1311 : 8a               [ 2]         txa
8213
1312 : 49c3             [ 2]         eor #$c3
8214
1314 : aa               [ 2]         tax
8215
1315 : 28               [ 4]         plp
8216
1316 : 86b3             [ 3]         stx zpt+1
8217
1318 : 08               [ 3]         php         ;flags after load/store sequence
8218
1319 : 49c3             [ 2]         eor #$c3
8219
131b : aa               [ 2]         tax
8220
131c : e4ba             [ 3]         cpx zp1+1   ;test result
8221 2 MichaelA
                                     trap_ne
8222 3 MichaelA
131e : f002             [ 3]>        beq skip0992
8223
                            >        trap           ;failed equal (zero)
8224
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8225
1320 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8226
1321 : 13                   >        db      test_num
8227
                            >
8228
1322 :                      >skip0992
8229 2 MichaelA
 
8230 3 MichaelA
1322 : 68               [ 4]         pla         ;load status
8231 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
8232 3 MichaelA
1323 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
8233 2 MichaelA
 
8234 3 MichaelA
1325 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
8235 2 MichaelA
                                     trap_ne
8236 3 MichaelA
1328 : f002             [ 3]>        beq skip0995
8237
                            >        trap           ;failed equal (zero)
8238
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8239
132a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8240
132b : 13                   >        db      test_num
8241
                            >
8242
132c :                      >skip0995
8243 2 MichaelA
 
8244
                                     set_stat $ff
8245
                            >            load_flag $ff
8246 3 MichaelA
132c : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
8247 2 MichaelA
                            >
8248 3 MichaelA
132e : 48               [ 3]>            pha         ;use stack to load status
8249
132f : 28               [ 4]>            plp
8250 2 MichaelA
 
8251 3 MichaelA
1330 : ae0a02           [ 4]         ldx abs1+2
8252
1333 : 08               [ 3]         php         ;test stores do not alter flags
8253
1334 : 8a               [ 2]         txa
8254
1335 : 49c3             [ 2]         eor #$c3
8255
1337 : aa               [ 2]         tax
8256
1338 : 28               [ 4]         plp
8257
1339 : 86b4             [ 3]         stx zpt+2
8258
133b : 08               [ 3]         php         ;flags after load/store sequence
8259
133c : 49c3             [ 2]         eor #$c3
8260
133e : aa               [ 2]         tax
8261
133f : e4bb             [ 3]         cpx zp1+2   ;test result
8262
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  144
8263
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8264
 
8265 2 MichaelA
                                     trap_ne
8266 3 MichaelA
1341 : f002             [ 3]>        beq skip0999
8267
                            >        trap           ;failed equal (zero)
8268
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8269
1343 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8270
1344 : 13                   >        db      test_num
8271
                            >
8272
1345 :                      >skip0999
8273 2 MichaelA
 
8274 3 MichaelA
1345 : 68               [ 4]         pla         ;load status
8275 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
8276 3 MichaelA
1346 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
8277 2 MichaelA
 
8278 3 MichaelA
1348 : cd0f02           [ 4]         cmp fLDx+2  ;test flags
8279 2 MichaelA
                                     trap_ne
8280 3 MichaelA
134b : f002             [ 3]>        beq skip1002
8281
                            >        trap           ;failed equal (zero)
8282
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8283
134d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8284
134e : 13                   >        db      test_num
8285
                            >
8286
134f :                      >skip1002
8287 2 MichaelA
 
8288
                                     set_stat $ff
8289
                            >            load_flag $ff
8290 3 MichaelA
134f : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
8291 2 MichaelA
                            >
8292 3 MichaelA
1351 : 48               [ 3]>            pha         ;use stack to load status
8293
1352 : 28               [ 4]>            plp
8294 2 MichaelA
 
8295 3 MichaelA
1353 : ae0b02           [ 4]         ldx abs1+3
8296
1356 : 08               [ 3]         php         ;test stores do not alter flags
8297
1357 : 8a               [ 2]         txa
8298
1358 : 49c3             [ 2]         eor #$c3
8299
135a : aa               [ 2]         tax
8300
135b : 28               [ 4]         plp
8301
135c : 86b5             [ 3]         stx zpt+3
8302
135e : 08               [ 3]         php         ;flags after load/store sequence
8303
135f : 49c3             [ 2]         eor #$c3
8304
1361 : aa               [ 2]         tax
8305
1362 : e4bc             [ 3]         cpx zp1+3   ;test result
8306 2 MichaelA
                                     trap_ne
8307 3 MichaelA
1364 : f002             [ 3]>        beq skip1006
8308
                            >        trap           ;failed equal (zero)
8309
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8310
1366 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8311
1367 : 13                   >        db      test_num
8312
                            >
8313
1368 :                      >skip1006
8314 2 MichaelA
 
8315 3 MichaelA
1368 : 68               [ 4]         pla         ;load status
8316
                                     eor_flag lo~fnz ;mask bits not altered
8317
1369 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
8318
 
8319
136b : cd1002           [ 4]         cmp fLDx+3  ;test flags
8320
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  145
8321 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8322
 
8323
                                     trap_ne
8324 3 MichaelA
136e : f002             [ 3]>        beq skip1009
8325
                            >        trap           ;failed equal (zero)
8326
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8327
1370 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8328
1371 : 13                   >        db      test_num
8329
                            >
8330
1372 :                      >skip1009
8331 2 MichaelA
 
8332
 
8333
                                     set_stat 0
8334
                            >            load_flag 0
8335 3 MichaelA
1372 : a900             [ 2]>            lda #0               ;allow test to change I-flag (no mask)
8336 2 MichaelA
                            >
8337 3 MichaelA
1374 : 48               [ 3]>            pha         ;use stack to load status
8338
1375 : 28               [ 4]>            plp
8339 2 MichaelA
 
8340 3 MichaelA
1376 : a2c3             [ 2]         ldx #$c3
8341
1378 : 08               [ 3]         php
8342
1379 : ec0802           [ 4]         cpx abs1    ;test result
8343 2 MichaelA
                                     trap_ne
8344 3 MichaelA
137c : f002             [ 3]>        beq skip1013
8345
                            >        trap           ;failed equal (zero)
8346
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8347
137e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8348
137f : 13                   >        db      test_num
8349
                            >
8350
1380 :                      >skip1013
8351 2 MichaelA
 
8352 3 MichaelA
1380 : 68               [ 4]         pla         ;load status
8353 2 MichaelA
                                     eor_flag 0
8354 3 MichaelA
1381 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
8355 2 MichaelA
 
8356 3 MichaelA
1383 : cd0d02           [ 4]         cmp fLDx    ;test flags
8357 2 MichaelA
                                     trap_ne
8358 3 MichaelA
1386 : f002             [ 3]>        beq skip1016
8359
                            >        trap           ;failed equal (zero)
8360
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8361
1388 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8362
1389 : 13                   >        db      test_num
8363
                            >
8364
138a :                      >skip1016
8365 2 MichaelA
 
8366
                                     set_stat 0
8367
                            >            load_flag 0
8368 3 MichaelA
138a : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
8369 2 MichaelA
                            >
8370 3 MichaelA
138c : 48               [ 3]>            pha         ;use stack to load status
8371
138d : 28               [ 4]>            plp
8372 2 MichaelA
 
8373 3 MichaelA
138e : a282             [ 2]         ldx #$82
8374
1390 : 08               [ 3]         php
8375
1391 : ec0902           [ 4]         cpx abs1+1  ;test result
8376 2 MichaelA
                                     trap_ne
8377 3 MichaelA
1394 : f002             [ 3]>        beq skip1020
8378
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  146
8379
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8380
 
8381
                            >        trap           ;failed equal (zero)
8382
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8383
1396 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8384
1397 : 13                   >        db      test_num
8385
                            >
8386
1398 :                      >skip1020
8387 2 MichaelA
 
8388 3 MichaelA
1398 : 68               [ 4]         pla         ;load status
8389 2 MichaelA
                                     eor_flag 0
8390 3 MichaelA
1399 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
8391 2 MichaelA
 
8392 3 MichaelA
139b : cd0e02           [ 4]         cmp fLDx+1  ;test flags
8393 2 MichaelA
                                     trap_ne
8394 3 MichaelA
139e : f002             [ 3]>        beq skip1023
8395
                            >        trap           ;failed equal (zero)
8396
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8397
13a0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8398
13a1 : 13                   >        db      test_num
8399
                            >
8400
13a2 :                      >skip1023
8401 2 MichaelA
 
8402
                                     set_stat 0
8403
                            >            load_flag 0
8404 3 MichaelA
13a2 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
8405 2 MichaelA
                            >
8406 3 MichaelA
13a4 : 48               [ 3]>            pha         ;use stack to load status
8407
13a5 : 28               [ 4]>            plp
8408 2 MichaelA
 
8409 3 MichaelA
13a6 : a241             [ 2]         ldx #$41
8410
13a8 : 08               [ 3]         php
8411
13a9 : ec0a02           [ 4]         cpx abs1+2  ;test result
8412 2 MichaelA
                                     trap_ne
8413 3 MichaelA
13ac : f002             [ 3]>        beq skip1027
8414
                            >        trap           ;failed equal (zero)
8415
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8416
13ae : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8417
13af : 13                   >        db      test_num
8418
                            >
8419
13b0 :                      >skip1027
8420 2 MichaelA
 
8421 3 MichaelA
13b0 : 68               [ 4]         pla         ;load status
8422 2 MichaelA
                                     eor_flag 0
8423 3 MichaelA
13b1 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
8424 2 MichaelA
 
8425 3 MichaelA
13b3 : cd0f02           [ 4]         cmp fLDx+2  ;test flags
8426 2 MichaelA
                                     trap_ne
8427 3 MichaelA
13b6 : f002             [ 3]>        beq skip1030
8428
                            >        trap           ;failed equal (zero)
8429
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8430
13b8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8431
13b9 : 13                   >        db      test_num
8432
                            >
8433
13ba :                      >skip1030
8434 2 MichaelA
 
8435
                                     set_stat 0
8436 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  147
8437
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8438
 
8439 2 MichaelA
                            >            load_flag 0
8440 3 MichaelA
13ba : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
8441 2 MichaelA
                            >
8442 3 MichaelA
13bc : 48               [ 3]>            pha         ;use stack to load status
8443
13bd : 28               [ 4]>            plp
8444 2 MichaelA
 
8445 3 MichaelA
13be : a200             [ 2]         ldx #0
8446
13c0 : 08               [ 3]         php
8447
13c1 : ec0b02           [ 4]         cpx abs1+3  ;test result
8448 2 MichaelA
                                     trap_ne
8449 3 MichaelA
13c4 : f002             [ 3]>        beq skip1034
8450
                            >        trap           ;failed equal (zero)
8451
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8452
13c6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8453
13c7 : 13                   >        db      test_num
8454
                            >
8455
13c8 :                      >skip1034
8456 2 MichaelA
 
8457 3 MichaelA
13c8 : 68               [ 4]         pla         ;load status
8458 2 MichaelA
                                     eor_flag 0
8459 3 MichaelA
13c9 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
8460 2 MichaelA
 
8461 3 MichaelA
13cb : cd1002           [ 4]         cmp fLDx+3  ;test flags
8462 2 MichaelA
                                     trap_ne
8463 3 MichaelA
13ce : f002             [ 3]>        beq skip1037
8464
                            >        trap           ;failed equal (zero)
8465
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8466
13d0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8467
13d1 : 13                   >        db      test_num
8468
                            >
8469
13d2 :                      >skip1037
8470 2 MichaelA
 
8471
 
8472
                                     set_stat $ff
8473
                            >            load_flag $ff
8474 3 MichaelA
13d2 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
8475 2 MichaelA
                            >
8476 3 MichaelA
13d4 : 48               [ 3]>            pha         ;use stack to load status
8477
13d5 : 28               [ 4]>            plp
8478 2 MichaelA
 
8479 3 MichaelA
13d6 : a2c3             [ 2]         ldx #$c3
8480
13d8 : 08               [ 3]         php
8481
13d9 : ec0802           [ 4]         cpx abs1    ;test result
8482 2 MichaelA
                                     trap_ne
8483 3 MichaelA
13dc : f002             [ 3]>        beq skip1041
8484
                            >        trap           ;failed equal (zero)
8485
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8486
13de : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8487
13df : 13                   >        db      test_num
8488
                            >
8489
13e0 :                      >skip1041
8490 2 MichaelA
 
8491 3 MichaelA
13e0 : 68               [ 4]         pla         ;load status
8492 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
8493 3 MichaelA
13e1 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
8494
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  148
8495 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8496
 
8497 3 MichaelA
 
8498
13e3 : cd0d02           [ 4]         cmp fLDx    ;test flags
8499 2 MichaelA
                                     trap_ne
8500 3 MichaelA
13e6 : f002             [ 3]>        beq skip1044
8501
                            >        trap           ;failed equal (zero)
8502
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8503
13e8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8504
13e9 : 13                   >        db      test_num
8505
                            >
8506
13ea :                      >skip1044
8507 2 MichaelA
 
8508
                                     set_stat $ff
8509
                            >            load_flag $ff
8510 3 MichaelA
13ea : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
8511 2 MichaelA
                            >
8512 3 MichaelA
13ec : 48               [ 3]>            pha         ;use stack to load status
8513
13ed : 28               [ 4]>            plp
8514 2 MichaelA
 
8515 3 MichaelA
13ee : a282             [ 2]         ldx #$82
8516
13f0 : 08               [ 3]         php
8517
13f1 : ec0902           [ 4]         cpx abs1+1  ;test result
8518 2 MichaelA
                                     trap_ne
8519 3 MichaelA
13f4 : f002             [ 3]>        beq skip1048
8520
                            >        trap           ;failed equal (zero)
8521
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8522
13f6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8523
13f7 : 13                   >        db      test_num
8524
                            >
8525
13f8 :                      >skip1048
8526 2 MichaelA
 
8527 3 MichaelA
13f8 : 68               [ 4]         pla         ;load status
8528 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
8529 3 MichaelA
13f9 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
8530 2 MichaelA
 
8531 3 MichaelA
13fb : cd0e02           [ 4]         cmp fLDx+1  ;test flags
8532 2 MichaelA
                                     trap_ne
8533 3 MichaelA
13fe : f002             [ 4]>        beq skip1051
8534
                            >        trap           ;failed equal (zero)
8535
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8536
1400 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8537
1401 : 13                   >        db      test_num
8538
                            >
8539
1402 :                      >skip1051
8540 2 MichaelA
 
8541
                                     set_stat $ff
8542
                            >            load_flag $ff
8543 3 MichaelA
1402 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
8544 2 MichaelA
                            >
8545 3 MichaelA
1404 : 48               [ 3]>            pha         ;use stack to load status
8546
1405 : 28               [ 4]>            plp
8547 2 MichaelA
 
8548 3 MichaelA
1406 : a241             [ 2]         ldx #$41
8549
1408 : 08               [ 3]         php
8550
1409 : ec0a02           [ 4]         cpx abs1+2  ;test result
8551 2 MichaelA
                                     trap_ne
8552 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  149
8553
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8554
 
8555
140c : f002             [ 3]>        beq skip1055
8556
                            >        trap           ;failed equal (zero)
8557
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8558
140e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8559
140f : 13                   >        db      test_num
8560
                            >
8561
1410 :                      >skip1055
8562 2 MichaelA
 
8563 3 MichaelA
1410 : 68               [ 4]         pla         ;load status
8564 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
8565 3 MichaelA
1411 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
8566 2 MichaelA
 
8567 3 MichaelA
1413 : cd0f02           [ 4]         cmp fLDx+2  ;test flags
8568 2 MichaelA
                                     trap_ne
8569 3 MichaelA
1416 : f002             [ 3]>        beq skip1058
8570
                            >        trap           ;failed equal (zero)
8571
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8572
1418 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8573
1419 : 13                   >        db      test_num
8574
                            >
8575
141a :                      >skip1058
8576 2 MichaelA
 
8577
                                     set_stat $ff
8578
                            >            load_flag $ff
8579 3 MichaelA
141a : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
8580 2 MichaelA
                            >
8581 3 MichaelA
141c : 48               [ 3]>            pha         ;use stack to load status
8582
141d : 28               [ 4]>            plp
8583 2 MichaelA
 
8584 3 MichaelA
141e : a200             [ 2]         ldx #0
8585
1420 : 08               [ 3]         php
8586
1421 : ec0b02           [ 4]         cpx abs1+3  ;test result
8587 2 MichaelA
                                     trap_ne
8588 3 MichaelA
1424 : f002             [ 3]>        beq skip1062
8589
                            >        trap           ;failed equal (zero)
8590
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8591
1426 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8592
1427 : 13                   >        db      test_num
8593
                            >
8594
1428 :                      >skip1062
8595 2 MichaelA
 
8596 3 MichaelA
1428 : 68               [ 4]         pla         ;load status
8597 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
8598 3 MichaelA
1429 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
8599 2 MichaelA
 
8600 3 MichaelA
142b : cd1002           [ 4]         cmp fLDx+3  ;test flags
8601 2 MichaelA
                                     trap_ne
8602 3 MichaelA
142e : f002             [ 3]>        beq skip1065
8603
                            >        trap           ;failed equal (zero)
8604
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8605
1430 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8606
1431 : 13                   >        db      test_num
8607
                            >
8608
1432 :                      >skip1065
8609 2 MichaelA
 
8610 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  150
8611
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8612
 
8613 2 MichaelA
 
8614 3 MichaelA
1432 : a200             [ 2]         ldx #0
8615
1434 : a5b2             [ 3]         lda zpt
8616
1436 : 49c3             [ 2]         eor #$c3
8617
1438 : c5b9             [ 3]         cmp zp1
8618 2 MichaelA
                                     trap_ne     ;store to zp data
8619 3 MichaelA
143a : f002             [ 3]>        beq skip1067
8620
                            >        trap           ;failed equal (zero)
8621
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8622
143c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8623
143d : 13                   >        db      test_num
8624
                            >
8625
143e :                      >skip1067
8626 2 MichaelA
 
8627 3 MichaelA
143e : 86b2             [ 3]         stx zpt     ;clear
8628
1440 : ad0302           [ 4]         lda abst
8629
1443 : 49c3             [ 2]         eor #$c3
8630
1445 : cd0802           [ 4]         cmp abs1
8631 2 MichaelA
                                     trap_ne     ;store to abs data
8632 3 MichaelA
1448 : f002             [ 3]>        beq skip1069
8633
                            >        trap           ;failed equal (zero)
8634
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8635
144a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8636
144b : 13                   >        db      test_num
8637
                            >
8638
144c :                      >skip1069
8639 2 MichaelA
 
8640 3 MichaelA
144c : 8e0302           [ 4]         stx abst    ;clear
8641
144f : a5b3             [ 3]         lda zpt+1
8642
1451 : 49c3             [ 2]         eor #$c3
8643
1453 : c5ba             [ 3]         cmp zp1+1
8644 2 MichaelA
                                     trap_ne     ;store to zp data
8645 3 MichaelA
1455 : f002             [ 3]>        beq skip1071
8646
                            >        trap           ;failed equal (zero)
8647
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8648
1457 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8649
1458 : 13                   >        db      test_num
8650
                            >
8651
1459 :                      >skip1071
8652 2 MichaelA
 
8653 3 MichaelA
1459 : 86b3             [ 3]         stx zpt+1   ;clear
8654
145b : ad0402           [ 4]         lda abst+1
8655
145e : 49c3             [ 2]         eor #$c3
8656
1460 : cd0902           [ 4]         cmp abs1+1
8657 2 MichaelA
                                     trap_ne     ;store to abs data
8658 3 MichaelA
1463 : f002             [ 3]>        beq skip1073
8659
                            >        trap           ;failed equal (zero)
8660
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8661
1465 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8662
1466 : 13                   >        db      test_num
8663
                            >
8664
1467 :                      >skip1073
8665 2 MichaelA
 
8666 3 MichaelA
1467 : 8e0402           [ 4]         stx abst+1  ;clear
8667
146a : a5b4             [ 3]         lda zpt+2
8668
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  151
8669
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8670
 
8671
146c : 49c3             [ 2]         eor #$c3
8672
146e : c5bb             [ 3]         cmp zp1+2
8673 2 MichaelA
                                     trap_ne     ;store to zp data
8674 3 MichaelA
1470 : f002             [ 3]>        beq skip1075
8675
                            >        trap           ;failed equal (zero)
8676
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8677
1472 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8678
1473 : 13                   >        db      test_num
8679
                            >
8680
1474 :                      >skip1075
8681 2 MichaelA
 
8682 3 MichaelA
1474 : 86b4             [ 3]         stx zpt+2   ;clear
8683
1476 : ad0502           [ 4]         lda abst+2
8684
1479 : 49c3             [ 2]         eor #$c3
8685
147b : cd0a02           [ 4]         cmp abs1+2
8686 2 MichaelA
                                     trap_ne     ;store to abs data
8687 3 MichaelA
147e : f002             [ 3]>        beq skip1077
8688
                            >        trap           ;failed equal (zero)
8689
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8690
1480 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8691
1481 : 13                   >        db      test_num
8692
                            >
8693
1482 :                      >skip1077
8694 2 MichaelA
 
8695 3 MichaelA
1482 : 8e0502           [ 4]         stx abst+2  ;clear
8696
1485 : a5b5             [ 3]         lda zpt+3
8697
1487 : 49c3             [ 2]         eor #$c3
8698
1489 : c5bc             [ 3]         cmp zp1+3
8699 2 MichaelA
                                     trap_ne     ;store to zp data
8700 3 MichaelA
148b : f002             [ 3]>        beq skip1079
8701
                            >        trap           ;failed equal (zero)
8702
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8703
148d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8704
148e : 13                   >        db      test_num
8705
                            >
8706
148f :                      >skip1079
8707 2 MichaelA
 
8708 3 MichaelA
148f : 86b5             [ 3]         stx zpt+3   ;clear
8709
1491 : ad0602           [ 4]         lda abst+3
8710
1494 : 49c3             [ 2]         eor #$c3
8711
1496 : cd0b02           [ 4]         cmp abs1+3
8712 2 MichaelA
                                     trap_ne     ;store to abs data
8713 3 MichaelA
1499 : f002             [ 3]>        beq skip1081
8714
                            >        trap           ;failed equal (zero)
8715
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8716
149b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8717
149c : 13                   >        db      test_num
8718
                            >
8719
149d :                      >skip1081
8720 2 MichaelA
 
8721 3 MichaelA
149d : 8e0602           [ 4]         stx abst+3  ;clear
8722 2 MichaelA
                                     next_test
8723 3 MichaelA
14a0 : ad0002           [ 4]>            lda test_case   ;previous test
8724
14a3 : c913             [ 2]>            cmp #test_num
8725 2 MichaelA
                            >            trap_ne         ;test is out of sequence
8726 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  152
8727
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8728
 
8729
14a5 : f002             [ 3]>        beq skip1084
8730
                            >        trap           ;failed equal (zero)
8731
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8732
14a7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8733
14a8 : 13                   >        db      test_num
8734 2 MichaelA
                            >
8735 3 MichaelA
14a9 :                      >skip1084
8736
                            >
8737 2 MichaelA
0014 =                      >test_num = test_num + 1
8738 3 MichaelA
14a9 : a914             [ 2]>            lda #test_num   ;*** this tests' number
8739
14ab : 8d0002           [ 4]>            sta test_case
8740 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
8741
 
8742
 
8743
                             ; LDY / STY - zp / abs / #
8744 3 MichaelA
 
8745 2 MichaelA
                                     set_stat 0
8746
                            >            load_flag 0
8747 3 MichaelA
14ae : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
8748 2 MichaelA
                            >
8749 3 MichaelA
14b0 : 48               [ 3]>            pha         ;use stack to load status
8750
14b1 : 28               [ 4]>            plp
8751 2 MichaelA
 
8752 3 MichaelA
14b2 : a4b9             [ 3]         ldy zp1
8753
14b4 : 08               [ 3]         php         ;test stores do not alter flags
8754
14b5 : 98               [ 2]         tya
8755
14b6 : 49c3             [ 2]         eor #$c3
8756
14b8 : a8               [ 2]         tay
8757
14b9 : 28               [ 4]         plp
8758
14ba : 8c0302           [ 4]         sty abst
8759
14bd : 08               [ 3]         php         ;flags after load/store sequence
8760
14be : 49c3             [ 2]         eor #$c3
8761
14c0 : a8               [ 2]         tay
8762
14c1 : c0c3             [ 2]         cpy #$c3    ;test result
8763 2 MichaelA
                                     trap_ne
8764 3 MichaelA
14c3 : f002             [ 3]>        beq skip1088
8765
                            >        trap           ;failed equal (zero)
8766
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8767
14c5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8768
14c6 : 14                   >        db      test_num
8769
                            >
8770
14c7 :                      >skip1088
8771 2 MichaelA
 
8772 3 MichaelA
14c7 : 68               [ 4]         pla         ;load status
8773 2 MichaelA
                                     eor_flag 0
8774 3 MichaelA
14c8 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
8775 2 MichaelA
 
8776 3 MichaelA
14ca : cd0d02           [ 4]         cmp fLDx    ;test flags
8777 2 MichaelA
                                     trap_ne
8778 3 MichaelA
14cd : f002             [ 3]>        beq skip1091
8779
                            >        trap           ;failed equal (zero)
8780
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8781
14cf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8782
14d0 : 14                   >        db      test_num
8783
                            >
8784
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  153
8785 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8786
 
8787 3 MichaelA
14d1 :                      >skip1091
8788 2 MichaelA
 
8789
                                     set_stat 0
8790
                            >            load_flag 0
8791 3 MichaelA
14d1 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
8792 2 MichaelA
                            >
8793 3 MichaelA
14d3 : 48               [ 3]>            pha         ;use stack to load status
8794
14d4 : 28               [ 4]>            plp
8795 2 MichaelA
 
8796 3 MichaelA
14d5 : a4ba             [ 3]         ldy zp1+1
8797
14d7 : 08               [ 3]         php         ;test stores do not alter flags
8798
14d8 : 98               [ 2]         tya
8799
14d9 : 49c3             [ 2]         eor #$c3
8800
14db : a8               [ 2]         tay
8801
14dc : 28               [ 4]         plp
8802
14dd : 8c0402           [ 4]         sty abst+1
8803
14e0 : 08               [ 3]         php         ;flags after load/store sequence
8804
14e1 : 49c3             [ 2]         eor #$c3
8805
14e3 : a8               [ 2]         tay
8806
14e4 : c082             [ 2]         cpy #$82    ;test result
8807 2 MichaelA
                                     trap_ne
8808 3 MichaelA
14e6 : f002             [ 3]>        beq skip1095
8809
                            >        trap           ;failed equal (zero)
8810
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8811
14e8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8812
14e9 : 14                   >        db      test_num
8813
                            >
8814
14ea :                      >skip1095
8815 2 MichaelA
 
8816 3 MichaelA
14ea : 68               [ 4]         pla         ;load status
8817 2 MichaelA
                                     eor_flag 0
8818 3 MichaelA
14eb : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
8819 2 MichaelA
 
8820 3 MichaelA
14ed : cd0e02           [ 4]         cmp fLDx+1  ;test flags
8821 2 MichaelA
                                     trap_ne
8822 3 MichaelA
14f0 : f002             [ 3]>        beq skip1098
8823
                            >        trap           ;failed equal (zero)
8824
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8825
14f2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8826
14f3 : 14                   >        db      test_num
8827
                            >
8828
14f4 :                      >skip1098
8829 2 MichaelA
 
8830
                                     set_stat 0
8831
                            >            load_flag 0
8832 3 MichaelA
14f4 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
8833 2 MichaelA
                            >
8834 3 MichaelA
14f6 : 48               [ 3]>            pha         ;use stack to load status
8835
14f7 : 28               [ 4]>            plp
8836 2 MichaelA
 
8837 3 MichaelA
14f8 : a4bb             [ 3]         ldy zp1+2
8838
14fa : 08               [ 3]         php         ;test stores do not alter flags
8839
14fb : 98               [ 2]         tya
8840
14fc : 49c3             [ 2]         eor #$c3
8841
14fe : a8               [ 2]         tay
8842
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  154
8843
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8844
 
8845
14ff : 28               [ 4]         plp
8846
1500 : 8c0502           [ 4]         sty abst+2
8847
1503 : 08               [ 3]         php         ;flags after load/store sequence
8848
1504 : 49c3             [ 2]         eor #$c3
8849
1506 : a8               [ 2]         tay
8850
1507 : c041             [ 2]         cpy #$41    ;test result
8851 2 MichaelA
                                     trap_ne
8852 3 MichaelA
1509 : f002             [ 3]>        beq skip1102
8853
                            >        trap           ;failed equal (zero)
8854
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8855
150b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8856
150c : 14                   >        db      test_num
8857
                            >
8858
150d :                      >skip1102
8859 2 MichaelA
 
8860 3 MichaelA
150d : 68               [ 4]         pla         ;load status
8861 2 MichaelA
                                     eor_flag 0
8862 3 MichaelA
150e : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
8863 2 MichaelA
 
8864 3 MichaelA
1510 : cd0f02           [ 4]         cmp fLDx+2  ;test flags
8865 2 MichaelA
                                     trap_ne
8866 3 MichaelA
1513 : f002             [ 3]>        beq skip1105
8867
                            >        trap           ;failed equal (zero)
8868
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8869
1515 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8870
1516 : 14                   >        db      test_num
8871
                            >
8872
1517 :                      >skip1105
8873 2 MichaelA
 
8874
                                     set_stat 0
8875
                            >            load_flag 0
8876 3 MichaelA
1517 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
8877 2 MichaelA
                            >
8878 3 MichaelA
1519 : 48               [ 3]>            pha         ;use stack to load status
8879
151a : 28               [ 4]>            plp
8880 2 MichaelA
 
8881 3 MichaelA
151b : a4bc             [ 3]         ldy zp1+3
8882
151d : 08               [ 3]         php         ;test stores do not alter flags
8883
151e : 98               [ 2]         tya
8884
151f : 49c3             [ 2]         eor #$c3
8885
1521 : a8               [ 2]         tay
8886
1522 : 28               [ 4]         plp
8887
1523 : 8c0602           [ 4]         sty abst+3
8888
1526 : 08               [ 3]         php         ;flags after load/store sequence
8889
1527 : 49c3             [ 2]         eor #$c3
8890
1529 : a8               [ 2]         tay
8891
152a : c000             [ 2]         cpy #0      ;test result
8892 2 MichaelA
                                     trap_ne
8893 3 MichaelA
152c : f002             [ 3]>        beq skip1109
8894
                            >        trap           ;failed equal (zero)
8895
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8896
152e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8897
152f : 14                   >        db      test_num
8898
                            >
8899
1530 :                      >skip1109
8900
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  155
8901
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8902
 
8903 2 MichaelA
 
8904 3 MichaelA
1530 : 68               [ 4]         pla         ;load status
8905 2 MichaelA
                                     eor_flag 0
8906 3 MichaelA
1531 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
8907 2 MichaelA
 
8908 3 MichaelA
1533 : cd1002           [ 4]         cmp fLDx+3  ;test flags
8909 2 MichaelA
                                     trap_ne
8910 3 MichaelA
1536 : f002             [ 3]>        beq skip1112
8911
                            >        trap           ;failed equal (zero)
8912
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8913
1538 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8914
1539 : 14                   >        db      test_num
8915
                            >
8916
153a :                      >skip1112
8917 2 MichaelA
 
8918
 
8919
                                     set_stat $ff
8920
                            >            load_flag $ff
8921 3 MichaelA
153a : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
8922 2 MichaelA
                            >
8923 3 MichaelA
153c : 48               [ 3]>            pha         ;use stack to load status
8924
153d : 28               [ 4]>            plp
8925 2 MichaelA
 
8926 3 MichaelA
153e : a4b9             [ 3]         ldy zp1
8927
1540 : 08               [ 3]         php         ;test stores do not alter flags
8928
1541 : 98               [ 2]         tya
8929
1542 : 49c3             [ 2]         eor #$c3
8930
1544 : a8               [ 2]         tay
8931
1545 : 28               [ 4]         plp
8932
1546 : 8c0302           [ 4]         sty abst
8933
1549 : 08               [ 3]         php         ;flags after load/store sequence
8934
154a : 49c3             [ 2]         eor #$c3
8935
154c : a8               [ 2]         tay
8936
154d : c0c3             [ 2]         cpy #$c3    ;test result
8937 2 MichaelA
                                     trap_ne
8938 3 MichaelA
154f : f002             [ 3]>        beq skip1116
8939
                            >        trap           ;failed equal (zero)
8940
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8941
1551 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8942
1552 : 14                   >        db      test_num
8943
                            >
8944
1553 :                      >skip1116
8945 2 MichaelA
 
8946 3 MichaelA
1553 : 68               [ 4]         pla         ;load status
8947 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
8948 3 MichaelA
1554 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
8949 2 MichaelA
 
8950 3 MichaelA
1556 : cd0d02           [ 4]         cmp fLDx    ;test flags
8951 2 MichaelA
                                     trap_ne
8952 3 MichaelA
1559 : f002             [ 3]>        beq skip1119
8953
                            >        trap           ;failed equal (zero)
8954
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8955
155b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8956
155c : 14                   >        db      test_num
8957
                            >
8958
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  156
8959
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
8960
 
8961
155d :                      >skip1119
8962 2 MichaelA
 
8963
                                     set_stat $ff
8964
                            >            load_flag $ff
8965 3 MichaelA
155d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
8966 2 MichaelA
                            >
8967 3 MichaelA
155f : 48               [ 3]>            pha         ;use stack to load status
8968
1560 : 28               [ 4]>            plp
8969 2 MichaelA
 
8970 3 MichaelA
1561 : a4ba             [ 3]         ldy zp1+1
8971
1563 : 08               [ 3]         php         ;test stores do not alter flags
8972
1564 : 98               [ 2]         tya
8973
1565 : 49c3             [ 2]         eor #$c3
8974
1567 : a8               [ 2]         tay
8975
1568 : 28               [ 4]         plp
8976
1569 : 8c0402           [ 4]         sty abst+1
8977
156c : 08               [ 3]         php         ;flags after load/store sequence
8978
156d : 49c3             [ 2]         eor #$c3
8979
156f : a8               [ 2]         tay
8980
1570 : c082             [ 2]         cpy #$82   ;test result
8981 2 MichaelA
                                     trap_ne
8982 3 MichaelA
1572 : f002             [ 3]>        beq skip1123
8983
                            >        trap           ;failed equal (zero)
8984
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8985
1574 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
8986
1575 : 14                   >        db      test_num
8987
                            >
8988
1576 :                      >skip1123
8989 2 MichaelA
 
8990 3 MichaelA
1576 : 68               [ 4]         pla         ;load status
8991 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
8992 3 MichaelA
1577 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
8993 2 MichaelA
 
8994 3 MichaelA
1579 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
8995 2 MichaelA
                                     trap_ne
8996 3 MichaelA
157c : f002             [ 3]>        beq skip1126
8997
                            >        trap           ;failed equal (zero)
8998
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
8999
157e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9000
157f : 14                   >        db      test_num
9001
                            >
9002
1580 :                      >skip1126
9003 2 MichaelA
 
9004
                                     set_stat $ff
9005
                            >            load_flag $ff
9006 3 MichaelA
1580 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
9007 2 MichaelA
                            >
9008 3 MichaelA
1582 : 48               [ 3]>            pha         ;use stack to load status
9009
1583 : 28               [ 4]>            plp
9010 2 MichaelA
 
9011 3 MichaelA
1584 : a4bb             [ 3]         ldy zp1+2
9012
1586 : 08               [ 3]         php         ;test stores do not alter flags
9013
1587 : 98               [ 2]         tya
9014
1588 : 49c3             [ 2]         eor #$c3
9015
158a : a8               [ 2]         tay
9016
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  157
9017 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9018
 
9019 3 MichaelA
158b : 28               [ 4]         plp
9020
158c : 8c0502           [ 4]         sty abst+2
9021
158f : 08               [ 3]         php         ;flags after load/store sequence
9022
1590 : 49c3             [ 2]         eor #$c3
9023
1592 : a8               [ 2]         tay
9024
1593 : c041             [ 2]         cpy #$41    ;test result
9025 2 MichaelA
                                     trap_ne
9026 3 MichaelA
1595 : f002             [ 3]>        beq skip1130
9027
                            >        trap           ;failed equal (zero)
9028
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9029
1597 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9030
1598 : 14                   >        db      test_num
9031
                            >
9032
1599 :                      >skip1130
9033 2 MichaelA
 
9034 3 MichaelA
1599 : 68               [ 4]         pla         ;load status
9035 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
9036 3 MichaelA
159a : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
9037 2 MichaelA
 
9038 3 MichaelA
159c : cd0f02           [ 4]         cmp fLDx+2  ;test flags
9039 2 MichaelA
                                     trap_ne
9040 3 MichaelA
159f : f002             [ 3]>        beq skip1133
9041
                            >        trap           ;failed equal (zero)
9042
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9043
15a1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9044
15a2 : 14                   >        db      test_num
9045
                            >
9046
15a3 :                      >skip1133
9047 2 MichaelA
 
9048
                                     set_stat $ff
9049
                            >            load_flag $ff
9050 3 MichaelA
15a3 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
9051 2 MichaelA
                            >
9052 3 MichaelA
15a5 : 48               [ 3]>            pha         ;use stack to load status
9053
15a6 : 28               [ 4]>            plp
9054 2 MichaelA
 
9055 3 MichaelA
15a7 : a4bc             [ 3]         ldy zp1+3
9056
15a9 : 08               [ 3]         php         ;test stores do not alter flags
9057
15aa : 98               [ 2]         tya
9058
15ab : 49c3             [ 2]         eor #$c3
9059
15ad : a8               [ 2]         tay
9060
15ae : 28               [ 4]         plp
9061
15af : 8c0602           [ 4]         sty abst+3
9062
15b2 : 08               [ 3]         php         ;flags after load/store sequence
9063
15b3 : 49c3             [ 2]         eor #$c3
9064
15b5 : a8               [ 2]         tay
9065
15b6 : c000             [ 2]         cpy #0      ;test result
9066 2 MichaelA
                                     trap_ne
9067 3 MichaelA
15b8 : f002             [ 3]>        beq skip1137
9068
                            >        trap           ;failed equal (zero)
9069
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9070
15ba : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9071
15bb : 14                   >        db      test_num
9072
                            >
9073
15bc :                      >skip1137
9074
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  158
9075
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9076
 
9077 2 MichaelA
 
9078 3 MichaelA
15bc : 68               [ 4]         pla         ;load status
9079 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
9080 3 MichaelA
15bd : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
9081 2 MichaelA
 
9082 3 MichaelA
15bf : cd1002           [ 4]         cmp fLDx+3  ;test flags
9083 2 MichaelA
                                     trap_ne
9084 3 MichaelA
15c2 : f002             [ 3]>        beq skip1140
9085
                            >        trap           ;failed equal (zero)
9086
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9087
15c4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9088
15c5 : 14                   >        db      test_num
9089
                            >
9090
15c6 :                      >skip1140
9091 2 MichaelA
 
9092
 
9093
                                     set_stat 0
9094
                            >            load_flag 0
9095 3 MichaelA
15c6 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
9096 2 MichaelA
                            >
9097 3 MichaelA
15c8 : 48               [ 3]>            pha         ;use stack to load status
9098
15c9 : 28               [ 4]>            plp
9099 2 MichaelA
 
9100 3 MichaelA
15ca : ac0802           [ 4]         ldy abs1
9101
15cd : 08               [ 3]         php         ;test stores do not alter flags
9102
15ce : 98               [ 2]         tya
9103
15cf : 49c3             [ 2]         eor #$c3
9104
15d1 : a8               [ 2]         tay
9105
15d2 : 28               [ 4]         plp
9106
15d3 : 84b2             [ 3]         sty zpt
9107
15d5 : 08               [ 3]         php         ;flags after load/store sequence
9108
15d6 : 49c3             [ 2]         eor #$c3
9109
15d8 : a8               [ 2]         tay
9110
15d9 : c4b9             [ 3]         cpy zp1     ;test result
9111 2 MichaelA
                                     trap_ne
9112 3 MichaelA
15db : f002             [ 3]>        beq skip1144
9113
                            >        trap           ;failed equal (zero)
9114
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9115
15dd : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9116
15de : 14                   >        db      test_num
9117
                            >
9118
15df :                      >skip1144
9119 2 MichaelA
 
9120 3 MichaelA
15df : 68               [ 4]         pla         ;load status
9121 2 MichaelA
                                     eor_flag 0
9122 3 MichaelA
15e0 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
9123 2 MichaelA
 
9124 3 MichaelA
15e2 : cd0d02           [ 4]         cmp fLDx    ;test flags
9125 2 MichaelA
                                     trap_ne
9126 3 MichaelA
15e5 : f002             [ 3]>        beq skip1147
9127
                            >        trap           ;failed equal (zero)
9128
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9129
15e7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9130
15e8 : 14                   >        db      test_num
9131
                            >
9132
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  159
9133
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9134
 
9135
15e9 :                      >skip1147
9136 2 MichaelA
 
9137
                                     set_stat 0
9138
                            >            load_flag 0
9139 3 MichaelA
15e9 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
9140 2 MichaelA
                            >
9141 3 MichaelA
15eb : 48               [ 3]>            pha         ;use stack to load status
9142
15ec : 28               [ 4]>            plp
9143 2 MichaelA
 
9144 3 MichaelA
15ed : ac0902           [ 4]         ldy abs1+1
9145
15f0 : 08               [ 3]         php         ;test stores do not alter flags
9146
15f1 : 98               [ 2]         tya
9147
15f2 : 49c3             [ 2]         eor #$c3
9148
15f4 : a8               [ 2]         tay
9149
15f5 : 28               [ 4]         plp
9150
15f6 : 84b3             [ 3]         sty zpt+1
9151
15f8 : 08               [ 3]         php         ;flags after load/store sequence
9152
15f9 : 49c3             [ 2]         eor #$c3
9153
15fb : a8               [ 2]         tay
9154
15fc : c4ba             [ 3]         cpy zp1+1   ;test result
9155 2 MichaelA
                                     trap_ne
9156 3 MichaelA
15fe : f002             [ 4]>        beq skip1151
9157
                            >        trap           ;failed equal (zero)
9158
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9159
1600 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9160
1601 : 14                   >        db      test_num
9161
                            >
9162
1602 :                      >skip1151
9163 2 MichaelA
 
9164 3 MichaelA
1602 : 68               [ 4]         pla         ;load status
9165 2 MichaelA
                                     eor_flag 0
9166 3 MichaelA
1603 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
9167 2 MichaelA
 
9168 3 MichaelA
1605 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
9169 2 MichaelA
                                     trap_ne
9170 3 MichaelA
1608 : f002             [ 3]>        beq skip1154
9171
                            >        trap           ;failed equal (zero)
9172
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9173
160a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9174
160b : 14                   >        db      test_num
9175
                            >
9176
160c :                      >skip1154
9177 2 MichaelA
 
9178
                                     set_stat 0
9179
                            >            load_flag 0
9180 3 MichaelA
160c : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
9181 2 MichaelA
                            >
9182 3 MichaelA
160e : 48               [ 3]>            pha         ;use stack to load status
9183
160f : 28               [ 4]>            plp
9184 2 MichaelA
 
9185 3 MichaelA
1610 : ac0a02           [ 4]         ldy abs1+2
9186
1613 : 08               [ 3]         php         ;test stores do not alter flags
9187
1614 : 98               [ 2]         tya
9188
1615 : 49c3             [ 2]         eor #$c3
9189
1617 : a8               [ 2]         tay
9190
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  160
9191 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9192
 
9193 3 MichaelA
1618 : 28               [ 4]         plp
9194
1619 : 84b4             [ 3]         sty zpt+2
9195
161b : 08               [ 3]         php         ;flags after load/store sequence
9196
161c : 49c3             [ 2]         eor #$c3
9197
161e : a8               [ 2]         tay
9198
161f : c4bb             [ 3]         cpy zp1+2   ;test result
9199 2 MichaelA
                                     trap_ne
9200 3 MichaelA
1621 : f002             [ 3]>        beq skip1158
9201
                            >        trap           ;failed equal (zero)
9202
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9203
1623 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9204
1624 : 14                   >        db      test_num
9205
                            >
9206
1625 :                      >skip1158
9207 2 MichaelA
 
9208 3 MichaelA
1625 : 68               [ 4]         pla         ;load status
9209 2 MichaelA
                                     eor_flag 0
9210 3 MichaelA
1626 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
9211 2 MichaelA
 
9212 3 MichaelA
1628 : cd0f02           [ 4]         cmp fLDx+2  ;test flags
9213 2 MichaelA
                                     trap_ne
9214 3 MichaelA
162b : f002             [ 3]>        beq skip1161
9215
                            >        trap           ;failed equal (zero)
9216
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9217
162d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9218
162e : 14                   >        db      test_num
9219
                            >
9220
162f :                      >skip1161
9221 2 MichaelA
 
9222
                                     set_stat 0
9223
                            >            load_flag 0
9224 3 MichaelA
162f : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
9225 2 MichaelA
                            >
9226 3 MichaelA
1631 : 48               [ 3]>            pha         ;use stack to load status
9227
1632 : 28               [ 4]>            plp
9228 2 MichaelA
 
9229 3 MichaelA
1633 : ac0b02           [ 4]         ldy abs1+3
9230
1636 : 08               [ 3]         php         ;test stores do not alter flags
9231
1637 : 98               [ 2]         tya
9232
1638 : 49c3             [ 2]         eor #$c3
9233
163a : a8               [ 2]         tay
9234
163b : 28               [ 4]         plp
9235
163c : 84b5             [ 3]         sty zpt+3
9236
163e : 08               [ 3]         php         ;flags after load/store sequence
9237
163f : 49c3             [ 2]         eor #$c3
9238
1641 : a8               [ 2]         tay
9239
1642 : c4bc             [ 3]         cpy zp1+3   ;test result
9240 2 MichaelA
                                     trap_ne
9241 3 MichaelA
1644 : f002             [ 3]>        beq skip1165
9242
                            >        trap           ;failed equal (zero)
9243
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9244
1646 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9245
1647 : 14                   >        db      test_num
9246
                            >
9247
1648 :                      >skip1165
9248
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  161
9249
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9250
 
9251 2 MichaelA
 
9252 3 MichaelA
1648 : 68               [ 4]         pla         ;load status
9253 2 MichaelA
                                     eor_flag 0
9254 3 MichaelA
1649 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
9255 2 MichaelA
 
9256 3 MichaelA
164b : cd1002           [ 4]         cmp fLDx+3  ;test flags
9257 2 MichaelA
                                     trap_ne
9258 3 MichaelA
164e : f002             [ 3]>        beq skip1168
9259
                            >        trap           ;failed equal (zero)
9260
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9261
1650 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9262
1651 : 14                   >        db      test_num
9263
                            >
9264
1652 :                      >skip1168
9265 2 MichaelA
 
9266
 
9267
                                     set_stat $ff
9268
                            >            load_flag $ff
9269 3 MichaelA
1652 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
9270 2 MichaelA
                            >
9271 3 MichaelA
1654 : 48               [ 3]>            pha         ;use stack to load status
9272
1655 : 28               [ 4]>            plp
9273 2 MichaelA
 
9274 3 MichaelA
1656 : ac0802           [ 4]         ldy abs1
9275
1659 : 08               [ 3]         php         ;test stores do not alter flags
9276
165a : 98               [ 2]         tya
9277
165b : 49c3             [ 2]         eor #$c3
9278
165d : a8               [ 2]         tay
9279
165e : 28               [ 4]         plp
9280
165f : 84b2             [ 3]         sty zpt
9281
1661 : 08               [ 3]         php         ;flags after load/store sequence
9282
1662 : 49c3             [ 2]         eor #$c3
9283
1664 : a8               [ 2]         tay
9284
1665 : c5b9             [ 3]         cmp zp1     ;test result
9285 2 MichaelA
                                     trap_ne
9286 3 MichaelA
1667 : f002             [ 3]>        beq skip1172
9287
                            >        trap           ;failed equal (zero)
9288
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9289
1669 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9290
166a : 14                   >        db      test_num
9291
                            >
9292
166b :                      >skip1172
9293 2 MichaelA
 
9294 3 MichaelA
166b : 68               [ 4]         pla         ;load status
9295 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
9296 3 MichaelA
166c : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
9297 2 MichaelA
 
9298 3 MichaelA
166e : cd0d02           [ 4]         cmp fLDx    ;test flags
9299 2 MichaelA
                                     trap_ne
9300 3 MichaelA
1671 : f002             [ 3]>        beq skip1175
9301
                            >        trap           ;failed equal (zero)
9302
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9303
1673 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9304
1674 : 14                   >        db      test_num
9305
                            >
9306
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  162
9307
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9308
 
9309
1675 :                      >skip1175
9310 2 MichaelA
 
9311
                                     set_stat $ff
9312
                            >            load_flag $ff
9313 3 MichaelA
1675 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
9314 2 MichaelA
                            >
9315 3 MichaelA
1677 : 48               [ 3]>            pha         ;use stack to load status
9316
1678 : 28               [ 4]>            plp
9317 2 MichaelA
 
9318 3 MichaelA
1679 : ac0902           [ 4]         ldy abs1+1
9319
167c : 08               [ 3]         php         ;test stores do not alter flags
9320
167d : 98               [ 2]         tya
9321
167e : 49c3             [ 2]         eor #$c3
9322
1680 : a8               [ 2]         tay
9323
1681 : 28               [ 4]         plp
9324
1682 : 84b3             [ 3]         sty zpt+1
9325
1684 : 08               [ 3]         php         ;flags after load/store sequence
9326
1685 : 49c3             [ 2]         eor #$c3
9327
1687 : a8               [ 2]         tay
9328
1688 : c5ba             [ 3]         cmp zp1+1   ;test result
9329 2 MichaelA
                                     trap_ne
9330 3 MichaelA
168a : f002             [ 3]>        beq skip1179
9331
                            >        trap           ;failed equal (zero)
9332
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9333
168c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9334
168d : 14                   >        db      test_num
9335
                            >
9336
168e :                      >skip1179
9337 2 MichaelA
 
9338 3 MichaelA
168e : 68               [ 4]         pla         ;load status
9339 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
9340 3 MichaelA
168f : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
9341 2 MichaelA
 
9342 3 MichaelA
1691 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
9343 2 MichaelA
                                     trap_ne
9344 3 MichaelA
1694 : f002             [ 3]>        beq skip1182
9345
                            >        trap           ;failed equal (zero)
9346
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9347
1696 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9348
1697 : 14                   >        db      test_num
9349
                            >
9350
1698 :                      >skip1182
9351 2 MichaelA
 
9352
                                     set_stat $ff
9353
                            >            load_flag $ff
9354 3 MichaelA
1698 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
9355
                            >
9356
169a : 48               [ 3]>            pha         ;use stack to load status
9357
169b : 28               [ 4]>            plp
9358
 
9359
169c : ac0a02           [ 4]         ldy abs1+2
9360
169f : 08               [ 3]         php         ;test stores do not alter flags
9361
16a0 : 98               [ 2]         tya
9362
16a1 : 49c3             [ 2]         eor #$c3
9363
16a3 : a8               [ 2]         tay
9364
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  163
9365 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9366
 
9367 3 MichaelA
16a4 : 28               [ 4]         plp
9368
16a5 : 84b4             [ 3]         sty zpt+2
9369
16a7 : 08               [ 3]         php         ;flags after load/store sequence
9370
16a8 : 49c3             [ 2]         eor #$c3
9371
16aa : a8               [ 2]         tay
9372
16ab : c5bb             [ 3]         cmp zp1+2   ;test result
9373
                                     trap_ne
9374
16ad : f002             [ 3]>        beq skip1186
9375
                            >        trap           ;failed equal (zero)
9376
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9377
16af : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9378
16b0 : 14                   >        db      test_num
9379 2 MichaelA
                            >
9380 3 MichaelA
16b1 :                      >skip1186
9381 2 MichaelA
 
9382 3 MichaelA
16b1 : 68               [ 4]         pla         ;load status
9383 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
9384 3 MichaelA
16b2 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
9385 2 MichaelA
 
9386 3 MichaelA
16b4 : cd0f02           [ 4]         cmp fLDx+2  ;test flags
9387 2 MichaelA
                                     trap_ne
9388 3 MichaelA
16b7 : f002             [ 3]>        beq skip1189
9389
                            >        trap           ;failed equal (zero)
9390
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9391
16b9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9392
16ba : 14                   >        db      test_num
9393
                            >
9394
16bb :                      >skip1189
9395 2 MichaelA
 
9396
                                     set_stat $ff
9397
                            >            load_flag $ff
9398 3 MichaelA
16bb : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
9399 2 MichaelA
                            >
9400 3 MichaelA
16bd : 48               [ 3]>            pha         ;use stack to load status
9401
16be : 28               [ 4]>            plp
9402 2 MichaelA
 
9403 3 MichaelA
16bf : ac0b02           [ 4]         ldy abs1+3
9404
16c2 : 08               [ 3]         php         ;test stores do not alter flags
9405
16c3 : 98               [ 2]         tya
9406
16c4 : 49c3             [ 2]         eor #$c3
9407
16c6 : a8               [ 2]         tay
9408
16c7 : 28               [ 4]         plp
9409
16c8 : 84b5             [ 3]         sty zpt+3
9410
16ca : 08               [ 3]         php         ;flags after load/store sequence
9411
16cb : 49c3             [ 2]         eor #$c3
9412
16cd : a8               [ 2]         tay
9413
16ce : c5bc             [ 3]         cmp zp1+3   ;test result
9414 2 MichaelA
                                     trap_ne
9415 3 MichaelA
16d0 : f002             [ 3]>        beq skip1193
9416
                            >        trap           ;failed equal (zero)
9417
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9418
16d2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9419
16d3 : 14                   >        db      test_num
9420
                            >
9421
16d4 :                      >skip1193
9422
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  164
9423
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9424
 
9425 2 MichaelA
 
9426 3 MichaelA
16d4 : 68               [ 4]         pla         ;load status
9427 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
9428 3 MichaelA
16d5 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
9429 2 MichaelA
 
9430 3 MichaelA
16d7 : cd1002           [ 4]         cmp fLDx+3  ;test flags
9431 2 MichaelA
                                     trap_ne
9432 3 MichaelA
16da : f002             [ 3]>        beq skip1196
9433
                            >        trap           ;failed equal (zero)
9434
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9435
16dc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9436
16dd : 14                   >        db      test_num
9437
                            >
9438
16de :                      >skip1196
9439 2 MichaelA
 
9440
 
9441
 
9442
                                     set_stat 0
9443
                            >            load_flag 0
9444 3 MichaelA
16de : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
9445 2 MichaelA
                            >
9446 3 MichaelA
16e0 : 48               [ 3]>            pha         ;use stack to load status
9447
16e1 : 28               [ 4]>            plp
9448 2 MichaelA
 
9449 3 MichaelA
16e2 : a0c3             [ 2]         ldy #$c3
9450
16e4 : 08               [ 3]         php
9451
16e5 : cc0802           [ 4]         cpy abs1    ;test result
9452 2 MichaelA
                                     trap_ne
9453 3 MichaelA
16e8 : f002             [ 3]>        beq skip1200
9454
                            >        trap           ;failed equal (zero)
9455
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9456
16ea : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9457
16eb : 14                   >        db      test_num
9458
                            >
9459
16ec :                      >skip1200
9460 2 MichaelA
 
9461 3 MichaelA
16ec : 68               [ 4]         pla         ;load status
9462 2 MichaelA
                                     eor_flag 0
9463 3 MichaelA
16ed : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
9464 2 MichaelA
 
9465 3 MichaelA
16ef : cd0d02           [ 4]         cmp fLDx    ;test flags
9466 2 MichaelA
                                     trap_ne
9467 3 MichaelA
16f2 : f002             [ 3]>        beq skip1203
9468
                            >        trap           ;failed equal (zero)
9469
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9470
16f4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9471
16f5 : 14                   >        db      test_num
9472
                            >
9473
16f6 :                      >skip1203
9474 2 MichaelA
 
9475
                                     set_stat 0
9476
                            >            load_flag 0
9477 3 MichaelA
16f6 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
9478 2 MichaelA
                            >
9479 3 MichaelA
16f8 : 48               [ 3]>            pha         ;use stack to load status
9480
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  165
9481
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9482
 
9483
16f9 : 28               [ 4]>            plp
9484 2 MichaelA
 
9485 3 MichaelA
16fa : a082             [ 2]         ldy #$82
9486
16fc : 08               [ 3]         php
9487
16fd : cc0902           [ 4]         cpy abs1+1  ;test result
9488 2 MichaelA
                                     trap_ne
9489 3 MichaelA
1700 : f002             [ 3]>        beq skip1207
9490
                            >        trap           ;failed equal (zero)
9491
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9492
1702 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9493
1703 : 14                   >        db      test_num
9494
                            >
9495
1704 :                      >skip1207
9496 2 MichaelA
 
9497 3 MichaelA
1704 : 68               [ 4]         pla         ;load status
9498 2 MichaelA
                                     eor_flag 0
9499 3 MichaelA
1705 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
9500 2 MichaelA
 
9501 3 MichaelA
1707 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
9502 2 MichaelA
                                     trap_ne
9503 3 MichaelA
170a : f002             [ 3]>        beq skip1210
9504
                            >        trap           ;failed equal (zero)
9505
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9506
170c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9507
170d : 14                   >        db      test_num
9508
                            >
9509
170e :                      >skip1210
9510 2 MichaelA
 
9511
                                     set_stat 0
9512
                            >            load_flag 0
9513 3 MichaelA
170e : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
9514 2 MichaelA
                            >
9515 3 MichaelA
1710 : 48               [ 3]>            pha         ;use stack to load status
9516
1711 : 28               [ 4]>            plp
9517 2 MichaelA
 
9518 3 MichaelA
1712 : a041             [ 2]         ldy #$41
9519
1714 : 08               [ 3]         php
9520
1715 : cc0a02           [ 4]         cpy abs1+2  ;test result
9521 2 MichaelA
                                     trap_ne
9522 3 MichaelA
1718 : f002             [ 3]>        beq skip1214
9523
                            >        trap           ;failed equal (zero)
9524
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9525
171a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9526
171b : 14                   >        db      test_num
9527
                            >
9528
171c :                      >skip1214
9529 2 MichaelA
 
9530 3 MichaelA
171c : 68               [ 4]         pla         ;load status
9531 2 MichaelA
                                     eor_flag 0
9532 3 MichaelA
171d : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
9533 2 MichaelA
 
9534 3 MichaelA
171f : cd0f02           [ 4]         cmp fLDx+2  ;test flags
9535 2 MichaelA
                                     trap_ne
9536 3 MichaelA
1722 : f002             [ 3]>        beq skip1217
9537
                            >        trap           ;failed equal (zero)
9538
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  166
9539
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9540
 
9541
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9542
1724 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9543
1725 : 14                   >        db      test_num
9544
                            >
9545
1726 :                      >skip1217
9546 2 MichaelA
 
9547
                                     set_stat 0
9548
                            >            load_flag 0
9549 3 MichaelA
1726 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
9550 2 MichaelA
                            >
9551 3 MichaelA
1728 : 48               [ 3]>            pha         ;use stack to load status
9552
1729 : 28               [ 4]>            plp
9553 2 MichaelA
 
9554 3 MichaelA
172a : a000             [ 2]         ldy #0
9555
172c : 08               [ 3]         php
9556
172d : cc0b02           [ 4]         cpy abs1+3  ;test result
9557 2 MichaelA
                                     trap_ne
9558 3 MichaelA
1730 : f002             [ 3]>        beq skip1221
9559
                            >        trap           ;failed equal (zero)
9560
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9561
1732 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9562
1733 : 14                   >        db      test_num
9563
                            >
9564
1734 :                      >skip1221
9565 2 MichaelA
 
9566 3 MichaelA
1734 : 68               [ 4]         pla         ;load status
9567 2 MichaelA
                                     eor_flag 0
9568 3 MichaelA
1735 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
9569 2 MichaelA
 
9570 3 MichaelA
1737 : cd1002           [ 4]         cmp fLDx+3  ;test flags
9571 2 MichaelA
                                     trap_ne
9572 3 MichaelA
173a : f002             [ 3]>        beq skip1224
9573
                            >        trap           ;failed equal (zero)
9574
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9575
173c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9576
173d : 14                   >        db      test_num
9577
                            >
9578
173e :                      >skip1224
9579 2 MichaelA
 
9580
 
9581
                                     set_stat $ff
9582
                            >            load_flag $ff
9583 3 MichaelA
173e : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
9584 2 MichaelA
                            >
9585 3 MichaelA
1740 : 48               [ 3]>            pha         ;use stack to load status
9586
1741 : 28               [ 4]>            plp
9587 2 MichaelA
 
9588 3 MichaelA
1742 : a0c3             [ 2]         ldy #$c3
9589
1744 : 08               [ 3]         php
9590
1745 : cc0802           [ 4]         cpy abs1    ;test result
9591 2 MichaelA
                                     trap_ne
9592 3 MichaelA
1748 : f002             [ 3]>        beq skip1228
9593
                            >        trap           ;failed equal (zero)
9594
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9595
174a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9596
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  167
9597
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9598
 
9599
174b : 14                   >        db      test_num
9600
                            >
9601
174c :                      >skip1228
9602 2 MichaelA
 
9603 3 MichaelA
174c : 68               [ 4]         pla         ;load status
9604 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
9605 3 MichaelA
174d : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
9606 2 MichaelA
 
9607 3 MichaelA
174f : cd0d02           [ 4]         cmp fLDx    ;test flags
9608 2 MichaelA
                                     trap_ne
9609 3 MichaelA
1752 : f002             [ 3]>        beq skip1231
9610
                            >        trap           ;failed equal (zero)
9611
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9612
1754 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9613
1755 : 14                   >        db      test_num
9614
                            >
9615
1756 :                      >skip1231
9616 2 MichaelA
 
9617
                                     set_stat $ff
9618
                            >            load_flag $ff
9619 3 MichaelA
1756 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
9620 2 MichaelA
                            >
9621 3 MichaelA
1758 : 48               [ 3]>            pha         ;use stack to load status
9622
1759 : 28               [ 4]>            plp
9623 2 MichaelA
 
9624 3 MichaelA
175a : a082             [ 2]         ldy #$82
9625
175c : 08               [ 3]         php
9626
175d : cc0902           [ 4]         cpy abs1+1  ;test result
9627 2 MichaelA
                                     trap_ne
9628 3 MichaelA
1760 : f002             [ 3]>        beq skip1235
9629
                            >        trap           ;failed equal (zero)
9630
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9631
1762 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9632
1763 : 14                   >        db      test_num
9633
                            >
9634
1764 :                      >skip1235
9635 2 MichaelA
 
9636 3 MichaelA
1764 : 68               [ 4]         pla         ;load status
9637 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
9638 3 MichaelA
1765 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
9639 2 MichaelA
 
9640 3 MichaelA
1767 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
9641 2 MichaelA
                                     trap_ne
9642 3 MichaelA
176a : f002             [ 3]>        beq skip1238
9643
                            >        trap           ;failed equal (zero)
9644
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9645
176c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9646
176d : 14                   >        db      test_num
9647
                            >
9648
176e :                      >skip1238
9649 2 MichaelA
 
9650
                                     set_stat $ff
9651
                            >            load_flag $ff
9652 3 MichaelA
176e : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
9653 2 MichaelA
                            >
9654 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  168
9655
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9656
 
9657
1770 : 48               [ 3]>            pha         ;use stack to load status
9658
1771 : 28               [ 4]>            plp
9659 2 MichaelA
 
9660 3 MichaelA
1772 : a041             [ 2]         ldy #$41
9661
1774 : 08               [ 3]         php
9662
1775 : cc0a02           [ 4]         cpy abs1+2   ;test result
9663 2 MichaelA
                                     trap_ne
9664 3 MichaelA
1778 : f002             [ 3]>        beq skip1242
9665
                            >        trap           ;failed equal (zero)
9666
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9667
177a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9668
177b : 14                   >        db      test_num
9669
                            >
9670
177c :                      >skip1242
9671 2 MichaelA
 
9672 3 MichaelA
177c : 68               [ 4]         pla         ;load status
9673 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
9674 3 MichaelA
177d : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
9675 2 MichaelA
 
9676 3 MichaelA
177f : cd0f02           [ 4]         cmp fLDx+2  ;test flags
9677 2 MichaelA
                                     trap_ne
9678 3 MichaelA
1782 : f002             [ 3]>        beq skip1245
9679
                            >        trap           ;failed equal (zero)
9680
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9681
1784 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9682
1785 : 14                   >        db      test_num
9683
                            >
9684
1786 :                      >skip1245
9685 2 MichaelA
 
9686
                                     set_stat $ff
9687
                            >            load_flag $ff
9688 3 MichaelA
1786 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
9689 2 MichaelA
                            >
9690 3 MichaelA
1788 : 48               [ 3]>            pha         ;use stack to load status
9691
1789 : 28               [ 4]>            plp
9692 2 MichaelA
 
9693 3 MichaelA
178a : a000             [ 2]         ldy #0
9694
178c : 08               [ 3]         php
9695
178d : cc0b02           [ 4]         cpy abs1+3  ;test result
9696 2 MichaelA
                                     trap_ne
9697 3 MichaelA
1790 : f002             [ 3]>        beq skip1249
9698
                            >        trap           ;failed equal (zero)
9699
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9700
1792 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9701
1793 : 14                   >        db      test_num
9702
                            >
9703
1794 :                      >skip1249
9704 2 MichaelA
 
9705 3 MichaelA
1794 : 68               [ 4]         pla         ;load status
9706 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
9707 3 MichaelA
1795 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
9708
 
9709
1797 : cd1002           [ 4]         cmp fLDx+3  ;test flags
9710
                                     trap_ne
9711
179a : f002             [ 3]>        beq skip1252
9712
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  169
9713 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9714
 
9715 3 MichaelA
                            >        trap           ;failed equal (zero)
9716
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9717
179c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9718
179d : 14                   >        db      test_num
9719
                            >
9720
179e :                      >skip1252
9721 2 MichaelA
 
9722
 
9723 3 MichaelA
179e : a000             [ 2]         ldy #0
9724
17a0 : a5b2             [ 3]         lda zpt
9725
17a2 : 49c3             [ 2]         eor #$c3
9726
17a4 : c5b9             [ 3]         cmp zp1
9727 2 MichaelA
                                     trap_ne     ;store to zp   data
9728 3 MichaelA
17a6 : f002             [ 3]>        beq skip1254
9729
                            >        trap           ;failed equal (zero)
9730
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9731
17a8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9732
17a9 : 14                   >        db      test_num
9733
                            >
9734
17aa :                      >skip1254
9735 2 MichaelA
 
9736 3 MichaelA
17aa : 84b2             [ 3]         sty zpt     ;clear
9737
17ac : ad0302           [ 4]         lda abst
9738
17af : 49c3             [ 2]         eor #$c3
9739
17b1 : cd0802           [ 4]         cmp abs1
9740 2 MichaelA
                                     trap_ne     ;store to abs   data
9741 3 MichaelA
17b4 : f002             [ 3]>        beq skip1256
9742
                            >        trap           ;failed equal (zero)
9743
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9744
17b6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9745
17b7 : 14                   >        db      test_num
9746
                            >
9747
17b8 :                      >skip1256
9748 2 MichaelA
 
9749 3 MichaelA
17b8 : 8c0302           [ 4]         sty abst    ;clear
9750
17bb : a5b3             [ 3]         lda zpt+1
9751
17bd : 49c3             [ 2]         eor #$c3
9752
17bf : c5ba             [ 3]         cmp zp1+1
9753 2 MichaelA
                                     trap_ne     ;store to zp+1 data
9754 3 MichaelA
17c1 : f002             [ 3]>        beq skip1258
9755
                            >        trap           ;failed equal (zero)
9756
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9757
17c3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9758
17c4 : 14                   >        db      test_num
9759
                            >
9760
17c5 :                      >skip1258
9761 2 MichaelA
 
9762 3 MichaelA
17c5 : 84b3             [ 3]         sty zpt+1   ;clear
9763
17c7 : ad0402           [ 4]         lda abst+1
9764
17ca : 49c3             [ 2]         eor #$c3
9765
17cc : cd0902           [ 4]         cmp abs1+1
9766 2 MichaelA
                                     trap_ne     ;store to abs+1 data
9767 3 MichaelA
17cf : f002             [ 3]>        beq skip1260
9768
                            >        trap           ;failed equal (zero)
9769
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9770
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  170
9771
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9772
 
9773
17d1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9774
17d2 : 14                   >        db      test_num
9775
                            >
9776
17d3 :                      >skip1260
9777 2 MichaelA
 
9778 3 MichaelA
17d3 : 8c0402           [ 4]         sty abst+1  ;clear
9779
17d6 : a5b4             [ 3]         lda zpt+2
9780
17d8 : 49c3             [ 2]         eor #$c3
9781
17da : c5bb             [ 3]         cmp zp1+2
9782 2 MichaelA
                                     trap_ne     ;store to zp+2 data
9783 3 MichaelA
17dc : f002             [ 3]>        beq skip1262
9784
                            >        trap           ;failed equal (zero)
9785
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9786
17de : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9787
17df : 14                   >        db      test_num
9788
                            >
9789
17e0 :                      >skip1262
9790 2 MichaelA
 
9791 3 MichaelA
17e0 : 84b4             [ 3]         sty zpt+2   ;clear
9792
17e2 : ad0502           [ 4]         lda abst+2
9793
17e5 : 49c3             [ 2]         eor #$c3
9794
17e7 : cd0a02           [ 4]         cmp abs1+2
9795 2 MichaelA
                                     trap_ne     ;store to abs+2 data
9796 3 MichaelA
17ea : f002             [ 3]>        beq skip1264
9797
                            >        trap           ;failed equal (zero)
9798
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9799
17ec : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9800
17ed : 14                   >        db      test_num
9801
                            >
9802
17ee :                      >skip1264
9803 2 MichaelA
 
9804 3 MichaelA
17ee : 8c0502           [ 4]         sty abst+2  ;clear
9805
17f1 : a5b5             [ 3]         lda zpt+3
9806
17f3 : 49c3             [ 2]         eor #$c3
9807
17f5 : c5bc             [ 3]         cmp zp1+3
9808 2 MichaelA
                                     trap_ne     ;store to zp+3 data
9809 3 MichaelA
17f7 : f002             [ 3]>        beq skip1266
9810
                            >        trap           ;failed equal (zero)
9811
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9812
17f9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9813
17fa : 14                   >        db      test_num
9814
                            >
9815
17fb :                      >skip1266
9816
 
9817
17fb : 84b5             [ 3]         sty zpt+3   ;clear
9818
17fd : ad0602           [ 4]         lda abst+3
9819
1800 : 49c3             [ 2]         eor #$c3
9820
1802 : cd0b02           [ 4]         cmp abs1+3
9821
                                     trap_ne     ;store to abs+3 data
9822
1805 : f002             [ 3]>        beq skip1268
9823
                            >        trap           ;failed equal (zero)
9824
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9825
1807 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9826
1808 : 14                   >        db      test_num
9827
                            >
9828
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  171
9829 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9830
 
9831 3 MichaelA
1809 :                      >skip1268
9832 2 MichaelA
 
9833 3 MichaelA
1809 : 8c0602           [ 4]         sty abst+3  ;clear
9834 2 MichaelA
                                     next_test
9835 3 MichaelA
180c : ad0002           [ 4]>            lda test_case   ;previous test
9836
180f : c914             [ 2]>            cmp #test_num
9837 2 MichaelA
                            >            trap_ne         ;test is out of sequence
9838 3 MichaelA
1811 : f002             [ 3]>        beq skip1271
9839
                            >        trap           ;failed equal (zero)
9840
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9841
1813 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9842
1814 : 14                   >        db      test_num
9843 2 MichaelA
                            >
9844 3 MichaelA
1815 :                      >skip1271
9845
                            >
9846 2 MichaelA
0015 =                      >test_num = test_num + 1
9847 3 MichaelA
1815 : a915             [ 2]>            lda #test_num   ;*** this tests' number
9848
1817 : 8d0002           [ 4]>            sta test_case
9849 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
9850
 
9851
 
9852
                             ; testing load / store accumulator LDA / STA all addressing modes
9853
                             ; LDA / STA - zp,x / abs,x
9854 3 MichaelA
 
9855
181a : a203             [ 2]         ldx #3
9856
181c :                       tldax
9857 2 MichaelA
                                     set_stat 0
9858
                            >            load_flag 0
9859 3 MichaelA
181c : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
9860 2 MichaelA
                            >
9861 3 MichaelA
181e : 48               [ 3]>            pha         ;use stack to load status
9862
181f : 28               [ 4]>            plp
9863 2 MichaelA
 
9864 3 MichaelA
1820 : b5b9             [ 4]         lda zp1,x
9865
1822 : 08               [ 3]         php         ;test stores do not alter flags
9866
1823 : 49c3             [ 2]         eor #$c3
9867
1825 : 28               [ 4]         plp
9868
1826 : 9d0302           [ 5]         sta abst,x
9869
1829 : 08               [ 3]         php         ;flags after load/store sequence
9870
182a : 49c3             [ 2]         eor #$c3
9871
182c : dd0802           [ 4]         cmp abs1,x  ;test result
9872 2 MichaelA
                                     trap_ne
9873 3 MichaelA
182f : f002             [ 3]>        beq skip1275
9874
                            >        trap           ;failed equal (zero)
9875
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9876
1831 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9877
1832 : 15                   >        db      test_num
9878
                            >
9879
1833 :                      >skip1275
9880 2 MichaelA
 
9881 3 MichaelA
1833 : 68               [ 4]         pla         ;load status
9882 2 MichaelA
                                     eor_flag 0
9883 3 MichaelA
1834 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
9884 2 MichaelA
 
9885 3 MichaelA
1836 : dd0d02           [ 4]         cmp fLDx,x  ;test flags
9886
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  172
9887
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9888
 
9889 2 MichaelA
                                     trap_ne
9890 3 MichaelA
1839 : f002             [ 3]>        beq skip1278
9891
                            >        trap           ;failed equal (zero)
9892
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9893
183b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9894
183c : 15                   >        db      test_num
9895
                            >
9896
183d :                      >skip1278
9897 2 MichaelA
 
9898 3 MichaelA
183d : ca               [ 2]         dex
9899
183e : 10dc             [ 3]         bpl tldax
9900 2 MichaelA
 
9901 3 MichaelA
1840 : a203             [ 2]         ldx #3
9902
1842 :                       tldax1
9903 2 MichaelA
                                     set_stat $ff
9904
                            >            load_flag $ff
9905 3 MichaelA
1842 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
9906 2 MichaelA
                            >
9907 3 MichaelA
1844 : 48               [ 3]>            pha         ;use stack to load status
9908
1845 : 28               [ 4]>            plp
9909 2 MichaelA
 
9910 3 MichaelA
1846 : b5b9             [ 4]         lda zp1,x
9911
1848 : 08               [ 3]         php         ;test stores do not alter flags
9912
1849 : 49c3             [ 2]         eor #$c3
9913
184b : 28               [ 4]         plp
9914
184c : 9d0302           [ 5]         sta abst,x
9915
184f : 08               [ 3]         php         ;flags after load/store sequence
9916
1850 : 49c3             [ 2]         eor #$c3
9917
1852 : dd0802           [ 4]         cmp abs1,x   ;test result
9918 2 MichaelA
                                     trap_ne
9919 3 MichaelA
1855 : f002             [ 3]>        beq skip1282
9920
                            >        trap           ;failed equal (zero)
9921
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9922
1857 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9923
1858 : 15                   >        db      test_num
9924
                            >
9925
1859 :                      >skip1282
9926 2 MichaelA
 
9927 3 MichaelA
1859 : 68               [ 4]         pla         ;load status
9928 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
9929 3 MichaelA
185a : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
9930 2 MichaelA
 
9931 3 MichaelA
185c : dd0d02           [ 4]         cmp fLDx,x  ;test flags
9932 2 MichaelA
                                     trap_ne
9933 3 MichaelA
185f : f002             [ 3]>        beq skip1285
9934
                            >        trap           ;failed equal (zero)
9935
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9936
1861 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9937
1862 : 15                   >        db      test_num
9938
                            >
9939
1863 :                      >skip1285
9940 2 MichaelA
 
9941 3 MichaelA
1863 : ca               [ 2]         dex
9942
1864 : 10dc             [ 3]         bpl tldax1
9943 2 MichaelA
 
9944 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  173
9945
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
9946
 
9947
1866 : a203             [ 2]         ldx #3
9948
1868 :                       tldax2
9949 2 MichaelA
                                     set_stat 0
9950
                            >            load_flag 0
9951 3 MichaelA
1868 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
9952 2 MichaelA
                            >
9953 3 MichaelA
186a : 48               [ 3]>            pha         ;use stack to load status
9954
186b : 28               [ 4]>            plp
9955 2 MichaelA
 
9956 3 MichaelA
186c : bd0802           [ 4]         lda abs1,x
9957
186f : 08               [ 3]         php         ;test stores do not alter flags
9958
1870 : 49c3             [ 2]         eor #$c3
9959
1872 : 28               [ 4]         plp
9960
1873 : 95b2             [ 4]         sta zpt,x
9961
1875 : 08               [ 3]         php         ;flags after load/store sequence
9962
1876 : 49c3             [ 2]         eor #$c3
9963
1878 : d5b9             [ 4]         cmp zp1,x   ;test result
9964 2 MichaelA
                                     trap_ne
9965 3 MichaelA
187a : f002             [ 3]>        beq skip1289
9966
                            >        trap           ;failed equal (zero)
9967
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9968
187c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9969
187d : 15                   >        db      test_num
9970
                            >
9971
187e :                      >skip1289
9972 2 MichaelA
 
9973 3 MichaelA
187e : 68               [ 4]         pla         ;load status
9974 2 MichaelA
                                     eor_flag 0
9975 3 MichaelA
187f : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
9976 2 MichaelA
 
9977 3 MichaelA
1881 : dd0d02           [ 4]         cmp fLDx,x  ;test flags
9978 2 MichaelA
                                     trap_ne
9979 3 MichaelA
1884 : f002             [ 3]>        beq skip1292
9980
                            >        trap           ;failed equal (zero)
9981
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
9982
1886 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
9983
1887 : 15                   >        db      test_num
9984
                            >
9985
1888 :                      >skip1292
9986 2 MichaelA
 
9987 3 MichaelA
1888 : ca               [ 2]         dex
9988
1889 : 10dd             [ 3]         bpl tldax2
9989 2 MichaelA
 
9990 3 MichaelA
188b : a203             [ 2]         ldx #3
9991
188d :                       tldax3
9992 2 MichaelA
                                     set_stat $ff
9993
                            >            load_flag $ff
9994 3 MichaelA
188d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
9995 2 MichaelA
                            >
9996 3 MichaelA
188f : 48               [ 3]>            pha         ;use stack to load status
9997
1890 : 28               [ 4]>            plp
9998 2 MichaelA
 
9999 3 MichaelA
1891 : bd0802           [ 4]         lda abs1,x
10000
1894 : 08               [ 3]         php         ;test stores do not alter flags
10001
1895 : 49c3             [ 2]         eor #$c3
10002
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  174
10003
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10004
 
10005
1897 : 28               [ 4]         plp
10006
1898 : 95b2             [ 4]         sta zpt,x
10007
189a : 08               [ 3]         php         ;flags after load/store sequence
10008
189b : 49c3             [ 2]         eor #$c3
10009
189d : d5b9             [ 4]         cmp zp1,x   ;test result
10010 2 MichaelA
                                     trap_ne
10011 3 MichaelA
189f : f002             [ 3]>        beq skip1296
10012
                            >        trap           ;failed equal (zero)
10013
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10014
18a1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10015
18a2 : 15                   >        db      test_num
10016
                            >
10017
18a3 :                      >skip1296
10018 2 MichaelA
 
10019 3 MichaelA
18a3 : 68               [ 4]         pla         ;load status
10020 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
10021 3 MichaelA
18a4 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
10022 2 MichaelA
 
10023 3 MichaelA
18a6 : dd0d02           [ 4]         cmp fLDx,x  ;test flags
10024 2 MichaelA
                                     trap_ne
10025 3 MichaelA
18a9 : f002             [ 3]>        beq skip1299
10026
                            >        trap           ;failed equal (zero)
10027
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10028
18ab : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10029
18ac : 15                   >        db      test_num
10030
                            >
10031
18ad :                      >skip1299
10032 2 MichaelA
 
10033 3 MichaelA
18ad : ca               [ 2]         dex
10034
18ae : 10dd             [ 3]         bpl tldax3
10035 2 MichaelA
 
10036 3 MichaelA
18b0 : a203             [ 2]         ldx #3      ;testing store result
10037
18b2 : a000             [ 2]         ldy #0
10038
18b4 : b5b2             [ 4] tstax   lda zpt,x
10039
18b6 : 49c3             [ 2]         eor #$c3
10040
18b8 : d5b9             [ 4]         cmp zp1,x
10041 2 MichaelA
                                     trap_ne     ;store to zp,x data
10042 3 MichaelA
18ba : f002             [ 3]>        beq skip1301
10043
                            >        trap           ;failed equal (zero)
10044
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10045
18bc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10046
18bd : 15                   >        db      test_num
10047
                            >
10048
18be :                      >skip1301
10049 2 MichaelA
 
10050 3 MichaelA
18be : 94b2             [ 4]         sty zpt,x   ;clear
10051
18c0 : bd0302           [ 4]         lda abst,x
10052
18c3 : 49c3             [ 2]         eor #$c3
10053
18c5 : dd0802           [ 4]         cmp abs1,x
10054 2 MichaelA
                                     trap_ne     ;store to abs,x data
10055 3 MichaelA
18c8 : f002             [ 3]>        beq skip1303
10056
                            >        trap           ;failed equal (zero)
10057
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10058
18ca : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10059
18cb : 15                   >        db      test_num
10060
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  175
10061 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10062
 
10063 3 MichaelA
                            >
10064
18cc :                      >skip1303
10065
 
10066
18cc : 8a               [ 2]         txa
10067
18cd : 9d0302           [ 5]         sta abst,x  ;clear
10068
18d0 : ca               [ 2]         dex
10069
18d1 : 10e1             [ 3]         bpl tstax
10070 2 MichaelA
                                     next_test
10071 3 MichaelA
18d3 : ad0002           [ 4]>            lda test_case   ;previous test
10072
18d6 : c915             [ 2]>            cmp #test_num
10073 2 MichaelA
                            >            trap_ne         ;test is out of sequence
10074 3 MichaelA
18d8 : f002             [ 3]>        beq skip1306
10075
                            >        trap           ;failed equal (zero)
10076
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10077
18da : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10078
18db : 15                   >        db      test_num
10079 2 MichaelA
                            >
10080 3 MichaelA
18dc :                      >skip1306
10081
                            >
10082 2 MichaelA
0016 =                      >test_num = test_num + 1
10083 3 MichaelA
18dc : a916             [ 2]>            lda #test_num   ;*** this tests' number
10084
18de : 8d0002           [ 4]>            sta test_case
10085 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
10086
 
10087
 
10088
                             ; LDA / STA - (zp),y / abs,y / (zp,x)
10089 3 MichaelA
 
10090
18e1 : a003             [ 2]         ldy #3
10091
18e3 :                       tlday
10092 2 MichaelA
                                     set_stat 0
10093
                            >            load_flag 0
10094 3 MichaelA
18e3 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
10095 2 MichaelA
                            >
10096 3 MichaelA
18e5 : 48               [ 3]>            pha         ;use stack to load status
10097
18e6 : 28               [ 4]>            plp
10098 2 MichaelA
 
10099 3 MichaelA
18e7 : b1ca             [ 5]         lda (ind1),y
10100
18e9 : 08               [ 3]         php         ;test stores do not alter flags
10101
18ea : 49c3             [ 2]         eor #$c3
10102
18ec : 28               [ 4]         plp
10103
18ed : 990302           [ 5]         sta abst,y
10104
18f0 : 08               [ 3]         php         ;flags after load/store sequence
10105
18f1 : 49c3             [ 2]         eor #$c3
10106
18f3 : d90802           [ 4]         cmp abs1,y  ;test result
10107 2 MichaelA
                                     trap_ne
10108 3 MichaelA
18f6 : f002             [ 3]>        beq skip1310
10109
                            >        trap           ;failed equal (zero)
10110
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10111
18f8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10112
18f9 : 16                   >        db      test_num
10113
                            >
10114
18fa :                      >skip1310
10115 2 MichaelA
 
10116 3 MichaelA
18fa : 68               [ 4]         pla         ;load status
10117 2 MichaelA
                                     eor_flag 0
10118 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  176
10119
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10120
 
10121
18fb : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
10122 2 MichaelA
 
10123 3 MichaelA
18fd : d90d02           [ 4]         cmp fLDx,y  ;test flags
10124 2 MichaelA
                                     trap_ne
10125 3 MichaelA
1900 : f002             [ 3]>        beq skip1313
10126
                            >        trap           ;failed equal (zero)
10127
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10128
1902 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10129
1903 : 16                   >        db      test_num
10130
                            >
10131
1904 :                      >skip1313
10132 2 MichaelA
 
10133 3 MichaelA
1904 : 88               [ 2]         dey
10134
1905 : 10dc             [ 4]         bpl tlday
10135 2 MichaelA
 
10136 3 MichaelA
1907 : a003             [ 2]         ldy #3
10137
1909 :                       tlday1
10138 2 MichaelA
                                     set_stat $ff
10139
                            >            load_flag $ff
10140 3 MichaelA
1909 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
10141 2 MichaelA
                            >
10142 3 MichaelA
190b : 48               [ 3]>            pha         ;use stack to load status
10143
190c : 28               [ 4]>            plp
10144 2 MichaelA
 
10145 3 MichaelA
190d : b1ca             [ 5]         lda (ind1),y
10146
190f : 08               [ 3]         php         ;test stores do not alter flags
10147
1910 : 49c3             [ 2]         eor #$c3
10148
1912 : 28               [ 4]         plp
10149
1913 : 990302           [ 5]         sta abst,y
10150
1916 : 08               [ 3]         php         ;flags after load/store sequence
10151
1917 : 49c3             [ 2]         eor #$c3
10152
1919 : d90802           [ 4]         cmp abs1,y  ;test result
10153 2 MichaelA
                                     trap_ne
10154 3 MichaelA
191c : f002             [ 3]>        beq skip1317
10155
                            >        trap           ;failed equal (zero)
10156
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10157
191e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10158
191f : 16                   >        db      test_num
10159
                            >
10160
1920 :                      >skip1317
10161 2 MichaelA
 
10162 3 MichaelA
1920 : 68               [ 4]         pla         ;load status
10163 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
10164 3 MichaelA
1921 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
10165 2 MichaelA
 
10166 3 MichaelA
1923 : d90d02           [ 4]         cmp fLDx,y  ;test flags
10167 2 MichaelA
                                     trap_ne
10168 3 MichaelA
1926 : f002             [ 3]>        beq skip1320
10169
                            >        trap           ;failed equal (zero)
10170
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10171
1928 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10172
1929 : 16                   >        db      test_num
10173
                            >
10174
192a :                      >skip1320
10175 2 MichaelA
 
10176 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  177
10177
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10178
 
10179
192a : 88               [ 2]         dey
10180
192b : 10dc             [ 3]         bpl tlday1
10181 2 MichaelA
 
10182 3 MichaelA
192d : a003             [ 2]         ldy #3      ;testing store result
10183
192f : a200             [ 2]         ldx #0
10184
1931 : b90302           [ 4] tstay   lda abst,y
10185
1934 : 49c3             [ 2]         eor #$c3
10186
1936 : d90802           [ 4]         cmp abs1,y
10187 2 MichaelA
                                     trap_ne     ;store to abs data
10188 3 MichaelA
1939 : f002             [ 3]>        beq skip1322
10189
                            >        trap           ;failed equal (zero)
10190
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10191
193b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10192
193c : 16                   >        db      test_num
10193
                            >
10194
193d :                      >skip1322
10195 2 MichaelA
 
10196 3 MichaelA
193d : 8a               [ 2]         txa
10197
193e : 990302           [ 5]         sta abst,y  ;clear
10198
1941 : 88               [ 2]         dey
10199
1942 : 10ed             [ 3]         bpl tstay
10200 2 MichaelA
 
10201 3 MichaelA
1944 : a003             [ 2]         ldy #3
10202
1946 :                       tlday2
10203 2 MichaelA
                                     set_stat 0
10204
                            >            load_flag 0
10205 3 MichaelA
1946 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
10206 2 MichaelA
                            >
10207 3 MichaelA
1948 : 48               [ 3]>            pha         ;use stack to load status
10208
1949 : 28               [ 4]>            plp
10209 2 MichaelA
 
10210 3 MichaelA
194a : b90802           [ 4]         lda abs1,y
10211
194d : 08               [ 3]         php         ;test stores do not alter flags
10212
194e : 49c3             [ 2]         eor #$c3
10213
1950 : 28               [ 4]         plp
10214
1951 : 91d6             [ 5]         sta (indt),y
10215
1953 : 08               [ 3]         php         ;flags after load/store sequence
10216
1954 : 49c3             [ 2]         eor #$c3
10217
1956 : d1ca             [ 5]         cmp (ind1),y    ;test result
10218 2 MichaelA
                                     trap_ne
10219 3 MichaelA
1958 : f002             [ 3]>        beq skip1326
10220
                            >        trap           ;failed equal (zero)
10221
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10222
195a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10223
195b : 16                   >        db      test_num
10224
                            >
10225
195c :                      >skip1326
10226 2 MichaelA
 
10227 3 MichaelA
195c : 68               [ 4]         pla         ;load status
10228 2 MichaelA
                                     eor_flag 0
10229 3 MichaelA
195d : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
10230 2 MichaelA
 
10231 3 MichaelA
195f : d90d02           [ 4]         cmp fLDx,y  ;test flags
10232 2 MichaelA
                                     trap_ne
10233 3 MichaelA
1962 : f002             [ 3]>        beq skip1329
10234
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  178
10235
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10236
 
10237
                            >        trap           ;failed equal (zero)
10238
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10239
1964 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10240
1965 : 16                   >        db      test_num
10241
                            >
10242
1966 :                      >skip1329
10243 2 MichaelA
 
10244 3 MichaelA
1966 : 88               [ 2]         dey
10245
1967 : 10dd             [ 3]         bpl tlday2
10246 2 MichaelA
 
10247 3 MichaelA
1969 : a003             [ 2]         ldy #3
10248
196b :                       tlday3
10249 2 MichaelA
                                     set_stat $ff
10250
                            >            load_flag $ff
10251 3 MichaelA
196b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
10252 2 MichaelA
                            >
10253 3 MichaelA
196d : 48               [ 3]>            pha         ;use stack to load status
10254
196e : 28               [ 4]>            plp
10255 2 MichaelA
 
10256 3 MichaelA
196f : b90802           [ 4]         lda abs1,y
10257
1972 : 08               [ 3]         php         ;test stores do not alter flags
10258
1973 : 49c3             [ 2]         eor #$c3
10259
1975 : 28               [ 4]         plp
10260
1976 : 91d6             [ 5]         sta (indt),y
10261
1978 : 08               [ 3]         php         ;flags after load/store sequence
10262
1979 : 49c3             [ 2]         eor #$c3
10263
197b : d1ca             [ 5]         cmp (ind1),y   ;test result
10264 2 MichaelA
                                     trap_ne
10265 3 MichaelA
197d : f002             [ 3]>        beq skip1333
10266
                            >        trap           ;failed equal (zero)
10267
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10268
197f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10269
1980 : 16                   >        db      test_num
10270
                            >
10271
1981 :                      >skip1333
10272 2 MichaelA
 
10273 3 MichaelA
1981 : 68               [ 4]         pla         ;load status
10274 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
10275 3 MichaelA
1982 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
10276 2 MichaelA
 
10277 3 MichaelA
1984 : d90d02           [ 4]         cmp fLDx,y  ;test flags
10278 2 MichaelA
                                     trap_ne
10279 3 MichaelA
1987 : f002             [ 3]>        beq skip1336
10280
                            >        trap           ;failed equal (zero)
10281
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10282
1989 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10283
198a : 16                   >        db      test_num
10284
                            >
10285
198b :                      >skip1336
10286 2 MichaelA
 
10287 3 MichaelA
198b : 88               [ 2]         dey
10288
198c : 10dd             [ 3]         bpl tlday3
10289 2 MichaelA
 
10290 3 MichaelA
198e : a003             [ 2]         ldy #3      ;testing store result
10291
1990 : a200             [ 2]         ldx #0
10292
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  179
10293
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10294
 
10295
1992 : b90302           [ 4] tstay1  lda abst,y
10296
1995 : 49c3             [ 2]         eor #$c3
10297
1997 : d90802           [ 4]         cmp abs1,y
10298 2 MichaelA
                                     trap_ne     ;store to abs data
10299 3 MichaelA
199a : f002             [ 3]>        beq skip1338
10300
                            >        trap           ;failed equal (zero)
10301
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10302
199c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10303
199d : 16                   >        db      test_num
10304
                            >
10305
199e :                      >skip1338
10306 2 MichaelA
 
10307 3 MichaelA
199e : 8a               [ 2]         txa
10308
199f : 990302           [ 5]         sta abst,y  ;clear
10309
19a2 : 88               [ 2]         dey
10310
19a3 : 10ed             [ 3]         bpl tstay1
10311 2 MichaelA
 
10312 3 MichaelA
19a5 : a206             [ 2]         ldx #6
10313
19a7 : a003             [ 2]         ldy #3
10314
19a9 :                       tldax4
10315 2 MichaelA
                                     set_stat 0
10316
                            >            load_flag 0
10317 3 MichaelA
19a9 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
10318 2 MichaelA
                            >
10319 3 MichaelA
19ab : 48               [ 3]>            pha         ;use stack to load status
10320
19ac : 28               [ 4]>            plp
10321 2 MichaelA
 
10322 3 MichaelA
19ad : a1ca             [ 6]         lda (ind1,x)
10323
19af : 08               [ 3]         php         ;test stores do not alter flags
10324
19b0 : 49c3             [ 2]         eor #$c3
10325
19b2 : 28               [ 4]         plp
10326
19b3 : 81d6             [ 6]         sta (indt,x)
10327
19b5 : 08               [ 3]         php         ;flags after load/store sequence
10328
19b6 : 49c3             [ 2]         eor #$c3
10329
19b8 : d90802           [ 4]         cmp abs1,y  ;test result
10330 2 MichaelA
                                     trap_ne
10331 3 MichaelA
19bb : f002             [ 3]>        beq skip1342
10332
                            >        trap           ;failed equal (zero)
10333
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10334
19bd : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10335
19be : 16                   >        db      test_num
10336
                            >
10337
19bf :                      >skip1342
10338 2 MichaelA
 
10339 3 MichaelA
19bf : 68               [ 4]         pla         ;load status
10340 2 MichaelA
                                     eor_flag 0
10341 3 MichaelA
19c0 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
10342 2 MichaelA
 
10343 3 MichaelA
19c2 : d90d02           [ 4]         cmp fLDx,y  ;test flags
10344 2 MichaelA
                                     trap_ne
10345 3 MichaelA
19c5 : f002             [ 3]>        beq skip1345
10346
                            >        trap           ;failed equal (zero)
10347
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10348
19c7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10349
19c8 : 16                   >        db      test_num
10350
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  180
10351
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10352
 
10353
                            >
10354
19c9 :                      >skip1345
10355 2 MichaelA
 
10356 3 MichaelA
19c9 : ca               [ 2]         dex
10357
19ca : ca               [ 2]         dex
10358
19cb : 88               [ 2]         dey
10359
19cc : 10db             [ 3]         bpl tldax4
10360 2 MichaelA
 
10361 3 MichaelA
19ce : a206             [ 2]         ldx #6
10362
19d0 : a003             [ 2]         ldy #3
10363
19d2 :                       tldax5
10364 2 MichaelA
                                     set_stat $ff
10365
                            >            load_flag $ff
10366 3 MichaelA
19d2 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
10367 2 MichaelA
                            >
10368 3 MichaelA
19d4 : 48               [ 3]>            pha         ;use stack to load status
10369
19d5 : 28               [ 4]>            plp
10370 2 MichaelA
 
10371 3 MichaelA
19d6 : a1ca             [ 6]         lda (ind1,x)
10372
19d8 : 08               [ 3]         php         ;test stores do not alter flags
10373
19d9 : 49c3             [ 2]         eor #$c3
10374
19db : 28               [ 4]         plp
10375
19dc : 81d6             [ 6]         sta (indt,x)
10376
19de : 08               [ 3]         php         ;flags after load/store sequence
10377
19df : 49c3             [ 2]         eor #$c3
10378
19e1 : d90802           [ 4]         cmp abs1,y  ;test result
10379 2 MichaelA
                                     trap_ne
10380 3 MichaelA
19e4 : f002             [ 3]>        beq skip1349
10381
                            >        trap           ;failed equal (zero)
10382
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10383
19e6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10384
19e7 : 16                   >        db      test_num
10385
                            >
10386
19e8 :                      >skip1349
10387 2 MichaelA
 
10388 3 MichaelA
19e8 : 68               [ 4]         pla         ;load status
10389 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
10390 3 MichaelA
19e9 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
10391 2 MichaelA
 
10392 3 MichaelA
19eb : d90d02           [ 4]         cmp fLDx,y  ;test flags
10393 2 MichaelA
                                     trap_ne
10394 3 MichaelA
19ee : f002             [ 3]>        beq skip1352
10395
                            >        trap           ;failed equal (zero)
10396
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10397
19f0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10398
19f1 : 16                   >        db      test_num
10399
                            >
10400
19f2 :                      >skip1352
10401 2 MichaelA
 
10402 3 MichaelA
19f2 : ca               [ 2]         dex
10403
19f3 : ca               [ 2]         dex
10404
19f4 : 88               [ 2]         dey
10405
19f5 : 10db             [ 3]         bpl tldax5
10406 2 MichaelA
 
10407 3 MichaelA
19f7 : a003             [ 2]         ldy #3      ;testing store result
10408
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  181
10409
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10410
 
10411
19f9 : a200             [ 2]         ldx #0
10412
19fb : b90302           [ 4] tstay2  lda abst,y
10413
19fe : 49c3             [ 2]         eor #$c3
10414
1a00 : d90802           [ 4]         cmp abs1,y
10415 2 MichaelA
                                     trap_ne     ;store to abs data
10416 3 MichaelA
1a03 : f002             [ 3]>        beq skip1354
10417
                            >        trap           ;failed equal (zero)
10418
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10419
1a05 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10420
1a06 : 16                   >        db      test_num
10421
                            >
10422
1a07 :                      >skip1354
10423 2 MichaelA
 
10424 3 MichaelA
1a07 : 8a               [ 2]         txa
10425
1a08 : 990302           [ 5]         sta abst,y  ;clear
10426
1a0b : 88               [ 2]         dey
10427
1a0c : 10ed             [ 4]         bpl tstay2
10428 2 MichaelA
                                     next_test
10429 3 MichaelA
1a0e : ad0002           [ 4]>            lda test_case   ;previous test
10430
1a11 : c916             [ 2]>            cmp #test_num
10431 2 MichaelA
                            >            trap_ne         ;test is out of sequence
10432 3 MichaelA
1a13 : f002             [ 3]>        beq skip1357
10433
                            >        trap           ;failed equal (zero)
10434
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10435
1a15 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10436
1a16 : 16                   >        db      test_num
10437 2 MichaelA
                            >
10438 3 MichaelA
1a17 :                      >skip1357
10439
                            >
10440 2 MichaelA
0017 =                      >test_num = test_num + 1
10441 3 MichaelA
1a17 : a917             [ 2]>            lda #test_num   ;*** this tests' number
10442
1a19 : 8d0002           [ 4]>            sta test_case
10443 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
10444
 
10445
 
10446
                             ; indexed wraparound test (only zp should wrap)
10447 3 MichaelA
 
10448
1a1c : a2fd             [ 2]         ldx #3+$fa
10449
1a1e : b5bf             [ 4] tldax6  lda zp1-$fa&$ff,x   ;wrap on indexed zp
10450
1a20 : 9d0901           [ 5]         sta abst-$fa,x      ;no STX abs,x!
10451
1a23 : ca               [ 2]         dex
10452
1a24 : e0fa             [ 2]         cpx #$fa
10453
1a26 : b0f6             [ 3]         bcs tldax6
10454
1a28 : a2fd             [ 2]         ldx #3+$fa
10455
1a2a : bd0e01           [ 4] tldax7  lda abs1-$fa,x      ;no wrap on indexed abs
10456
1a2d : 95b8             [ 4]         sta zpt-$fa&$ff,x
10457
1a2f : ca               [ 2]         dex
10458
1a30 : e0fa             [ 2]         cpx #$fa
10459
1a32 : b0f6             [ 3]         bcs tldax7
10460 2 MichaelA
 
10461 3 MichaelA
1a34 : a203             [ 2]         ldx #3      ;testing wraparound result
10462
1a36 : a000             [ 2]         ldy #0
10463
1a38 : b5b2             [ 4] tstax1  lda zpt,x
10464
1a3a : d5b9             [ 4]         cmp zp1,x
10465 2 MichaelA
                                     trap_ne     ;store to zp,x data
10466 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  182
10467 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10468
 
10469 3 MichaelA
1a3c : f002             [ 3]>        beq skip1359
10470
                            >        trap           ;failed equal (zero)
10471
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10472
1a3e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10473
1a3f : 17                   >        db      test_num
10474
                            >
10475
1a40 :                      >skip1359
10476 2 MichaelA
 
10477 3 MichaelA
1a40 : 94b2             [ 4]         sty zpt,x   ;clear
10478
1a42 : bd0302           [ 4]         lda abst,x
10479
1a45 : dd0802           [ 4]         cmp abs1,x
10480 2 MichaelA
                                     trap_ne     ;store to abs,x data
10481 3 MichaelA
1a48 : f002             [ 3]>        beq skip1361
10482
                            >        trap           ;failed equal (zero)
10483
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10484
1a4a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10485
1a4b : 17                   >        db      test_num
10486
                            >
10487
1a4c :                      >skip1361
10488 2 MichaelA
 
10489 3 MichaelA
1a4c : 8a               [ 2]         txa
10490
1a4d : 9d0302           [ 5]         sta abst,x  ;clear
10491
1a50 : ca               [ 2]         dex
10492
1a51 : 10e5             [ 3]         bpl tstax1
10493 2 MichaelA
 
10494 3 MichaelA
1a53 : a0fb             [ 2]         ldy #3+$f8
10495
1a55 : a2fe             [ 2]         ldx #6+$f8
10496
1a57 : a1d2             [ 6] tlday4  lda (ind1-$f8&$ff,x) ;wrap on indexed zp indirect
10497
1a59 : 990b01           [ 5]         sta abst-$f8,y
10498
1a5c : ca               [ 2]         dex
10499
1a5d : ca               [ 2]         dex
10500
1a5e : 88               [ 2]         dey
10501
1a5f : c0f8             [ 2]         cpy #$f8
10502
1a61 : b0f4             [ 3]         bcs tlday4
10503
1a63 : a003             [ 2]         ldy #3      ;testing wraparound result
10504
1a65 : a200             [ 2]         ldx #0
10505
1a67 : b90302           [ 4] tstay4  lda abst,y
10506
1a6a : d90802           [ 4]         cmp abs1,y
10507 2 MichaelA
                                     trap_ne     ;store to abs data
10508 3 MichaelA
1a6d : f002             [ 3]>        beq skip1363
10509
                            >        trap           ;failed equal (zero)
10510
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10511
1a6f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10512
1a70 : 17                   >        db      test_num
10513
                            >
10514
1a71 :                      >skip1363
10515 2 MichaelA
 
10516 3 MichaelA
1a71 : 8a               [ 2]         txa
10517
1a72 : 990302           [ 5]         sta abst,y  ;clear
10518
1a75 : 88               [ 2]         dey
10519
1a76 : 10ef             [ 3]         bpl tstay4
10520 2 MichaelA
 
10521 3 MichaelA
1a78 : a0fb             [ 2]         ldy #3+$f8
10522
1a7a : b91001           [ 4] tlday5  lda abs1-$f8,y  ;no wrap on indexed abs
10523
1a7d : 91de             [ 5]         sta (inwt),y
10524
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  183
10525
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10526
 
10527
1a7f : 88               [ 2]         dey
10528
1a80 : c0f8             [ 2]         cpy #$f8
10529
1a82 : b0f6             [ 3]         bcs tlday5
10530
1a84 : a003             [ 2]         ldy #3      ;testing wraparound result
10531
1a86 : a200             [ 2]         ldx #0
10532
1a88 : b90302           [ 4] tstay5  lda abst,y
10533
1a8b : d90802           [ 4]         cmp abs1,y
10534 2 MichaelA
                                     trap_ne     ;store to abs data
10535 3 MichaelA
1a8e : f002             [ 3]>        beq skip1365
10536
                            >        trap           ;failed equal (zero)
10537
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10538
1a90 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10539
1a91 : 17                   >        db      test_num
10540
                            >
10541
1a92 :                      >skip1365
10542 2 MichaelA
 
10543 3 MichaelA
1a92 : 8a               [ 2]         txa
10544
1a93 : 990302           [ 5]         sta abst,y  ;clear
10545
1a96 : 88               [ 2]         dey
10546
1a97 : 10ef             [ 3]         bpl tstay5
10547 2 MichaelA
 
10548 3 MichaelA
1a99 : a0fb             [ 2]         ldy #3+$f8
10549
1a9b : a2fe             [ 2]         ldx #6+$f8
10550
1a9d : b1d4             [ 5] tlday6  lda (inw1),y    ;no wrap on zp indirect indexed
10551
1a9f : 81de             [ 6]         sta (indt-$f8&$ff,x)
10552
1aa1 : ca               [ 2]         dex
10553
1aa2 : ca               [ 2]         dex
10554
1aa3 : 88               [ 2]         dey
10555
1aa4 : c0f8             [ 2]         cpy #$f8
10556
1aa6 : b0f5             [ 3]         bcs tlday6
10557
1aa8 : a003             [ 2]         ldy #3      ;testing wraparound result
10558
1aaa : a200             [ 2]         ldx #0
10559
1aac : b90302           [ 4] tstay6  lda abst,y
10560
1aaf : d90802           [ 4]         cmp abs1,y
10561 2 MichaelA
                                     trap_ne     ;store to abs data
10562 3 MichaelA
1ab2 : f002             [ 3]>        beq skip1367
10563
                            >        trap           ;failed equal (zero)
10564
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10565
1ab4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10566
1ab5 : 17                   >        db      test_num
10567
                            >
10568
1ab6 :                      >skip1367
10569 2 MichaelA
 
10570 3 MichaelA
1ab6 : 8a               [ 2]         txa
10571
1ab7 : 990302           [ 5]         sta abst,y  ;clear
10572
1aba : 88               [ 2]         dey
10573
1abb : 10ef             [ 3]         bpl tstay6
10574 2 MichaelA
                                     next_test
10575 3 MichaelA
1abd : ad0002           [ 4]>            lda test_case   ;previous test
10576
1ac0 : c917             [ 2]>            cmp #test_num
10577 2 MichaelA
                            >            trap_ne         ;test is out of sequence
10578 3 MichaelA
1ac2 : f002             [ 3]>        beq skip1370
10579
                            >        trap           ;failed equal (zero)
10580
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10581
1ac4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10582
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  184
10583
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10584
 
10585
1ac5 : 17                   >        db      test_num
10586 2 MichaelA
                            >
10587 3 MichaelA
1ac6 :                      >skip1370
10588
                            >
10589 2 MichaelA
0018 =                      >test_num = test_num + 1
10590 3 MichaelA
1ac6 : a918             [ 2]>            lda #test_num   ;*** this tests' number
10591
1ac8 : 8d0002           [ 4]>            sta test_case
10592 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
10593
 
10594
 
10595
                             ; LDA / STA - zp / abs / #
10596 3 MichaelA
 
10597 2 MichaelA
                                     set_stat 0
10598
                            >            load_flag 0
10599 3 MichaelA
1acb : a900             [ 2]>            lda #0               ;allow test to change I-flag (no mask)
10600 2 MichaelA
                            >
10601 3 MichaelA
1acd : 48               [ 3]>            pha         ;use stack to load status
10602
1ace : 28               [ 4]>            plp
10603 2 MichaelA
 
10604 3 MichaelA
1acf : a5b9             [ 3]         lda zp1
10605
1ad1 : 08               [ 3]         php         ;test stores do not alter flags
10606
1ad2 : 49c3             [ 2]         eor #$c3
10607
1ad4 : 28               [ 4]         plp
10608
1ad5 : 8d0302           [ 4]         sta abst
10609
1ad8 : 08               [ 3]         php         ;flags after load/store sequence
10610
1ad9 : 49c3             [ 2]         eor #$c3
10611
1adb : c9c3             [ 2]         cmp #$c3    ;test result
10612 2 MichaelA
                                     trap_ne
10613 3 MichaelA
1add : f002             [ 3]>        beq skip1374
10614
                            >        trap           ;failed equal (zero)
10615
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10616
1adf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10617
1ae0 : 18                   >        db      test_num
10618
                            >
10619
1ae1 :                      >skip1374
10620 2 MichaelA
 
10621 3 MichaelA
1ae1 : 68               [ 4]         pla         ;load status
10622 2 MichaelA
                                     eor_flag 0
10623 3 MichaelA
1ae2 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
10624 2 MichaelA
 
10625 3 MichaelA
1ae4 : cd0d02           [ 4]         cmp fLDx    ;test flags
10626 2 MichaelA
                                     trap_ne
10627 3 MichaelA
1ae7 : f002             [ 3]>        beq skip1377
10628
                            >        trap           ;failed equal (zero)
10629
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10630
1ae9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10631
1aea : 18                   >        db      test_num
10632
                            >
10633
1aeb :                      >skip1377
10634 2 MichaelA
 
10635
                                     set_stat 0
10636
                            >            load_flag 0
10637 3 MichaelA
1aeb : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
10638 2 MichaelA
                            >
10639 3 MichaelA
1aed : 48               [ 3]>            pha         ;use stack to load status
10640
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  185
10641
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10642
 
10643
1aee : 28               [ 4]>            plp
10644 2 MichaelA
 
10645 3 MichaelA
1aef : a5ba             [ 3]         lda zp1+1
10646
1af1 : 08               [ 3]         php         ;test stores do not alter flags
10647
1af2 : 49c3             [ 2]         eor #$c3
10648
1af4 : 28               [ 4]         plp
10649
1af5 : 8d0402           [ 4]         sta abst+1
10650
1af8 : 08               [ 3]         php         ;flags after load/store sequence
10651
1af9 : 49c3             [ 2]         eor #$c3
10652
1afb : c982             [ 2]         cmp #$82    ;test result
10653 2 MichaelA
                                     trap_ne
10654 3 MichaelA
1afd : f002             [ 4]>        beq skip1381
10655
                            >        trap           ;failed equal (zero)
10656
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10657
1aff : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10658
1b00 : 18                   >        db      test_num
10659
                            >
10660
1b01 :                      >skip1381
10661 2 MichaelA
 
10662 3 MichaelA
1b01 : 68               [ 4]         pla         ;load status
10663 2 MichaelA
                                     eor_flag 0
10664 3 MichaelA
1b02 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
10665 2 MichaelA
 
10666 3 MichaelA
1b04 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
10667 2 MichaelA
                                     trap_ne
10668 3 MichaelA
1b07 : f002             [ 3]>        beq skip1384
10669
                            >        trap           ;failed equal (zero)
10670
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10671
1b09 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10672
1b0a : 18                   >        db      test_num
10673
                            >
10674
1b0b :                      >skip1384
10675 2 MichaelA
 
10676
                                     set_stat 0
10677
                            >            load_flag 0
10678 3 MichaelA
1b0b : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
10679 2 MichaelA
                            >
10680 3 MichaelA
1b0d : 48               [ 3]>            pha         ;use stack to load status
10681
1b0e : 28               [ 4]>            plp
10682 2 MichaelA
 
10683 3 MichaelA
1b0f : a5bb             [ 3]         lda zp1+2
10684
1b11 : 08               [ 3]         php         ;test stores do not alter flags
10685
1b12 : 49c3             [ 2]         eor #$c3
10686
1b14 : 28               [ 4]         plp
10687
1b15 : 8d0502           [ 4]         sta abst+2
10688
1b18 : 08               [ 3]         php         ;flags after load/store sequence
10689
1b19 : 49c3             [ 2]         eor #$c3
10690
1b1b : c941             [ 2]         cmp #$41    ;test result
10691 2 MichaelA
                                     trap_ne
10692 3 MichaelA
1b1d : f002             [ 3]>        beq skip1388
10693
                            >        trap           ;failed equal (zero)
10694
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10695
1b1f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10696
1b20 : 18                   >        db      test_num
10697
                            >
10698
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  186
10699
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10700
 
10701
1b21 :                      >skip1388
10702 2 MichaelA
 
10703 3 MichaelA
1b21 : 68               [ 4]         pla         ;load status
10704 2 MichaelA
                                     eor_flag 0
10705 3 MichaelA
1b22 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
10706 2 MichaelA
 
10707 3 MichaelA
1b24 : cd0f02           [ 4]         cmp fLDx+2  ;test flags
10708 2 MichaelA
                                     trap_ne
10709 3 MichaelA
1b27 : f002             [ 3]>        beq skip1391
10710
                            >        trap           ;failed equal (zero)
10711
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10712
1b29 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10713
1b2a : 18                   >        db      test_num
10714
                            >
10715
1b2b :                      >skip1391
10716 2 MichaelA
 
10717
                                     set_stat 0
10718
                            >            load_flag 0
10719 3 MichaelA
1b2b : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
10720 2 MichaelA
                            >
10721 3 MichaelA
1b2d : 48               [ 3]>            pha         ;use stack to load status
10722
1b2e : 28               [ 4]>            plp
10723 2 MichaelA
 
10724 3 MichaelA
1b2f : a5bc             [ 3]         lda zp1+3
10725
1b31 : 08               [ 3]         php         ;test stores do not alter flags
10726
1b32 : 49c3             [ 2]         eor #$c3
10727
1b34 : 28               [ 4]         plp
10728
1b35 : 8d0602           [ 4]         sta abst+3
10729
1b38 : 08               [ 3]         php         ;flags after load/store sequence
10730
1b39 : 49c3             [ 2]         eor #$c3
10731
1b3b : c900             [ 2]         cmp #0      ;test result
10732 2 MichaelA
                                     trap_ne
10733 3 MichaelA
1b3d : f002             [ 3]>        beq skip1395
10734
                            >        trap           ;failed equal (zero)
10735
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10736
1b3f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10737
1b40 : 18                   >        db      test_num
10738
                            >
10739
1b41 :                      >skip1395
10740 2 MichaelA
 
10741 3 MichaelA
1b41 : 68               [ 4]         pla         ;load status
10742 2 MichaelA
                                     eor_flag 0
10743 3 MichaelA
1b42 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
10744 2 MichaelA
 
10745 3 MichaelA
1b44 : cd1002           [ 4]         cmp fLDx+3  ;test flags
10746 2 MichaelA
                                     trap_ne
10747 3 MichaelA
1b47 : f002             [ 3]>        beq skip1398
10748
                            >        trap           ;failed equal (zero)
10749
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10750
1b49 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10751
1b4a : 18                   >        db      test_num
10752
                            >
10753
1b4b :                      >skip1398
10754 2 MichaelA
 
10755
                                     set_stat $ff
10756 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  187
10757
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10758
 
10759 2 MichaelA
                            >            load_flag $ff
10760 3 MichaelA
1b4b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
10761 2 MichaelA
                            >
10762 3 MichaelA
1b4d : 48               [ 3]>            pha         ;use stack to load status
10763
1b4e : 28               [ 4]>            plp
10764 2 MichaelA
 
10765 3 MichaelA
1b4f : a5b9             [ 3]         lda zp1
10766
1b51 : 08               [ 3]         php         ;test stores do not alter flags
10767
1b52 : 49c3             [ 2]         eor #$c3
10768
1b54 : 28               [ 4]         plp
10769
1b55 : 8d0302           [ 4]         sta abst
10770
1b58 : 08               [ 3]         php         ;flags after load/store sequence
10771
1b59 : 49c3             [ 2]         eor #$c3
10772
1b5b : c9c3             [ 2]         cmp #$c3    ;test result
10773 2 MichaelA
                                     trap_ne
10774 3 MichaelA
1b5d : f002             [ 3]>        beq skip1402
10775
                            >        trap           ;failed equal (zero)
10776
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10777
1b5f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10778
1b60 : 18                   >        db      test_num
10779
                            >
10780
1b61 :                      >skip1402
10781 2 MichaelA
 
10782 3 MichaelA
1b61 : 68               [ 4]         pla         ;load status
10783 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
10784 3 MichaelA
1b62 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
10785 2 MichaelA
 
10786 3 MichaelA
1b64 : cd0d02           [ 4]         cmp fLDx    ;test flags
10787 2 MichaelA
                                     trap_ne
10788 3 MichaelA
1b67 : f002             [ 3]>        beq skip1405
10789
                            >        trap           ;failed equal (zero)
10790
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10791
1b69 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10792
1b6a : 18                   >        db      test_num
10793
                            >
10794
1b6b :                      >skip1405
10795 2 MichaelA
 
10796
                                     set_stat $ff
10797
                            >            load_flag $ff
10798 3 MichaelA
1b6b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
10799 2 MichaelA
                            >
10800 3 MichaelA
1b6d : 48               [ 3]>            pha         ;use stack to load status
10801
1b6e : 28               [ 4]>            plp
10802
 
10803
1b6f : a5ba             [ 3]         lda zp1+1
10804
1b71 : 08               [ 3]         php         ;test stores do not alter flags
10805
1b72 : 49c3             [ 2]         eor #$c3
10806
1b74 : 28               [ 4]         plp
10807
1b75 : 8d0402           [ 4]         sta abst+1
10808
1b78 : 08               [ 3]         php         ;flags after load/store sequence
10809
1b79 : 49c3             [ 2]         eor #$c3
10810
1b7b : c982             [ 2]         cmp #$82    ;test result
10811
                                     trap_ne
10812
1b7d : f002             [ 3]>        beq skip1409
10813
                            >        trap           ;failed equal (zero)
10814
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  188
10815 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10816
 
10817 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10818
1b7f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10819
1b80 : 18                   >        db      test_num
10820
                            >
10821
1b81 :                      >skip1409
10822 2 MichaelA
 
10823 3 MichaelA
1b81 : 68               [ 4]         pla         ;load status
10824 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
10825 3 MichaelA
1b82 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
10826 2 MichaelA
 
10827 3 MichaelA
1b84 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
10828 2 MichaelA
                                     trap_ne
10829 3 MichaelA
1b87 : f002             [ 3]>        beq skip1412
10830
                            >        trap           ;failed equal (zero)
10831
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10832
1b89 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10833
1b8a : 18                   >        db      test_num
10834
                            >
10835
1b8b :                      >skip1412
10836 2 MichaelA
 
10837
                                     set_stat $ff
10838
                            >            load_flag $ff
10839 3 MichaelA
1b8b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
10840 2 MichaelA
                            >
10841 3 MichaelA
1b8d : 48               [ 3]>            pha         ;use stack to load status
10842
1b8e : 28               [ 4]>            plp
10843 2 MichaelA
 
10844 3 MichaelA
1b8f : a5bb             [ 3]         lda zp1+2
10845
1b91 : 08               [ 3]         php         ;test stores do not alter flags
10846
1b92 : 49c3             [ 2]         eor #$c3
10847
1b94 : 28               [ 4]         plp
10848
1b95 : 8d0502           [ 4]         sta abst+2
10849
1b98 : 08               [ 3]         php         ;flags after load/store sequence
10850
1b99 : 49c3             [ 2]         eor #$c3
10851
1b9b : c941             [ 2]         cmp #$41    ;test result
10852 2 MichaelA
                                     trap_ne
10853 3 MichaelA
1b9d : f002             [ 3]>        beq skip1416
10854
                            >        trap           ;failed equal (zero)
10855
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10856
1b9f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10857
1ba0 : 18                   >        db      test_num
10858
                            >
10859
1ba1 :                      >skip1416
10860 2 MichaelA
 
10861 3 MichaelA
1ba1 : 68               [ 4]         pla         ;load status
10862 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
10863 3 MichaelA
1ba2 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
10864 2 MichaelA
 
10865 3 MichaelA
1ba4 : cd0f02           [ 4]         cmp fLDx+2  ;test flags
10866 2 MichaelA
                                     trap_ne
10867 3 MichaelA
1ba7 : f002             [ 3]>        beq skip1419
10868
                            >        trap           ;failed equal (zero)
10869
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10870
1ba9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10871
1baa : 18                   >        db      test_num
10872
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  189
10873
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10874
 
10875
                            >
10876
1bab :                      >skip1419
10877 2 MichaelA
 
10878
                                     set_stat $ff
10879
                            >            load_flag $ff
10880 3 MichaelA
1bab : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
10881 2 MichaelA
                            >
10882 3 MichaelA
1bad : 48               [ 3]>            pha         ;use stack to load status
10883
1bae : 28               [ 4]>            plp
10884 2 MichaelA
 
10885 3 MichaelA
1baf : a5bc             [ 3]         lda zp1+3
10886
1bb1 : 08               [ 3]         php         ;test stores do not alter flags
10887
1bb2 : 49c3             [ 2]         eor #$c3
10888
1bb4 : 28               [ 4]         plp
10889
1bb5 : 8d0602           [ 4]         sta abst+3
10890
1bb8 : 08               [ 3]         php         ;flags after load/store sequence
10891
1bb9 : 49c3             [ 2]         eor #$c3
10892
1bbb : c900             [ 2]         cmp #0      ;test result
10893 2 MichaelA
                                     trap_ne
10894 3 MichaelA
1bbd : f002             [ 3]>        beq skip1423
10895
                            >        trap           ;failed equal (zero)
10896
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10897
1bbf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10898
1bc0 : 18                   >        db      test_num
10899
                            >
10900
1bc1 :                      >skip1423
10901 2 MichaelA
 
10902 3 MichaelA
1bc1 : 68               [ 4]         pla         ;load status
10903 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
10904 3 MichaelA
1bc2 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
10905 2 MichaelA
 
10906 3 MichaelA
1bc4 : cd1002           [ 4]         cmp fLDx+3  ;test flags
10907 2 MichaelA
                                     trap_ne
10908 3 MichaelA
1bc7 : f002             [ 3]>        beq skip1426
10909
                            >        trap           ;failed equal (zero)
10910
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10911
1bc9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10912
1bca : 18                   >        db      test_num
10913
                            >
10914
1bcb :                      >skip1426
10915 2 MichaelA
 
10916
                                     set_stat 0
10917
                            >            load_flag 0
10918 3 MichaelA
1bcb : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
10919 2 MichaelA
                            >
10920 3 MichaelA
1bcd : 48               [ 3]>            pha         ;use stack to load status
10921
1bce : 28               [ 4]>            plp
10922 2 MichaelA
 
10923 3 MichaelA
1bcf : ad0802           [ 4]         lda abs1
10924
1bd2 : 08               [ 3]         php         ;test stores do not alter flags
10925
1bd3 : 49c3             [ 2]         eor #$c3
10926
1bd5 : 28               [ 4]         plp
10927
1bd6 : 85b2             [ 3]         sta zpt
10928
1bd8 : 08               [ 3]         php         ;flags after load/store sequence
10929
1bd9 : 49c3             [ 2]         eor #$c3
10930
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  190
10931
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10932
 
10933
1bdb : c5b9             [ 3]         cmp zp1     ;test result
10934 2 MichaelA
                                     trap_ne
10935 3 MichaelA
1bdd : f002             [ 3]>        beq skip1430
10936
                            >        trap           ;failed equal (zero)
10937
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10938
1bdf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10939
1be0 : 18                   >        db      test_num
10940
                            >
10941
1be1 :                      >skip1430
10942 2 MichaelA
 
10943 3 MichaelA
1be1 : 68               [ 4]         pla         ;load status
10944 2 MichaelA
                                     eor_flag 0
10945 3 MichaelA
1be2 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
10946 2 MichaelA
 
10947 3 MichaelA
1be4 : cd0d02           [ 4]         cmp fLDx    ;test flags
10948 2 MichaelA
                                     trap_ne
10949 3 MichaelA
1be7 : f002             [ 3]>        beq skip1433
10950
                            >        trap           ;failed equal (zero)
10951
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10952
1be9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10953
1bea : 18                   >        db      test_num
10954
                            >
10955
1beb :                      >skip1433
10956 2 MichaelA
 
10957
                                     set_stat 0
10958
                            >            load_flag 0
10959 3 MichaelA
1beb : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
10960 2 MichaelA
                            >
10961 3 MichaelA
1bed : 48               [ 3]>            pha         ;use stack to load status
10962
1bee : 28               [ 4]>            plp
10963 2 MichaelA
 
10964 3 MichaelA
1bef : ad0902           [ 4]         lda abs1+1
10965
1bf2 : 08               [ 3]         php         ;test stores do not alter flags
10966
1bf3 : 49c3             [ 2]         eor #$c3
10967
1bf5 : 28               [ 4]         plp
10968
1bf6 : 85b3             [ 3]         sta zpt+1
10969
1bf8 : 08               [ 3]         php         ;flags after load/store sequence
10970
1bf9 : 49c3             [ 2]         eor #$c3
10971
1bfb : c5ba             [ 3]         cmp zp1+1   ;test result
10972 2 MichaelA
                                     trap_ne
10973 3 MichaelA
1bfd : f002             [ 4]>        beq skip1437
10974
                            >        trap           ;failed equal (zero)
10975
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10976
1bff : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10977
1c00 : 18                   >        db      test_num
10978
                            >
10979
1c01 :                      >skip1437
10980 2 MichaelA
 
10981 3 MichaelA
1c01 : 68               [ 4]         pla         ;load status
10982 2 MichaelA
                                     eor_flag 0
10983 3 MichaelA
1c02 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
10984 2 MichaelA
 
10985 3 MichaelA
1c04 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
10986 2 MichaelA
                                     trap_ne
10987 3 MichaelA
1c07 : f002             [ 3]>        beq skip1440
10988
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  191
10989
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
10990
 
10991
                            >        trap           ;failed equal (zero)
10992
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
10993
1c09 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
10994
1c0a : 18                   >        db      test_num
10995
                            >
10996
1c0b :                      >skip1440
10997 2 MichaelA
 
10998
                                     set_stat 0
10999
                            >            load_flag 0
11000 3 MichaelA
1c0b : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
11001 2 MichaelA
                            >
11002 3 MichaelA
1c0d : 48               [ 3]>            pha         ;use stack to load status
11003
1c0e : 28               [ 4]>            plp
11004 2 MichaelA
 
11005 3 MichaelA
1c0f : ad0a02           [ 4]         lda abs1+2
11006
1c12 : 08               [ 3]         php         ;test stores do not alter flags
11007
1c13 : 49c3             [ 2]         eor #$c3
11008
1c15 : 28               [ 4]         plp
11009
1c16 : 85b4             [ 3]         sta zpt+2
11010
1c18 : 08               [ 3]         php         ;flags after load/store sequence
11011
1c19 : 49c3             [ 2]         eor #$c3
11012
1c1b : c5bb             [ 3]         cmp zp1+2   ;test result
11013 2 MichaelA
                                     trap_ne
11014 3 MichaelA
1c1d : f002             [ 3]>        beq skip1444
11015
                            >        trap           ;failed equal (zero)
11016
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11017
1c1f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11018
1c20 : 18                   >        db      test_num
11019
                            >
11020
1c21 :                      >skip1444
11021 2 MichaelA
 
11022 3 MichaelA
1c21 : 68               [ 4]         pla         ;load status
11023 2 MichaelA
                                     eor_flag 0
11024 3 MichaelA
1c22 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
11025 2 MichaelA
 
11026 3 MichaelA
1c24 : cd0f02           [ 4]         cmp fLDx+2  ;test flags
11027 2 MichaelA
                                     trap_ne
11028 3 MichaelA
1c27 : f002             [ 3]>        beq skip1447
11029
                            >        trap           ;failed equal (zero)
11030
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11031
1c29 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11032
1c2a : 18                   >        db      test_num
11033
                            >
11034
1c2b :                      >skip1447
11035 2 MichaelA
 
11036
                                     set_stat 0
11037
                            >            load_flag 0
11038 3 MichaelA
1c2b : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
11039 2 MichaelA
                            >
11040 3 MichaelA
1c2d : 48               [ 3]>            pha         ;use stack to load status
11041
1c2e : 28               [ 4]>            plp
11042 2 MichaelA
 
11043 3 MichaelA
1c2f : ad0b02           [ 4]         lda abs1+3
11044
1c32 : 08               [ 3]         php         ;test stores do not alter flags
11045
1c33 : 49c3             [ 2]         eor #$c3
11046
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  192
11047 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11048
 
11049 3 MichaelA
1c35 : 28               [ 4]         plp
11050
1c36 : 85b5             [ 3]         sta zpt+3
11051
1c38 : 08               [ 3]         php         ;flags after load/store sequence
11052
1c39 : 49c3             [ 2]         eor #$c3
11053
1c3b : c5bc             [ 3]         cmp zp1+3   ;test result
11054 2 MichaelA
                                     trap_ne
11055 3 MichaelA
1c3d : f002             [ 3]>        beq skip1451
11056
                            >        trap           ;failed equal (zero)
11057
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11058
1c3f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11059
1c40 : 18                   >        db      test_num
11060
                            >
11061
1c41 :                      >skip1451
11062 2 MichaelA
 
11063 3 MichaelA
1c41 : 68               [ 4]         pla         ;load status
11064 2 MichaelA
                                     eor_flag 0
11065 3 MichaelA
1c42 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
11066 2 MichaelA
 
11067 3 MichaelA
1c44 : cd1002           [ 4]         cmp fLDx+3  ;test flags
11068 2 MichaelA
                                     trap_ne
11069 3 MichaelA
1c47 : f002             [ 3]>        beq skip1454
11070
                            >        trap           ;failed equal (zero)
11071
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11072
1c49 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11073
1c4a : 18                   >        db      test_num
11074
                            >
11075
1c4b :                      >skip1454
11076 2 MichaelA
 
11077
                                     set_stat $ff
11078
                            >            load_flag $ff
11079 3 MichaelA
1c4b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
11080 2 MichaelA
                            >
11081 3 MichaelA
1c4d : 48               [ 3]>            pha         ;use stack to load status
11082
1c4e : 28               [ 4]>            plp
11083 2 MichaelA
 
11084 3 MichaelA
1c4f : ad0802           [ 4]         lda abs1
11085
1c52 : 08               [ 3]         php         ;test stores do not alter flags
11086
1c53 : 49c3             [ 2]         eor #$c3
11087
1c55 : 28               [ 4]         plp
11088
1c56 : 85b2             [ 3]         sta zpt
11089
1c58 : 08               [ 3]         php         ;flags after load/store sequence
11090
1c59 : 49c3             [ 2]         eor #$c3
11091
1c5b : c5b9             [ 3]         cmp zp1     ;test result
11092 2 MichaelA
                                     trap_ne
11093 3 MichaelA
1c5d : f002             [ 3]>        beq skip1458
11094
                            >        trap           ;failed equal (zero)
11095
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11096
1c5f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11097
1c60 : 18                   >        db      test_num
11098
                            >
11099
1c61 :                      >skip1458
11100 2 MichaelA
 
11101 3 MichaelA
1c61 : 68               [ 4]         pla         ;load status
11102 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
11103 3 MichaelA
1c62 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
11104
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  193
11105
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11106
 
11107 2 MichaelA
 
11108 3 MichaelA
1c64 : cd0d02           [ 4]         cmp fLDx    ;test flags
11109 2 MichaelA
                                     trap_ne
11110 3 MichaelA
1c67 : f002             [ 3]>        beq skip1461
11111
                            >        trap           ;failed equal (zero)
11112
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11113
1c69 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11114
1c6a : 18                   >        db      test_num
11115
                            >
11116
1c6b :                      >skip1461
11117 2 MichaelA
 
11118
                                     set_stat $ff
11119
                            >            load_flag $ff
11120 3 MichaelA
1c6b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
11121 2 MichaelA
                            >
11122 3 MichaelA
1c6d : 48               [ 3]>            pha         ;use stack to load status
11123
1c6e : 28               [ 4]>            plp
11124 2 MichaelA
 
11125 3 MichaelA
1c6f : ad0902           [ 4]         lda abs1+1
11126
1c72 : 08               [ 3]         php         ;test stores do not alter flags
11127
1c73 : 49c3             [ 2]         eor #$c3
11128
1c75 : 28               [ 4]         plp
11129
1c76 : 85b3             [ 3]         sta zpt+1
11130
1c78 : 08               [ 3]         php         ;flags after load/store sequence
11131
1c79 : 49c3             [ 2]         eor #$c3
11132
1c7b : c5ba             [ 3]         cmp zp1+1   ;test result
11133 2 MichaelA
                                     trap_ne
11134 3 MichaelA
1c7d : f002             [ 3]>        beq skip1465
11135
                            >        trap           ;failed equal (zero)
11136
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11137
1c7f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11138
1c80 : 18                   >        db      test_num
11139
                            >
11140
1c81 :                      >skip1465
11141 2 MichaelA
 
11142 3 MichaelA
1c81 : 68               [ 4]         pla         ;load status
11143 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
11144 3 MichaelA
1c82 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
11145 2 MichaelA
 
11146 3 MichaelA
1c84 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
11147 2 MichaelA
                                     trap_ne
11148 3 MichaelA
1c87 : f002             [ 3]>        beq skip1468
11149
                            >        trap           ;failed equal (zero)
11150
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11151
1c89 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11152
1c8a : 18                   >        db      test_num
11153
                            >
11154
1c8b :                      >skip1468
11155 2 MichaelA
 
11156
                                     set_stat $ff
11157
                            >            load_flag $ff
11158 3 MichaelA
1c8b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
11159 2 MichaelA
                            >
11160 3 MichaelA
1c8d : 48               [ 3]>            pha         ;use stack to load status
11161
1c8e : 28               [ 4]>            plp
11162
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  194
11163
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11164
 
11165 2 MichaelA
 
11166 3 MichaelA
1c8f : ad0a02           [ 4]         lda abs1+2
11167
1c92 : 08               [ 3]         php         ;test stores do not alter flags
11168
1c93 : 49c3             [ 2]         eor #$c3
11169
1c95 : 28               [ 4]         plp
11170
1c96 : 85b4             [ 3]         sta zpt+2
11171
1c98 : 08               [ 3]         php         ;flags after load/store sequence
11172
1c99 : 49c3             [ 2]         eor #$c3
11173
1c9b : c5bb             [ 3]         cmp zp1+2   ;test result
11174 2 MichaelA
                                     trap_ne
11175 3 MichaelA
1c9d : f002             [ 3]>        beq skip1472
11176
                            >        trap           ;failed equal (zero)
11177
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11178
1c9f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11179
1ca0 : 18                   >        db      test_num
11180
                            >
11181
1ca1 :                      >skip1472
11182 2 MichaelA
 
11183 3 MichaelA
1ca1 : 68               [ 4]         pla         ;load status
11184 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
11185 3 MichaelA
1ca2 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
11186 2 MichaelA
 
11187 3 MichaelA
1ca4 : cd0f02           [ 4]         cmp fLDx+2  ;test flags
11188 2 MichaelA
                                     trap_ne
11189 3 MichaelA
1ca7 : f002             [ 3]>        beq skip1475
11190
                            >        trap           ;failed equal (zero)
11191
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11192
1ca9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11193
1caa : 18                   >        db      test_num
11194
                            >
11195
1cab :                      >skip1475
11196 2 MichaelA
 
11197
                                     set_stat $ff
11198
                            >            load_flag $ff
11199 3 MichaelA
1cab : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
11200 2 MichaelA
                            >
11201 3 MichaelA
1cad : 48               [ 3]>            pha         ;use stack to load status
11202
1cae : 28               [ 4]>            plp
11203 2 MichaelA
 
11204 3 MichaelA
1caf : ad0b02           [ 4]         lda abs1+3
11205
1cb2 : 08               [ 3]         php         ;test stores do not alter flags
11206
1cb3 : 49c3             [ 2]         eor #$c3
11207
1cb5 : 28               [ 4]         plp
11208
1cb6 : 85b5             [ 3]         sta zpt+3
11209
1cb8 : 08               [ 3]         php         ;flags after load/store sequence
11210
1cb9 : 49c3             [ 2]         eor #$c3
11211
1cbb : c5bc             [ 3]         cmp zp1+3   ;test result
11212 2 MichaelA
                                     trap_ne
11213 3 MichaelA
1cbd : f002             [ 3]>        beq skip1479
11214
                            >        trap           ;failed equal (zero)
11215
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11216
1cbf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11217
1cc0 : 18                   >        db      test_num
11218
                            >
11219
1cc1 :                      >skip1479
11220
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  195
11221 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11222
 
11223
 
11224 3 MichaelA
1cc1 : 68               [ 4]         pla         ;load status
11225
                                     eor_flag lo~fnz ;mask bits not altered
11226
1cc2 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
11227
 
11228
1cc4 : cd1002           [ 4]         cmp fLDx+3  ;test flags
11229 2 MichaelA
                                     trap_ne
11230 3 MichaelA
1cc7 : f002             [ 3]>        beq skip1482
11231
                            >        trap           ;failed equal (zero)
11232
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11233
1cc9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11234
1cca : 18                   >        db      test_num
11235
                            >
11236
1ccb :                      >skip1482
11237 2 MichaelA
 
11238
                                     set_stat 0
11239
                            >            load_flag 0
11240 3 MichaelA
1ccb : a900             [ 2]>            lda #0               ;allow test to change I-flag (no mask)
11241 2 MichaelA
                            >
11242 3 MichaelA
1ccd : 48               [ 3]>            pha         ;use stack to load status
11243
1cce : 28               [ 4]>            plp
11244 2 MichaelA
 
11245 3 MichaelA
1ccf : a9c3             [ 2]         lda #$c3
11246
1cd1 : 08               [ 3]         php
11247
1cd2 : cd0802           [ 4]         cmp abs1    ;test result
11248 2 MichaelA
                                     trap_ne
11249 3 MichaelA
1cd5 : f002             [ 3]>        beq skip1486
11250
                            >        trap           ;failed equal (zero)
11251
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11252
1cd7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11253
1cd8 : 18                   >        db      test_num
11254
                            >
11255
1cd9 :                      >skip1486
11256 2 MichaelA
 
11257 3 MichaelA
1cd9 : 68               [ 4]         pla         ;load status
11258 2 MichaelA
                                     eor_flag 0
11259 3 MichaelA
1cda : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
11260 2 MichaelA
 
11261 3 MichaelA
1cdc : cd0d02           [ 4]         cmp fLDx    ;test flags
11262 2 MichaelA
                                     trap_ne
11263 3 MichaelA
1cdf : f002             [ 3]>        beq skip1489
11264
                            >        trap           ;failed equal (zero)
11265
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11266
1ce1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11267
1ce2 : 18                   >        db      test_num
11268
                            >
11269
1ce3 :                      >skip1489
11270 2 MichaelA
 
11271
                                     set_stat 0
11272
                            >            load_flag 0
11273 3 MichaelA
1ce3 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
11274 2 MichaelA
                            >
11275 3 MichaelA
1ce5 : 48               [ 3]>            pha         ;use stack to load status
11276
1ce6 : 28               [ 4]>            plp
11277 2 MichaelA
 
11278 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  196
11279
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11280
 
11281
1ce7 : a982             [ 2]         lda #$82
11282
1ce9 : 08               [ 3]         php
11283
1cea : cd0902           [ 4]         cmp abs1+1  ;test result
11284 2 MichaelA
                                     trap_ne
11285 3 MichaelA
1ced : f002             [ 3]>        beq skip1493
11286
                            >        trap           ;failed equal (zero)
11287
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11288
1cef : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11289
1cf0 : 18                   >        db      test_num
11290
                            >
11291
1cf1 :                      >skip1493
11292 2 MichaelA
 
11293 3 MichaelA
1cf1 : 68               [ 4]         pla         ;load status
11294 2 MichaelA
                                     eor_flag 0
11295 3 MichaelA
1cf2 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
11296 2 MichaelA
 
11297 3 MichaelA
1cf4 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
11298 2 MichaelA
                                     trap_ne
11299 3 MichaelA
1cf7 : f002             [ 3]>        beq skip1496
11300
                            >        trap           ;failed equal (zero)
11301
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11302
1cf9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11303
1cfa : 18                   >        db      test_num
11304
                            >
11305
1cfb :                      >skip1496
11306 2 MichaelA
 
11307
                                     set_stat 0
11308
                            >            load_flag 0
11309 3 MichaelA
1cfb : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
11310 2 MichaelA
                            >
11311 3 MichaelA
1cfd : 48               [ 3]>            pha         ;use stack to load status
11312
1cfe : 28               [ 4]>            plp
11313 2 MichaelA
 
11314 3 MichaelA
1cff : a941             [ 2]         lda #$41
11315
1d01 : 08               [ 3]         php
11316
1d02 : cd0a02           [ 4]         cmp abs1+2  ;test result
11317 2 MichaelA
                                     trap_ne
11318 3 MichaelA
1d05 : f002             [ 3]>        beq skip1500
11319
                            >        trap           ;failed equal (zero)
11320
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11321
1d07 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11322
1d08 : 18                   >        db      test_num
11323
                            >
11324
1d09 :                      >skip1500
11325 2 MichaelA
 
11326 3 MichaelA
1d09 : 68               [ 4]         pla         ;load status
11327 2 MichaelA
                                     eor_flag 0
11328 3 MichaelA
1d0a : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
11329 2 MichaelA
 
11330 3 MichaelA
1d0c : cd0f02           [ 4]         cmp fLDx+2  ;test flags
11331 2 MichaelA
                                     trap_ne
11332 3 MichaelA
1d0f : f002             [ 3]>        beq skip1503
11333
                            >        trap           ;failed equal (zero)
11334
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11335
1d11 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11336
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  197
11337
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11338
 
11339
1d12 : 18                   >        db      test_num
11340
                            >
11341
1d13 :                      >skip1503
11342 2 MichaelA
 
11343
                                     set_stat 0
11344
                            >            load_flag 0
11345 3 MichaelA
1d13 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
11346 2 MichaelA
                            >
11347 3 MichaelA
1d15 : 48               [ 3]>            pha         ;use stack to load status
11348
1d16 : 28               [ 4]>            plp
11349 2 MichaelA
 
11350 3 MichaelA
1d17 : a900             [ 2]         lda #0
11351
1d19 : 08               [ 3]         php
11352
1d1a : cd0b02           [ 4]         cmp abs1+3  ;test result
11353 2 MichaelA
                                     trap_ne
11354 3 MichaelA
1d1d : f002             [ 3]>        beq skip1507
11355
                            >        trap           ;failed equal (zero)
11356
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11357
1d1f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11358
1d20 : 18                   >        db      test_num
11359
                            >
11360
1d21 :                      >skip1507
11361 2 MichaelA
 
11362 3 MichaelA
1d21 : 68               [ 4]         pla         ;load status
11363 2 MichaelA
                                     eor_flag 0
11364 3 MichaelA
1d22 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
11365 2 MichaelA
 
11366 3 MichaelA
1d24 : cd1002           [ 4]         cmp fLDx+3  ;test flags
11367 2 MichaelA
                                     trap_ne
11368 3 MichaelA
1d27 : f002             [ 3]>        beq skip1510
11369
                            >        trap           ;failed equal (zero)
11370
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11371
1d29 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11372
1d2a : 18                   >        db      test_num
11373
                            >
11374
1d2b :                      >skip1510
11375 2 MichaelA
 
11376
 
11377
                                     set_stat $ff
11378
                            >            load_flag $ff
11379 3 MichaelA
1d2b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
11380 2 MichaelA
                            >
11381 3 MichaelA
1d2d : 48               [ 3]>            pha         ;use stack to load status
11382
1d2e : 28               [ 4]>            plp
11383 2 MichaelA
 
11384 3 MichaelA
1d2f : a9c3             [ 2]         lda #$c3
11385
1d31 : 08               [ 3]         php
11386
1d32 : cd0802           [ 4]         cmp abs1    ;test result
11387 2 MichaelA
                                     trap_ne
11388 3 MichaelA
1d35 : f002             [ 3]>        beq skip1514
11389
                            >        trap           ;failed equal (zero)
11390
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11391
1d37 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11392
1d38 : 18                   >        db      test_num
11393
                            >
11394
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  198
11395
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11396
 
11397
1d39 :                      >skip1514
11398 2 MichaelA
 
11399 3 MichaelA
1d39 : 68               [ 4]         pla         ;load status
11400 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
11401 3 MichaelA
1d3a : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
11402 2 MichaelA
 
11403 3 MichaelA
1d3c : cd0d02           [ 4]         cmp fLDx    ;test flags
11404 2 MichaelA
                                     trap_ne
11405 3 MichaelA
1d3f : f002             [ 3]>        beq skip1517
11406
                            >        trap           ;failed equal (zero)
11407
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11408
1d41 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11409
1d42 : 18                   >        db      test_num
11410
                            >
11411
1d43 :                      >skip1517
11412 2 MichaelA
 
11413
                                     set_stat $ff
11414
                            >            load_flag $ff
11415 3 MichaelA
1d43 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
11416 2 MichaelA
                            >
11417 3 MichaelA
1d45 : 48               [ 3]>            pha         ;use stack to load status
11418
1d46 : 28               [ 4]>            plp
11419 2 MichaelA
 
11420 3 MichaelA
1d47 : a982             [ 2]         lda #$82
11421
1d49 : 08               [ 3]         php
11422
1d4a : cd0902           [ 4]         cmp abs1+1  ;test result
11423 2 MichaelA
                                     trap_ne
11424 3 MichaelA
1d4d : f002             [ 3]>        beq skip1521
11425
                            >        trap           ;failed equal (zero)
11426
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11427
1d4f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11428
1d50 : 18                   >        db      test_num
11429
                            >
11430
1d51 :                      >skip1521
11431 2 MichaelA
 
11432 3 MichaelA
1d51 : 68               [ 4]         pla         ;load status
11433 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
11434 3 MichaelA
1d52 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
11435 2 MichaelA
 
11436 3 MichaelA
1d54 : cd0e02           [ 4]         cmp fLDx+1  ;test flags
11437 2 MichaelA
                                     trap_ne
11438 3 MichaelA
1d57 : f002             [ 3]>        beq skip1524
11439
                            >        trap           ;failed equal (zero)
11440
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11441
1d59 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11442
1d5a : 18                   >        db      test_num
11443
                            >
11444
1d5b :                      >skip1524
11445 2 MichaelA
 
11446
                                     set_stat $ff
11447
                            >            load_flag $ff
11448 3 MichaelA
1d5b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
11449 2 MichaelA
                            >
11450 3 MichaelA
1d5d : 48               [ 3]>            pha         ;use stack to load status
11451
1d5e : 28               [ 4]>            plp
11452
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  199
11453
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11454
 
11455 2 MichaelA
 
11456 3 MichaelA
1d5f : a941             [ 2]         lda #$41
11457
1d61 : 08               [ 3]         php
11458
1d62 : cd0a02           [ 4]         cmp abs1+2  ;test result
11459 2 MichaelA
                                     trap_ne
11460 3 MichaelA
1d65 : f002             [ 3]>        beq skip1528
11461
                            >        trap           ;failed equal (zero)
11462
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11463
1d67 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11464
1d68 : 18                   >        db      test_num
11465
                            >
11466
1d69 :                      >skip1528
11467 2 MichaelA
 
11468 3 MichaelA
1d69 : 68               [ 4]         pla         ;load status
11469 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
11470 3 MichaelA
1d6a : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
11471 2 MichaelA
 
11472 3 MichaelA
1d6c : cd0f02           [ 4]         cmp fLDx+2  ;test flags
11473 2 MichaelA
                                     trap_ne
11474 3 MichaelA
1d6f : f002             [ 3]>        beq skip1531
11475
                            >        trap           ;failed equal (zero)
11476
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11477
1d71 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11478
1d72 : 18                   >        db      test_num
11479
                            >
11480
1d73 :                      >skip1531
11481 2 MichaelA
 
11482
                                     set_stat $ff
11483
                            >            load_flag $ff
11484 3 MichaelA
1d73 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
11485 2 MichaelA
                            >
11486 3 MichaelA
1d75 : 48               [ 3]>            pha         ;use stack to load status
11487
1d76 : 28               [ 4]>            plp
11488 2 MichaelA
 
11489 3 MichaelA
1d77 : a900             [ 2]         lda #0
11490
1d79 : 08               [ 3]         php
11491
1d7a : cd0b02           [ 4]         cmp abs1+3  ;test result
11492 2 MichaelA
                                     trap_ne
11493 3 MichaelA
1d7d : f002             [ 3]>        beq skip1535
11494
                            >        trap           ;failed equal (zero)
11495
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11496
1d7f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11497
1d80 : 18                   >        db      test_num
11498
                            >
11499
1d81 :                      >skip1535
11500 2 MichaelA
 
11501 3 MichaelA
1d81 : 68               [ 4]         pla         ;load status
11502 2 MichaelA
                                     eor_flag lo~fnz ;mask bits not altered
11503 3 MichaelA
1d82 : 497d             [ 2]>            eor #lo~fnz |fao         ;invert expected flags + always on bits
11504 2 MichaelA
 
11505 3 MichaelA
1d84 : cd1002           [ 4]         cmp fLDx+3  ;test flags
11506 2 MichaelA
                                     trap_ne
11507 3 MichaelA
1d87 : f002             [ 3]>        beq skip1538
11508
                            >        trap           ;failed equal (zero)
11509
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11510
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  200
11511
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11512
 
11513
1d89 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11514
1d8a : 18                   >        db      test_num
11515
                            >
11516
1d8b :                      >skip1538
11517 2 MichaelA
 
11518
 
11519 3 MichaelA
1d8b : a200             [ 2]         ldx #0
11520
1d8d : a5b2             [ 3]         lda zpt
11521
1d8f : 49c3             [ 2]         eor #$c3
11522
1d91 : c5b9             [ 3]         cmp zp1
11523 2 MichaelA
                                     trap_ne     ;store to zp data
11524 3 MichaelA
1d93 : f002             [ 3]>        beq skip1540
11525
                            >        trap           ;failed equal (zero)
11526
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11527
1d95 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11528
1d96 : 18                   >        db      test_num
11529
                            >
11530
1d97 :                      >skip1540
11531 2 MichaelA
 
11532 3 MichaelA
1d97 : 86b2             [ 3]         stx zpt     ;clear
11533
1d99 : ad0302           [ 4]         lda abst
11534
1d9c : 49c3             [ 2]         eor #$c3
11535
1d9e : cd0802           [ 4]         cmp abs1
11536 2 MichaelA
                                     trap_ne     ;store to abs data
11537 3 MichaelA
1da1 : f002             [ 3]>        beq skip1542
11538
                            >        trap           ;failed equal (zero)
11539
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11540
1da3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11541
1da4 : 18                   >        db      test_num
11542
                            >
11543
1da5 :                      >skip1542
11544 2 MichaelA
 
11545 3 MichaelA
1da5 : 8e0302           [ 4]         stx abst    ;clear
11546
1da8 : a5b3             [ 3]         lda zpt+1
11547
1daa : 49c3             [ 2]         eor #$c3
11548
1dac : c5ba             [ 3]         cmp zp1+1
11549 2 MichaelA
                                     trap_ne     ;store to zp data
11550 3 MichaelA
1dae : f002             [ 3]>        beq skip1544
11551
                            >        trap           ;failed equal (zero)
11552
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11553
1db0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11554
1db1 : 18                   >        db      test_num
11555
                            >
11556
1db2 :                      >skip1544
11557 2 MichaelA
 
11558 3 MichaelA
1db2 : 86b3             [ 3]         stx zpt+1   ;clear
11559
1db4 : ad0402           [ 4]         lda abst+1
11560
1db7 : 49c3             [ 2]         eor #$c3
11561
1db9 : cd0902           [ 4]         cmp abs1+1
11562 2 MichaelA
                                     trap_ne     ;store to abs data
11563 3 MichaelA
1dbc : f002             [ 3]>        beq skip1546
11564
                            >        trap           ;failed equal (zero)
11565
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11566
1dbe : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11567
1dbf : 18                   >        db      test_num
11568
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  201
11569
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11570
 
11571
                            >
11572
1dc0 :                      >skip1546
11573 2 MichaelA
 
11574 3 MichaelA
1dc0 : 8e0402           [ 4]         stx abst+1  ;clear
11575
1dc3 : a5b4             [ 3]         lda zpt+2
11576
1dc5 : 49c3             [ 2]         eor #$c3
11577
1dc7 : c5bb             [ 3]         cmp zp1+2
11578 2 MichaelA
                                     trap_ne     ;store to zp data
11579 3 MichaelA
1dc9 : f002             [ 3]>        beq skip1548
11580
                            >        trap           ;failed equal (zero)
11581
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11582
1dcb : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11583
1dcc : 18                   >        db      test_num
11584
                            >
11585
1dcd :                      >skip1548
11586 2 MichaelA
 
11587 3 MichaelA
1dcd : 86b4             [ 3]         stx zpt+2   ;clear
11588
1dcf : ad0502           [ 4]         lda abst+2
11589
1dd2 : 49c3             [ 2]         eor #$c3
11590
1dd4 : cd0a02           [ 4]         cmp abs1+2
11591 2 MichaelA
                                     trap_ne     ;store to abs data
11592 3 MichaelA
1dd7 : f002             [ 3]>        beq skip1550
11593
                            >        trap           ;failed equal (zero)
11594
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11595
1dd9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11596
1dda : 18                   >        db      test_num
11597
                            >
11598
1ddb :                      >skip1550
11599 2 MichaelA
 
11600 3 MichaelA
1ddb : 8e0502           [ 4]         stx abst+2  ;clear
11601
1dde : a5b5             [ 3]         lda zpt+3
11602
1de0 : 49c3             [ 2]         eor #$c3
11603
1de2 : c5bc             [ 3]         cmp zp1+3
11604 2 MichaelA
                                     trap_ne     ;store to zp data
11605 3 MichaelA
1de4 : f002             [ 3]>        beq skip1552
11606
                            >        trap           ;failed equal (zero)
11607
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11608
1de6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11609
1de7 : 18                   >        db      test_num
11610
                            >
11611
1de8 :                      >skip1552
11612 2 MichaelA
 
11613 3 MichaelA
1de8 : 86b5             [ 3]         stx zpt+3   ;clear
11614
1dea : ad0602           [ 4]         lda abst+3
11615
1ded : 49c3             [ 2]         eor #$c3
11616
1def : cd0b02           [ 4]         cmp abs1+3
11617 2 MichaelA
                                     trap_ne     ;store to abs data
11618 3 MichaelA
1df2 : f002             [ 3]>        beq skip1554
11619
                            >        trap           ;failed equal (zero)
11620
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11621
1df4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11622
1df5 : 18                   >        db      test_num
11623
                            >
11624
1df6 :                      >skip1554
11625 2 MichaelA
 
11626 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  202
11627
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11628
 
11629
1df6 : 8e0602           [ 4]         stx abst+3  ;clear
11630 2 MichaelA
                                     next_test
11631 3 MichaelA
1df9 : ad0002           [ 4]>            lda test_case   ;previous test
11632
1dfc : c918             [ 2]>            cmp #test_num
11633 2 MichaelA
                            >            trap_ne         ;test is out of sequence
11634 3 MichaelA
1dfe : f002             [ 4]>        beq skip1557
11635
                            >        trap           ;failed equal (zero)
11636
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11637
1e00 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11638
1e01 : 18                   >        db      test_num
11639 2 MichaelA
                            >
11640 3 MichaelA
1e02 :                      >skip1557
11641
                            >
11642 2 MichaelA
0019 =                      >test_num = test_num + 1
11643 3 MichaelA
1e02 : a919             [ 2]>            lda #test_num   ;*** this tests' number
11644
1e04 : 8d0002           [ 4]>            sta test_case
11645 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
11646
 
11647
 
11648
                             ; testing bit test & compares BIT CPX CPY CMP all addressing modes
11649
                             ; BIT - zp / abs
11650 3 MichaelA
 
11651 2 MichaelA
                                     set_a $ff,0
11652
                            >            load_flag 0
11653 3 MichaelA
1e07 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
11654 2 MichaelA
                            >
11655 3 MichaelA
1e09 : 48               [ 3]>            pha         ;use stack to load status
11656
1e0a : a9ff             [ 2]>            lda #$ff     ;precharge accu
11657
1e0c : 28               [ 4]>            plp
11658 2 MichaelA
 
11659 3 MichaelA
1e0d : 24bc             [ 3]         bit zp1+3   ;00 - should set Z / clear  NV
11660 2 MichaelA
                                     tst_a $ff,fz
11661 3 MichaelA
1e0f : 08               [ 3]>            php         ;save flags
11662
1e10 : 08               [ 3]>            php
11663
1e11 : c9ff             [ 2]>            cmp #$ff     ;test result
11664 2 MichaelA
                            >            trap_ne
11665 3 MichaelA
1e13 : f002             [ 3]>        beq skip1562
11666
                            >        trap           ;failed equal (zero)
11667
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11668
1e15 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11669
1e16 : 19                   >        db      test_num
11670 2 MichaelA
                            >
11671 3 MichaelA
1e17 :                      >skip1562
11672
                            >
11673
1e17 : 68               [ 4]>            pla         ;load status
11674 2 MichaelA
                            >            cmp_flag fz
11675 3 MichaelA
1e18 : c932             [ 2]>            cmp #(fz |fao)&m8    ;expected flags + always on bits
11676 2 MichaelA
                            >
11677
                            >            trap_ne
11678 3 MichaelA
1e1a : f002             [ 3]>        beq skip1565
11679
                            >        trap           ;failed equal (zero)
11680
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11681
1e1c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11682
1e1d : 19                   >        db      test_num
11683 2 MichaelA
                            >
11684 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  203
11685
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11686
 
11687
1e1e :                      >skip1565
11688
                            >
11689
1e1e : 28               [ 4]>            plp         ;restore status
11690 2 MichaelA
 
11691
                                     set_a 1,0
11692
                            >            load_flag 0
11693 3 MichaelA
1e1f : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
11694 2 MichaelA
                            >
11695 3 MichaelA
1e21 : 48               [ 3]>            pha         ;use stack to load status
11696
1e22 : a901             [ 2]>            lda #1     ;precharge accu
11697
1e24 : 28               [ 4]>            plp
11698 2 MichaelA
 
11699 3 MichaelA
1e25 : 24bb             [ 3]         bit zp1+2   ;41 - should set V (M6) / clear NZ
11700 2 MichaelA
                                     tst_a 1,fv
11701 3 MichaelA
1e27 : 08               [ 3]>            php         ;save flags
11702
1e28 : 08               [ 3]>            php
11703
1e29 : c901             [ 2]>            cmp #1     ;test result
11704 2 MichaelA
                            >            trap_ne
11705 3 MichaelA
1e2b : f002             [ 3]>        beq skip1570
11706
                            >        trap           ;failed equal (zero)
11707
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11708
1e2d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11709
1e2e : 19                   >        db      test_num
11710 2 MichaelA
                            >
11711 3 MichaelA
1e2f :                      >skip1570
11712
                            >
11713
1e2f : 68               [ 4]>            pla         ;load status
11714 2 MichaelA
                            >            cmp_flag fv
11715 3 MichaelA
1e30 : c970             [ 2]>            cmp #(fv|fao)&m8    ;expected flags + always on bits
11716 2 MichaelA
                            >
11717
                            >            trap_ne
11718 3 MichaelA
1e32 : f002             [ 3]>        beq skip1573
11719
                            >        trap           ;failed equal (zero)
11720
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11721
1e34 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11722
1e35 : 19                   >        db      test_num
11723 2 MichaelA
                            >
11724 3 MichaelA
1e36 :                      >skip1573
11725
                            >
11726
1e36 : 28               [ 4]>            plp         ;restore status
11727 2 MichaelA
 
11728
                                     set_a 1,0
11729
                            >            load_flag 0
11730 3 MichaelA
1e37 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
11731 2 MichaelA
                            >
11732 3 MichaelA
1e39 : 48               [ 3]>            pha         ;use stack to load status
11733
1e3a : a901             [ 2]>            lda #1     ;precharge accu
11734
1e3c : 28               [ 4]>            plp
11735 2 MichaelA
 
11736 3 MichaelA
1e3d : 24ba             [ 3]         bit zp1+1   ;82 - should set N (M7) & Z / clear V
11737 2 MichaelA
                                     tst_a 1,fnz
11738 3 MichaelA
1e3f : 08               [ 3]>            php         ;save flags
11739
1e40 : 08               [ 3]>            php
11740
1e41 : c901             [ 2]>            cmp #1     ;test result
11741 2 MichaelA
                            >            trap_ne
11742 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  204
11743
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11744
 
11745
1e43 : f002             [ 3]>        beq skip1578
11746
                            >        trap           ;failed equal (zero)
11747
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11748
1e45 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11749
1e46 : 19                   >        db      test_num
11750 2 MichaelA
                            >
11751 3 MichaelA
1e47 :                      >skip1578
11752
                            >
11753
1e47 : 68               [ 4]>            pla         ;load status
11754 2 MichaelA
                            >            cmp_flag fnz
11755 3 MichaelA
1e48 : c9b2             [ 2]>            cmp #(fnz|fao)&m8    ;expected flags + always on bits
11756 2 MichaelA
                            >
11757
                            >            trap_ne
11758 3 MichaelA
1e4a : f002             [ 3]>        beq skip1581
11759
                            >        trap           ;failed equal (zero)
11760
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11761
1e4c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11762
1e4d : 19                   >        db      test_num
11763 2 MichaelA
                            >
11764 3 MichaelA
1e4e :                      >skip1581
11765
                            >
11766
1e4e : 28               [ 4]>            plp         ;restore status
11767 2 MichaelA
 
11768
                                     set_a 1,0
11769
                            >            load_flag 0
11770 3 MichaelA
1e4f : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
11771 2 MichaelA
                            >
11772 3 MichaelA
1e51 : 48               [ 3]>            pha         ;use stack to load status
11773
1e52 : a901             [ 2]>            lda #1     ;precharge accu
11774
1e54 : 28               [ 4]>            plp
11775 2 MichaelA
 
11776 3 MichaelA
1e55 : 24b9             [ 3]         bit zp1     ;c3 - should set N (M7) & V (M6) / clear Z
11777 2 MichaelA
                                     tst_a 1,fnv
11778 3 MichaelA
1e57 : 08               [ 3]>            php         ;save flags
11779
1e58 : 08               [ 3]>            php
11780
1e59 : c901             [ 2]>            cmp #1     ;test result
11781 2 MichaelA
                            >            trap_ne
11782 3 MichaelA
1e5b : f002             [ 3]>        beq skip1586
11783
                            >        trap           ;failed equal (zero)
11784
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11785
1e5d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11786
1e5e : 19                   >        db      test_num
11787 2 MichaelA
                            >
11788 3 MichaelA
1e5f :                      >skip1586
11789
                            >
11790
1e5f : 68               [ 4]>            pla         ;load status
11791 2 MichaelA
                            >            cmp_flag fnv
11792 3 MichaelA
1e60 : c9f0             [ 2]>            cmp #(fnv|fao)&m8    ;expected flags + always on bits
11793 2 MichaelA
                            >
11794
                            >            trap_ne
11795 3 MichaelA
1e62 : f002             [ 3]>        beq skip1589
11796
                            >        trap           ;failed equal (zero)
11797
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11798
1e64 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11799
1e65 : 19                   >        db      test_num
11800
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  205
11801
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11802
 
11803 2 MichaelA
                            >
11804 3 MichaelA
1e66 :                      >skip1589
11805
                            >
11806
1e66 : 28               [ 4]>            plp         ;restore status
11807 2 MichaelA
 
11808
 
11809
                                     set_a $ff,$ff
11810
                            >            load_flag $ff
11811 3 MichaelA
1e67 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
11812 2 MichaelA
                            >
11813 3 MichaelA
1e69 : 48               [ 3]>            pha         ;use stack to load status
11814
1e6a : a9ff             [ 2]>            lda #$ff     ;precharge accu
11815
1e6c : 28               [ 4]>            plp
11816 2 MichaelA
 
11817 3 MichaelA
1e6d : 24bc             [ 3]         bit zp1+3   ;00 - should set Z / clear  NV
11818 2 MichaelA
                                     tst_a $ff,~fnv
11819 3 MichaelA
1e6f : 08               [ 3]>            php         ;save flags
11820
1e70 : 08               [ 3]>            php
11821
1e71 : c9ff             [ 2]>            cmp #$ff     ;test result
11822 2 MichaelA
                            >            trap_ne
11823 3 MichaelA
1e73 : f002             [ 3]>        beq skip1594
11824
                            >        trap           ;failed equal (zero)
11825
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11826
1e75 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11827
1e76 : 19                   >        db      test_num
11828 2 MichaelA
                            >
11829 3 MichaelA
1e77 :                      >skip1594
11830
                            >
11831
1e77 : 68               [ 4]>            pla         ;load status
11832 2 MichaelA
                            >            cmp_flag ~fnv
11833 3 MichaelA
1e78 : c93f             [ 2]>            cmp #(~fnv |fao)&m8    ;expected flags + always on bits
11834 2 MichaelA
                            >
11835
                            >            trap_ne
11836 3 MichaelA
1e7a : f002             [ 3]>        beq skip1597
11837
                            >        trap           ;failed equal (zero)
11838
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11839
1e7c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11840
1e7d : 19                   >        db      test_num
11841 2 MichaelA
                            >
11842 3 MichaelA
1e7e :                      >skip1597
11843
                            >
11844
1e7e : 28               [ 4]>            plp         ;restore status
11845 2 MichaelA
 
11846
                                     set_a 1,$ff
11847
                            >            load_flag $ff
11848 3 MichaelA
1e7f : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
11849 2 MichaelA
                            >
11850 3 MichaelA
1e81 : 48               [ 3]>            pha         ;use stack to load status
11851
1e82 : a901             [ 2]>            lda #1     ;precharge accu
11852
1e84 : 28               [ 4]>            plp
11853 2 MichaelA
 
11854 3 MichaelA
1e85 : 24bb             [ 3]         bit zp1+2   ;41 - should set V (M6) / clear NZ
11855 2 MichaelA
                                     tst_a 1,~fnz
11856 3 MichaelA
1e87 : 08               [ 3]>            php         ;save flags
11857
1e88 : 08               [ 3]>            php
11858
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  206
11859 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11860
 
11861 3 MichaelA
1e89 : c901             [ 2]>            cmp #1     ;test result
11862 2 MichaelA
                            >            trap_ne
11863 3 MichaelA
1e8b : f002             [ 3]>        beq skip1602
11864
                            >        trap           ;failed equal (zero)
11865
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11866
1e8d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11867
1e8e : 19                   >        db      test_num
11868 2 MichaelA
                            >
11869 3 MichaelA
1e8f :                      >skip1602
11870
                            >
11871
1e8f : 68               [ 4]>            pla         ;load status
11872 2 MichaelA
                            >            cmp_flag ~fnz
11873 3 MichaelA
1e90 : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
11874 2 MichaelA
                            >
11875
                            >            trap_ne
11876 3 MichaelA
1e92 : f002             [ 3]>        beq skip1605
11877
                            >        trap           ;failed equal (zero)
11878
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11879
1e94 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11880
1e95 : 19                   >        db      test_num
11881 2 MichaelA
                            >
11882 3 MichaelA
1e96 :                      >skip1605
11883
                            >
11884
1e96 : 28               [ 4]>            plp         ;restore status
11885 2 MichaelA
 
11886
                                     set_a 1,$ff
11887
                            >            load_flag $ff
11888 3 MichaelA
1e97 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
11889 2 MichaelA
                            >
11890 3 MichaelA
1e99 : 48               [ 3]>            pha         ;use stack to load status
11891
1e9a : a901             [ 2]>            lda #1     ;precharge accu
11892
1e9c : 28               [ 4]>            plp
11893 2 MichaelA
 
11894 3 MichaelA
1e9d : 24ba             [ 3]         bit zp1+1   ;82 - should set N (M7) & Z / clear V
11895 2 MichaelA
                                     tst_a 1,~fv
11896 3 MichaelA
1e9f : 08               [ 3]>            php         ;save flags
11897
1ea0 : 08               [ 3]>            php
11898
1ea1 : c901             [ 2]>            cmp #1     ;test result
11899 2 MichaelA
                            >            trap_ne
11900 3 MichaelA
1ea3 : f002             [ 3]>        beq skip1610
11901
                            >        trap           ;failed equal (zero)
11902
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11903
1ea5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11904
1ea6 : 19                   >        db      test_num
11905 2 MichaelA
                            >
11906 3 MichaelA
1ea7 :                      >skip1610
11907
                            >
11908
1ea7 : 68               [ 4]>            pla         ;load status
11909 2 MichaelA
                            >            cmp_flag ~fv
11910 3 MichaelA
1ea8 : c9bf             [ 2]>            cmp #(~fv|fao)&m8    ;expected flags + always on bits
11911 2 MichaelA
                            >
11912
                            >            trap_ne
11913 3 MichaelA
1eaa : f002             [ 3]>        beq skip1613
11914
                            >        trap           ;failed equal (zero)
11915
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11916
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  207
11917
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11918
 
11919
1eac : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11920
1ead : 19                   >        db      test_num
11921 2 MichaelA
                            >
11922 3 MichaelA
1eae :                      >skip1613
11923
                            >
11924
1eae : 28               [ 4]>            plp         ;restore status
11925 2 MichaelA
 
11926
                                     set_a 1,$ff
11927
                            >            load_flag $ff
11928 3 MichaelA
1eaf : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
11929 2 MichaelA
                            >
11930 3 MichaelA
1eb1 : 48               [ 3]>            pha         ;use stack to load status
11931
1eb2 : a901             [ 2]>            lda #1     ;precharge accu
11932
1eb4 : 28               [ 4]>            plp
11933 2 MichaelA
 
11934 3 MichaelA
1eb5 : 24b9             [ 3]         bit zp1     ;c3 - should set N (M7) & V (M6) / clear Z
11935 2 MichaelA
                                     tst_a 1,~fz
11936 3 MichaelA
1eb7 : 08               [ 3]>            php         ;save flags
11937
1eb8 : 08               [ 3]>            php
11938
1eb9 : c901             [ 2]>            cmp #1     ;test result
11939 2 MichaelA
                            >            trap_ne
11940 3 MichaelA
1ebb : f002             [ 3]>        beq skip1618
11941
                            >        trap           ;failed equal (zero)
11942
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11943
1ebd : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11944
1ebe : 19                   >        db      test_num
11945 2 MichaelA
                            >
11946 3 MichaelA
1ebf :                      >skip1618
11947
                            >
11948
1ebf : 68               [ 4]>            pla         ;load status
11949 2 MichaelA
                            >            cmp_flag ~fz
11950 3 MichaelA
1ec0 : c9fd             [ 2]>            cmp #(~fz|fao)&m8    ;expected flags + always on bits
11951 2 MichaelA
                            >
11952
                            >            trap_ne
11953 3 MichaelA
1ec2 : f002             [ 3]>        beq skip1621
11954
                            >        trap           ;failed equal (zero)
11955
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11956
1ec4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11957
1ec5 : 19                   >        db      test_num
11958 2 MichaelA
                            >
11959 3 MichaelA
1ec6 :                      >skip1621
11960
                            >
11961
1ec6 : 28               [ 4]>            plp         ;restore status
11962 2 MichaelA
 
11963
 
11964
                                     set_a $ff,0
11965
                            >            load_flag 0
11966 3 MichaelA
1ec7 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
11967 2 MichaelA
                            >
11968 3 MichaelA
1ec9 : 48               [ 3]>            pha         ;use stack to load status
11969
1eca : a9ff             [ 2]>            lda #$ff     ;precharge accu
11970
1ecc : 28               [ 4]>            plp
11971 2 MichaelA
 
11972 3 MichaelA
1ecd : 2c0b02           [ 4]         bit abs1+3  ;00 - should set Z / clear  NV
11973 2 MichaelA
                                     tst_a $ff,fz
11974 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  208
11975
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
11976
 
11977
1ed0 : 08               [ 3]>            php         ;save flags
11978
1ed1 : 08               [ 3]>            php
11979
1ed2 : c9ff             [ 2]>            cmp #$ff     ;test result
11980 2 MichaelA
                            >            trap_ne
11981 3 MichaelA
1ed4 : f002             [ 3]>        beq skip1626
11982
                            >        trap           ;failed equal (zero)
11983
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11984
1ed6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11985
1ed7 : 19                   >        db      test_num
11986 2 MichaelA
                            >
11987 3 MichaelA
1ed8 :                      >skip1626
11988
                            >
11989
1ed8 : 68               [ 4]>            pla         ;load status
11990 2 MichaelA
                            >            cmp_flag fz
11991 3 MichaelA
1ed9 : c932             [ 2]>            cmp #(fz |fao)&m8    ;expected flags + always on bits
11992 2 MichaelA
                            >
11993
                            >            trap_ne
11994 3 MichaelA
1edb : f002             [ 3]>        beq skip1629
11995
                            >        trap           ;failed equal (zero)
11996
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
11997
1edd : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
11998
1ede : 19                   >        db      test_num
11999 2 MichaelA
                            >
12000 3 MichaelA
1edf :                      >skip1629
12001
                            >
12002
1edf : 28               [ 4]>            plp         ;restore status
12003 2 MichaelA
 
12004
                                     set_a 1,0
12005
                            >            load_flag 0
12006 3 MichaelA
1ee0 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
12007 2 MichaelA
                            >
12008 3 MichaelA
1ee2 : 48               [ 3]>            pha         ;use stack to load status
12009
1ee3 : a901             [ 2]>            lda #1     ;precharge accu
12010
1ee5 : 28               [ 4]>            plp
12011 2 MichaelA
 
12012 3 MichaelA
1ee6 : 2c0a02           [ 4]         bit abs1+2  ;41 - should set V (M6) / clear NZ
12013 2 MichaelA
                                     tst_a 1,fv
12014 3 MichaelA
1ee9 : 08               [ 3]>            php         ;save flags
12015
1eea : 08               [ 3]>            php
12016
1eeb : c901             [ 2]>            cmp #1     ;test result
12017 2 MichaelA
                            >            trap_ne
12018 3 MichaelA
1eed : f002             [ 3]>        beq skip1634
12019
                            >        trap           ;failed equal (zero)
12020
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12021
1eef : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12022
1ef0 : 19                   >        db      test_num
12023 2 MichaelA
                            >
12024 3 MichaelA
1ef1 :                      >skip1634
12025
                            >
12026
1ef1 : 68               [ 4]>            pla         ;load status
12027 2 MichaelA
                            >            cmp_flag fv
12028 3 MichaelA
1ef2 : c970             [ 2]>            cmp #(fv|fao)&m8    ;expected flags + always on bits
12029 2 MichaelA
                            >
12030
                            >            trap_ne
12031 3 MichaelA
1ef4 : f002             [ 3]>        beq skip1637
12032
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  209
12033 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12034
 
12035 3 MichaelA
                            >        trap           ;failed equal (zero)
12036
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12037
1ef6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12038
1ef7 : 19                   >        db      test_num
12039 2 MichaelA
                            >
12040 3 MichaelA
1ef8 :                      >skip1637
12041
                            >
12042
1ef8 : 28               [ 4]>            plp         ;restore status
12043 2 MichaelA
 
12044
                                     set_a 1,0
12045
                            >            load_flag 0
12046 3 MichaelA
1ef9 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
12047 2 MichaelA
                            >
12048 3 MichaelA
1efb : 48               [ 3]>            pha         ;use stack to load status
12049
1efc : a901             [ 2]>            lda #1     ;precharge accu
12050
1efe : 28               [ 4]>            plp
12051 2 MichaelA
 
12052 3 MichaelA
1eff : 2c0902           [ 4]         bit abs1+1  ;82 - should set N (M7) & Z / clear V
12053 2 MichaelA
                                     tst_a 1,fnz
12054 3 MichaelA
1f02 : 08               [ 3]>            php         ;save flags
12055
1f03 : 08               [ 3]>            php
12056
1f04 : c901             [ 2]>            cmp #1     ;test result
12057 2 MichaelA
                            >            trap_ne
12058 3 MichaelA
1f06 : f002             [ 3]>        beq skip1642
12059
                            >        trap           ;failed equal (zero)
12060
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12061
1f08 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12062
1f09 : 19                   >        db      test_num
12063 2 MichaelA
                            >
12064 3 MichaelA
1f0a :                      >skip1642
12065
                            >
12066
1f0a : 68               [ 4]>            pla         ;load status
12067 2 MichaelA
                            >            cmp_flag fnz
12068 3 MichaelA
1f0b : c9b2             [ 2]>            cmp #(fnz|fao)&m8    ;expected flags + always on bits
12069 2 MichaelA
                            >
12070
                            >            trap_ne
12071 3 MichaelA
1f0d : f002             [ 3]>        beq skip1645
12072
                            >        trap           ;failed equal (zero)
12073
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12074
1f0f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12075
1f10 : 19                   >        db      test_num
12076 2 MichaelA
                            >
12077 3 MichaelA
1f11 :                      >skip1645
12078
                            >
12079
1f11 : 28               [ 4]>            plp         ;restore status
12080 2 MichaelA
 
12081
                                     set_a 1,0
12082
                            >            load_flag 0
12083 3 MichaelA
1f12 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
12084 2 MichaelA
                            >
12085 3 MichaelA
1f14 : 48               [ 3]>            pha         ;use stack to load status
12086
1f15 : a901             [ 2]>            lda #1     ;precharge accu
12087
1f17 : 28               [ 4]>            plp
12088 2 MichaelA
 
12089 3 MichaelA
1f18 : 2c0802           [ 4]         bit abs1    ;c3 - should set N (M7) & V (M6) / clear Z
12090
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  210
12091
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12092
 
12093 2 MichaelA
                                     tst_a 1,fnv
12094 3 MichaelA
1f1b : 08               [ 3]>            php         ;save flags
12095
1f1c : 08               [ 3]>            php
12096
1f1d : c901             [ 2]>            cmp #1     ;test result
12097 2 MichaelA
                            >            trap_ne
12098 3 MichaelA
1f1f : f002             [ 3]>        beq skip1650
12099
                            >        trap           ;failed equal (zero)
12100
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12101
1f21 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12102
1f22 : 19                   >        db      test_num
12103 2 MichaelA
                            >
12104 3 MichaelA
1f23 :                      >skip1650
12105
                            >
12106
1f23 : 68               [ 4]>            pla         ;load status
12107 2 MichaelA
                            >            cmp_flag fnv
12108 3 MichaelA
1f24 : c9f0             [ 2]>            cmp #(fnv|fao)&m8    ;expected flags + always on bits
12109 2 MichaelA
                            >
12110
                            >            trap_ne
12111 3 MichaelA
1f26 : f002             [ 3]>        beq skip1653
12112
                            >        trap           ;failed equal (zero)
12113
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12114
1f28 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12115
1f29 : 19                   >        db      test_num
12116 2 MichaelA
                            >
12117 3 MichaelA
1f2a :                      >skip1653
12118
                            >
12119
1f2a : 28               [ 4]>            plp         ;restore status
12120 2 MichaelA
 
12121
 
12122
                                     set_a $ff,$ff
12123
                            >            load_flag $ff
12124 3 MichaelA
1f2b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
12125 2 MichaelA
                            >
12126 3 MichaelA
1f2d : 48               [ 3]>            pha         ;use stack to load status
12127
1f2e : a9ff             [ 2]>            lda #$ff     ;precharge accu
12128
1f30 : 28               [ 4]>            plp
12129 2 MichaelA
 
12130 3 MichaelA
1f31 : 2c0b02           [ 4]         bit abs1+3  ;00 - should set Z / clear  NV
12131 2 MichaelA
                                     tst_a $ff,~fnv
12132 3 MichaelA
1f34 : 08               [ 3]>            php         ;save flags
12133
1f35 : 08               [ 3]>            php
12134
1f36 : c9ff             [ 2]>            cmp #$ff     ;test result
12135 2 MichaelA
                            >            trap_ne
12136 3 MichaelA
1f38 : f002             [ 3]>        beq skip1658
12137
                            >        trap           ;failed equal (zero)
12138
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12139
1f3a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12140
1f3b : 19                   >        db      test_num
12141 2 MichaelA
                            >
12142 3 MichaelA
1f3c :                      >skip1658
12143
                            >
12144
1f3c : 68               [ 4]>            pla         ;load status
12145 2 MichaelA
                            >            cmp_flag ~fnv
12146 3 MichaelA
1f3d : c93f             [ 2]>            cmp #(~fnv |fao)&m8    ;expected flags + always on bits
12147 2 MichaelA
                            >
12148 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  211
12149
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12150
 
12151 2 MichaelA
                            >            trap_ne
12152 3 MichaelA
1f3f : f002             [ 3]>        beq skip1661
12153
                            >        trap           ;failed equal (zero)
12154
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12155
1f41 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12156
1f42 : 19                   >        db      test_num
12157 2 MichaelA
                            >
12158 3 MichaelA
1f43 :                      >skip1661
12159
                            >
12160
1f43 : 28               [ 4]>            plp         ;restore status
12161 2 MichaelA
 
12162
                                     set_a 1,$ff
12163
                            >            load_flag $ff
12164 3 MichaelA
1f44 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
12165 2 MichaelA
                            >
12166 3 MichaelA
1f46 : 48               [ 3]>            pha         ;use stack to load status
12167
1f47 : a901             [ 2]>            lda #1     ;precharge accu
12168
1f49 : 28               [ 4]>            plp
12169 2 MichaelA
 
12170 3 MichaelA
1f4a : 2c0a02           [ 4]         bit abs1+2  ;41 - should set V (M6) / clear NZ
12171 2 MichaelA
                                     tst_a 1,~fnz
12172 3 MichaelA
1f4d : 08               [ 3]>            php         ;save flags
12173
1f4e : 08               [ 3]>            php
12174
1f4f : c901             [ 2]>            cmp #1     ;test result
12175 2 MichaelA
                            >            trap_ne
12176 3 MichaelA
1f51 : f002             [ 3]>        beq skip1666
12177
                            >        trap           ;failed equal (zero)
12178
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12179
1f53 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12180
1f54 : 19                   >        db      test_num
12181 2 MichaelA
                            >
12182 3 MichaelA
1f55 :                      >skip1666
12183
                            >
12184
1f55 : 68               [ 4]>            pla         ;load status
12185 2 MichaelA
                            >            cmp_flag ~fnz
12186 3 MichaelA
1f56 : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
12187 2 MichaelA
                            >
12188
                            >            trap_ne
12189 3 MichaelA
1f58 : f002             [ 3]>        beq skip1669
12190
                            >        trap           ;failed equal (zero)
12191
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12192
1f5a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12193
1f5b : 19                   >        db      test_num
12194 2 MichaelA
                            >
12195 3 MichaelA
1f5c :                      >skip1669
12196
                            >
12197
1f5c : 28               [ 4]>            plp         ;restore status
12198 2 MichaelA
 
12199
                                     set_a 1,$ff
12200
                            >            load_flag $ff
12201 3 MichaelA
1f5d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
12202 2 MichaelA
                            >
12203 3 MichaelA
1f5f : 48               [ 3]>            pha         ;use stack to load status
12204
1f60 : a901             [ 2]>            lda #1     ;precharge accu
12205
1f62 : 28               [ 4]>            plp
12206
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  212
12207 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12208
 
12209
 
12210 3 MichaelA
1f63 : 2c0902           [ 4]         bit abs1+1  ;82 - should set N (M7) & Z / clear V
12211 2 MichaelA
                                     tst_a 1,~fv
12212 3 MichaelA
1f66 : 08               [ 3]>            php         ;save flags
12213
1f67 : 08               [ 3]>            php
12214
1f68 : c901             [ 2]>            cmp #1     ;test result
12215 2 MichaelA
                            >            trap_ne
12216 3 MichaelA
1f6a : f002             [ 3]>        beq skip1674
12217
                            >        trap           ;failed equal (zero)
12218
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12219
1f6c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12220
1f6d : 19                   >        db      test_num
12221 2 MichaelA
                            >
12222 3 MichaelA
1f6e :                      >skip1674
12223
                            >
12224
1f6e : 68               [ 4]>            pla         ;load status
12225 2 MichaelA
                            >            cmp_flag ~fv
12226 3 MichaelA
1f6f : c9bf             [ 2]>            cmp #(~fv|fao)&m8    ;expected flags + always on bits
12227 2 MichaelA
                            >
12228
                            >            trap_ne
12229 3 MichaelA
1f71 : f002             [ 3]>        beq skip1677
12230
                            >        trap           ;failed equal (zero)
12231
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12232
1f73 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12233
1f74 : 19                   >        db      test_num
12234 2 MichaelA
                            >
12235 3 MichaelA
1f75 :                      >skip1677
12236
                            >
12237
1f75 : 28               [ 4]>            plp         ;restore status
12238 2 MichaelA
 
12239
                                     set_a 1,$ff
12240
                            >            load_flag $ff
12241 3 MichaelA
1f76 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
12242 2 MichaelA
                            >
12243 3 MichaelA
1f78 : 48               [ 3]>            pha         ;use stack to load status
12244
1f79 : a901             [ 2]>            lda #1     ;precharge accu
12245
1f7b : 28               [ 4]>            plp
12246 2 MichaelA
 
12247 3 MichaelA
1f7c : 2c0802           [ 4]         bit abs1    ;c3 - should set N (M7) & V (M6) / clear Z
12248 2 MichaelA
                                     tst_a 1,~fz
12249 3 MichaelA
1f7f : 08               [ 3]>            php         ;save flags
12250
1f80 : 08               [ 3]>            php
12251
1f81 : c901             [ 2]>            cmp #1     ;test result
12252 2 MichaelA
                            >            trap_ne
12253 3 MichaelA
1f83 : f002             [ 3]>        beq skip1682
12254
                            >        trap           ;failed equal (zero)
12255
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12256
1f85 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12257
1f86 : 19                   >        db      test_num
12258 2 MichaelA
                            >
12259 3 MichaelA
1f87 :                      >skip1682
12260
                            >
12261
1f87 : 68               [ 4]>            pla         ;load status
12262 2 MichaelA
                            >            cmp_flag ~fz
12263 3 MichaelA
1f88 : c9fd             [ 2]>            cmp #(~fz|fao)&m8    ;expected flags + always on bits
12264
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  213
12265
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12266
 
12267 2 MichaelA
                            >
12268
                            >            trap_ne
12269 3 MichaelA
1f8a : f002             [ 3]>        beq skip1685
12270
                            >        trap           ;failed equal (zero)
12271
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12272
1f8c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12273
1f8d : 19                   >        db      test_num
12274 2 MichaelA
                            >
12275 3 MichaelA
1f8e :                      >skip1685
12276
                            >
12277
1f8e : 28               [ 4]>            plp         ;restore status
12278 2 MichaelA
 
12279
                                     next_test
12280 3 MichaelA
1f8f : ad0002           [ 4]>            lda test_case   ;previous test
12281
1f92 : c919             [ 2]>            cmp #test_num
12282 2 MichaelA
                            >            trap_ne         ;test is out of sequence
12283 3 MichaelA
1f94 : f002             [ 3]>        beq skip1688
12284
                            >        trap           ;failed equal (zero)
12285
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12286
1f96 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12287
1f97 : 19                   >        db      test_num
12288 2 MichaelA
                            >
12289 3 MichaelA
1f98 :                      >skip1688
12290
                            >
12291 2 MichaelA
001a =                      >test_num = test_num + 1
12292 3 MichaelA
1f98 : a91a             [ 2]>            lda #test_num   ;*** this tests' number
12293
1f9a : 8d0002           [ 4]>            sta test_case
12294 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
12295
 
12296
 
12297
                             ; CPX - zp / abs / #
12298 3 MichaelA
 
12299 2 MichaelA
                                     set_x $80,0
12300
                            >            load_flag 0
12301 3 MichaelA
1f9d : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
12302 2 MichaelA
                            >
12303 3 MichaelA
1f9f : 48               [ 3]>            pha         ;use stack to load status
12304
1fa0 : a280             [ 2]>            ldx #$80     ;precharge index x
12305
1fa2 : 28               [ 4]>            plp
12306 2 MichaelA
 
12307 3 MichaelA
1fa3 : e4bd             [ 3]         cpx zp7f
12308 2 MichaelA
                                     tst_stat fc
12309 3 MichaelA
1fa5 : 08               [ 3]>            php         ;save status
12310
1fa6 : 08               [ 3]>            php         ;use stack to retrieve status
12311
1fa7 : 68               [ 4]>            pla
12312 2 MichaelA
                            >            cmp_flag fc
12313 3 MichaelA
1fa8 : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
12314 2 MichaelA
                            >
12315
                            >            trap_ne
12316 3 MichaelA
1faa : f002             [ 3]>        beq skip1694
12317
                            >        trap           ;failed equal (zero)
12318
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12319
1fac : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12320
1fad : 1a                   >        db      test_num
12321 2 MichaelA
                            >
12322 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  214
12323
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12324
 
12325
1fae :                      >skip1694
12326
                            >
12327
1fae : 28               [ 4]>            plp         ;restore status
12328 2 MichaelA
 
12329 3 MichaelA
1faf : ca               [ 2]         dex
12330
1fb0 : e4bd             [ 3]         cpx zp7f
12331 2 MichaelA
                                     tst_stat fzc
12332 3 MichaelA
1fb2 : 08               [ 3]>            php         ;save status
12333
1fb3 : 08               [ 3]>            php         ;use stack to retrieve status
12334
1fb4 : 68               [ 4]>            pla
12335 2 MichaelA
                            >            cmp_flag fzc
12336 3 MichaelA
1fb5 : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
12337 2 MichaelA
                            >
12338
                            >            trap_ne
12339 3 MichaelA
1fb7 : f002             [ 3]>        beq skip1698
12340
                            >        trap           ;failed equal (zero)
12341
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12342
1fb9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12343
1fba : 1a                   >        db      test_num
12344 2 MichaelA
                            >
12345 3 MichaelA
1fbb :                      >skip1698
12346
                            >
12347
1fbb : 28               [ 4]>            plp         ;restore status
12348 2 MichaelA
 
12349 3 MichaelA
1fbc : ca               [ 2]         dex
12350
1fbd : e4bd             [ 3]         cpx zp7f
12351 2 MichaelA
                                     tst_x $7e,fn
12352 3 MichaelA
1fbf : 08               [ 3]>            php         ;save flags
12353
1fc0 : 08               [ 3]>            php
12354
1fc1 : e07e             [ 2]>            cpx #$7e     ;test result
12355 2 MichaelA
                            >            trap_ne
12356 3 MichaelA
1fc3 : f002             [ 3]>        beq skip1701
12357
                            >        trap           ;failed equal (zero)
12358
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12359
1fc5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12360
1fc6 : 1a                   >        db      test_num
12361 2 MichaelA
                            >
12362 3 MichaelA
1fc7 :                      >skip1701
12363
                            >
12364
1fc7 : 68               [ 4]>            pla         ;load status
12365 2 MichaelA
                            >            cmp_flag fn
12366 3 MichaelA
1fc8 : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
12367 2 MichaelA
                            >
12368
                            >            trap_ne
12369 3 MichaelA
1fca : f002             [ 3]>        beq skip1704
12370
                            >        trap           ;failed equal (zero)
12371
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12372
1fcc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12373
1fcd : 1a                   >        db      test_num
12374 2 MichaelA
                            >
12375 3 MichaelA
1fce :                      >skip1704
12376
                            >
12377
1fce : 28               [ 4]>            plp         ;restore status
12378
 
12379
                                     set_x $80,$ff
12380
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  215
12381 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12382
 
12383
                            >            load_flag $ff
12384 3 MichaelA
1fcf : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
12385 2 MichaelA
                            >
12386 3 MichaelA
1fd1 : 48               [ 3]>            pha         ;use stack to load status
12387
1fd2 : a280             [ 2]>            ldx #$80     ;precharge index x
12388
1fd4 : 28               [ 4]>            plp
12389 2 MichaelA
 
12390 3 MichaelA
1fd5 : e4bd             [ 3]         cpx zp7f
12391 2 MichaelA
                                     tst_stat ~fnz
12392 3 MichaelA
1fd7 : 08               [ 3]>            php         ;save status
12393
1fd8 : 08               [ 3]>            php         ;use stack to retrieve status
12394
1fd9 : 68               [ 4]>            pla
12395 2 MichaelA
                            >            cmp_flag ~fnz
12396 3 MichaelA
1fda : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
12397 2 MichaelA
                            >
12398
                            >            trap_ne
12399 3 MichaelA
1fdc : f002             [ 3]>        beq skip1710
12400
                            >        trap           ;failed equal (zero)
12401
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12402
1fde : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12403
1fdf : 1a                   >        db      test_num
12404 2 MichaelA
                            >
12405 3 MichaelA
1fe0 :                      >skip1710
12406
                            >
12407
1fe0 : 28               [ 4]>            plp         ;restore status
12408 2 MichaelA
 
12409 3 MichaelA
1fe1 : ca               [ 2]         dex
12410
1fe2 : e4bd             [ 3]         cpx zp7f
12411 2 MichaelA
                                     tst_stat ~fn
12412 3 MichaelA
1fe4 : 08               [ 3]>            php         ;save status
12413
1fe5 : 08               [ 3]>            php         ;use stack to retrieve status
12414
1fe6 : 68               [ 4]>            pla
12415 2 MichaelA
                            >            cmp_flag ~fn
12416 3 MichaelA
1fe7 : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
12417 2 MichaelA
                            >
12418
                            >            trap_ne
12419 3 MichaelA
1fe9 : f002             [ 3]>        beq skip1714
12420
                            >        trap           ;failed equal (zero)
12421
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12422
1feb : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12423
1fec : 1a                   >        db      test_num
12424 2 MichaelA
                            >
12425 3 MichaelA
1fed :                      >skip1714
12426
                            >
12427
1fed : 28               [ 4]>            plp         ;restore status
12428 2 MichaelA
 
12429 3 MichaelA
1fee : ca               [ 2]         dex
12430
1fef : e4bd             [ 3]         cpx zp7f
12431 2 MichaelA
                                     tst_x $7e,~fzc
12432 3 MichaelA
1ff1 : 08               [ 3]>            php         ;save flags
12433
1ff2 : 08               [ 3]>            php
12434
1ff3 : e07e             [ 2]>            cpx #$7e     ;test result
12435 2 MichaelA
                            >            trap_ne
12436 3 MichaelA
1ff5 : f002             [ 3]>        beq skip1717
12437
                            >        trap           ;failed equal (zero)
12438
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  216
12439
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12440
 
12441
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12442
1ff7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12443
1ff8 : 1a                   >        db      test_num
12444 2 MichaelA
                            >
12445 3 MichaelA
1ff9 :                      >skip1717
12446
                            >
12447
1ff9 : 68               [ 4]>            pla         ;load status
12448 2 MichaelA
                            >            cmp_flag ~fzc
12449 3 MichaelA
1ffa : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
12450 2 MichaelA
                            >
12451
                            >            trap_ne
12452 3 MichaelA
1ffc : f002             [ 4]>        beq skip1720
12453
                            >        trap           ;failed equal (zero)
12454
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12455
1ffe : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12456
1fff : 1a                   >        db      test_num
12457 2 MichaelA
                            >
12458 3 MichaelA
2000 :                      >skip1720
12459
                            >
12460
2000 : 28               [ 4]>            plp         ;restore status
12461 2 MichaelA
 
12462
 
12463
                                     set_x $80,0
12464
                            >            load_flag 0
12465 3 MichaelA
2001 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
12466 2 MichaelA
                            >
12467 3 MichaelA
2003 : 48               [ 3]>            pha         ;use stack to load status
12468
2004 : a280             [ 2]>            ldx #$80     ;precharge index x
12469
2006 : 28               [ 4]>            plp
12470 2 MichaelA
 
12471 3 MichaelA
2007 : ec0c02           [ 4]         cpx abs7f
12472 2 MichaelA
                                     tst_stat fc
12473 3 MichaelA
200a : 08               [ 3]>            php         ;save status
12474
200b : 08               [ 3]>            php         ;use stack to retrieve status
12475
200c : 68               [ 4]>            pla
12476 2 MichaelA
                            >            cmp_flag fc
12477 3 MichaelA
200d : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
12478 2 MichaelA
                            >
12479
                            >            trap_ne
12480 3 MichaelA
200f : f002             [ 3]>        beq skip1726
12481
                            >        trap           ;failed equal (zero)
12482
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12483
2011 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12484
2012 : 1a                   >        db      test_num
12485 2 MichaelA
                            >
12486 3 MichaelA
2013 :                      >skip1726
12487
                            >
12488
2013 : 28               [ 4]>            plp         ;restore status
12489 2 MichaelA
 
12490 3 MichaelA
2014 : ca               [ 2]         dex
12491
2015 : ec0c02           [ 4]         cpx abs7f
12492 2 MichaelA
                                     tst_stat fzc
12493 3 MichaelA
2018 : 08               [ 3]>            php         ;save status
12494
2019 : 08               [ 3]>            php         ;use stack to retrieve status
12495
201a : 68               [ 4]>            pla
12496
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  217
12497
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12498
 
12499 2 MichaelA
                            >            cmp_flag fzc
12500 3 MichaelA
201b : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
12501 2 MichaelA
                            >
12502
                            >            trap_ne
12503 3 MichaelA
201d : f002             [ 3]>        beq skip1730
12504
                            >        trap           ;failed equal (zero)
12505
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12506
201f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12507
2020 : 1a                   >        db      test_num
12508 2 MichaelA
                            >
12509 3 MichaelA
2021 :                      >skip1730
12510
                            >
12511
2021 : 28               [ 4]>            plp         ;restore status
12512 2 MichaelA
 
12513 3 MichaelA
2022 : ca               [ 2]         dex
12514
2023 : ec0c02           [ 4]         cpx abs7f
12515 2 MichaelA
                                     tst_x $7e,fn
12516 3 MichaelA
2026 : 08               [ 3]>            php         ;save flags
12517
2027 : 08               [ 3]>            php
12518
2028 : e07e             [ 2]>            cpx #$7e     ;test result
12519 2 MichaelA
                            >            trap_ne
12520 3 MichaelA
202a : f002             [ 3]>        beq skip1733
12521
                            >        trap           ;failed equal (zero)
12522
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12523
202c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12524
202d : 1a                   >        db      test_num
12525 2 MichaelA
                            >
12526 3 MichaelA
202e :                      >skip1733
12527
                            >
12528
202e : 68               [ 4]>            pla         ;load status
12529 2 MichaelA
                            >            cmp_flag fn
12530 3 MichaelA
202f : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
12531 2 MichaelA
                            >
12532
                            >            trap_ne
12533 3 MichaelA
2031 : f002             [ 3]>        beq skip1736
12534
                            >        trap           ;failed equal (zero)
12535
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12536
2033 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12537
2034 : 1a                   >        db      test_num
12538 2 MichaelA
                            >
12539 3 MichaelA
2035 :                      >skip1736
12540
                            >
12541
2035 : 28               [ 4]>            plp         ;restore status
12542 2 MichaelA
 
12543
                                     set_x $80,$ff
12544
                            >            load_flag $ff
12545 3 MichaelA
2036 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
12546 2 MichaelA
                            >
12547 3 MichaelA
2038 : 48               [ 3]>            pha         ;use stack to load status
12548
2039 : a280             [ 2]>            ldx #$80     ;precharge index x
12549
203b : 28               [ 4]>            plp
12550 2 MichaelA
 
12551 3 MichaelA
203c : ec0c02           [ 4]         cpx abs7f
12552 2 MichaelA
                                     tst_stat ~fnz
12553 3 MichaelA
203f : 08               [ 3]>            php         ;save status
12554
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  218
12555
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12556
 
12557
2040 : 08               [ 3]>            php         ;use stack to retrieve status
12558
2041 : 68               [ 4]>            pla
12559 2 MichaelA
                            >            cmp_flag ~fnz
12560 3 MichaelA
2042 : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
12561 2 MichaelA
                            >
12562
                            >            trap_ne
12563 3 MichaelA
2044 : f002             [ 3]>        beq skip1742
12564
                            >        trap           ;failed equal (zero)
12565
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12566
2046 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12567
2047 : 1a                   >        db      test_num
12568 2 MichaelA
                            >
12569 3 MichaelA
2048 :                      >skip1742
12570
                            >
12571
2048 : 28               [ 4]>            plp         ;restore status
12572 2 MichaelA
 
12573 3 MichaelA
2049 : ca               [ 2]         dex
12574
204a : ec0c02           [ 4]         cpx abs7f
12575 2 MichaelA
                                     tst_stat ~fn
12576 3 MichaelA
204d : 08               [ 3]>            php         ;save status
12577
204e : 08               [ 3]>            php         ;use stack to retrieve status
12578
204f : 68               [ 4]>            pla
12579 2 MichaelA
                            >            cmp_flag ~fn
12580 3 MichaelA
2050 : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
12581 2 MichaelA
                            >
12582
                            >            trap_ne
12583 3 MichaelA
2052 : f002             [ 3]>        beq skip1746
12584
                            >        trap           ;failed equal (zero)
12585
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12586
2054 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12587
2055 : 1a                   >        db      test_num
12588 2 MichaelA
                            >
12589 3 MichaelA
2056 :                      >skip1746
12590
                            >
12591
2056 : 28               [ 4]>            plp         ;restore status
12592 2 MichaelA
 
12593 3 MichaelA
2057 : ca               [ 2]         dex
12594
2058 : ec0c02           [ 4]         cpx abs7f
12595 2 MichaelA
                                     tst_x $7e,~fzc
12596 3 MichaelA
205b : 08               [ 3]>            php         ;save flags
12597
205c : 08               [ 3]>            php
12598
205d : e07e             [ 2]>            cpx #$7e     ;test result
12599 2 MichaelA
                            >            trap_ne
12600 3 MichaelA
205f : f002             [ 3]>        beq skip1749
12601
                            >        trap           ;failed equal (zero)
12602
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12603
2061 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12604
2062 : 1a                   >        db      test_num
12605 2 MichaelA
                            >
12606 3 MichaelA
2063 :                      >skip1749
12607
                            >
12608
2063 : 68               [ 4]>            pla         ;load status
12609 2 MichaelA
                            >            cmp_flag ~fzc
12610 3 MichaelA
2064 : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
12611 2 MichaelA
                            >
12612 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  219
12613
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12614
 
12615 2 MichaelA
                            >            trap_ne
12616 3 MichaelA
2066 : f002             [ 3]>        beq skip1752
12617
                            >        trap           ;failed equal (zero)
12618
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12619
2068 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12620
2069 : 1a                   >        db      test_num
12621 2 MichaelA
                            >
12622 3 MichaelA
206a :                      >skip1752
12623
                            >
12624
206a : 28               [ 4]>            plp         ;restore status
12625 2 MichaelA
 
12626
 
12627
                                     set_x $80,0
12628
                            >            load_flag 0
12629 3 MichaelA
206b : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
12630 2 MichaelA
                            >
12631 3 MichaelA
206d : 48               [ 3]>            pha         ;use stack to load status
12632
206e : a280             [ 2]>            ldx #$80     ;precharge index x
12633
2070 : 28               [ 4]>            plp
12634 2 MichaelA
 
12635 3 MichaelA
2071 : e07f             [ 2]         cpx #$7f
12636 2 MichaelA
                                     tst_stat fc
12637 3 MichaelA
2073 : 08               [ 3]>            php         ;save status
12638
2074 : 08               [ 3]>            php         ;use stack to retrieve status
12639
2075 : 68               [ 4]>            pla
12640 2 MichaelA
                            >            cmp_flag fc
12641 3 MichaelA
2076 : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
12642 2 MichaelA
                            >
12643
                            >            trap_ne
12644 3 MichaelA
2078 : f002             [ 3]>        beq skip1758
12645
                            >        trap           ;failed equal (zero)
12646
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12647
207a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12648
207b : 1a                   >        db      test_num
12649 2 MichaelA
                            >
12650 3 MichaelA
207c :                      >skip1758
12651
                            >
12652
207c : 28               [ 4]>            plp         ;restore status
12653 2 MichaelA
 
12654 3 MichaelA
207d : ca               [ 2]         dex
12655
207e : e07f             [ 2]         cpx #$7f
12656 2 MichaelA
                                     tst_stat fzc
12657 3 MichaelA
2080 : 08               [ 3]>            php         ;save status
12658
2081 : 08               [ 3]>            php         ;use stack to retrieve status
12659
2082 : 68               [ 4]>            pla
12660 2 MichaelA
                            >            cmp_flag fzc
12661 3 MichaelA
2083 : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
12662 2 MichaelA
                            >
12663
                            >            trap_ne
12664 3 MichaelA
2085 : f002             [ 3]>        beq skip1762
12665
                            >        trap           ;failed equal (zero)
12666
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12667
2087 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12668
2088 : 1a                   >        db      test_num
12669 2 MichaelA
                            >
12670 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  220
12671
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12672
 
12673
2089 :                      >skip1762
12674
                            >
12675
2089 : 28               [ 4]>            plp         ;restore status
12676 2 MichaelA
 
12677 3 MichaelA
208a : ca               [ 2]         dex
12678
208b : e07f             [ 2]         cpx #$7f
12679 2 MichaelA
                                     tst_x $7e,fn
12680 3 MichaelA
208d : 08               [ 3]>            php         ;save flags
12681
208e : 08               [ 3]>            php
12682
208f : e07e             [ 2]>            cpx #$7e     ;test result
12683 2 MichaelA
                            >            trap_ne
12684 3 MichaelA
2091 : f002             [ 3]>        beq skip1765
12685
                            >        trap           ;failed equal (zero)
12686
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12687
2093 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12688
2094 : 1a                   >        db      test_num
12689 2 MichaelA
                            >
12690 3 MichaelA
2095 :                      >skip1765
12691
                            >
12692
2095 : 68               [ 4]>            pla         ;load status
12693 2 MichaelA
                            >            cmp_flag fn
12694 3 MichaelA
2096 : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
12695 2 MichaelA
                            >
12696
                            >            trap_ne
12697 3 MichaelA
2098 : f002             [ 3]>        beq skip1768
12698
                            >        trap           ;failed equal (zero)
12699
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12700
209a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12701
209b : 1a                   >        db      test_num
12702 2 MichaelA
                            >
12703 3 MichaelA
209c :                      >skip1768
12704
                            >
12705
209c : 28               [ 4]>            plp         ;restore status
12706 2 MichaelA
 
12707
                                     set_x $80,$ff
12708
                            >            load_flag $ff
12709 3 MichaelA
209d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
12710 2 MichaelA
                            >
12711 3 MichaelA
209f : 48               [ 3]>            pha         ;use stack to load status
12712
20a0 : a280             [ 2]>            ldx #$80     ;precharge index x
12713
20a2 : 28               [ 4]>            plp
12714 2 MichaelA
 
12715 3 MichaelA
20a3 : e07f             [ 2]         cpx #$7f
12716 2 MichaelA
                                     tst_stat ~fnz
12717 3 MichaelA
20a5 : 08               [ 3]>            php         ;save status
12718
20a6 : 08               [ 3]>            php         ;use stack to retrieve status
12719
20a7 : 68               [ 4]>            pla
12720 2 MichaelA
                            >            cmp_flag ~fnz
12721 3 MichaelA
20a8 : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
12722 2 MichaelA
                            >
12723
                            >            trap_ne
12724 3 MichaelA
20aa : f002             [ 3]>        beq skip1774
12725
                            >        trap           ;failed equal (zero)
12726
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12727
20ac : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12728
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  221
12729
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12730
 
12731
20ad : 1a                   >        db      test_num
12732 2 MichaelA
                            >
12733 3 MichaelA
20ae :                      >skip1774
12734
                            >
12735
20ae : 28               [ 4]>            plp         ;restore status
12736 2 MichaelA
 
12737 3 MichaelA
20af : ca               [ 2]         dex
12738
20b0 : e07f             [ 2]         cpx #$7f
12739 2 MichaelA
                                     tst_stat ~fn
12740 3 MichaelA
20b2 : 08               [ 3]>            php         ;save status
12741
20b3 : 08               [ 3]>            php         ;use stack to retrieve status
12742
20b4 : 68               [ 4]>            pla
12743 2 MichaelA
                            >            cmp_flag ~fn
12744 3 MichaelA
20b5 : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
12745 2 MichaelA
                            >
12746
                            >            trap_ne
12747 3 MichaelA
20b7 : f002             [ 3]>        beq skip1778
12748
                            >        trap           ;failed equal (zero)
12749
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12750
20b9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12751
20ba : 1a                   >        db      test_num
12752 2 MichaelA
                            >
12753 3 MichaelA
20bb :                      >skip1778
12754
                            >
12755
20bb : 28               [ 4]>            plp         ;restore status
12756 2 MichaelA
 
12757 3 MichaelA
20bc : ca               [ 2]         dex
12758
20bd : e07f             [ 2]         cpx #$7f
12759 2 MichaelA
                                     tst_x $7e,~fzc
12760 3 MichaelA
20bf : 08               [ 3]>            php         ;save flags
12761
20c0 : 08               [ 3]>            php
12762
20c1 : e07e             [ 2]>            cpx #$7e     ;test result
12763 2 MichaelA
                            >            trap_ne
12764 3 MichaelA
20c3 : f002             [ 3]>        beq skip1781
12765
                            >        trap           ;failed equal (zero)
12766
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12767
20c5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12768
20c6 : 1a                   >        db      test_num
12769 2 MichaelA
                            >
12770 3 MichaelA
20c7 :                      >skip1781
12771
                            >
12772
20c7 : 68               [ 4]>            pla         ;load status
12773 2 MichaelA
                            >            cmp_flag ~fzc
12774 3 MichaelA
20c8 : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
12775 2 MichaelA
                            >
12776
                            >            trap_ne
12777 3 MichaelA
20ca : f002             [ 3]>        beq skip1784
12778
                            >        trap           ;failed equal (zero)
12779
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12780
20cc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12781
20cd : 1a                   >        db      test_num
12782 2 MichaelA
                            >
12783 3 MichaelA
20ce :                      >skip1784
12784
                            >
12785
20ce : 28               [ 4]>            plp         ;restore status
12786
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  222
12787
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12788
 
12789 2 MichaelA
 
12790
                                     next_test
12791 3 MichaelA
20cf : ad0002           [ 4]>            lda test_case   ;previous test
12792
20d2 : c91a             [ 2]>            cmp #test_num
12793 2 MichaelA
                            >            trap_ne         ;test is out of sequence
12794 3 MichaelA
20d4 : f002             [ 3]>        beq skip1787
12795
                            >        trap           ;failed equal (zero)
12796
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12797
20d6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12798
20d7 : 1a                   >        db      test_num
12799 2 MichaelA
                            >
12800 3 MichaelA
20d8 :                      >skip1787
12801
                            >
12802 2 MichaelA
001b =                      >test_num = test_num + 1
12803 3 MichaelA
20d8 : a91b             [ 2]>            lda #test_num   ;*** this tests' number
12804
20da : 8d0002           [ 4]>            sta test_case
12805 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
12806
 
12807
 
12808
                             ; CPY - zp / abs / #
12809 3 MichaelA
 
12810 2 MichaelA
                                     set_y $80,0
12811
                            >            load_flag 0
12812 3 MichaelA
20dd : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
12813 2 MichaelA
                            >
12814 3 MichaelA
20df : 48               [ 3]>            pha         ;use stack to load status
12815
20e0 : a080             [ 2]>            ldy #$80     ;precharge index y
12816
20e2 : 28               [ 4]>            plp
12817 2 MichaelA
 
12818 3 MichaelA
20e3 : c4bd             [ 3]         cpy zp7f
12819 2 MichaelA
                                     tst_stat fc
12820 3 MichaelA
20e5 : 08               [ 3]>            php         ;save status
12821
20e6 : 08               [ 3]>            php         ;use stack to retrieve status
12822
20e7 : 68               [ 4]>            pla
12823 2 MichaelA
                            >            cmp_flag fc
12824 3 MichaelA
20e8 : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
12825 2 MichaelA
                            >
12826
                            >            trap_ne
12827 3 MichaelA
20ea : f002             [ 3]>        beq skip1793
12828
                            >        trap           ;failed equal (zero)
12829
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12830
20ec : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12831
20ed : 1b                   >        db      test_num
12832 2 MichaelA
                            >
12833 3 MichaelA
20ee :                      >skip1793
12834
                            >
12835
20ee : 28               [ 4]>            plp         ;restore status
12836 2 MichaelA
 
12837 3 MichaelA
20ef : 88               [ 2]         dey
12838
20f0 : c4bd             [ 3]         cpy zp7f
12839 2 MichaelA
                                     tst_stat fzc
12840 3 MichaelA
20f2 : 08               [ 3]>            php         ;save status
12841
20f3 : 08               [ 3]>            php         ;use stack to retrieve status
12842
20f4 : 68               [ 4]>            pla
12843 2 MichaelA
                            >            cmp_flag fzc
12844 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  223
12845
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12846
 
12847
20f5 : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
12848 2 MichaelA
                            >
12849
                            >            trap_ne
12850 3 MichaelA
20f7 : f002             [ 3]>        beq skip1797
12851
                            >        trap           ;failed equal (zero)
12852
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12853
20f9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12854
20fa : 1b                   >        db      test_num
12855 2 MichaelA
                            >
12856 3 MichaelA
20fb :                      >skip1797
12857
                            >
12858
20fb : 28               [ 4]>            plp         ;restore status
12859 2 MichaelA
 
12860 3 MichaelA
20fc : 88               [ 2]         dey
12861
20fd : c4bd             [ 3]         cpy zp7f
12862 2 MichaelA
                                     tst_y $7e,fn
12863 3 MichaelA
20ff : 08               [ 3]>            php         ;save flags
12864
2100 : 08               [ 3]>            php
12865
2101 : c07e             [ 2]>            cpy #$7e     ;test result
12866 2 MichaelA
                            >            trap_ne
12867 3 MichaelA
2103 : f002             [ 3]>        beq skip1800
12868
                            >        trap           ;failed equal (zero)
12869
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12870
2105 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12871
2106 : 1b                   >        db      test_num
12872 2 MichaelA
                            >
12873 3 MichaelA
2107 :                      >skip1800
12874
                            >
12875
2107 : 68               [ 4]>            pla         ;load status
12876 2 MichaelA
                            >            cmp_flag fn
12877 3 MichaelA
2108 : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
12878 2 MichaelA
                            >
12879
                            >            trap_ne
12880 3 MichaelA
210a : f002             [ 3]>        beq skip1803
12881
                            >        trap           ;failed equal (zero)
12882
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12883
210c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12884
210d : 1b                   >        db      test_num
12885 2 MichaelA
                            >
12886 3 MichaelA
210e :                      >skip1803
12887
                            >
12888
210e : 28               [ 4]>            plp         ;restore status
12889 2 MichaelA
 
12890
                                     set_y $80,$ff
12891
                            >            load_flag $ff
12892 3 MichaelA
210f : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
12893 2 MichaelA
                            >
12894 3 MichaelA
2111 : 48               [ 3]>            pha         ;use stack to load status
12895
2112 : a080             [ 2]>            ldy #$80     ;precharge index y
12896
2114 : 28               [ 4]>            plp
12897 2 MichaelA
 
12898 3 MichaelA
2115 : c4bd             [ 3]         cpy zp7f
12899 2 MichaelA
                                     tst_stat ~fnz
12900 3 MichaelA
2117 : 08               [ 3]>            php         ;save status
12901
2118 : 08               [ 3]>            php         ;use stack to retrieve status
12902
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  224
12903
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12904
 
12905
2119 : 68               [ 4]>            pla
12906 2 MichaelA
                            >            cmp_flag ~fnz
12907 3 MichaelA
211a : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
12908 2 MichaelA
                            >
12909
                            >            trap_ne
12910 3 MichaelA
211c : f002             [ 3]>        beq skip1809
12911
                            >        trap           ;failed equal (zero)
12912
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12913
211e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12914
211f : 1b                   >        db      test_num
12915 2 MichaelA
                            >
12916 3 MichaelA
2120 :                      >skip1809
12917
                            >
12918
2120 : 28               [ 4]>            plp         ;restore status
12919 2 MichaelA
 
12920 3 MichaelA
2121 : 88               [ 2]         dey
12921
2122 : c4bd             [ 3]         cpy zp7f
12922 2 MichaelA
                                     tst_stat ~fn
12923 3 MichaelA
2124 : 08               [ 3]>            php         ;save status
12924
2125 : 08               [ 3]>            php         ;use stack to retrieve status
12925
2126 : 68               [ 4]>            pla
12926 2 MichaelA
                            >            cmp_flag ~fn
12927 3 MichaelA
2127 : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
12928 2 MichaelA
                            >
12929
                            >            trap_ne
12930 3 MichaelA
2129 : f002             [ 3]>        beq skip1813
12931
                            >        trap           ;failed equal (zero)
12932
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12933
212b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12934
212c : 1b                   >        db      test_num
12935 2 MichaelA
                            >
12936 3 MichaelA
212d :                      >skip1813
12937
                            >
12938
212d : 28               [ 4]>            plp         ;restore status
12939 2 MichaelA
 
12940 3 MichaelA
212e : 88               [ 2]         dey
12941
212f : c4bd             [ 3]         cpy zp7f
12942 2 MichaelA
                                     tst_y $7e,~fzc
12943 3 MichaelA
2131 : 08               [ 3]>            php         ;save flags
12944
2132 : 08               [ 3]>            php
12945
2133 : c07e             [ 2]>            cpy #$7e     ;test result
12946 2 MichaelA
                            >            trap_ne
12947 3 MichaelA
2135 : f002             [ 3]>        beq skip1816
12948
                            >        trap           ;failed equal (zero)
12949
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12950
2137 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12951
2138 : 1b                   >        db      test_num
12952 2 MichaelA
                            >
12953 3 MichaelA
2139 :                      >skip1816
12954
                            >
12955
2139 : 68               [ 4]>            pla         ;load status
12956 2 MichaelA
                            >            cmp_flag ~fzc
12957 3 MichaelA
213a : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
12958 2 MichaelA
                            >
12959
                            >            trap_ne
12960 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  225
12961 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
12962
 
12963 3 MichaelA
213c : f002             [ 3]>        beq skip1819
12964
                            >        trap           ;failed equal (zero)
12965
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12966
213e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12967
213f : 1b                   >        db      test_num
12968
                            >
12969
2140 :                      >skip1819
12970
                            >
12971
2140 : 28               [ 4]>            plp         ;restore status
12972 2 MichaelA
 
12973
 
12974
                                     set_y $80,0
12975
                            >            load_flag 0
12976 3 MichaelA
2141 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
12977 2 MichaelA
                            >
12978 3 MichaelA
2143 : 48               [ 3]>            pha         ;use stack to load status
12979
2144 : a080             [ 2]>            ldy #$80     ;precharge index y
12980
2146 : 28               [ 4]>            plp
12981 2 MichaelA
 
12982 3 MichaelA
2147 : cc0c02           [ 4]         cpy abs7f
12983 2 MichaelA
                                     tst_stat fc
12984 3 MichaelA
214a : 08               [ 3]>            php         ;save status
12985
214b : 08               [ 3]>            php         ;use stack to retrieve status
12986
214c : 68               [ 4]>            pla
12987 2 MichaelA
                            >            cmp_flag fc
12988 3 MichaelA
214d : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
12989 2 MichaelA
                            >
12990
                            >            trap_ne
12991 3 MichaelA
214f : f002             [ 3]>        beq skip1825
12992
                            >        trap           ;failed equal (zero)
12993
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
12994
2151 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
12995
2152 : 1b                   >        db      test_num
12996 2 MichaelA
                            >
12997 3 MichaelA
2153 :                      >skip1825
12998
                            >
12999
2153 : 28               [ 4]>            plp         ;restore status
13000 2 MichaelA
 
13001 3 MichaelA
2154 : 88               [ 2]         dey
13002
2155 : cc0c02           [ 4]         cpy abs7f
13003 2 MichaelA
                                     tst_stat fzc
13004 3 MichaelA
2158 : 08               [ 3]>            php         ;save status
13005
2159 : 08               [ 3]>            php         ;use stack to retrieve status
13006
215a : 68               [ 4]>            pla
13007 2 MichaelA
                            >            cmp_flag fzc
13008 3 MichaelA
215b : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
13009 2 MichaelA
                            >
13010
                            >            trap_ne
13011 3 MichaelA
215d : f002             [ 3]>        beq skip1829
13012
                            >        trap           ;failed equal (zero)
13013
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13014
215f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13015
2160 : 1b                   >        db      test_num
13016 2 MichaelA
                            >
13017 3 MichaelA
2161 :                      >skip1829
13018
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  226
13019
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13020
 
13021
                            >
13022
2161 : 28               [ 4]>            plp         ;restore status
13023 2 MichaelA
 
13024 3 MichaelA
2162 : 88               [ 2]         dey
13025
2163 : cc0c02           [ 4]         cpy abs7f
13026 2 MichaelA
                                     tst_y $7e,fn
13027 3 MichaelA
2166 : 08               [ 3]>            php         ;save flags
13028
2167 : 08               [ 3]>            php
13029
2168 : c07e             [ 2]>            cpy #$7e     ;test result
13030 2 MichaelA
                            >            trap_ne
13031 3 MichaelA
216a : f002             [ 3]>        beq skip1832
13032
                            >        trap           ;failed equal (zero)
13033
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13034
216c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13035
216d : 1b                   >        db      test_num
13036 2 MichaelA
                            >
13037 3 MichaelA
216e :                      >skip1832
13038
                            >
13039
216e : 68               [ 4]>            pla         ;load status
13040 2 MichaelA
                            >            cmp_flag fn
13041 3 MichaelA
216f : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
13042 2 MichaelA
                            >
13043
                            >            trap_ne
13044 3 MichaelA
2171 : f002             [ 3]>        beq skip1835
13045
                            >        trap           ;failed equal (zero)
13046
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13047
2173 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13048
2174 : 1b                   >        db      test_num
13049 2 MichaelA
                            >
13050 3 MichaelA
2175 :                      >skip1835
13051
                            >
13052
2175 : 28               [ 4]>            plp         ;restore status
13053 2 MichaelA
 
13054
                                     set_y $80,$ff
13055
                            >            load_flag $ff
13056 3 MichaelA
2176 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
13057 2 MichaelA
                            >
13058 3 MichaelA
2178 : 48               [ 3]>            pha         ;use stack to load status
13059
2179 : a080             [ 2]>            ldy #$80     ;precharge index y
13060
217b : 28               [ 4]>            plp
13061 2 MichaelA
 
13062 3 MichaelA
217c : cc0c02           [ 4]         cpy abs7f
13063 2 MichaelA
                                     tst_stat ~fnz
13064 3 MichaelA
217f : 08               [ 3]>            php         ;save status
13065
2180 : 08               [ 3]>            php         ;use stack to retrieve status
13066
2181 : 68               [ 4]>            pla
13067 2 MichaelA
                            >            cmp_flag ~fnz
13068 3 MichaelA
2182 : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
13069 2 MichaelA
                            >
13070
                            >            trap_ne
13071 3 MichaelA
2184 : f002             [ 3]>        beq skip1841
13072
                            >        trap           ;failed equal (zero)
13073
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13074
2186 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13075
2187 : 1b                   >        db      test_num
13076
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  227
13077
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13078
 
13079 2 MichaelA
                            >
13080 3 MichaelA
2188 :                      >skip1841
13081
                            >
13082
2188 : 28               [ 4]>            plp         ;restore status
13083 2 MichaelA
 
13084 3 MichaelA
2189 : 88               [ 2]         dey
13085
218a : cc0c02           [ 4]         cpy abs7f
13086 2 MichaelA
                                     tst_stat ~fn
13087 3 MichaelA
218d : 08               [ 3]>            php         ;save status
13088
218e : 08               [ 3]>            php         ;use stack to retrieve status
13089
218f : 68               [ 4]>            pla
13090 2 MichaelA
                            >            cmp_flag ~fn
13091 3 MichaelA
2190 : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
13092 2 MichaelA
                            >
13093
                            >            trap_ne
13094 3 MichaelA
2192 : f002             [ 3]>        beq skip1845
13095
                            >        trap           ;failed equal (zero)
13096
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13097
2194 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13098
2195 : 1b                   >        db      test_num
13099 2 MichaelA
                            >
13100 3 MichaelA
2196 :                      >skip1845
13101
                            >
13102
2196 : 28               [ 4]>            plp         ;restore status
13103 2 MichaelA
 
13104 3 MichaelA
2197 : 88               [ 2]         dey
13105
2198 : cc0c02           [ 4]         cpy abs7f
13106 2 MichaelA
                                     tst_y $7e,~fzc
13107 3 MichaelA
219b : 08               [ 3]>            php         ;save flags
13108
219c : 08               [ 3]>            php
13109
219d : c07e             [ 2]>            cpy #$7e     ;test result
13110 2 MichaelA
                            >            trap_ne
13111 3 MichaelA
219f : f002             [ 3]>        beq skip1848
13112
                            >        trap           ;failed equal (zero)
13113
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13114
21a1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13115
21a2 : 1b                   >        db      test_num
13116 2 MichaelA
                            >
13117 3 MichaelA
21a3 :                      >skip1848
13118
                            >
13119
21a3 : 68               [ 4]>            pla         ;load status
13120 2 MichaelA
                            >            cmp_flag ~fzc
13121 3 MichaelA
21a4 : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
13122 2 MichaelA
                            >
13123
                            >            trap_ne
13124 3 MichaelA
21a6 : f002             [ 3]>        beq skip1851
13125
                            >        trap           ;failed equal (zero)
13126
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13127
21a8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13128
21a9 : 1b                   >        db      test_num
13129 2 MichaelA
                            >
13130 3 MichaelA
21aa :                      >skip1851
13131
                            >
13132
21aa : 28               [ 4]>            plp         ;restore status
13133 2 MichaelA
 
13134 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  228
13135 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13136
 
13137 3 MichaelA
 
13138 2 MichaelA
                                     set_y $80,0
13139
                            >            load_flag 0
13140 3 MichaelA
21ab : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
13141 2 MichaelA
                            >
13142 3 MichaelA
21ad : 48               [ 3]>            pha         ;use stack to load status
13143
21ae : a080             [ 2]>            ldy #$80     ;precharge index y
13144
21b0 : 28               [ 4]>            plp
13145 2 MichaelA
 
13146 3 MichaelA
21b1 : c07f             [ 2]         cpy #$7f
13147 2 MichaelA
                                     tst_stat fc
13148 3 MichaelA
21b3 : 08               [ 3]>            php         ;save status
13149
21b4 : 08               [ 3]>            php         ;use stack to retrieve status
13150
21b5 : 68               [ 4]>            pla
13151 2 MichaelA
                            >            cmp_flag fc
13152 3 MichaelA
21b6 : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
13153 2 MichaelA
                            >
13154
                            >            trap_ne
13155 3 MichaelA
21b8 : f002             [ 3]>        beq skip1857
13156
                            >        trap           ;failed equal (zero)
13157
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13158
21ba : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13159
21bb : 1b                   >        db      test_num
13160 2 MichaelA
                            >
13161 3 MichaelA
21bc :                      >skip1857
13162
                            >
13163
21bc : 28               [ 4]>            plp         ;restore status
13164 2 MichaelA
 
13165 3 MichaelA
21bd : 88               [ 2]         dey
13166
21be : c07f             [ 2]         cpy #$7f
13167 2 MichaelA
                                     tst_stat fzc
13168 3 MichaelA
21c0 : 08               [ 3]>            php         ;save status
13169
21c1 : 08               [ 3]>            php         ;use stack to retrieve status
13170
21c2 : 68               [ 4]>            pla
13171 2 MichaelA
                            >            cmp_flag fzc
13172 3 MichaelA
21c3 : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
13173 2 MichaelA
                            >
13174
                            >            trap_ne
13175 3 MichaelA
21c5 : f002             [ 3]>        beq skip1861
13176
                            >        trap           ;failed equal (zero)
13177
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13178
21c7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13179
21c8 : 1b                   >        db      test_num
13180 2 MichaelA
                            >
13181 3 MichaelA
21c9 :                      >skip1861
13182
                            >
13183
21c9 : 28               [ 4]>            plp         ;restore status
13184 2 MichaelA
 
13185 3 MichaelA
21ca : 88               [ 2]         dey
13186
21cb : c07f             [ 2]         cpy #$7f
13187 2 MichaelA
                                     tst_y $7e,fn
13188 3 MichaelA
21cd : 08               [ 3]>            php         ;save flags
13189
21ce : 08               [ 3]>            php
13190
21cf : c07e             [ 2]>            cpy #$7e     ;test result
13191 2 MichaelA
                            >            trap_ne
13192 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  229
13193
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13194
 
13195
21d1 : f002             [ 3]>        beq skip1864
13196
                            >        trap           ;failed equal (zero)
13197
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13198
21d3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13199
21d4 : 1b                   >        db      test_num
13200 2 MichaelA
                            >
13201 3 MichaelA
21d5 :                      >skip1864
13202
                            >
13203
21d5 : 68               [ 4]>            pla         ;load status
13204 2 MichaelA
                            >            cmp_flag fn
13205 3 MichaelA
21d6 : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
13206 2 MichaelA
                            >
13207
                            >            trap_ne
13208 3 MichaelA
21d8 : f002             [ 3]>        beq skip1867
13209
                            >        trap           ;failed equal (zero)
13210
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13211
21da : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13212
21db : 1b                   >        db      test_num
13213 2 MichaelA
                            >
13214 3 MichaelA
21dc :                      >skip1867
13215
                            >
13216
21dc : 28               [ 4]>            plp         ;restore status
13217 2 MichaelA
 
13218
                                     set_y $80,$ff
13219
                            >            load_flag $ff
13220 3 MichaelA
21dd : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
13221 2 MichaelA
                            >
13222 3 MichaelA
21df : 48               [ 3]>            pha         ;use stack to load status
13223
21e0 : a080             [ 2]>            ldy #$80     ;precharge index y
13224
21e2 : 28               [ 4]>            plp
13225 2 MichaelA
 
13226 3 MichaelA
21e3 : c07f             [ 2]         cpy #$7f
13227 2 MichaelA
                                     tst_stat ~fnz
13228 3 MichaelA
21e5 : 08               [ 3]>            php         ;save status
13229
21e6 : 08               [ 3]>            php         ;use stack to retrieve status
13230
21e7 : 68               [ 4]>            pla
13231 2 MichaelA
                            >            cmp_flag ~fnz
13232 3 MichaelA
21e8 : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
13233 2 MichaelA
                            >
13234
                            >            trap_ne
13235 3 MichaelA
21ea : f002             [ 3]>        beq skip1873
13236
                            >        trap           ;failed equal (zero)
13237
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13238
21ec : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13239
21ed : 1b                   >        db      test_num
13240 2 MichaelA
                            >
13241 3 MichaelA
21ee :                      >skip1873
13242
                            >
13243
21ee : 28               [ 4]>            plp         ;restore status
13244 2 MichaelA
 
13245 3 MichaelA
21ef : 88               [ 2]         dey
13246
21f0 : c07f             [ 2]         cpy #$7f
13247 2 MichaelA
                                     tst_stat ~fn
13248 3 MichaelA
21f2 : 08               [ 3]>            php         ;save status
13249
21f3 : 08               [ 3]>            php         ;use stack to retrieve status
13250
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  230
13251
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13252
 
13253
21f4 : 68               [ 4]>            pla
13254 2 MichaelA
                            >            cmp_flag ~fn
13255 3 MichaelA
21f5 : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
13256 2 MichaelA
                            >
13257
                            >            trap_ne
13258 3 MichaelA
21f7 : f002             [ 3]>        beq skip1877
13259
                            >        trap           ;failed equal (zero)
13260
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13261
21f9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13262
21fa : 1b                   >        db      test_num
13263 2 MichaelA
                            >
13264 3 MichaelA
21fb :                      >skip1877
13265
                            >
13266
21fb : 28               [ 4]>            plp         ;restore status
13267 2 MichaelA
 
13268 3 MichaelA
21fc : 88               [ 2]         dey
13269
21fd : c07f             [ 2]         cpy #$7f
13270 2 MichaelA
                                     tst_y $7e,~fzc
13271 3 MichaelA
21ff : 08               [ 3]>            php         ;save flags
13272
2200 : 08               [ 3]>            php
13273
2201 : c07e             [ 2]>            cpy #$7e     ;test result
13274 2 MichaelA
                            >            trap_ne
13275 3 MichaelA
2203 : f002             [ 3]>        beq skip1880
13276
                            >        trap           ;failed equal (zero)
13277
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13278
2205 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13279
2206 : 1b                   >        db      test_num
13280 2 MichaelA
                            >
13281 3 MichaelA
2207 :                      >skip1880
13282
                            >
13283
2207 : 68               [ 4]>            pla         ;load status
13284 2 MichaelA
                            >            cmp_flag ~fzc
13285 3 MichaelA
2208 : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
13286 2 MichaelA
                            >
13287
                            >            trap_ne
13288 3 MichaelA
220a : f002             [ 3]>        beq skip1883
13289
                            >        trap           ;failed equal (zero)
13290
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13291
220c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13292
220d : 1b                   >        db      test_num
13293 2 MichaelA
                            >
13294 3 MichaelA
220e :                      >skip1883
13295
                            >
13296
220e : 28               [ 4]>            plp         ;restore status
13297 2 MichaelA
 
13298
                                     next_test
13299 3 MichaelA
220f : ad0002           [ 4]>            lda test_case   ;previous test
13300
2212 : c91b             [ 2]>            cmp #test_num
13301 2 MichaelA
                            >            trap_ne         ;test is out of sequence
13302 3 MichaelA
2214 : f002             [ 3]>        beq skip1886
13303
                            >        trap           ;failed equal (zero)
13304
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13305
2216 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13306
2217 : 1b                   >        db      test_num
13307
                            >
13308
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  231
13309 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13310
 
13311 3 MichaelA
2218 :                      >skip1886
13312 2 MichaelA
                            >
13313
001c =                      >test_num = test_num + 1
13314 3 MichaelA
2218 : a91c             [ 2]>            lda #test_num   ;*** this tests' number
13315
221a : 8d0002           [ 4]>            sta test_case
13316 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
13317
 
13318
 
13319
                             ; CMP - zp / abs / #
13320 3 MichaelA
 
13321 2 MichaelA
                                     set_a $80,0
13322
                            >            load_flag 0
13323 3 MichaelA
221d : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
13324 2 MichaelA
                            >
13325 3 MichaelA
221f : 48               [ 3]>            pha         ;use stack to load status
13326
2220 : a980             [ 2]>            lda #$80     ;precharge accu
13327
2222 : 28               [ 4]>            plp
13328 2 MichaelA
 
13329 3 MichaelA
2223 : c5bd             [ 3]         cmp zp7f
13330 2 MichaelA
                                     tst_a $80,fc
13331 3 MichaelA
2225 : 08               [ 3]>            php         ;save flags
13332
2226 : 08               [ 3]>            php
13333
2227 : c980             [ 2]>            cmp #$80     ;test result
13334 2 MichaelA
                            >            trap_ne
13335 3 MichaelA
2229 : f002             [ 3]>        beq skip1891
13336
                            >        trap           ;failed equal (zero)
13337
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13338
222b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13339
222c : 1c                   >        db      test_num
13340 2 MichaelA
                            >
13341 3 MichaelA
222d :                      >skip1891
13342
                            >
13343
222d : 68               [ 4]>            pla         ;load status
13344 2 MichaelA
                            >            cmp_flag fc
13345 3 MichaelA
222e : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
13346 2 MichaelA
                            >
13347
                            >            trap_ne
13348 3 MichaelA
2230 : f002             [ 3]>        beq skip1894
13349
                            >        trap           ;failed equal (zero)
13350
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13351
2232 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13352
2233 : 1c                   >        db      test_num
13353 2 MichaelA
                            >
13354 3 MichaelA
2234 :                      >skip1894
13355
                            >
13356
2234 : 28               [ 4]>            plp         ;restore status
13357 2 MichaelA
 
13358
                                     set_a $7f,0
13359
                            >            load_flag 0
13360 3 MichaelA
2235 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
13361 2 MichaelA
                            >
13362 3 MichaelA
2237 : 48               [ 3]>            pha         ;use stack to load status
13363
2238 : a97f             [ 2]>            lda #$7f     ;precharge accu
13364
223a : 28               [ 4]>            plp
13365 2 MichaelA
 
13366 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  232
13367
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13368
 
13369
223b : c5bd             [ 3]         cmp zp7f
13370 2 MichaelA
                                     tst_a $7f,fzc
13371 3 MichaelA
223d : 08               [ 3]>            php         ;save flags
13372
223e : 08               [ 3]>            php
13373
223f : c97f             [ 2]>            cmp #$7f     ;test result
13374 2 MichaelA
                            >            trap_ne
13375 3 MichaelA
2241 : f002             [ 3]>        beq skip1899
13376
                            >        trap           ;failed equal (zero)
13377
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13378
2243 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13379
2244 : 1c                   >        db      test_num
13380 2 MichaelA
                            >
13381 3 MichaelA
2245 :                      >skip1899
13382
                            >
13383
2245 : 68               [ 4]>            pla         ;load status
13384 2 MichaelA
                            >            cmp_flag fzc
13385 3 MichaelA
2246 : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
13386 2 MichaelA
                            >
13387
                            >            trap_ne
13388 3 MichaelA
2248 : f002             [ 3]>        beq skip1902
13389
                            >        trap           ;failed equal (zero)
13390
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13391
224a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13392
224b : 1c                   >        db      test_num
13393 2 MichaelA
                            >
13394 3 MichaelA
224c :                      >skip1902
13395
                            >
13396
224c : 28               [ 4]>            plp         ;restore status
13397 2 MichaelA
 
13398
                                     set_a $7e,0
13399
                            >            load_flag 0
13400 3 MichaelA
224d : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
13401 2 MichaelA
                            >
13402 3 MichaelA
224f : 48               [ 3]>            pha         ;use stack to load status
13403
2250 : a97e             [ 2]>            lda #$7e     ;precharge accu
13404
2252 : 28               [ 4]>            plp
13405 2 MichaelA
 
13406 3 MichaelA
2253 : c5bd             [ 3]         cmp zp7f
13407 2 MichaelA
                                     tst_a $7e,fn
13408 3 MichaelA
2255 : 08               [ 3]>            php         ;save flags
13409
2256 : 08               [ 3]>            php
13410
2257 : c97e             [ 2]>            cmp #$7e     ;test result
13411 2 MichaelA
                            >            trap_ne
13412 3 MichaelA
2259 : f002             [ 3]>        beq skip1907
13413
                            >        trap           ;failed equal (zero)
13414
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13415
225b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13416
225c : 1c                   >        db      test_num
13417 2 MichaelA
                            >
13418 3 MichaelA
225d :                      >skip1907
13419
                            >
13420
225d : 68               [ 4]>            pla         ;load status
13421 2 MichaelA
                            >            cmp_flag fn
13422 3 MichaelA
225e : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
13423 2 MichaelA
                            >
13424 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  233
13425
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13426
 
13427 2 MichaelA
                            >            trap_ne
13428 3 MichaelA
2260 : f002             [ 3]>        beq skip1910
13429
                            >        trap           ;failed equal (zero)
13430
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13431
2262 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13432
2263 : 1c                   >        db      test_num
13433 2 MichaelA
                            >
13434 3 MichaelA
2264 :                      >skip1910
13435
                            >
13436
2264 : 28               [ 4]>            plp         ;restore status
13437 2 MichaelA
 
13438
                                     set_a $80,$ff
13439
                            >            load_flag $ff
13440 3 MichaelA
2265 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
13441 2 MichaelA
                            >
13442 3 MichaelA
2267 : 48               [ 3]>            pha         ;use stack to load status
13443
2268 : a980             [ 2]>            lda #$80     ;precharge accu
13444
226a : 28               [ 4]>            plp
13445 2 MichaelA
 
13446 3 MichaelA
226b : c5bd             [ 3]         cmp zp7f
13447 2 MichaelA
                                     tst_a $80,~fnz
13448 3 MichaelA
226d : 08               [ 3]>            php         ;save flags
13449
226e : 08               [ 3]>            php
13450
226f : c980             [ 2]>            cmp #$80     ;test result
13451 2 MichaelA
                            >            trap_ne
13452 3 MichaelA
2271 : f002             [ 3]>        beq skip1915
13453
                            >        trap           ;failed equal (zero)
13454
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13455
2273 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13456
2274 : 1c                   >        db      test_num
13457 2 MichaelA
                            >
13458 3 MichaelA
2275 :                      >skip1915
13459
                            >
13460
2275 : 68               [ 4]>            pla         ;load status
13461 2 MichaelA
                            >            cmp_flag ~fnz
13462 3 MichaelA
2276 : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
13463 2 MichaelA
                            >
13464
                            >            trap_ne
13465 3 MichaelA
2278 : f002             [ 3]>        beq skip1918
13466
                            >        trap           ;failed equal (zero)
13467
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13468
227a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13469
227b : 1c                   >        db      test_num
13470 2 MichaelA
                            >
13471 3 MichaelA
227c :                      >skip1918
13472
                            >
13473
227c : 28               [ 4]>            plp         ;restore status
13474 2 MichaelA
 
13475
                                     set_a $7f,$ff
13476 3 MichaelA
                            >            load_flag $ff
13477
227d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
13478
                            >
13479
227f : 48               [ 3]>            pha         ;use stack to load status
13480
2280 : a97f             [ 2]>            lda #$7f     ;precharge accu
13481
2282 : 28               [ 4]>            plp
13482
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  234
13483 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13484
 
13485
 
13486 3 MichaelA
2283 : c5bd             [ 3]         cmp zp7f
13487 2 MichaelA
                                     tst_a $7f,~fn
13488 3 MichaelA
2285 : 08               [ 3]>            php         ;save flags
13489
2286 : 08               [ 3]>            php
13490
2287 : c97f             [ 2]>            cmp #$7f     ;test result
13491 2 MichaelA
                            >            trap_ne
13492 3 MichaelA
2289 : f002             [ 3]>        beq skip1923
13493
                            >        trap           ;failed equal (zero)
13494
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13495
228b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13496
228c : 1c                   >        db      test_num
13497 2 MichaelA
                            >
13498 3 MichaelA
228d :                      >skip1923
13499
                            >
13500
228d : 68               [ 4]>            pla         ;load status
13501 2 MichaelA
                            >            cmp_flag ~fn
13502 3 MichaelA
228e : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
13503 2 MichaelA
                            >
13504
                            >            trap_ne
13505 3 MichaelA
2290 : f002             [ 3]>        beq skip1926
13506
                            >        trap           ;failed equal (zero)
13507
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13508
2292 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13509
2293 : 1c                   >        db      test_num
13510 2 MichaelA
                            >
13511 3 MichaelA
2294 :                      >skip1926
13512
                            >
13513
2294 : 28               [ 4]>            plp         ;restore status
13514 2 MichaelA
 
13515
                                     set_a $7e,$ff
13516
                            >            load_flag $ff
13517 3 MichaelA
2295 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
13518 2 MichaelA
                            >
13519 3 MichaelA
2297 : 48               [ 3]>            pha         ;use stack to load status
13520
2298 : a97e             [ 2]>            lda #$7e     ;precharge accu
13521
229a : 28               [ 4]>            plp
13522 2 MichaelA
 
13523 3 MichaelA
229b : c5bd             [ 3]         cmp zp7f
13524 2 MichaelA
                                     tst_a $7e,~fzc
13525 3 MichaelA
229d : 08               [ 3]>            php         ;save flags
13526
229e : 08               [ 3]>            php
13527
229f : c97e             [ 2]>            cmp #$7e     ;test result
13528 2 MichaelA
                            >            trap_ne
13529 3 MichaelA
22a1 : f002             [ 3]>        beq skip1931
13530
                            >        trap           ;failed equal (zero)
13531
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13532
22a3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13533
22a4 : 1c                   >        db      test_num
13534 2 MichaelA
                            >
13535 3 MichaelA
22a5 :                      >skip1931
13536
                            >
13537
22a5 : 68               [ 4]>            pla         ;load status
13538 2 MichaelA
                            >            cmp_flag ~fzc
13539 3 MichaelA
22a6 : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
13540
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  235
13541
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13542
 
13543 2 MichaelA
                            >
13544
                            >            trap_ne
13545 3 MichaelA
22a8 : f002             [ 3]>        beq skip1934
13546
                            >        trap           ;failed equal (zero)
13547
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13548
22aa : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13549
22ab : 1c                   >        db      test_num
13550 2 MichaelA
                            >
13551 3 MichaelA
22ac :                      >skip1934
13552
                            >
13553
22ac : 28               [ 4]>            plp         ;restore status
13554 2 MichaelA
 
13555
 
13556
                                     set_a $80,0
13557
                            >            load_flag 0
13558 3 MichaelA
22ad : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
13559 2 MichaelA
                            >
13560 3 MichaelA
22af : 48               [ 3]>            pha         ;use stack to load status
13561
22b0 : a980             [ 2]>            lda #$80     ;precharge accu
13562
22b2 : 28               [ 4]>            plp
13563 2 MichaelA
 
13564 3 MichaelA
22b3 : cd0c02           [ 4]         cmp abs7f
13565 2 MichaelA
                                     tst_a $80,fc
13566 3 MichaelA
22b6 : 08               [ 3]>            php         ;save flags
13567
22b7 : 08               [ 3]>            php
13568
22b8 : c980             [ 2]>            cmp #$80     ;test result
13569 2 MichaelA
                            >            trap_ne
13570 3 MichaelA
22ba : f002             [ 3]>        beq skip1939
13571
                            >        trap           ;failed equal (zero)
13572
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13573
22bc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13574
22bd : 1c                   >        db      test_num
13575 2 MichaelA
                            >
13576 3 MichaelA
22be :                      >skip1939
13577
                            >
13578
22be : 68               [ 4]>            pla         ;load status
13579 2 MichaelA
                            >            cmp_flag fc
13580 3 MichaelA
22bf : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
13581 2 MichaelA
                            >
13582
                            >            trap_ne
13583 3 MichaelA
22c1 : f002             [ 3]>        beq skip1942
13584
                            >        trap           ;failed equal (zero)
13585
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13586
22c3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13587
22c4 : 1c                   >        db      test_num
13588 2 MichaelA
                            >
13589 3 MichaelA
22c5 :                      >skip1942
13590
                            >
13591
22c5 : 28               [ 4]>            plp         ;restore status
13592 2 MichaelA
 
13593
                                     set_a $7f,0
13594
                            >            load_flag 0
13595 3 MichaelA
22c6 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
13596 2 MichaelA
                            >
13597 3 MichaelA
22c8 : 48               [ 3]>            pha         ;use stack to load status
13598
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  236
13599
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13600
 
13601
22c9 : a97f             [ 2]>            lda #$7f     ;precharge accu
13602
22cb : 28               [ 4]>            plp
13603 2 MichaelA
 
13604 3 MichaelA
22cc : cd0c02           [ 4]         cmp abs7f
13605 2 MichaelA
                                     tst_a $7f,fzc
13606 3 MichaelA
22cf : 08               [ 3]>            php         ;save flags
13607
22d0 : 08               [ 3]>            php
13608
22d1 : c97f             [ 2]>            cmp #$7f     ;test result
13609 2 MichaelA
                            >            trap_ne
13610 3 MichaelA
22d3 : f002             [ 3]>        beq skip1947
13611
                            >        trap           ;failed equal (zero)
13612
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13613
22d5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13614
22d6 : 1c                   >        db      test_num
13615 2 MichaelA
                            >
13616 3 MichaelA
22d7 :                      >skip1947
13617
                            >
13618
22d7 : 68               [ 4]>            pla         ;load status
13619 2 MichaelA
                            >            cmp_flag fzc
13620 3 MichaelA
22d8 : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
13621 2 MichaelA
                            >
13622
                            >            trap_ne
13623 3 MichaelA
22da : f002             [ 3]>        beq skip1950
13624
                            >        trap           ;failed equal (zero)
13625
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13626
22dc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13627
22dd : 1c                   >        db      test_num
13628 2 MichaelA
                            >
13629 3 MichaelA
22de :                      >skip1950
13630
                            >
13631
22de : 28               [ 4]>            plp         ;restore status
13632 2 MichaelA
 
13633
                                     set_a $7e,0
13634
                            >            load_flag 0
13635 3 MichaelA
22df : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
13636 2 MichaelA
                            >
13637 3 MichaelA
22e1 : 48               [ 3]>            pha         ;use stack to load status
13638
22e2 : a97e             [ 2]>            lda #$7e     ;precharge accu
13639
22e4 : 28               [ 4]>            plp
13640 2 MichaelA
 
13641 3 MichaelA
22e5 : cd0c02           [ 4]         cmp abs7f
13642 2 MichaelA
                                     tst_a $7e,fn
13643 3 MichaelA
22e8 : 08               [ 3]>            php         ;save flags
13644
22e9 : 08               [ 3]>            php
13645
22ea : c97e             [ 2]>            cmp #$7e     ;test result
13646
                            >            trap_ne
13647
22ec : f002             [ 3]>        beq skip1955
13648
                            >        trap           ;failed equal (zero)
13649
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13650
22ee : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13651
22ef : 1c                   >        db      test_num
13652
                            >
13653
22f0 :                      >skip1955
13654
                            >
13655
22f0 : 68               [ 4]>            pla         ;load status
13656
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  237
13657 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13658
 
13659
                            >            cmp_flag fn
13660 3 MichaelA
22f1 : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
13661 2 MichaelA
                            >
13662
                            >            trap_ne
13663 3 MichaelA
22f3 : f002             [ 3]>        beq skip1958
13664
                            >        trap           ;failed equal (zero)
13665
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13666
22f5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13667
22f6 : 1c                   >        db      test_num
13668 2 MichaelA
                            >
13669 3 MichaelA
22f7 :                      >skip1958
13670
                            >
13671
22f7 : 28               [ 4]>            plp         ;restore status
13672 2 MichaelA
 
13673
                                     set_a $80,$ff
13674
                            >            load_flag $ff
13675 3 MichaelA
22f8 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
13676 2 MichaelA
                            >
13677 3 MichaelA
22fa : 48               [ 3]>            pha         ;use stack to load status
13678
22fb : a980             [ 2]>            lda #$80     ;precharge accu
13679
22fd : 28               [ 4]>            plp
13680 2 MichaelA
 
13681 3 MichaelA
22fe : cd0c02           [ 4]         cmp abs7f
13682 2 MichaelA
                                     tst_a $80,~fnz
13683 3 MichaelA
2301 : 08               [ 3]>            php         ;save flags
13684
2302 : 08               [ 3]>            php
13685
2303 : c980             [ 2]>            cmp #$80     ;test result
13686 2 MichaelA
                            >            trap_ne
13687 3 MichaelA
2305 : f002             [ 3]>        beq skip1963
13688
                            >        trap           ;failed equal (zero)
13689
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13690
2307 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13691
2308 : 1c                   >        db      test_num
13692 2 MichaelA
                            >
13693 3 MichaelA
2309 :                      >skip1963
13694
                            >
13695
2309 : 68               [ 4]>            pla         ;load status
13696 2 MichaelA
                            >            cmp_flag ~fnz
13697 3 MichaelA
230a : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
13698 2 MichaelA
                            >
13699
                            >            trap_ne
13700 3 MichaelA
230c : f002             [ 3]>        beq skip1966
13701
                            >        trap           ;failed equal (zero)
13702
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13703
230e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13704
230f : 1c                   >        db      test_num
13705 2 MichaelA
                            >
13706 3 MichaelA
2310 :                      >skip1966
13707
                            >
13708
2310 : 28               [ 4]>            plp         ;restore status
13709 2 MichaelA
 
13710
                                     set_a $7f,$ff
13711
                            >            load_flag $ff
13712 3 MichaelA
2311 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
13713 2 MichaelA
                            >
13714 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  238
13715
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13716
 
13717
2313 : 48               [ 3]>            pha         ;use stack to load status
13718
2314 : a97f             [ 2]>            lda #$7f     ;precharge accu
13719
2316 : 28               [ 4]>            plp
13720 2 MichaelA
 
13721 3 MichaelA
2317 : cd0c02           [ 4]         cmp abs7f
13722 2 MichaelA
                                     tst_a $7f,~fn
13723 3 MichaelA
231a : 08               [ 3]>            php         ;save flags
13724
231b : 08               [ 3]>            php
13725
231c : c97f             [ 2]>            cmp #$7f     ;test result
13726 2 MichaelA
                            >            trap_ne
13727 3 MichaelA
231e : f002             [ 3]>        beq skip1971
13728
                            >        trap           ;failed equal (zero)
13729
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13730
2320 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13731
2321 : 1c                   >        db      test_num
13732 2 MichaelA
                            >
13733 3 MichaelA
2322 :                      >skip1971
13734
                            >
13735
2322 : 68               [ 4]>            pla         ;load status
13736 2 MichaelA
                            >            cmp_flag ~fn
13737 3 MichaelA
2323 : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
13738 2 MichaelA
                            >
13739
                            >            trap_ne
13740 3 MichaelA
2325 : f002             [ 3]>        beq skip1974
13741
                            >        trap           ;failed equal (zero)
13742
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13743
2327 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13744
2328 : 1c                   >        db      test_num
13745 2 MichaelA
                            >
13746 3 MichaelA
2329 :                      >skip1974
13747
                            >
13748
2329 : 28               [ 4]>            plp         ;restore status
13749 2 MichaelA
 
13750
                                     set_a $7e,$ff
13751
                            >            load_flag $ff
13752 3 MichaelA
232a : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
13753 2 MichaelA
                            >
13754 3 MichaelA
232c : 48               [ 3]>            pha         ;use stack to load status
13755
232d : a97e             [ 2]>            lda #$7e     ;precharge accu
13756
232f : 28               [ 4]>            plp
13757 2 MichaelA
 
13758 3 MichaelA
2330 : cd0c02           [ 4]         cmp abs7f
13759 2 MichaelA
                                     tst_a $7e,~fzc
13760 3 MichaelA
2333 : 08               [ 3]>            php         ;save flags
13761
2334 : 08               [ 3]>            php
13762
2335 : c97e             [ 2]>            cmp #$7e     ;test result
13763 2 MichaelA
                            >            trap_ne
13764 3 MichaelA
2337 : f002             [ 3]>        beq skip1979
13765
                            >        trap           ;failed equal (zero)
13766
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13767
2339 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13768
233a : 1c                   >        db      test_num
13769 2 MichaelA
                            >
13770 3 MichaelA
233b :                      >skip1979
13771
                            >
13772
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  239
13773
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13774
 
13775
233b : 68               [ 4]>            pla         ;load status
13776 2 MichaelA
                            >            cmp_flag ~fzc
13777 3 MichaelA
233c : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
13778 2 MichaelA
                            >
13779
                            >            trap_ne
13780 3 MichaelA
233e : f002             [ 3]>        beq skip1982
13781
                            >        trap           ;failed equal (zero)
13782
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13783
2340 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13784
2341 : 1c                   >        db      test_num
13785 2 MichaelA
                            >
13786 3 MichaelA
2342 :                      >skip1982
13787
                            >
13788
2342 : 28               [ 4]>            plp         ;restore status
13789 2 MichaelA
 
13790
 
13791
                                     set_a $80,0
13792
                            >            load_flag 0
13793 3 MichaelA
2343 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
13794 2 MichaelA
                            >
13795 3 MichaelA
2345 : 48               [ 3]>            pha         ;use stack to load status
13796
2346 : a980             [ 2]>            lda #$80     ;precharge accu
13797
2348 : 28               [ 4]>            plp
13798 2 MichaelA
 
13799 3 MichaelA
2349 : c97f             [ 2]         cmp #$7f
13800 2 MichaelA
                                     tst_a $80,fc
13801 3 MichaelA
234b : 08               [ 3]>            php         ;save flags
13802
234c : 08               [ 3]>            php
13803
234d : c980             [ 2]>            cmp #$80     ;test result
13804 2 MichaelA
                            >            trap_ne
13805 3 MichaelA
234f : f002             [ 3]>        beq skip1987
13806
                            >        trap           ;failed equal (zero)
13807
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13808
2351 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13809
2352 : 1c                   >        db      test_num
13810 2 MichaelA
                            >
13811 3 MichaelA
2353 :                      >skip1987
13812
                            >
13813
2353 : 68               [ 4]>            pla         ;load status
13814 2 MichaelA
                            >            cmp_flag fc
13815 3 MichaelA
2354 : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
13816 2 MichaelA
                            >
13817
                            >            trap_ne
13818 3 MichaelA
2356 : f002             [ 3]>        beq skip1990
13819
                            >        trap           ;failed equal (zero)
13820
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13821
2358 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13822
2359 : 1c                   >        db      test_num
13823 2 MichaelA
                            >
13824 3 MichaelA
235a :                      >skip1990
13825
                            >
13826
235a : 28               [ 4]>            plp         ;restore status
13827 2 MichaelA
 
13828
                                     set_a $7f,0
13829
                            >            load_flag 0
13830 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  240
13831
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13832
 
13833
235b : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
13834 2 MichaelA
                            >
13835 3 MichaelA
235d : 48               [ 3]>            pha         ;use stack to load status
13836
235e : a97f             [ 2]>            lda #$7f     ;precharge accu
13837
2360 : 28               [ 4]>            plp
13838 2 MichaelA
 
13839 3 MichaelA
2361 : c97f             [ 2]         cmp #$7f
13840 2 MichaelA
                                     tst_a $7f,fzc
13841 3 MichaelA
2363 : 08               [ 3]>            php         ;save flags
13842
2364 : 08               [ 3]>            php
13843
2365 : c97f             [ 2]>            cmp #$7f     ;test result
13844 2 MichaelA
                            >            trap_ne
13845 3 MichaelA
2367 : f002             [ 3]>        beq skip1995
13846
                            >        trap           ;failed equal (zero)
13847
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13848
2369 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13849
236a : 1c                   >        db      test_num
13850 2 MichaelA
                            >
13851 3 MichaelA
236b :                      >skip1995
13852
                            >
13853
236b : 68               [ 4]>            pla         ;load status
13854 2 MichaelA
                            >            cmp_flag fzc
13855 3 MichaelA
236c : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
13856 2 MichaelA
                            >
13857
                            >            trap_ne
13858 3 MichaelA
236e : f002             [ 3]>        beq skip1998
13859
                            >        trap           ;failed equal (zero)
13860
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13861
2370 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13862
2371 : 1c                   >        db      test_num
13863 2 MichaelA
                            >
13864 3 MichaelA
2372 :                      >skip1998
13865
                            >
13866
2372 : 28               [ 4]>            plp         ;restore status
13867 2 MichaelA
 
13868
                                     set_a $7e,0
13869
                            >            load_flag 0
13870 3 MichaelA
2373 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
13871 2 MichaelA
                            >
13872 3 MichaelA
2375 : 48               [ 3]>            pha         ;use stack to load status
13873
2376 : a97e             [ 2]>            lda #$7e     ;precharge accu
13874
2378 : 28               [ 4]>            plp
13875 2 MichaelA
 
13876 3 MichaelA
2379 : c97f             [ 2]         cmp #$7f
13877 2 MichaelA
                                     tst_a $7e,fn
13878 3 MichaelA
237b : 08               [ 3]>            php         ;save flags
13879
237c : 08               [ 3]>            php
13880
237d : c97e             [ 2]>            cmp #$7e     ;test result
13881 2 MichaelA
                            >            trap_ne
13882 3 MichaelA
237f : f002             [ 3]>        beq skip2003
13883
                            >        trap           ;failed equal (zero)
13884
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13885
2381 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13886
2382 : 1c                   >        db      test_num
13887 2 MichaelA
                            >
13888 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  241
13889
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13890
 
13891
2383 :                      >skip2003
13892
                            >
13893
2383 : 68               [ 4]>            pla         ;load status
13894 2 MichaelA
                            >            cmp_flag fn
13895 3 MichaelA
2384 : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
13896 2 MichaelA
                            >
13897
                            >            trap_ne
13898 3 MichaelA
2386 : f002             [ 3]>        beq skip2006
13899
                            >        trap           ;failed equal (zero)
13900
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13901
2388 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13902
2389 : 1c                   >        db      test_num
13903 2 MichaelA
                            >
13904 3 MichaelA
238a :                      >skip2006
13905
                            >
13906
238a : 28               [ 4]>            plp         ;restore status
13907 2 MichaelA
 
13908
                                     set_a $80,$ff
13909
                            >            load_flag $ff
13910 3 MichaelA
238b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
13911 2 MichaelA
                            >
13912 3 MichaelA
238d : 48               [ 3]>            pha         ;use stack to load status
13913
238e : a980             [ 2]>            lda #$80     ;precharge accu
13914
2390 : 28               [ 4]>            plp
13915 2 MichaelA
 
13916 3 MichaelA
2391 : c97f             [ 2]         cmp #$7f
13917 2 MichaelA
                                     tst_a $80,~fnz
13918 3 MichaelA
2393 : 08               [ 3]>            php         ;save flags
13919
2394 : 08               [ 3]>            php
13920
2395 : c980             [ 2]>            cmp #$80     ;test result
13921 2 MichaelA
                            >            trap_ne
13922 3 MichaelA
2397 : f002             [ 3]>        beq skip2011
13923
                            >        trap           ;failed equal (zero)
13924
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13925
2399 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13926
239a : 1c                   >        db      test_num
13927 2 MichaelA
                            >
13928 3 MichaelA
239b :                      >skip2011
13929
                            >
13930
239b : 68               [ 4]>            pla         ;load status
13931 2 MichaelA
                            >            cmp_flag ~fnz
13932 3 MichaelA
239c : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
13933 2 MichaelA
                            >
13934
                            >            trap_ne
13935 3 MichaelA
239e : f002             [ 3]>        beq skip2014
13936
                            >        trap           ;failed equal (zero)
13937
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13938
23a0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13939
23a1 : 1c                   >        db      test_num
13940 2 MichaelA
                            >
13941 3 MichaelA
23a2 :                      >skip2014
13942
                            >
13943
23a2 : 28               [ 4]>            plp         ;restore status
13944 2 MichaelA
 
13945
                                     set_a $7f,$ff
13946 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  242
13947
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
13948
 
13949 2 MichaelA
                            >            load_flag $ff
13950 3 MichaelA
23a3 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
13951 2 MichaelA
                            >
13952 3 MichaelA
23a5 : 48               [ 3]>            pha         ;use stack to load status
13953
23a6 : a97f             [ 2]>            lda #$7f     ;precharge accu
13954
23a8 : 28               [ 4]>            plp
13955 2 MichaelA
 
13956 3 MichaelA
23a9 : c97f             [ 2]         cmp #$7f
13957 2 MichaelA
                                     tst_a $7f,~fn
13958 3 MichaelA
23ab : 08               [ 3]>            php         ;save flags
13959
23ac : 08               [ 3]>            php
13960
23ad : c97f             [ 2]>            cmp #$7f     ;test result
13961 2 MichaelA
                            >            trap_ne
13962 3 MichaelA
23af : f002             [ 3]>        beq skip2019
13963
                            >        trap           ;failed equal (zero)
13964
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13965
23b1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13966
23b2 : 1c                   >        db      test_num
13967 2 MichaelA
                            >
13968 3 MichaelA
23b3 :                      >skip2019
13969
                            >
13970
23b3 : 68               [ 4]>            pla         ;load status
13971 2 MichaelA
                            >            cmp_flag ~fn
13972 3 MichaelA
23b4 : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
13973 2 MichaelA
                            >
13974
                            >            trap_ne
13975 3 MichaelA
23b6 : f002             [ 3]>        beq skip2022
13976
                            >        trap           ;failed equal (zero)
13977
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
13978
23b8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
13979
23b9 : 1c                   >        db      test_num
13980 2 MichaelA
                            >
13981 3 MichaelA
23ba :                      >skip2022
13982
                            >
13983
23ba : 28               [ 4]>            plp         ;restore status
13984 2 MichaelA
 
13985
                                     set_a $7e,$ff
13986
                            >            load_flag $ff
13987 3 MichaelA
23bb : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
13988 2 MichaelA
                            >
13989 3 MichaelA
23bd : 48               [ 3]>            pha         ;use stack to load status
13990
23be : a97e             [ 2]>            lda #$7e     ;precharge accu
13991
23c0 : 28               [ 4]>            plp
13992 2 MichaelA
 
13993 3 MichaelA
23c1 : c97f             [ 2]         cmp #$7f
13994 2 MichaelA
                                     tst_a $7e,~fzc
13995 3 MichaelA
23c3 : 08               [ 3]>            php         ;save flags
13996
23c4 : 08               [ 3]>            php
13997
23c5 : c97e             [ 2]>            cmp #$7e     ;test result
13998 2 MichaelA
                            >            trap_ne
13999 3 MichaelA
23c7 : f002             [ 3]>        beq skip2027
14000
                            >        trap           ;failed equal (zero)
14001
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14002
23c9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14003
23ca : 1c                   >        db      test_num
14004
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  243
14005
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14006
 
14007 2 MichaelA
                            >
14008 3 MichaelA
23cb :                      >skip2027
14009
                            >
14010
23cb : 68               [ 4]>            pla         ;load status
14011 2 MichaelA
                            >            cmp_flag ~fzc
14012 3 MichaelA
23cc : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
14013 2 MichaelA
                            >
14014
                            >            trap_ne
14015 3 MichaelA
23ce : f002             [ 3]>        beq skip2030
14016
                            >        trap           ;failed equal (zero)
14017
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14018
23d0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14019
23d1 : 1c                   >        db      test_num
14020 2 MichaelA
                            >
14021 3 MichaelA
23d2 :                      >skip2030
14022
                            >
14023
23d2 : 28               [ 4]>            plp         ;restore status
14024 2 MichaelA
 
14025
 
14026 3 MichaelA
23d3 : a204             [ 2]         ldx #4          ;with indexing by X
14027 2 MichaelA
                                     set_a $80,0
14028
                            >            load_flag 0
14029 3 MichaelA
23d5 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14030 2 MichaelA
                            >
14031 3 MichaelA
23d7 : 48               [ 3]>            pha         ;use stack to load status
14032
23d8 : a980             [ 2]>            lda #$80     ;precharge accu
14033
23da : 28               [ 4]>            plp
14034 2 MichaelA
 
14035 3 MichaelA
23db : d5b9             [ 4]         cmp zp1,x
14036 2 MichaelA
                                     tst_a $80,fc
14037 3 MichaelA
23dd : 08               [ 3]>            php         ;save flags
14038
23de : 08               [ 3]>            php
14039
23df : c980             [ 2]>            cmp #$80     ;test result
14040 2 MichaelA
                            >            trap_ne
14041 3 MichaelA
23e1 : f002             [ 3]>        beq skip2035
14042
                            >        trap           ;failed equal (zero)
14043
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14044
23e3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14045
23e4 : 1c                   >        db      test_num
14046 2 MichaelA
                            >
14047 3 MichaelA
23e5 :                      >skip2035
14048
                            >
14049
23e5 : 68               [ 4]>            pla         ;load status
14050 2 MichaelA
                            >            cmp_flag fc
14051 3 MichaelA
23e6 : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
14052 2 MichaelA
                            >
14053
                            >            trap_ne
14054 3 MichaelA
23e8 : f002             [ 3]>        beq skip2038
14055
                            >        trap           ;failed equal (zero)
14056
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14057
23ea : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14058
23eb : 1c                   >        db      test_num
14059 2 MichaelA
                            >
14060 3 MichaelA
23ec :                      >skip2038
14061
                            >
14062
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  244
14063
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14064
 
14065
23ec : 28               [ 4]>            plp         ;restore status
14066 2 MichaelA
 
14067
                                     set_a $7f,0
14068
                            >            load_flag 0
14069 3 MichaelA
23ed : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14070 2 MichaelA
                            >
14071 3 MichaelA
23ef : 48               [ 3]>            pha         ;use stack to load status
14072
23f0 : a97f             [ 2]>            lda #$7f     ;precharge accu
14073
23f2 : 28               [ 4]>            plp
14074 2 MichaelA
 
14075 3 MichaelA
23f3 : d5b9             [ 4]         cmp zp1,x
14076 2 MichaelA
                                     tst_a $7f,fzc
14077 3 MichaelA
23f5 : 08               [ 3]>            php         ;save flags
14078
23f6 : 08               [ 3]>            php
14079
23f7 : c97f             [ 2]>            cmp #$7f     ;test result
14080 2 MichaelA
                            >            trap_ne
14081 3 MichaelA
23f9 : f002             [ 3]>        beq skip2043
14082
                            >        trap           ;failed equal (zero)
14083
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14084
23fb : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14085
23fc : 1c                   >        db      test_num
14086 2 MichaelA
                            >
14087 3 MichaelA
23fd :                      >skip2043
14088
                            >
14089
23fd : 68               [ 4]>            pla         ;load status
14090 2 MichaelA
                            >            cmp_flag fzc
14091 3 MichaelA
23fe : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
14092 2 MichaelA
                            >
14093
                            >            trap_ne
14094 3 MichaelA
2400 : f002             [ 3]>        beq skip2046
14095
                            >        trap           ;failed equal (zero)
14096
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14097
2402 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14098
2403 : 1c                   >        db      test_num
14099 2 MichaelA
                            >
14100 3 MichaelA
2404 :                      >skip2046
14101
                            >
14102
2404 : 28               [ 4]>            plp         ;restore status
14103 2 MichaelA
 
14104
                                     set_a $7e,0
14105
                            >            load_flag 0
14106 3 MichaelA
2405 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14107 2 MichaelA
                            >
14108 3 MichaelA
2407 : 48               [ 3]>            pha         ;use stack to load status
14109
2408 : a97e             [ 2]>            lda #$7e     ;precharge accu
14110
240a : 28               [ 4]>            plp
14111 2 MichaelA
 
14112 3 MichaelA
240b : d5b9             [ 4]         cmp zp1,x
14113 2 MichaelA
                                     tst_a $7e,fn
14114 3 MichaelA
240d : 08               [ 3]>            php         ;save flags
14115
240e : 08               [ 3]>            php
14116
240f : c97e             [ 2]>            cmp #$7e     ;test result
14117 2 MichaelA
                            >            trap_ne
14118 3 MichaelA
2411 : f002             [ 3]>        beq skip2051
14119
                            >        trap           ;failed equal (zero)
14120
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  245
14121
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14122
 
14123
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14124
2413 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14125
2414 : 1c                   >        db      test_num
14126 2 MichaelA
                            >
14127 3 MichaelA
2415 :                      >skip2051
14128
                            >
14129
2415 : 68               [ 4]>            pla         ;load status
14130 2 MichaelA
                            >            cmp_flag fn
14131 3 MichaelA
2416 : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
14132 2 MichaelA
                            >
14133
                            >            trap_ne
14134 3 MichaelA
2418 : f002             [ 3]>        beq skip2054
14135
                            >        trap           ;failed equal (zero)
14136
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14137
241a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14138
241b : 1c                   >        db      test_num
14139 2 MichaelA
                            >
14140 3 MichaelA
241c :                      >skip2054
14141
                            >
14142
241c : 28               [ 4]>            plp         ;restore status
14143 2 MichaelA
 
14144
                                     set_a $80,$ff
14145
                            >            load_flag $ff
14146 3 MichaelA
241d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
14147 2 MichaelA
                            >
14148 3 MichaelA
241f : 48               [ 3]>            pha         ;use stack to load status
14149
2420 : a980             [ 2]>            lda #$80     ;precharge accu
14150
2422 : 28               [ 4]>            plp
14151 2 MichaelA
 
14152 3 MichaelA
2423 : d5b9             [ 4]         cmp zp1,x
14153 2 MichaelA
                                     tst_a $80,~fnz
14154 3 MichaelA
2425 : 08               [ 3]>            php         ;save flags
14155
2426 : 08               [ 3]>            php
14156
2427 : c980             [ 2]>            cmp #$80     ;test result
14157 2 MichaelA
                            >            trap_ne
14158 3 MichaelA
2429 : f002             [ 3]>        beq skip2059
14159
                            >        trap           ;failed equal (zero)
14160
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14161
242b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14162
242c : 1c                   >        db      test_num
14163 2 MichaelA
                            >
14164 3 MichaelA
242d :                      >skip2059
14165
                            >
14166
242d : 68               [ 4]>            pla         ;load status
14167 2 MichaelA
                            >            cmp_flag ~fnz
14168 3 MichaelA
242e : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
14169 2 MichaelA
                            >
14170
                            >            trap_ne
14171 3 MichaelA
2430 : f002             [ 3]>        beq skip2062
14172
                            >        trap           ;failed equal (zero)
14173
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14174
2432 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14175
2433 : 1c                   >        db      test_num
14176 2 MichaelA
                            >
14177 3 MichaelA
2434 :                      >skip2062
14178
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  246
14179
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14180
 
14181
                            >
14182
2434 : 28               [ 4]>            plp         ;restore status
14183 2 MichaelA
 
14184
                                     set_a $7f,$ff
14185
                            >            load_flag $ff
14186 3 MichaelA
2435 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
14187 2 MichaelA
                            >
14188 3 MichaelA
2437 : 48               [ 3]>            pha         ;use stack to load status
14189
2438 : a97f             [ 2]>            lda #$7f     ;precharge accu
14190
243a : 28               [ 4]>            plp
14191 2 MichaelA
 
14192 3 MichaelA
243b : d5b9             [ 4]         cmp zp1,x
14193 2 MichaelA
                                     tst_a $7f,~fn
14194 3 MichaelA
243d : 08               [ 3]>            php         ;save flags
14195
243e : 08               [ 3]>            php
14196
243f : c97f             [ 2]>            cmp #$7f     ;test result
14197 2 MichaelA
                            >            trap_ne
14198 3 MichaelA
2441 : f002             [ 3]>        beq skip2067
14199
                            >        trap           ;failed equal (zero)
14200
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14201
2443 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14202
2444 : 1c                   >        db      test_num
14203 2 MichaelA
                            >
14204 3 MichaelA
2445 :                      >skip2067
14205
                            >
14206
2445 : 68               [ 4]>            pla         ;load status
14207 2 MichaelA
                            >            cmp_flag ~fn
14208 3 MichaelA
2446 : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
14209 2 MichaelA
                            >
14210
                            >            trap_ne
14211 3 MichaelA
2448 : f002             [ 3]>        beq skip2070
14212
                            >        trap           ;failed equal (zero)
14213
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14214
244a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14215
244b : 1c                   >        db      test_num
14216 2 MichaelA
                            >
14217 3 MichaelA
244c :                      >skip2070
14218
                            >
14219
244c : 28               [ 4]>            plp         ;restore status
14220 2 MichaelA
 
14221
                                     set_a $7e,$ff
14222
                            >            load_flag $ff
14223 3 MichaelA
244d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
14224 2 MichaelA
                            >
14225 3 MichaelA
244f : 48               [ 3]>            pha         ;use stack to load status
14226
2450 : a97e             [ 2]>            lda #$7e     ;precharge accu
14227
2452 : 28               [ 4]>            plp
14228 2 MichaelA
 
14229 3 MichaelA
2453 : d5b9             [ 4]         cmp zp1,x
14230 2 MichaelA
                                     tst_a $7e,~fzc
14231 3 MichaelA
2455 : 08               [ 3]>            php         ;save flags
14232
2456 : 08               [ 3]>            php
14233
2457 : c97e             [ 2]>            cmp #$7e     ;test result
14234 2 MichaelA
                            >            trap_ne
14235 3 MichaelA
2459 : f002             [ 3]>        beq skip2075
14236
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  247
14237 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14238
 
14239 3 MichaelA
                            >        trap           ;failed equal (zero)
14240
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14241
245b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14242
245c : 1c                   >        db      test_num
14243
                            >
14244
245d :                      >skip2075
14245
                            >
14246
245d : 68               [ 4]>            pla         ;load status
14247 2 MichaelA
                            >            cmp_flag ~fzc
14248 3 MichaelA
245e : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
14249 2 MichaelA
                            >
14250
                            >            trap_ne
14251 3 MichaelA
2460 : f002             [ 3]>        beq skip2078
14252
                            >        trap           ;failed equal (zero)
14253
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14254
2462 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14255
2463 : 1c                   >        db      test_num
14256 2 MichaelA
                            >
14257 3 MichaelA
2464 :                      >skip2078
14258
                            >
14259
2464 : 28               [ 4]>            plp         ;restore status
14260 2 MichaelA
 
14261
 
14262
                                     set_a $80,0
14263
                            >            load_flag 0
14264 3 MichaelA
2465 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14265 2 MichaelA
                            >
14266 3 MichaelA
2467 : 48               [ 3]>            pha         ;use stack to load status
14267
2468 : a980             [ 2]>            lda #$80     ;precharge accu
14268
246a : 28               [ 4]>            plp
14269 2 MichaelA
 
14270 3 MichaelA
246b : dd0802           [ 4]         cmp abs1,x
14271 2 MichaelA
                                     tst_a $80,fc
14272 3 MichaelA
246e : 08               [ 3]>            php         ;save flags
14273
246f : 08               [ 3]>            php
14274
2470 : c980             [ 2]>            cmp #$80     ;test result
14275 2 MichaelA
                            >            trap_ne
14276 3 MichaelA
2472 : f002             [ 3]>        beq skip2083
14277
                            >        trap           ;failed equal (zero)
14278
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14279
2474 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14280
2475 : 1c                   >        db      test_num
14281 2 MichaelA
                            >
14282 3 MichaelA
2476 :                      >skip2083
14283
                            >
14284
2476 : 68               [ 4]>            pla         ;load status
14285 2 MichaelA
                            >            cmp_flag fc
14286 3 MichaelA
2477 : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
14287 2 MichaelA
                            >
14288
                            >            trap_ne
14289 3 MichaelA
2479 : f002             [ 3]>        beq skip2086
14290
                            >        trap           ;failed equal (zero)
14291
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14292
247b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14293
247c : 1c                   >        db      test_num
14294
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  248
14295
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14296
 
14297 2 MichaelA
                            >
14298 3 MichaelA
247d :                      >skip2086
14299
                            >
14300
247d : 28               [ 4]>            plp         ;restore status
14301 2 MichaelA
 
14302
                                     set_a $7f,0
14303
                            >            load_flag 0
14304 3 MichaelA
247e : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14305 2 MichaelA
                            >
14306 3 MichaelA
2480 : 48               [ 3]>            pha         ;use stack to load status
14307
2481 : a97f             [ 2]>            lda #$7f     ;precharge accu
14308
2483 : 28               [ 4]>            plp
14309 2 MichaelA
 
14310 3 MichaelA
2484 : dd0802           [ 4]         cmp abs1,x
14311 2 MichaelA
                                     tst_a $7f,fzc
14312 3 MichaelA
2487 : 08               [ 3]>            php         ;save flags
14313
2488 : 08               [ 3]>            php
14314
2489 : c97f             [ 2]>            cmp #$7f     ;test result
14315 2 MichaelA
                            >            trap_ne
14316 3 MichaelA
248b : f002             [ 3]>        beq skip2091
14317
                            >        trap           ;failed equal (zero)
14318
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14319
248d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14320
248e : 1c                   >        db      test_num
14321 2 MichaelA
                            >
14322 3 MichaelA
248f :                      >skip2091
14323
                            >
14324
248f : 68               [ 4]>            pla         ;load status
14325 2 MichaelA
                            >            cmp_flag fzc
14326 3 MichaelA
2490 : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
14327 2 MichaelA
                            >
14328
                            >            trap_ne
14329 3 MichaelA
2492 : f002             [ 3]>        beq skip2094
14330
                            >        trap           ;failed equal (zero)
14331
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14332
2494 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14333
2495 : 1c                   >        db      test_num
14334 2 MichaelA
                            >
14335 3 MichaelA
2496 :                      >skip2094
14336
                            >
14337
2496 : 28               [ 4]>            plp         ;restore status
14338 2 MichaelA
 
14339
                                     set_a $7e,0
14340
                            >            load_flag 0
14341 3 MichaelA
2497 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14342 2 MichaelA
                            >
14343 3 MichaelA
2499 : 48               [ 3]>            pha         ;use stack to load status
14344
249a : a97e             [ 2]>            lda #$7e     ;precharge accu
14345
249c : 28               [ 4]>            plp
14346 2 MichaelA
 
14347 3 MichaelA
249d : dd0802           [ 4]         cmp abs1,x
14348 2 MichaelA
                                     tst_a $7e,fn
14349 3 MichaelA
24a0 : 08               [ 3]>            php         ;save flags
14350
24a1 : 08               [ 3]>            php
14351
24a2 : c97e             [ 2]>            cmp #$7e     ;test result
14352
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  249
14353
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14354
 
14355 2 MichaelA
                            >            trap_ne
14356 3 MichaelA
24a4 : f002             [ 3]>        beq skip2099
14357
                            >        trap           ;failed equal (zero)
14358
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14359
24a6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14360
24a7 : 1c                   >        db      test_num
14361 2 MichaelA
                            >
14362 3 MichaelA
24a8 :                      >skip2099
14363
                            >
14364
24a8 : 68               [ 4]>            pla         ;load status
14365 2 MichaelA
                            >            cmp_flag fn
14366 3 MichaelA
24a9 : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
14367 2 MichaelA
                            >
14368
                            >            trap_ne
14369 3 MichaelA
24ab : f002             [ 3]>        beq skip2102
14370
                            >        trap           ;failed equal (zero)
14371
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14372
24ad : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14373
24ae : 1c                   >        db      test_num
14374 2 MichaelA
                            >
14375 3 MichaelA
24af :                      >skip2102
14376
                            >
14377
24af : 28               [ 4]>            plp         ;restore status
14378 2 MichaelA
 
14379
                                     set_a $80,$ff
14380
                            >            load_flag $ff
14381 3 MichaelA
24b0 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
14382 2 MichaelA
                            >
14383 3 MichaelA
24b2 : 48               [ 3]>            pha         ;use stack to load status
14384
24b3 : a980             [ 2]>            lda #$80     ;precharge accu
14385
24b5 : 28               [ 4]>            plp
14386 2 MichaelA
 
14387 3 MichaelA
24b6 : dd0802           [ 4]         cmp abs1,x
14388 2 MichaelA
                                     tst_a $80,~fnz
14389 3 MichaelA
24b9 : 08               [ 3]>            php         ;save flags
14390
24ba : 08               [ 3]>            php
14391
24bb : c980             [ 2]>            cmp #$80     ;test result
14392 2 MichaelA
                            >            trap_ne
14393 3 MichaelA
24bd : f002             [ 3]>        beq skip2107
14394
                            >        trap           ;failed equal (zero)
14395
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14396
24bf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14397
24c0 : 1c                   >        db      test_num
14398 2 MichaelA
                            >
14399 3 MichaelA
24c1 :                      >skip2107
14400
                            >
14401
24c1 : 68               [ 4]>            pla         ;load status
14402 2 MichaelA
                            >            cmp_flag ~fnz
14403 3 MichaelA
24c2 : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
14404 2 MichaelA
                            >
14405
                            >            trap_ne
14406 3 MichaelA
24c4 : f002             [ 3]>        beq skip2110
14407
                            >        trap           ;failed equal (zero)
14408
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14409
24c6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14410
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  250
14411
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14412
 
14413
24c7 : 1c                   >        db      test_num
14414 2 MichaelA
                            >
14415 3 MichaelA
24c8 :                      >skip2110
14416
                            >
14417
24c8 : 28               [ 4]>            plp         ;restore status
14418 2 MichaelA
 
14419
                                     set_a $7f,$ff
14420
                            >            load_flag $ff
14421 3 MichaelA
24c9 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
14422 2 MichaelA
                            >
14423 3 MichaelA
24cb : 48               [ 3]>            pha         ;use stack to load status
14424
24cc : a97f             [ 2]>            lda #$7f     ;precharge accu
14425
24ce : 28               [ 4]>            plp
14426 2 MichaelA
 
14427 3 MichaelA
24cf : dd0802           [ 4]         cmp abs1,x
14428 2 MichaelA
                                     tst_a $7f,~fn
14429 3 MichaelA
24d2 : 08               [ 3]>            php         ;save flags
14430
24d3 : 08               [ 3]>            php
14431
24d4 : c97f             [ 2]>            cmp #$7f     ;test result
14432 2 MichaelA
                            >            trap_ne
14433 3 MichaelA
24d6 : f002             [ 3]>        beq skip2115
14434
                            >        trap           ;failed equal (zero)
14435
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14436
24d8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14437
24d9 : 1c                   >        db      test_num
14438 2 MichaelA
                            >
14439 3 MichaelA
24da :                      >skip2115
14440
                            >
14441
24da : 68               [ 4]>            pla         ;load status
14442 2 MichaelA
                            >            cmp_flag ~fn
14443 3 MichaelA
24db : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
14444 2 MichaelA
                            >
14445
                            >            trap_ne
14446 3 MichaelA
24dd : f002             [ 3]>        beq skip2118
14447
                            >        trap           ;failed equal (zero)
14448
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14449
24df : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14450
24e0 : 1c                   >        db      test_num
14451 2 MichaelA
                            >
14452 3 MichaelA
24e1 :                      >skip2118
14453
                            >
14454
24e1 : 28               [ 4]>            plp         ;restore status
14455 2 MichaelA
 
14456
                                     set_a $7e,$ff
14457
                            >            load_flag $ff
14458 3 MichaelA
24e2 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
14459 2 MichaelA
                            >
14460 3 MichaelA
24e4 : 48               [ 3]>            pha         ;use stack to load status
14461
24e5 : a97e             [ 2]>            lda #$7e     ;precharge accu
14462
24e7 : 28               [ 4]>            plp
14463 2 MichaelA
 
14464 3 MichaelA
24e8 : dd0802           [ 4]         cmp abs1,x
14465 2 MichaelA
                                     tst_a $7e,~fzc
14466 3 MichaelA
24eb : 08               [ 3]>            php         ;save flags
14467
24ec : 08               [ 3]>            php
14468
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  251
14469
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14470
 
14471
24ed : c97e             [ 2]>            cmp #$7e     ;test result
14472 2 MichaelA
                            >            trap_ne
14473 3 MichaelA
24ef : f002             [ 3]>        beq skip2123
14474
                            >        trap           ;failed equal (zero)
14475
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14476
24f1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14477
24f2 : 1c                   >        db      test_num
14478 2 MichaelA
                            >
14479 3 MichaelA
24f3 :                      >skip2123
14480
                            >
14481
24f3 : 68               [ 4]>            pla         ;load status
14482 2 MichaelA
                            >            cmp_flag ~fzc
14483 3 MichaelA
24f4 : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
14484 2 MichaelA
                            >
14485
                            >            trap_ne
14486 3 MichaelA
24f6 : f002             [ 3]>        beq skip2126
14487
                            >        trap           ;failed equal (zero)
14488
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14489
24f8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14490
24f9 : 1c                   >        db      test_num
14491 2 MichaelA
                            >
14492 3 MichaelA
24fa :                      >skip2126
14493
                            >
14494
24fa : 28               [ 4]>            plp         ;restore status
14495 2 MichaelA
 
14496
 
14497 3 MichaelA
24fb : a004             [ 2]         ldy #4          ;with indexing by Y
14498
24fd : a208             [ 2]         ldx #8          ;with indexed indirect
14499 2 MichaelA
                                     set_a $80,0
14500
                            >            load_flag 0
14501 3 MichaelA
24ff : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14502 2 MichaelA
                            >
14503 3 MichaelA
2501 : 48               [ 3]>            pha         ;use stack to load status
14504
2502 : a980             [ 2]>            lda #$80     ;precharge accu
14505
2504 : 28               [ 4]>            plp
14506 2 MichaelA
 
14507 3 MichaelA
2505 : d90802           [ 4]         cmp abs1,y
14508 2 MichaelA
                                     tst_a $80,fc
14509 3 MichaelA
2508 : 08               [ 3]>            php         ;save flags
14510
2509 : 08               [ 3]>            php
14511
250a : c980             [ 2]>            cmp #$80     ;test result
14512 2 MichaelA
                            >            trap_ne
14513 3 MichaelA
250c : f002             [ 3]>        beq skip2131
14514
                            >        trap           ;failed equal (zero)
14515
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14516
250e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14517
250f : 1c                   >        db      test_num
14518 2 MichaelA
                            >
14519 3 MichaelA
2510 :                      >skip2131
14520
                            >
14521
2510 : 68               [ 4]>            pla         ;load status
14522 2 MichaelA
                            >            cmp_flag fc
14523 3 MichaelA
2511 : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
14524 2 MichaelA
                            >
14525
                            >            trap_ne
14526 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  252
14527
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14528
 
14529
2513 : f002             [ 3]>        beq skip2134
14530
                            >        trap           ;failed equal (zero)
14531
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14532
2515 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14533
2516 : 1c                   >        db      test_num
14534 2 MichaelA
                            >
14535 3 MichaelA
2517 :                      >skip2134
14536
                            >
14537
2517 : 28               [ 4]>            plp         ;restore status
14538 2 MichaelA
 
14539
                                     set_a $7f,0
14540
                            >            load_flag 0
14541 3 MichaelA
2518 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14542 2 MichaelA
                            >
14543 3 MichaelA
251a : 48               [ 3]>            pha         ;use stack to load status
14544
251b : a97f             [ 2]>            lda #$7f     ;precharge accu
14545
251d : 28               [ 4]>            plp
14546 2 MichaelA
 
14547 3 MichaelA
251e : d90802           [ 4]         cmp abs1,y
14548 2 MichaelA
                                     tst_a $7f,fzc
14549 3 MichaelA
2521 : 08               [ 3]>            php         ;save flags
14550
2522 : 08               [ 3]>            php
14551
2523 : c97f             [ 2]>            cmp #$7f     ;test result
14552 2 MichaelA
                            >            trap_ne
14553 3 MichaelA
2525 : f002             [ 3]>        beq skip2139
14554
                            >        trap           ;failed equal (zero)
14555
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14556
2527 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14557
2528 : 1c                   >        db      test_num
14558 2 MichaelA
                            >
14559 3 MichaelA
2529 :                      >skip2139
14560
                            >
14561
2529 : 68               [ 4]>            pla         ;load status
14562 2 MichaelA
                            >            cmp_flag fzc
14563 3 MichaelA
252a : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
14564 2 MichaelA
                            >
14565
                            >            trap_ne
14566 3 MichaelA
252c : f002             [ 3]>        beq skip2142
14567
                            >        trap           ;failed equal (zero)
14568
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14569
252e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14570
252f : 1c                   >        db      test_num
14571 2 MichaelA
                            >
14572 3 MichaelA
2530 :                      >skip2142
14573
                            >
14574
2530 : 28               [ 4]>            plp         ;restore status
14575 2 MichaelA
 
14576
                                     set_a $7e,0
14577
                            >            load_flag 0
14578 3 MichaelA
2531 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14579 2 MichaelA
                            >
14580 3 MichaelA
2533 : 48               [ 3]>            pha         ;use stack to load status
14581
2534 : a97e             [ 2]>            lda #$7e     ;precharge accu
14582
2536 : 28               [ 4]>            plp
14583 2 MichaelA
 
14584 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  253
14585 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14586
 
14587 3 MichaelA
2537 : d90802           [ 4]         cmp abs1,y
14588 2 MichaelA
                                     tst_a $7e,fn
14589 3 MichaelA
253a : 08               [ 3]>            php         ;save flags
14590
253b : 08               [ 3]>            php
14591
253c : c97e             [ 2]>            cmp #$7e     ;test result
14592 2 MichaelA
                            >            trap_ne
14593 3 MichaelA
253e : f002             [ 3]>        beq skip2147
14594
                            >        trap           ;failed equal (zero)
14595
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14596
2540 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14597
2541 : 1c                   >        db      test_num
14598 2 MichaelA
                            >
14599 3 MichaelA
2542 :                      >skip2147
14600
                            >
14601
2542 : 68               [ 4]>            pla         ;load status
14602 2 MichaelA
                            >            cmp_flag fn
14603 3 MichaelA
2543 : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
14604 2 MichaelA
                            >
14605
                            >            trap_ne
14606 3 MichaelA
2545 : f002             [ 3]>        beq skip2150
14607
                            >        trap           ;failed equal (zero)
14608
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14609
2547 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14610
2548 : 1c                   >        db      test_num
14611 2 MichaelA
                            >
14612 3 MichaelA
2549 :                      >skip2150
14613
                            >
14614
2549 : 28               [ 4]>            plp         ;restore status
14615 2 MichaelA
 
14616
                                     set_a $80,$ff
14617
                            >            load_flag $ff
14618 3 MichaelA
254a : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
14619 2 MichaelA
                            >
14620 3 MichaelA
254c : 48               [ 3]>            pha         ;use stack to load status
14621
254d : a980             [ 2]>            lda #$80     ;precharge accu
14622
254f : 28               [ 4]>            plp
14623 2 MichaelA
 
14624 3 MichaelA
2550 : d90802           [ 4]         cmp abs1,y
14625 2 MichaelA
                                     tst_a $80,~fnz
14626 3 MichaelA
2553 : 08               [ 3]>            php         ;save flags
14627
2554 : 08               [ 3]>            php
14628
2555 : c980             [ 2]>            cmp #$80     ;test result
14629 2 MichaelA
                            >            trap_ne
14630 3 MichaelA
2557 : f002             [ 3]>        beq skip2155
14631
                            >        trap           ;failed equal (zero)
14632
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14633
2559 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14634
255a : 1c                   >        db      test_num
14635 2 MichaelA
                            >
14636 3 MichaelA
255b :                      >skip2155
14637
                            >
14638
255b : 68               [ 4]>            pla         ;load status
14639 2 MichaelA
                            >            cmp_flag ~fnz
14640 3 MichaelA
255c : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
14641 2 MichaelA
                            >
14642 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  254
14643
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14644
 
14645 2 MichaelA
                            >            trap_ne
14646 3 MichaelA
255e : f002             [ 3]>        beq skip2158
14647
                            >        trap           ;failed equal (zero)
14648
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14649
2560 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14650
2561 : 1c                   >        db      test_num
14651 2 MichaelA
                            >
14652 3 MichaelA
2562 :                      >skip2158
14653
                            >
14654
2562 : 28               [ 4]>            plp         ;restore status
14655 2 MichaelA
 
14656
                                     set_a $7f,$ff
14657
                            >            load_flag $ff
14658 3 MichaelA
2563 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
14659 2 MichaelA
                            >
14660 3 MichaelA
2565 : 48               [ 3]>            pha         ;use stack to load status
14661
2566 : a97f             [ 2]>            lda #$7f     ;precharge accu
14662
2568 : 28               [ 4]>            plp
14663 2 MichaelA
 
14664 3 MichaelA
2569 : d90802           [ 4]         cmp abs1,y
14665 2 MichaelA
                                     tst_a $7f,~fn
14666 3 MichaelA
256c : 08               [ 3]>            php         ;save flags
14667
256d : 08               [ 3]>            php
14668
256e : c97f             [ 2]>            cmp #$7f     ;test result
14669 2 MichaelA
                            >            trap_ne
14670 3 MichaelA
2570 : f002             [ 3]>        beq skip2163
14671
                            >        trap           ;failed equal (zero)
14672
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14673
2572 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14674
2573 : 1c                   >        db      test_num
14675 2 MichaelA
                            >
14676 3 MichaelA
2574 :                      >skip2163
14677
                            >
14678
2574 : 68               [ 4]>            pla         ;load status
14679 2 MichaelA
                            >            cmp_flag ~fn
14680 3 MichaelA
2575 : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
14681 2 MichaelA
                            >
14682
                            >            trap_ne
14683 3 MichaelA
2577 : f002             [ 3]>        beq skip2166
14684
                            >        trap           ;failed equal (zero)
14685
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14686
2579 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14687
257a : 1c                   >        db      test_num
14688 2 MichaelA
                            >
14689 3 MichaelA
257b :                      >skip2166
14690
                            >
14691
257b : 28               [ 4]>            plp         ;restore status
14692 2 MichaelA
 
14693
                                     set_a $7e,$ff
14694
                            >            load_flag $ff
14695 3 MichaelA
257c : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
14696 2 MichaelA
                            >
14697 3 MichaelA
257e : 48               [ 3]>            pha         ;use stack to load status
14698
257f : a97e             [ 2]>            lda #$7e     ;precharge accu
14699
2581 : 28               [ 4]>            plp
14700
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  255
14701
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14702
 
14703 2 MichaelA
 
14704 3 MichaelA
2582 : d90802           [ 4]         cmp abs1,y
14705 2 MichaelA
                                     tst_a $7e,~fzc
14706 3 MichaelA
2585 : 08               [ 3]>            php         ;save flags
14707
2586 : 08               [ 3]>            php
14708
2587 : c97e             [ 2]>            cmp #$7e     ;test result
14709 2 MichaelA
                            >            trap_ne
14710 3 MichaelA
2589 : f002             [ 3]>        beq skip2171
14711
                            >        trap           ;failed equal (zero)
14712
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14713
258b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14714
258c : 1c                   >        db      test_num
14715 2 MichaelA
                            >
14716 3 MichaelA
258d :                      >skip2171
14717
                            >
14718
258d : 68               [ 4]>            pla         ;load status
14719 2 MichaelA
                            >            cmp_flag ~fzc
14720 3 MichaelA
258e : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
14721 2 MichaelA
                            >
14722
                            >            trap_ne
14723 3 MichaelA
2590 : f002             [ 3]>        beq skip2174
14724
                            >        trap           ;failed equal (zero)
14725
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14726
2592 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14727
2593 : 1c                   >        db      test_num
14728 2 MichaelA
                            >
14729 3 MichaelA
2594 :                      >skip2174
14730
                            >
14731
2594 : 28               [ 4]>            plp         ;restore status
14732 2 MichaelA
 
14733
 
14734
                                     set_a $80,0
14735
                            >            load_flag 0
14736 3 MichaelA
2595 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14737 2 MichaelA
                            >
14738 3 MichaelA
2597 : 48               [ 3]>            pha         ;use stack to load status
14739
2598 : a980             [ 2]>            lda #$80     ;precharge accu
14740
259a : 28               [ 4]>            plp
14741 2 MichaelA
 
14742 3 MichaelA
259b : c1ca             [ 6]         cmp (ind1,x)
14743 2 MichaelA
                                     tst_a $80,fc
14744 3 MichaelA
259d : 08               [ 3]>            php         ;save flags
14745
259e : 08               [ 3]>            php
14746
259f : c980             [ 2]>            cmp #$80     ;test result
14747 2 MichaelA
                            >            trap_ne
14748 3 MichaelA
25a1 : f002             [ 3]>        beq skip2179
14749
                            >        trap           ;failed equal (zero)
14750
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14751
25a3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14752
25a4 : 1c                   >        db      test_num
14753 2 MichaelA
                            >
14754 3 MichaelA
25a5 :                      >skip2179
14755
                            >
14756
25a5 : 68               [ 4]>            pla         ;load status
14757
                            >            cmp_flag fc
14758
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  256
14759 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14760
 
14761 3 MichaelA
25a6 : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
14762 2 MichaelA
                            >
14763
                            >            trap_ne
14764 3 MichaelA
25a8 : f002             [ 3]>        beq skip2182
14765
                            >        trap           ;failed equal (zero)
14766
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14767
25aa : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14768
25ab : 1c                   >        db      test_num
14769 2 MichaelA
                            >
14770 3 MichaelA
25ac :                      >skip2182
14771
                            >
14772
25ac : 28               [ 4]>            plp         ;restore status
14773 2 MichaelA
 
14774
                                     set_a $7f,0
14775
                            >            load_flag 0
14776 3 MichaelA
25ad : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14777 2 MichaelA
                            >
14778 3 MichaelA
25af : 48               [ 3]>            pha         ;use stack to load status
14779
25b0 : a97f             [ 2]>            lda #$7f     ;precharge accu
14780
25b2 : 28               [ 4]>            plp
14781 2 MichaelA
 
14782 3 MichaelA
25b3 : c1ca             [ 6]         cmp (ind1,x)
14783 2 MichaelA
                                     tst_a $7f,fzc
14784 3 MichaelA
25b5 : 08               [ 3]>            php         ;save flags
14785
25b6 : 08               [ 3]>            php
14786
25b7 : c97f             [ 2]>            cmp #$7f     ;test result
14787 2 MichaelA
                            >            trap_ne
14788 3 MichaelA
25b9 : f002             [ 3]>        beq skip2187
14789
                            >        trap           ;failed equal (zero)
14790
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14791
25bb : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14792
25bc : 1c                   >        db      test_num
14793 2 MichaelA
                            >
14794 3 MichaelA
25bd :                      >skip2187
14795
                            >
14796
25bd : 68               [ 4]>            pla         ;load status
14797 2 MichaelA
                            >            cmp_flag fzc
14798 3 MichaelA
25be : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
14799 2 MichaelA
                            >
14800
                            >            trap_ne
14801 3 MichaelA
25c0 : f002             [ 3]>        beq skip2190
14802
                            >        trap           ;failed equal (zero)
14803
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14804
25c2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14805
25c3 : 1c                   >        db      test_num
14806 2 MichaelA
                            >
14807 3 MichaelA
25c4 :                      >skip2190
14808
                            >
14809
25c4 : 28               [ 4]>            plp         ;restore status
14810 2 MichaelA
 
14811
                                     set_a $7e,0
14812
                            >            load_flag 0
14813 3 MichaelA
25c5 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14814 2 MichaelA
                            >
14815 3 MichaelA
25c7 : 48               [ 3]>            pha         ;use stack to load status
14816
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  257
14817
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14818
 
14819
25c8 : a97e             [ 2]>            lda #$7e     ;precharge accu
14820
25ca : 28               [ 4]>            plp
14821 2 MichaelA
 
14822 3 MichaelA
25cb : c1ca             [ 6]         cmp (ind1,x)
14823 2 MichaelA
                                     tst_a $7e,fn
14824 3 MichaelA
25cd : 08               [ 3]>            php         ;save flags
14825
25ce : 08               [ 3]>            php
14826
25cf : c97e             [ 2]>            cmp #$7e     ;test result
14827 2 MichaelA
                            >            trap_ne
14828 3 MichaelA
25d1 : f002             [ 3]>        beq skip2195
14829
                            >        trap           ;failed equal (zero)
14830
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14831
25d3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14832
25d4 : 1c                   >        db      test_num
14833 2 MichaelA
                            >
14834 3 MichaelA
25d5 :                      >skip2195
14835
                            >
14836
25d5 : 68               [ 4]>            pla         ;load status
14837 2 MichaelA
                            >            cmp_flag fn
14838 3 MichaelA
25d6 : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
14839 2 MichaelA
                            >
14840
                            >            trap_ne
14841 3 MichaelA
25d8 : f002             [ 3]>        beq skip2198
14842
                            >        trap           ;failed equal (zero)
14843
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14844
25da : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14845
25db : 1c                   >        db      test_num
14846 2 MichaelA
                            >
14847 3 MichaelA
25dc :                      >skip2198
14848
                            >
14849
25dc : 28               [ 4]>            plp         ;restore status
14850 2 MichaelA
 
14851
                                     set_a $80,$ff
14852
                            >            load_flag $ff
14853 3 MichaelA
25dd : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
14854 2 MichaelA
                            >
14855 3 MichaelA
25df : 48               [ 3]>            pha         ;use stack to load status
14856
25e0 : a980             [ 2]>            lda #$80     ;precharge accu
14857
25e2 : 28               [ 4]>            plp
14858 2 MichaelA
 
14859 3 MichaelA
25e3 : c1ca             [ 6]         cmp (ind1,x)
14860 2 MichaelA
                                     tst_a $80,~fnz
14861 3 MichaelA
25e5 : 08               [ 3]>            php         ;save flags
14862
25e6 : 08               [ 3]>            php
14863
25e7 : c980             [ 2]>            cmp #$80     ;test result
14864 2 MichaelA
                            >            trap_ne
14865 3 MichaelA
25e9 : f002             [ 3]>        beq skip2203
14866
                            >        trap           ;failed equal (zero)
14867
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14868
25eb : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14869
25ec : 1c                   >        db      test_num
14870 2 MichaelA
                            >
14871 3 MichaelA
25ed :                      >skip2203
14872
                            >
14873
25ed : 68               [ 4]>            pla         ;load status
14874
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  258
14875
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14876
 
14877 2 MichaelA
                            >            cmp_flag ~fnz
14878 3 MichaelA
25ee : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
14879 2 MichaelA
                            >
14880
                            >            trap_ne
14881 3 MichaelA
25f0 : f002             [ 3]>        beq skip2206
14882
                            >        trap           ;failed equal (zero)
14883
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14884
25f2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14885
25f3 : 1c                   >        db      test_num
14886 2 MichaelA
                            >
14887 3 MichaelA
25f4 :                      >skip2206
14888
                            >
14889
25f4 : 28               [ 4]>            plp         ;restore status
14890 2 MichaelA
 
14891
                                     set_a $7f,$ff
14892
                            >            load_flag $ff
14893 3 MichaelA
25f5 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
14894 2 MichaelA
                            >
14895 3 MichaelA
25f7 : 48               [ 3]>            pha         ;use stack to load status
14896
25f8 : a97f             [ 2]>            lda #$7f     ;precharge accu
14897
25fa : 28               [ 4]>            plp
14898 2 MichaelA
 
14899 3 MichaelA
25fb : c1ca             [ 6]         cmp (ind1,x)
14900 2 MichaelA
                                     tst_a $7f,~fn
14901 3 MichaelA
25fd : 08               [ 3]>            php         ;save flags
14902
25fe : 08               [ 3]>            php
14903
25ff : c97f             [ 2]>            cmp #$7f     ;test result
14904 2 MichaelA
                            >            trap_ne
14905 3 MichaelA
2601 : f002             [ 3]>        beq skip2211
14906
                            >        trap           ;failed equal (zero)
14907
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14908
2603 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14909
2604 : 1c                   >        db      test_num
14910 2 MichaelA
                            >
14911 3 MichaelA
2605 :                      >skip2211
14912
                            >
14913
2605 : 68               [ 4]>            pla         ;load status
14914 2 MichaelA
                            >            cmp_flag ~fn
14915 3 MichaelA
2606 : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
14916 2 MichaelA
                            >
14917
                            >            trap_ne
14918 3 MichaelA
2608 : f002             [ 3]>        beq skip2214
14919
                            >        trap           ;failed equal (zero)
14920
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14921
260a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14922
260b : 1c                   >        db      test_num
14923 2 MichaelA
                            >
14924 3 MichaelA
260c :                      >skip2214
14925
                            >
14926
260c : 28               [ 4]>            plp         ;restore status
14927 2 MichaelA
 
14928
                                     set_a $7e,$ff
14929
                            >            load_flag $ff
14930 3 MichaelA
260d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
14931
                            >
14932
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  259
14933 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14934
 
14935 3 MichaelA
260f : 48               [ 3]>            pha         ;use stack to load status
14936
2610 : a97e             [ 2]>            lda #$7e     ;precharge accu
14937
2612 : 28               [ 4]>            plp
14938 2 MichaelA
 
14939 3 MichaelA
2613 : c1ca             [ 6]         cmp (ind1,x)
14940 2 MichaelA
                                     tst_a $7e,~fzc
14941 3 MichaelA
2615 : 08               [ 3]>            php         ;save flags
14942
2616 : 08               [ 3]>            php
14943
2617 : c97e             [ 2]>            cmp #$7e     ;test result
14944 2 MichaelA
                            >            trap_ne
14945 3 MichaelA
2619 : f002             [ 3]>        beq skip2219
14946
                            >        trap           ;failed equal (zero)
14947
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14948
261b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14949
261c : 1c                   >        db      test_num
14950 2 MichaelA
                            >
14951 3 MichaelA
261d :                      >skip2219
14952
                            >
14953
261d : 68               [ 4]>            pla         ;load status
14954 2 MichaelA
                            >            cmp_flag ~fzc
14955 3 MichaelA
261e : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
14956 2 MichaelA
                            >
14957
                            >            trap_ne
14958 3 MichaelA
2620 : f002             [ 3]>        beq skip2222
14959
                            >        trap           ;failed equal (zero)
14960
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14961
2622 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14962
2623 : 1c                   >        db      test_num
14963 2 MichaelA
                            >
14964 3 MichaelA
2624 :                      >skip2222
14965
                            >
14966
2624 : 28               [ 4]>            plp         ;restore status
14967 2 MichaelA
 
14968
 
14969
                                     set_a $80,0
14970
                            >            load_flag 0
14971 3 MichaelA
2625 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
14972 2 MichaelA
                            >
14973 3 MichaelA
2627 : 48               [ 3]>            pha         ;use stack to load status
14974
2628 : a980             [ 2]>            lda #$80     ;precharge accu
14975
262a : 28               [ 4]>            plp
14976 2 MichaelA
 
14977 3 MichaelA
262b : d1ca             [ 5]         cmp (ind1),y
14978 2 MichaelA
                                     tst_a $80,fc
14979 3 MichaelA
262d : 08               [ 3]>            php         ;save flags
14980
262e : 08               [ 3]>            php
14981
262f : c980             [ 2]>            cmp #$80     ;test result
14982 2 MichaelA
                            >            trap_ne
14983 3 MichaelA
2631 : f002             [ 3]>        beq skip2227
14984
                            >        trap           ;failed equal (zero)
14985
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
14986
2633 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
14987
2634 : 1c                   >        db      test_num
14988 2 MichaelA
                            >
14989 3 MichaelA
2635 :                      >skip2227
14990
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  260
14991
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
14992
 
14993
                            >
14994
2635 : 68               [ 4]>            pla         ;load status
14995 2 MichaelA
                            >            cmp_flag fc
14996 3 MichaelA
2636 : c931             [ 2]>            cmp #(fc|fao)&m8    ;expected flags + always on bits
14997 2 MichaelA
                            >
14998
                            >            trap_ne
14999 3 MichaelA
2638 : f002             [ 3]>        beq skip2230
15000
                            >        trap           ;failed equal (zero)
15001
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15002
263a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15003
263b : 1c                   >        db      test_num
15004 2 MichaelA
                            >
15005 3 MichaelA
263c :                      >skip2230
15006
                            >
15007
263c : 28               [ 4]>            plp         ;restore status
15008 2 MichaelA
 
15009
                                     set_a $7f,0
15010
                            >            load_flag 0
15011 3 MichaelA
263d : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
15012 2 MichaelA
                            >
15013 3 MichaelA
263f : 48               [ 3]>            pha         ;use stack to load status
15014
2640 : a97f             [ 2]>            lda #$7f     ;precharge accu
15015
2642 : 28               [ 4]>            plp
15016 2 MichaelA
 
15017 3 MichaelA
2643 : d1ca             [ 5]         cmp (ind1),y
15018 2 MichaelA
                                     tst_a $7f,fzc
15019 3 MichaelA
2645 : 08               [ 3]>            php         ;save flags
15020
2646 : 08               [ 3]>            php
15021
2647 : c97f             [ 2]>            cmp #$7f     ;test result
15022 2 MichaelA
                            >            trap_ne
15023 3 MichaelA
2649 : f002             [ 3]>        beq skip2235
15024
                            >        trap           ;failed equal (zero)
15025
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15026
264b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15027
264c : 1c                   >        db      test_num
15028 2 MichaelA
                            >
15029 3 MichaelA
264d :                      >skip2235
15030
                            >
15031
264d : 68               [ 4]>            pla         ;load status
15032 2 MichaelA
                            >            cmp_flag fzc
15033 3 MichaelA
264e : c933             [ 2]>            cmp #(fzc|fao)&m8    ;expected flags + always on bits
15034 2 MichaelA
                            >
15035
                            >            trap_ne
15036 3 MichaelA
2650 : f002             [ 3]>        beq skip2238
15037
                            >        trap           ;failed equal (zero)
15038
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15039
2652 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15040
2653 : 1c                   >        db      test_num
15041 2 MichaelA
                            >
15042 3 MichaelA
2654 :                      >skip2238
15043
                            >
15044
2654 : 28               [ 4]>            plp         ;restore status
15045 2 MichaelA
 
15046
                                     set_a $7e,0
15047
                            >            load_flag 0
15048 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  261
15049
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15050
 
15051
2655 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
15052 2 MichaelA
                            >
15053 3 MichaelA
2657 : 48               [ 3]>            pha         ;use stack to load status
15054
2658 : a97e             [ 2]>            lda #$7e     ;precharge accu
15055
265a : 28               [ 4]>            plp
15056 2 MichaelA
 
15057 3 MichaelA
265b : d1ca             [ 5]         cmp (ind1),y
15058 2 MichaelA
                                     tst_a $7e,fn
15059 3 MichaelA
265d : 08               [ 3]>            php         ;save flags
15060
265e : 08               [ 3]>            php
15061
265f : c97e             [ 2]>            cmp #$7e     ;test result
15062 2 MichaelA
                            >            trap_ne
15063 3 MichaelA
2661 : f002             [ 3]>        beq skip2243
15064
                            >        trap           ;failed equal (zero)
15065
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15066
2663 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15067
2664 : 1c                   >        db      test_num
15068 2 MichaelA
                            >
15069 3 MichaelA
2665 :                      >skip2243
15070
                            >
15071
2665 : 68               [ 4]>            pla         ;load status
15072 2 MichaelA
                            >            cmp_flag fn
15073 3 MichaelA
2666 : c9b0             [ 2]>            cmp #(fn|fao)&m8    ;expected flags + always on bits
15074 2 MichaelA
                            >
15075
                            >            trap_ne
15076 3 MichaelA
2668 : f002             [ 3]>        beq skip2246
15077
                            >        trap           ;failed equal (zero)
15078
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15079
266a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15080
266b : 1c                   >        db      test_num
15081 2 MichaelA
                            >
15082 3 MichaelA
266c :                      >skip2246
15083
                            >
15084
266c : 28               [ 4]>            plp         ;restore status
15085 2 MichaelA
 
15086
                                     set_a $80,$ff
15087
                            >            load_flag $ff
15088 3 MichaelA
266d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
15089 2 MichaelA
                            >
15090 3 MichaelA
266f : 48               [ 3]>            pha         ;use stack to load status
15091
2670 : a980             [ 2]>            lda #$80     ;precharge accu
15092
2672 : 28               [ 4]>            plp
15093 2 MichaelA
 
15094 3 MichaelA
2673 : d1ca             [ 5]         cmp (ind1),y
15095 2 MichaelA
                                     tst_a $80,~fnz
15096 3 MichaelA
2675 : 08               [ 3]>            php         ;save flags
15097
2676 : 08               [ 3]>            php
15098
2677 : c980             [ 2]>            cmp #$80     ;test result
15099
                            >            trap_ne
15100
2679 : f002             [ 3]>        beq skip2251
15101
                            >        trap           ;failed equal (zero)
15102
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15103
267b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15104
267c : 1c                   >        db      test_num
15105
                            >
15106
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  262
15107 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15108
 
15109 3 MichaelA
267d :                      >skip2251
15110 2 MichaelA
                            >
15111 3 MichaelA
267d : 68               [ 4]>            pla         ;load status
15112 2 MichaelA
                            >            cmp_flag ~fnz
15113 3 MichaelA
267e : c97d             [ 2]>            cmp #(~fnz|fao)&m8    ;expected flags + always on bits
15114 2 MichaelA
                            >
15115
                            >            trap_ne
15116 3 MichaelA
2680 : f002             [ 3]>        beq skip2254
15117
                            >        trap           ;failed equal (zero)
15118
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15119
2682 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15120
2683 : 1c                   >        db      test_num
15121 2 MichaelA
                            >
15122 3 MichaelA
2684 :                      >skip2254
15123
                            >
15124
2684 : 28               [ 4]>            plp         ;restore status
15125 2 MichaelA
 
15126
                                     set_a $7f,$ff
15127
                            >            load_flag $ff
15128 3 MichaelA
2685 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
15129 2 MichaelA
                            >
15130 3 MichaelA
2687 : 48               [ 3]>            pha         ;use stack to load status
15131
2688 : a97f             [ 2]>            lda #$7f     ;precharge accu
15132
268a : 28               [ 4]>            plp
15133 2 MichaelA
 
15134 3 MichaelA
268b : d1ca             [ 5]         cmp (ind1),y
15135 2 MichaelA
                                     tst_a $7f,~fn
15136 3 MichaelA
268d : 08               [ 3]>            php         ;save flags
15137
268e : 08               [ 3]>            php
15138
268f : c97f             [ 2]>            cmp #$7f     ;test result
15139 2 MichaelA
                            >            trap_ne
15140 3 MichaelA
2691 : f002             [ 3]>        beq skip2259
15141
                            >        trap           ;failed equal (zero)
15142
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15143
2693 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15144
2694 : 1c                   >        db      test_num
15145 2 MichaelA
                            >
15146 3 MichaelA
2695 :                      >skip2259
15147
                            >
15148
2695 : 68               [ 4]>            pla         ;load status
15149 2 MichaelA
                            >            cmp_flag ~fn
15150 3 MichaelA
2696 : c97f             [ 2]>            cmp #(~fn|fao)&m8    ;expected flags + always on bits
15151 2 MichaelA
                            >
15152
                            >            trap_ne
15153 3 MichaelA
2698 : f002             [ 3]>        beq skip2262
15154
                            >        trap           ;failed equal (zero)
15155
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15156
269a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15157
269b : 1c                   >        db      test_num
15158 2 MichaelA
                            >
15159 3 MichaelA
269c :                      >skip2262
15160
                            >
15161
269c : 28               [ 4]>            plp         ;restore status
15162 2 MichaelA
 
15163
                                     set_a $7e,$ff
15164 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  263
15165
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15166
 
15167 2 MichaelA
                            >            load_flag $ff
15168 3 MichaelA
269d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
15169 2 MichaelA
                            >
15170 3 MichaelA
269f : 48               [ 3]>            pha         ;use stack to load status
15171
26a0 : a97e             [ 2]>            lda #$7e     ;precharge accu
15172
26a2 : 28               [ 4]>            plp
15173 2 MichaelA
 
15174 3 MichaelA
26a3 : d1ca             [ 5]         cmp (ind1),y
15175 2 MichaelA
                                     tst_a $7e,~fzc
15176 3 MichaelA
26a5 : 08               [ 3]>            php         ;save flags
15177
26a6 : 08               [ 3]>            php
15178
26a7 : c97e             [ 2]>            cmp #$7e     ;test result
15179 2 MichaelA
                            >            trap_ne
15180 3 MichaelA
26a9 : f002             [ 3]>        beq skip2267
15181
                            >        trap           ;failed equal (zero)
15182
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15183
26ab : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15184
26ac : 1c                   >        db      test_num
15185 2 MichaelA
                            >
15186 3 MichaelA
26ad :                      >skip2267
15187
                            >
15188
26ad : 68               [ 4]>            pla         ;load status
15189 2 MichaelA
                            >            cmp_flag ~fzc
15190 3 MichaelA
26ae : c9fc             [ 2]>            cmp #(~fzc|fao)&m8    ;expected flags + always on bits
15191 2 MichaelA
                            >
15192
                            >            trap_ne
15193 3 MichaelA
26b0 : f002             [ 3]>        beq skip2270
15194
                            >        trap           ;failed equal (zero)
15195
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15196
26b2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15197
26b3 : 1c                   >        db      test_num
15198 2 MichaelA
                            >
15199 3 MichaelA
26b4 :                      >skip2270
15200
                            >
15201
26b4 : 28               [ 4]>            plp         ;restore status
15202 2 MichaelA
 
15203
                                     next_test
15204 3 MichaelA
26b5 : ad0002           [ 4]>            lda test_case   ;previous test
15205
26b8 : c91c             [ 2]>            cmp #test_num
15206 2 MichaelA
                            >            trap_ne         ;test is out of sequence
15207 3 MichaelA
26ba : f002             [ 3]>        beq skip2273
15208
                            >        trap           ;failed equal (zero)
15209
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15210
26bc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15211
26bd : 1c                   >        db      test_num
15212 2 MichaelA
                            >
15213 3 MichaelA
26be :                      >skip2273
15214
                            >
15215 2 MichaelA
001d =                      >test_num = test_num + 1
15216 3 MichaelA
26be : a91d             [ 2]>            lda #test_num   ;*** this tests' number
15217
26c0 : 8d0002           [ 4]>            sta test_case
15218 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
15219
 
15220
 
15221
                             ; testing shifts - ASL LSR ROL ROR all addressing modes
15222 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  264
15223
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15224
 
15225 2 MichaelA
                             ; shifts - accumulator
15226 3 MichaelA
 
15227
26c3 : a203             [ 2]         ldx #3
15228
26c5 :                       tasl
15229 2 MichaelA
                                     set_ax zp1,0
15230
                            >            load_flag 0
15231 3 MichaelA
26c5 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
15232 2 MichaelA
                            >
15233 3 MichaelA
26c7 : 48               [ 3]>            pha         ;use stack to load status
15234
26c8 : b5b9             [ 4]>            lda zp1,x    ;precharge accu
15235
26ca : 28               [ 4]>            plp
15236 2 MichaelA
 
15237 3 MichaelA
26cb : 0a               [ 2]         asl a
15238 2 MichaelA
                                     tst_ax rASL,fASL,0
15239 3 MichaelA
26cc : 08               [ 3]>            php         ;save flags
15240
26cd : dd1102           [ 4]>            cmp rASL,x    ;test result
15241 2 MichaelA
                            >            trap_ne
15242 3 MichaelA
26d0 : f002             [ 3]>        beq skip2278
15243
                            >        trap           ;failed equal (zero)
15244
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15245
26d2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15246
26d3 : 1d                   >        db      test_num
15247 2 MichaelA
                            >
15248 3 MichaelA
26d4 :                      >skip2278
15249
                            >
15250
26d4 : 68               [ 4]>            pla         ;load status
15251 2 MichaelA
                            >            eor_flag 0
15252 3 MichaelA
26d5 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
15253 2 MichaelA
                            >
15254 3 MichaelA
26d7 : dd2102           [ 4]>            cmp fASL,x    ;test flags
15255 2 MichaelA
                            >            trap_ne     ;
15256 3 MichaelA
26da : f002             [ 3]>        beq skip2281
15257
                            >        trap           ;failed equal (zero)
15258
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15259
26dc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15260
26dd : 1d                   >        db      test_num
15261 2 MichaelA
                            >
15262 3 MichaelA
26de :                      >skip2281
15263
                            >
15264 2 MichaelA
 
15265 3 MichaelA
26de : ca               [ 2]         dex
15266
26df : 10e4             [ 3]         bpl tasl
15267
26e1 : a203             [ 2]         ldx #3
15268
26e3 :                       tasl1
15269 2 MichaelA
                                     set_ax zp1,$ff
15270
                            >            load_flag $ff
15271 3 MichaelA
26e3 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
15272 2 MichaelA
                            >
15273 3 MichaelA
26e5 : 48               [ 3]>            pha         ;use stack to load status
15274
26e6 : b5b9             [ 4]>            lda zp1,x    ;precharge accu
15275
26e8 : 28               [ 4]>            plp
15276 2 MichaelA
 
15277 3 MichaelA
26e9 : 0a               [ 2]         asl a
15278 2 MichaelA
                                     tst_ax rASL,fASL,$ff-fnzc
15279 3 MichaelA
26ea : 08               [ 3]>            php         ;save flags
15280
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  265
15281
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15282
 
15283
26eb : dd1102           [ 4]>            cmp rASL,x    ;test result
15284 2 MichaelA
                            >            trap_ne
15285 3 MichaelA
26ee : f002             [ 3]>        beq skip2286
15286
                            >        trap           ;failed equal (zero)
15287
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15288
26f0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15289
26f1 : 1d                   >        db      test_num
15290 2 MichaelA
                            >
15291 3 MichaelA
26f2 :                      >skip2286
15292
                            >
15293
26f2 : 68               [ 4]>            pla         ;load status
15294 2 MichaelA
                            >            eor_flag $ff-fnzc
15295 3 MichaelA
26f3 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
15296 2 MichaelA
                            >
15297 3 MichaelA
26f5 : dd2102           [ 4]>            cmp fASL,x    ;test flags
15298 2 MichaelA
                            >            trap_ne     ;
15299 3 MichaelA
26f8 : f002             [ 3]>        beq skip2289
15300
                            >        trap           ;failed equal (zero)
15301
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15302
26fa : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15303
26fb : 1d                   >        db      test_num
15304 2 MichaelA
                            >
15305 3 MichaelA
26fc :                      >skip2289
15306
                            >
15307 2 MichaelA
 
15308 3 MichaelA
26fc : ca               [ 2]         dex
15309
26fd : 10e4             [ 3]         bpl tasl1
15310 2 MichaelA
 
15311 3 MichaelA
26ff : a203             [ 2]         ldx #3
15312
2701 :                       tlsr
15313 2 MichaelA
                                     set_ax zp1,0
15314
                            >            load_flag 0
15315 3 MichaelA
2701 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
15316 2 MichaelA
                            >
15317 3 MichaelA
2703 : 48               [ 3]>            pha         ;use stack to load status
15318
2704 : b5b9             [ 4]>            lda zp1,x    ;precharge accu
15319
2706 : 28               [ 4]>            plp
15320 2 MichaelA
 
15321 3 MichaelA
2707 : 4a               [ 2]         lsr a
15322 2 MichaelA
                                     tst_ax rLSR,fLSR,0
15323 3 MichaelA
2708 : 08               [ 3]>            php         ;save flags
15324
2709 : dd1902           [ 4]>            cmp rLSR,x    ;test result
15325 2 MichaelA
                            >            trap_ne
15326 3 MichaelA
270c : f002             [ 3]>        beq skip2294
15327
                            >        trap           ;failed equal (zero)
15328
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15329
270e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15330
270f : 1d                   >        db      test_num
15331 2 MichaelA
                            >
15332 3 MichaelA
2710 :                      >skip2294
15333
                            >
15334
2710 : 68               [ 4]>            pla         ;load status
15335 2 MichaelA
                            >            eor_flag 0
15336 3 MichaelA
2711 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
15337 2 MichaelA
                            >
15338 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  266
15339
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15340
 
15341
2713 : dd2902           [ 4]>            cmp fLSR,x    ;test flags
15342 2 MichaelA
                            >            trap_ne     ;
15343 3 MichaelA
2716 : f002             [ 3]>        beq skip2297
15344
                            >        trap           ;failed equal (zero)
15345
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15346
2718 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15347
2719 : 1d                   >        db      test_num
15348 2 MichaelA
                            >
15349 3 MichaelA
271a :                      >skip2297
15350
                            >
15351 2 MichaelA
 
15352 3 MichaelA
271a : ca               [ 2]         dex
15353
271b : 10e4             [ 3]         bpl tlsr
15354
271d : a203             [ 2]         ldx #3
15355
271f :                       tlsr1
15356 2 MichaelA
                                     set_ax zp1,$ff
15357
                            >            load_flag $ff
15358 3 MichaelA
271f : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
15359 2 MichaelA
                            >
15360 3 MichaelA
2721 : 48               [ 3]>            pha         ;use stack to load status
15361
2722 : b5b9             [ 4]>            lda zp1,x    ;precharge accu
15362
2724 : 28               [ 4]>            plp
15363 2 MichaelA
 
15364 3 MichaelA
2725 : 4a               [ 2]         lsr a
15365 2 MichaelA
                                     tst_ax rLSR,fLSR,$ff-fnzc
15366 3 MichaelA
2726 : 08               [ 3]>            php         ;save flags
15367
2727 : dd1902           [ 4]>            cmp rLSR,x    ;test result
15368 2 MichaelA
                            >            trap_ne
15369 3 MichaelA
272a : f002             [ 3]>        beq skip2302
15370
                            >        trap           ;failed equal (zero)
15371
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15372
272c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15373
272d : 1d                   >        db      test_num
15374 2 MichaelA
                            >
15375 3 MichaelA
272e :                      >skip2302
15376
                            >
15377
272e : 68               [ 4]>            pla         ;load status
15378 2 MichaelA
                            >            eor_flag $ff-fnzc
15379 3 MichaelA
272f : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
15380 2 MichaelA
                            >
15381 3 MichaelA
2731 : dd2902           [ 4]>            cmp fLSR,x    ;test flags
15382 2 MichaelA
                            >            trap_ne     ;
15383 3 MichaelA
2734 : f002             [ 3]>        beq skip2305
15384
                            >        trap           ;failed equal (zero)
15385
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15386
2736 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15387
2737 : 1d                   >        db      test_num
15388 2 MichaelA
                            >
15389 3 MichaelA
2738 :                      >skip2305
15390
                            >
15391 2 MichaelA
 
15392 3 MichaelA
2738 : ca               [ 2]         dex
15393
2739 : 10e4             [ 3]         bpl tlsr1
15394 2 MichaelA
 
15395 3 MichaelA
273b : a203             [ 2]         ldx #3
15396
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  267
15397
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15398
 
15399
273d :                       trol
15400 2 MichaelA
                                     set_ax zp1,0
15401
                            >            load_flag 0
15402 3 MichaelA
273d : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
15403 2 MichaelA
                            >
15404 3 MichaelA
273f : 48               [ 3]>            pha         ;use stack to load status
15405
2740 : b5b9             [ 4]>            lda zp1,x    ;precharge accu
15406
2742 : 28               [ 4]>            plp
15407 2 MichaelA
 
15408 3 MichaelA
2743 : 2a               [ 2]         rol a
15409 2 MichaelA
                                     tst_ax rROL,fROL,0
15410 3 MichaelA
2744 : 08               [ 3]>            php         ;save flags
15411
2745 : dd1102           [ 4]>            cmp rROL,x    ;test result
15412 2 MichaelA
                            >            trap_ne
15413 3 MichaelA
2748 : f002             [ 3]>        beq skip2310
15414
                            >        trap           ;failed equal (zero)
15415
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15416
274a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15417
274b : 1d                   >        db      test_num
15418 2 MichaelA
                            >
15419 3 MichaelA
274c :                      >skip2310
15420
                            >
15421
274c : 68               [ 4]>            pla         ;load status
15422 2 MichaelA
                            >            eor_flag 0
15423 3 MichaelA
274d : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
15424 2 MichaelA
                            >
15425 3 MichaelA
274f : dd2102           [ 4]>            cmp fROL,x    ;test flags
15426 2 MichaelA
                            >            trap_ne     ;
15427 3 MichaelA
2752 : f002             [ 3]>        beq skip2313
15428
                            >        trap           ;failed equal (zero)
15429
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15430
2754 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15431
2755 : 1d                   >        db      test_num
15432 2 MichaelA
                            >
15433 3 MichaelA
2756 :                      >skip2313
15434
                            >
15435 2 MichaelA
 
15436 3 MichaelA
2756 : ca               [ 2]         dex
15437
2757 : 10e4             [ 3]         bpl trol
15438
2759 : a203             [ 2]         ldx #3
15439
275b :                       trol1
15440 2 MichaelA
                                     set_ax zp1,$ff-fc
15441
                            >            load_flag $ff-fc
15442 3 MichaelA
275b : a9fe             [ 2]>            lda #$ff-fc             ;allow test to change I-flag (no mask)
15443 2 MichaelA
                            >
15444 3 MichaelA
275d : 48               [ 3]>            pha         ;use stack to load status
15445
275e : b5b9             [ 4]>            lda zp1,x    ;precharge accu
15446
2760 : 28               [ 4]>            plp
15447 2 MichaelA
 
15448 3 MichaelA
2761 : 2a               [ 2]         rol a
15449 2 MichaelA
                                     tst_ax rROL,fROL,$ff-fnzc
15450 3 MichaelA
2762 : 08               [ 3]>            php         ;save flags
15451
2763 : dd1102           [ 4]>            cmp rROL,x    ;test result
15452 2 MichaelA
                            >            trap_ne
15453 3 MichaelA
2766 : f002             [ 3]>        beq skip2318
15454
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  268
15455
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15456
 
15457
                            >        trap           ;failed equal (zero)
15458
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15459
2768 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15460
2769 : 1d                   >        db      test_num
15461 2 MichaelA
                            >
15462 3 MichaelA
276a :                      >skip2318
15463
                            >
15464
276a : 68               [ 4]>            pla         ;load status
15465 2 MichaelA
                            >            eor_flag $ff-fnzc
15466 3 MichaelA
276b : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
15467 2 MichaelA
                            >
15468 3 MichaelA
276d : dd2102           [ 4]>            cmp fROL,x    ;test flags
15469 2 MichaelA
                            >            trap_ne     ;
15470 3 MichaelA
2770 : f002             [ 3]>        beq skip2321
15471
                            >        trap           ;failed equal (zero)
15472
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15473
2772 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15474
2773 : 1d                   >        db      test_num
15475 2 MichaelA
                            >
15476 3 MichaelA
2774 :                      >skip2321
15477
                            >
15478 2 MichaelA
 
15479 3 MichaelA
2774 : ca               [ 2]         dex
15480
2775 : 10e4             [ 3]         bpl trol1
15481 2 MichaelA
 
15482 3 MichaelA
2777 : a203             [ 2]         ldx #3
15483
2779 :                       trolc
15484 2 MichaelA
                                     set_ax zp1,fc
15485
                            >            load_flag fc
15486 3 MichaelA
2779 : a901             [ 2]>            lda #fc             ;allow test to change I-flag (no mask)
15487 2 MichaelA
                            >
15488 3 MichaelA
277b : 48               [ 3]>            pha         ;use stack to load status
15489
277c : b5b9             [ 4]>            lda zp1,x    ;precharge accu
15490
277e : 28               [ 4]>            plp
15491 2 MichaelA
 
15492 3 MichaelA
277f : 2a               [ 2]         rol a
15493 2 MichaelA
                                     tst_ax rROLc,fROLc,0
15494 3 MichaelA
2780 : 08               [ 3]>            php         ;save flags
15495
2781 : dd1502           [ 4]>            cmp rROLc,x    ;test result
15496 2 MichaelA
                            >            trap_ne
15497 3 MichaelA
2784 : f002             [ 3]>        beq skip2326
15498
                            >        trap           ;failed equal (zero)
15499
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15500
2786 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15501
2787 : 1d                   >        db      test_num
15502 2 MichaelA
                            >
15503 3 MichaelA
2788 :                      >skip2326
15504
                            >
15505
2788 : 68               [ 4]>            pla         ;load status
15506 2 MichaelA
                            >            eor_flag 0
15507 3 MichaelA
2789 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
15508 2 MichaelA
                            >
15509 3 MichaelA
278b : dd2502           [ 4]>            cmp fROLc,x    ;test flags
15510 2 MichaelA
                            >            trap_ne     ;
15511 3 MichaelA
278e : f002             [ 3]>        beq skip2329
15512
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  269
15513
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15514
 
15515
                            >        trap           ;failed equal (zero)
15516
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15517
2790 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15518
2791 : 1d                   >        db      test_num
15519 2 MichaelA
                            >
15520 3 MichaelA
2792 :                      >skip2329
15521
                            >
15522 2 MichaelA
 
15523 3 MichaelA
2792 : ca               [ 2]         dex
15524
2793 : 10e4             [ 3]         bpl trolc
15525
2795 : a203             [ 2]         ldx #3
15526
2797 :                       trolc1
15527 2 MichaelA
                                     set_ax zp1,$ff
15528
                            >            load_flag $ff
15529 3 MichaelA
2797 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
15530 2 MichaelA
                            >
15531 3 MichaelA
2799 : 48               [ 3]>            pha         ;use stack to load status
15532
279a : b5b9             [ 4]>            lda zp1,x    ;precharge accu
15533
279c : 28               [ 4]>            plp
15534 2 MichaelA
 
15535 3 MichaelA
279d : 2a               [ 2]         rol a
15536 2 MichaelA
                                     tst_ax rROLc,fROLc,$ff-fnzc
15537 3 MichaelA
279e : 08               [ 3]>            php         ;save flags
15538
279f : dd1502           [ 4]>            cmp rROLc,x    ;test result
15539 2 MichaelA
                            >            trap_ne
15540 3 MichaelA
27a2 : f002             [ 3]>        beq skip2334
15541
                            >        trap           ;failed equal (zero)
15542
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15543
27a4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15544
27a5 : 1d                   >        db      test_num
15545 2 MichaelA
                            >
15546 3 MichaelA
27a6 :                      >skip2334
15547
                            >
15548
27a6 : 68               [ 4]>            pla         ;load status
15549 2 MichaelA
                            >            eor_flag $ff-fnzc
15550 3 MichaelA
27a7 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
15551 2 MichaelA
                            >
15552 3 MichaelA
27a9 : dd2502           [ 4]>            cmp fROLc,x    ;test flags
15553 2 MichaelA
                            >            trap_ne     ;
15554 3 MichaelA
27ac : f002             [ 3]>        beq skip2337
15555
                            >        trap           ;failed equal (zero)
15556
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15557
27ae : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15558
27af : 1d                   >        db      test_num
15559 2 MichaelA
                            >
15560 3 MichaelA
27b0 :                      >skip2337
15561
                            >
15562 2 MichaelA
 
15563 3 MichaelA
27b0 : ca               [ 2]         dex
15564
27b1 : 10e4             [ 3]         bpl trolc1
15565 2 MichaelA
 
15566 3 MichaelA
27b3 : a203             [ 2]         ldx #3
15567
27b5 :                       tror
15568 2 MichaelA
                                     set_ax zp1,0
15569
                            >            load_flag 0
15570 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  270
15571
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15572
 
15573
27b5 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
15574 2 MichaelA
                            >
15575 3 MichaelA
27b7 : 48               [ 3]>            pha         ;use stack to load status
15576
27b8 : b5b9             [ 4]>            lda zp1,x    ;precharge accu
15577
27ba : 28               [ 4]>            plp
15578 2 MichaelA
 
15579 3 MichaelA
27bb : 6a               [ 2]         ror a
15580 2 MichaelA
                                     tst_ax rROR,fROR,0
15581 3 MichaelA
27bc : 08               [ 3]>            php         ;save flags
15582
27bd : dd1902           [ 4]>            cmp rROR,x    ;test result
15583 2 MichaelA
                            >            trap_ne
15584 3 MichaelA
27c0 : f002             [ 3]>        beq skip2342
15585
                            >        trap           ;failed equal (zero)
15586
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15587
27c2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15588
27c3 : 1d                   >        db      test_num
15589 2 MichaelA
                            >
15590 3 MichaelA
27c4 :                      >skip2342
15591
                            >
15592
27c4 : 68               [ 4]>            pla         ;load status
15593 2 MichaelA
                            >            eor_flag 0
15594 3 MichaelA
27c5 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
15595 2 MichaelA
                            >
15596 3 MichaelA
27c7 : dd2902           [ 4]>            cmp fROR,x    ;test flags
15597 2 MichaelA
                            >            trap_ne     ;
15598 3 MichaelA
27ca : f002             [ 3]>        beq skip2345
15599
                            >        trap           ;failed equal (zero)
15600
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15601
27cc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15602
27cd : 1d                   >        db      test_num
15603 2 MichaelA
                            >
15604 3 MichaelA
27ce :                      >skip2345
15605
                            >
15606 2 MichaelA
 
15607 3 MichaelA
27ce : ca               [ 2]         dex
15608
27cf : 10e4             [ 3]         bpl tror
15609
27d1 : a203             [ 2]         ldx #3
15610
27d3 :                       tror1
15611 2 MichaelA
                                     set_ax zp1,$ff-fc
15612
                            >            load_flag $ff-fc
15613 3 MichaelA
27d3 : a9fe             [ 2]>            lda #$ff-fc             ;allow test to change I-flag (no mask)
15614 2 MichaelA
                            >
15615 3 MichaelA
27d5 : 48               [ 3]>            pha         ;use stack to load status
15616
27d6 : b5b9             [ 4]>            lda zp1,x    ;precharge accu
15617
27d8 : 28               [ 4]>            plp
15618 2 MichaelA
 
15619 3 MichaelA
27d9 : 6a               [ 2]         ror a
15620 2 MichaelA
                                     tst_ax rROR,fROR,$ff-fnzc
15621 3 MichaelA
27da : 08               [ 3]>            php         ;save flags
15622
27db : dd1902           [ 4]>            cmp rROR,x    ;test result
15623 2 MichaelA
                            >            trap_ne
15624 3 MichaelA
27de : f002             [ 3]>        beq skip2350
15625
                            >        trap           ;failed equal (zero)
15626
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15627
27e0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15628
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  271
15629
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15630
 
15631
27e1 : 1d                   >        db      test_num
15632 2 MichaelA
                            >
15633 3 MichaelA
27e2 :                      >skip2350
15634
                            >
15635
27e2 : 68               [ 4]>            pla         ;load status
15636 2 MichaelA
                            >            eor_flag $ff-fnzc
15637 3 MichaelA
27e3 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
15638 2 MichaelA
                            >
15639 3 MichaelA
27e5 : dd2902           [ 4]>            cmp fROR,x    ;test flags
15640 2 MichaelA
                            >            trap_ne     ;
15641 3 MichaelA
27e8 : f002             [ 3]>        beq skip2353
15642
                            >        trap           ;failed equal (zero)
15643
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15644
27ea : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15645
27eb : 1d                   >        db      test_num
15646 2 MichaelA
                            >
15647 3 MichaelA
27ec :                      >skip2353
15648
                            >
15649 2 MichaelA
 
15650 3 MichaelA
27ec : ca               [ 2]         dex
15651
27ed : 10e4             [ 3]         bpl tror1
15652 2 MichaelA
 
15653 3 MichaelA
27ef : a203             [ 2]         ldx #3
15654
27f1 :                       trorc
15655 2 MichaelA
                                     set_ax zp1,fc
15656
                            >            load_flag fc
15657 3 MichaelA
27f1 : a901             [ 2]>            lda #fc             ;allow test to change I-flag (no mask)
15658 2 MichaelA
                            >
15659 3 MichaelA
27f3 : 48               [ 3]>            pha         ;use stack to load status
15660
27f4 : b5b9             [ 4]>            lda zp1,x    ;precharge accu
15661
27f6 : 28               [ 4]>            plp
15662 2 MichaelA
 
15663 3 MichaelA
27f7 : 6a               [ 2]         ror a
15664 2 MichaelA
                                     tst_ax rRORc,fRORc,0
15665 3 MichaelA
27f8 : 08               [ 3]>            php         ;save flags
15666
27f9 : dd1d02           [ 4]>            cmp rRORc,x    ;test result
15667 2 MichaelA
                            >            trap_ne
15668 3 MichaelA
27fc : f002             [ 4]>        beq skip2358
15669
                            >        trap           ;failed equal (zero)
15670
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15671
27fe : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15672
27ff : 1d                   >        db      test_num
15673 2 MichaelA
                            >
15674 3 MichaelA
2800 :                      >skip2358
15675
                            >
15676
2800 : 68               [ 4]>            pla         ;load status
15677 2 MichaelA
                            >            eor_flag 0
15678 3 MichaelA
2801 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
15679 2 MichaelA
                            >
15680 3 MichaelA
2803 : dd2d02           [ 4]>            cmp fRORc,x    ;test flags
15681
                            >            trap_ne     ;
15682
2806 : f002             [ 3]>        beq skip2361
15683
                            >        trap           ;failed equal (zero)
15684
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15685
2808 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15686
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  272
15687 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15688
 
15689 3 MichaelA
2809 : 1d                   >        db      test_num
15690 2 MichaelA
                            >
15691 3 MichaelA
280a :                      >skip2361
15692
                            >
15693 2 MichaelA
 
15694 3 MichaelA
280a : ca               [ 2]         dex
15695
280b : 10e4             [ 4]         bpl trorc
15696
280d : a203             [ 2]         ldx #3
15697
280f :                       trorc1
15698 2 MichaelA
                                     set_ax zp1,$ff
15699
                            >            load_flag $ff
15700 3 MichaelA
280f : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
15701 2 MichaelA
                            >
15702 3 MichaelA
2811 : 48               [ 3]>            pha         ;use stack to load status
15703
2812 : b5b9             [ 4]>            lda zp1,x    ;precharge accu
15704
2814 : 28               [ 4]>            plp
15705 2 MichaelA
 
15706 3 MichaelA
2815 : 6a               [ 2]         ror a
15707 2 MichaelA
                                     tst_ax rRORc,fRORc,$ff-fnzc
15708 3 MichaelA
2816 : 08               [ 3]>            php         ;save flags
15709
2817 : dd1d02           [ 4]>            cmp rRORc,x    ;test result
15710 2 MichaelA
                            >            trap_ne
15711 3 MichaelA
281a : f002             [ 3]>        beq skip2366
15712
                            >        trap           ;failed equal (zero)
15713
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15714
281c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15715
281d : 1d                   >        db      test_num
15716 2 MichaelA
                            >
15717 3 MichaelA
281e :                      >skip2366
15718
                            >
15719
281e : 68               [ 4]>            pla         ;load status
15720 2 MichaelA
                            >            eor_flag $ff-fnzc
15721 3 MichaelA
281f : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
15722 2 MichaelA
                            >
15723 3 MichaelA
2821 : dd2d02           [ 4]>            cmp fRORc,x    ;test flags
15724 2 MichaelA
                            >            trap_ne     ;
15725 3 MichaelA
2824 : f002             [ 3]>        beq skip2369
15726
                            >        trap           ;failed equal (zero)
15727
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15728
2826 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15729
2827 : 1d                   >        db      test_num
15730 2 MichaelA
                            >
15731 3 MichaelA
2828 :                      >skip2369
15732
                            >
15733 2 MichaelA
 
15734 3 MichaelA
2828 : ca               [ 2]         dex
15735
2829 : 10e4             [ 3]         bpl trorc1
15736 2 MichaelA
                                     next_test
15737 3 MichaelA
282b : ad0002           [ 4]>            lda test_case   ;previous test
15738
282e : c91d             [ 2]>            cmp #test_num
15739 2 MichaelA
                            >            trap_ne         ;test is out of sequence
15740 3 MichaelA
2830 : f002             [ 3]>        beq skip2372
15741
                            >        trap           ;failed equal (zero)
15742
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15743
2832 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15744
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  273
15745
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15746
 
15747
2833 : 1d                   >        db      test_num
15748 2 MichaelA
                            >
15749 3 MichaelA
2834 :                      >skip2372
15750
                            >
15751 2 MichaelA
001e =                      >test_num = test_num + 1
15752 3 MichaelA
2834 : a91e             [ 2]>            lda #test_num   ;*** this tests' number
15753
2836 : 8d0002           [ 4]>            sta test_case
15754 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
15755
 
15756
 
15757
                             ; shifts - zeropage
15758 3 MichaelA
 
15759
2839 : a203             [ 2]         ldx #3
15760
283b :                       tasl2
15761 2 MichaelA
                                     set_z zp1,0
15762
                            >            load_flag 0
15763 3 MichaelA
283b : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
15764 2 MichaelA
                            >
15765 3 MichaelA
283d : 48               [ 3]>            pha         ;use stack to load status
15766
283e : b5b9             [ 4]>            lda zp1,x    ;load to zeropage
15767
2840 : 85b2             [ 3]>            sta zpt
15768
2842 : 28               [ 4]>            plp
15769 2 MichaelA
 
15770 3 MichaelA
2843 : 06b2             [ 5]         asl zpt
15771 2 MichaelA
                                     tst_z rASL,fASL,0
15772 3 MichaelA
2845 : 08               [ 3]>            php         ;save flags
15773
2846 : a5b2             [ 3]>            lda zpt
15774
2848 : dd1102           [ 4]>            cmp rASL,x    ;test result
15775 2 MichaelA
                            >            trap_ne
15776 3 MichaelA
284b : f002             [ 3]>        beq skip2377
15777
                            >        trap           ;failed equal (zero)
15778
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15779
284d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15780
284e : 1e                   >        db      test_num
15781 2 MichaelA
                            >
15782 3 MichaelA
284f :                      >skip2377
15783
                            >
15784
284f : 68               [ 4]>            pla         ;load status
15785 2 MichaelA
                            >            eor_flag 0
15786 3 MichaelA
2850 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
15787 2 MichaelA
                            >
15788 3 MichaelA
2852 : dd2102           [ 4]>            cmp fASL,x    ;test flags
15789 2 MichaelA
                            >            trap_ne
15790 3 MichaelA
2855 : f002             [ 3]>        beq skip2380
15791
                            >        trap           ;failed equal (zero)
15792
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15793
2857 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15794
2858 : 1e                   >        db      test_num
15795 2 MichaelA
                            >
15796 3 MichaelA
2859 :                      >skip2380
15797
                            >
15798 2 MichaelA
 
15799 3 MichaelA
2859 : ca               [ 2]         dex
15800
285a : 10df             [ 3]         bpl tasl2
15801
285c : a203             [ 2]         ldx #3
15802
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  274
15803
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15804
 
15805
285e :                       tasl3
15806 2 MichaelA
                                     set_z zp1,$ff
15807
                            >            load_flag $ff
15808 3 MichaelA
285e : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
15809 2 MichaelA
                            >
15810 3 MichaelA
2860 : 48               [ 3]>            pha         ;use stack to load status
15811
2861 : b5b9             [ 4]>            lda zp1,x    ;load to zeropage
15812
2863 : 85b2             [ 3]>            sta zpt
15813
2865 : 28               [ 4]>            plp
15814 2 MichaelA
 
15815 3 MichaelA
2866 : 06b2             [ 5]         asl zpt
15816 2 MichaelA
                                     tst_z rASL,fASL,$ff-fnzc
15817 3 MichaelA
2868 : 08               [ 3]>            php         ;save flags
15818
2869 : a5b2             [ 3]>            lda zpt
15819
286b : dd1102           [ 4]>            cmp rASL,x    ;test result
15820 2 MichaelA
                            >            trap_ne
15821 3 MichaelA
286e : f002             [ 3]>        beq skip2385
15822
                            >        trap           ;failed equal (zero)
15823
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15824
2870 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15825
2871 : 1e                   >        db      test_num
15826 2 MichaelA
                            >
15827 3 MichaelA
2872 :                      >skip2385
15828
                            >
15829
2872 : 68               [ 4]>            pla         ;load status
15830 2 MichaelA
                            >            eor_flag $ff-fnzc
15831 3 MichaelA
2873 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
15832 2 MichaelA
                            >
15833 3 MichaelA
2875 : dd2102           [ 4]>            cmp fASL,x    ;test flags
15834 2 MichaelA
                            >            trap_ne
15835 3 MichaelA
2878 : f002             [ 3]>        beq skip2388
15836
                            >        trap           ;failed equal (zero)
15837
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15838
287a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15839
287b : 1e                   >        db      test_num
15840 2 MichaelA
                            >
15841 3 MichaelA
287c :                      >skip2388
15842
                            >
15843 2 MichaelA
 
15844 3 MichaelA
287c : ca               [ 2]         dex
15845
287d : 10df             [ 3]         bpl tasl3
15846 2 MichaelA
 
15847 3 MichaelA
287f : a203             [ 2]         ldx #3
15848
2881 :                       tlsr2
15849 2 MichaelA
                                     set_z zp1,0
15850
                            >            load_flag 0
15851 3 MichaelA
2881 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
15852 2 MichaelA
                            >
15853 3 MichaelA
2883 : 48               [ 3]>            pha         ;use stack to load status
15854
2884 : b5b9             [ 4]>            lda zp1,x    ;load to zeropage
15855
2886 : 85b2             [ 3]>            sta zpt
15856
2888 : 28               [ 4]>            plp
15857 2 MichaelA
 
15858 3 MichaelA
2889 : 46b2             [ 5]         lsr zpt
15859 2 MichaelA
                                     tst_z rLSR,fLSR,0
15860 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  275
15861
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15862
 
15863
288b : 08               [ 3]>            php         ;save flags
15864
288c : a5b2             [ 3]>            lda zpt
15865
288e : dd1902           [ 4]>            cmp rLSR,x    ;test result
15866 2 MichaelA
                            >            trap_ne
15867 3 MichaelA
2891 : f002             [ 3]>        beq skip2393
15868
                            >        trap           ;failed equal (zero)
15869
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15870
2893 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15871
2894 : 1e                   >        db      test_num
15872 2 MichaelA
                            >
15873 3 MichaelA
2895 :                      >skip2393
15874
                            >
15875
2895 : 68               [ 4]>            pla         ;load status
15876 2 MichaelA
                            >            eor_flag 0
15877 3 MichaelA
2896 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
15878 2 MichaelA
                            >
15879 3 MichaelA
2898 : dd2902           [ 4]>            cmp fLSR,x    ;test flags
15880 2 MichaelA
                            >            trap_ne
15881 3 MichaelA
289b : f002             [ 3]>        beq skip2396
15882
                            >        trap           ;failed equal (zero)
15883
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15884
289d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15885
289e : 1e                   >        db      test_num
15886 2 MichaelA
                            >
15887 3 MichaelA
289f :                      >skip2396
15888
                            >
15889 2 MichaelA
 
15890 3 MichaelA
289f : ca               [ 2]         dex
15891
28a0 : 10df             [ 3]         bpl tlsr2
15892
28a2 : a203             [ 2]         ldx #3
15893
28a4 :                       tlsr3
15894 2 MichaelA
                                     set_z zp1,$ff
15895
                            >            load_flag $ff
15896 3 MichaelA
28a4 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
15897 2 MichaelA
                            >
15898 3 MichaelA
28a6 : 48               [ 3]>            pha         ;use stack to load status
15899
28a7 : b5b9             [ 4]>            lda zp1,x    ;load to zeropage
15900
28a9 : 85b2             [ 3]>            sta zpt
15901
28ab : 28               [ 4]>            plp
15902 2 MichaelA
 
15903 3 MichaelA
28ac : 46b2             [ 5]         lsr zpt
15904 2 MichaelA
                                     tst_z rLSR,fLSR,$ff-fnzc
15905 3 MichaelA
28ae : 08               [ 3]>            php         ;save flags
15906
28af : a5b2             [ 3]>            lda zpt
15907
28b1 : dd1902           [ 4]>            cmp rLSR,x    ;test result
15908 2 MichaelA
                            >            trap_ne
15909 3 MichaelA
28b4 : f002             [ 3]>        beq skip2401
15910
                            >        trap           ;failed equal (zero)
15911
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15912
28b6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15913
28b7 : 1e                   >        db      test_num
15914 2 MichaelA
                            >
15915 3 MichaelA
28b8 :                      >skip2401
15916
                            >
15917
28b8 : 68               [ 4]>            pla         ;load status
15918
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  276
15919
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15920
 
15921 2 MichaelA
                            >            eor_flag $ff-fnzc
15922 3 MichaelA
28b9 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
15923 2 MichaelA
                            >
15924 3 MichaelA
28bb : dd2902           [ 4]>            cmp fLSR,x    ;test flags
15925 2 MichaelA
                            >            trap_ne
15926 3 MichaelA
28be : f002             [ 3]>        beq skip2404
15927
                            >        trap           ;failed equal (zero)
15928
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15929
28c0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15930
28c1 : 1e                   >        db      test_num
15931 2 MichaelA
                            >
15932 3 MichaelA
28c2 :                      >skip2404
15933
                            >
15934 2 MichaelA
 
15935 3 MichaelA
28c2 : ca               [ 2]         dex
15936
28c3 : 10df             [ 3]         bpl tlsr3
15937 2 MichaelA
 
15938 3 MichaelA
28c5 : a203             [ 2]         ldx #3
15939
28c7 :                       trol2
15940 2 MichaelA
                                     set_z zp1,0
15941
                            >            load_flag 0
15942 3 MichaelA
28c7 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
15943 2 MichaelA
                            >
15944 3 MichaelA
28c9 : 48               [ 3]>            pha         ;use stack to load status
15945
28ca : b5b9             [ 4]>            lda zp1,x    ;load to zeropage
15946
28cc : 85b2             [ 3]>            sta zpt
15947
28ce : 28               [ 4]>            plp
15948 2 MichaelA
 
15949 3 MichaelA
28cf : 26b2             [ 5]         rol zpt
15950 2 MichaelA
                                     tst_z rROL,fROL,0
15951 3 MichaelA
28d1 : 08               [ 3]>            php         ;save flags
15952
28d2 : a5b2             [ 3]>            lda zpt
15953
28d4 : dd1102           [ 4]>            cmp rROL,x    ;test result
15954 2 MichaelA
                            >            trap_ne
15955 3 MichaelA
28d7 : f002             [ 3]>        beq skip2409
15956
                            >        trap           ;failed equal (zero)
15957
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15958
28d9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15959
28da : 1e                   >        db      test_num
15960 2 MichaelA
                            >
15961 3 MichaelA
28db :                      >skip2409
15962
                            >
15963
28db : 68               [ 4]>            pla         ;load status
15964 2 MichaelA
                            >            eor_flag 0
15965 3 MichaelA
28dc : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
15966 2 MichaelA
                            >
15967 3 MichaelA
28de : dd2102           [ 4]>            cmp fROL,x    ;test flags
15968 2 MichaelA
                            >            trap_ne
15969 3 MichaelA
28e1 : f002             [ 3]>        beq skip2412
15970
                            >        trap           ;failed equal (zero)
15971
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
15972
28e3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
15973
28e4 : 1e                   >        db      test_num
15974 2 MichaelA
                            >
15975 3 MichaelA
28e5 :                      >skip2412
15976
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  277
15977
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
15978
 
15979
                            >
15980 2 MichaelA
 
15981 3 MichaelA
28e5 : ca               [ 2]         dex
15982
28e6 : 10df             [ 3]         bpl trol2
15983
28e8 : a203             [ 2]         ldx #3
15984
28ea :                       trol3
15985 2 MichaelA
                                     set_z zp1,$ff-fc
15986
                            >            load_flag $ff-fc
15987 3 MichaelA
28ea : a9fe             [ 2]>            lda #$ff-fc             ;allow test to change I-flag (no mask)
15988 2 MichaelA
                            >
15989 3 MichaelA
28ec : 48               [ 3]>            pha         ;use stack to load status
15990
28ed : b5b9             [ 4]>            lda zp1,x    ;load to zeropage
15991
28ef : 85b2             [ 3]>            sta zpt
15992
28f1 : 28               [ 4]>            plp
15993 2 MichaelA
 
15994 3 MichaelA
28f2 : 26b2             [ 5]         rol zpt
15995 2 MichaelA
                                     tst_z rROL,fROL,$ff-fnzc
15996 3 MichaelA
28f4 : 08               [ 3]>            php         ;save flags
15997
28f5 : a5b2             [ 3]>            lda zpt
15998
28f7 : dd1102           [ 4]>            cmp rROL,x    ;test result
15999 2 MichaelA
                            >            trap_ne
16000 3 MichaelA
28fa : f002             [ 3]>        beq skip2417
16001
                            >        trap           ;failed equal (zero)
16002
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16003
28fc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16004
28fd : 1e                   >        db      test_num
16005 2 MichaelA
                            >
16006 3 MichaelA
28fe :                      >skip2417
16007
                            >
16008
28fe : 68               [ 4]>            pla         ;load status
16009 2 MichaelA
                            >            eor_flag $ff-fnzc
16010 3 MichaelA
28ff : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
16011 2 MichaelA
                            >
16012 3 MichaelA
2901 : dd2102           [ 4]>            cmp fROL,x    ;test flags
16013 2 MichaelA
                            >            trap_ne
16014 3 MichaelA
2904 : f002             [ 3]>        beq skip2420
16015
                            >        trap           ;failed equal (zero)
16016
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16017
2906 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16018
2907 : 1e                   >        db      test_num
16019 2 MichaelA
                            >
16020 3 MichaelA
2908 :                      >skip2420
16021
                            >
16022 2 MichaelA
 
16023 3 MichaelA
2908 : ca               [ 2]         dex
16024
2909 : 10df             [ 4]         bpl trol3
16025 2 MichaelA
 
16026 3 MichaelA
290b : a203             [ 2]         ldx #3
16027
290d :                       trolc2
16028 2 MichaelA
                                     set_z zp1,fc
16029
                            >            load_flag fc
16030 3 MichaelA
290d : a901             [ 2]>            lda #fc             ;allow test to change I-flag (no mask)
16031 2 MichaelA
                            >
16032 3 MichaelA
290f : 48               [ 3]>            pha         ;use stack to load status
16033
2910 : b5b9             [ 4]>            lda zp1,x    ;load to zeropage
16034
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  278
16035
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16036
 
16037
2912 : 85b2             [ 3]>            sta zpt
16038
2914 : 28               [ 4]>            plp
16039 2 MichaelA
 
16040 3 MichaelA
2915 : 26b2             [ 5]         rol zpt
16041 2 MichaelA
                                     tst_z rROLc,fROLc,0
16042 3 MichaelA
2917 : 08               [ 3]>            php         ;save flags
16043
2918 : a5b2             [ 3]>            lda zpt
16044
291a : dd1502           [ 4]>            cmp rROLc,x    ;test result
16045 2 MichaelA
                            >            trap_ne
16046 3 MichaelA
291d : f002             [ 3]>        beq skip2425
16047
                            >        trap           ;failed equal (zero)
16048
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16049
291f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16050
2920 : 1e                   >        db      test_num
16051 2 MichaelA
                            >
16052 3 MichaelA
2921 :                      >skip2425
16053
                            >
16054
2921 : 68               [ 4]>            pla         ;load status
16055 2 MichaelA
                            >            eor_flag 0
16056 3 MichaelA
2922 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
16057 2 MichaelA
                            >
16058 3 MichaelA
2924 : dd2502           [ 4]>            cmp fROLc,x    ;test flags
16059 2 MichaelA
                            >            trap_ne
16060 3 MichaelA
2927 : f002             [ 3]>        beq skip2428
16061
                            >        trap           ;failed equal (zero)
16062
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16063
2929 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16064
292a : 1e                   >        db      test_num
16065 2 MichaelA
                            >
16066 3 MichaelA
292b :                      >skip2428
16067
                            >
16068 2 MichaelA
 
16069 3 MichaelA
292b : ca               [ 2]         dex
16070
292c : 10df             [ 3]         bpl trolc2
16071
292e : a203             [ 2]         ldx #3
16072
2930 :                       trolc3
16073 2 MichaelA
                                     set_z zp1,$ff
16074
                            >            load_flag $ff
16075 3 MichaelA
2930 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
16076 2 MichaelA
                            >
16077 3 MichaelA
2932 : 48               [ 3]>            pha         ;use stack to load status
16078
2933 : b5b9             [ 4]>            lda zp1,x    ;load to zeropage
16079
2935 : 85b2             [ 3]>            sta zpt
16080
2937 : 28               [ 4]>            plp
16081 2 MichaelA
 
16082 3 MichaelA
2938 : 26b2             [ 5]         rol zpt
16083 2 MichaelA
                                     tst_z rROLc,fROLc,$ff-fnzc
16084 3 MichaelA
293a : 08               [ 3]>            php         ;save flags
16085
293b : a5b2             [ 3]>            lda zpt
16086
293d : dd1502           [ 4]>            cmp rROLc,x    ;test result
16087
                            >            trap_ne
16088
2940 : f002             [ 3]>        beq skip2433
16089
                            >        trap           ;failed equal (zero)
16090
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16091
2942 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16092
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  279
16093 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16094
 
16095 3 MichaelA
2943 : 1e                   >        db      test_num
16096 2 MichaelA
                            >
16097 3 MichaelA
2944 :                      >skip2433
16098
                            >
16099
2944 : 68               [ 4]>            pla         ;load status
16100 2 MichaelA
                            >            eor_flag $ff-fnzc
16101 3 MichaelA
2945 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
16102 2 MichaelA
                            >
16103 3 MichaelA
2947 : dd2502           [ 4]>            cmp fROLc,x    ;test flags
16104 2 MichaelA
                            >            trap_ne
16105 3 MichaelA
294a : f002             [ 3]>        beq skip2436
16106
                            >        trap           ;failed equal (zero)
16107
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16108
294c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16109
294d : 1e                   >        db      test_num
16110 2 MichaelA
                            >
16111 3 MichaelA
294e :                      >skip2436
16112
                            >
16113 2 MichaelA
 
16114 3 MichaelA
294e : ca               [ 2]         dex
16115
294f : 10df             [ 3]         bpl trolc3
16116 2 MichaelA
 
16117 3 MichaelA
2951 : a203             [ 2]         ldx #3
16118
2953 :                       tror2
16119 2 MichaelA
                                     set_z zp1,0
16120
                            >            load_flag 0
16121 3 MichaelA
2953 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
16122 2 MichaelA
                            >
16123 3 MichaelA
2955 : 48               [ 3]>            pha         ;use stack to load status
16124
2956 : b5b9             [ 4]>            lda zp1,x    ;load to zeropage
16125
2958 : 85b2             [ 3]>            sta zpt
16126
295a : 28               [ 4]>            plp
16127 2 MichaelA
 
16128 3 MichaelA
295b : 66b2             [ 5]         ror zpt
16129 2 MichaelA
                                     tst_z rROR,fROR,0
16130 3 MichaelA
295d : 08               [ 3]>            php         ;save flags
16131
295e : a5b2             [ 3]>            lda zpt
16132
2960 : dd1902           [ 4]>            cmp rROR,x    ;test result
16133 2 MichaelA
                            >            trap_ne
16134 3 MichaelA
2963 : f002             [ 3]>        beq skip2441
16135
                            >        trap           ;failed equal (zero)
16136
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16137
2965 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16138
2966 : 1e                   >        db      test_num
16139 2 MichaelA
                            >
16140 3 MichaelA
2967 :                      >skip2441
16141
                            >
16142
2967 : 68               [ 4]>            pla         ;load status
16143 2 MichaelA
                            >            eor_flag 0
16144 3 MichaelA
2968 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
16145 2 MichaelA
                            >
16146 3 MichaelA
296a : dd2902           [ 4]>            cmp fROR,x    ;test flags
16147 2 MichaelA
                            >            trap_ne
16148 3 MichaelA
296d : f002             [ 3]>        beq skip2444
16149
                            >        trap           ;failed equal (zero)
16150
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  280
16151
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16152
 
16153
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16154
296f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16155
2970 : 1e                   >        db      test_num
16156 2 MichaelA
                            >
16157 3 MichaelA
2971 :                      >skip2444
16158
                            >
16159 2 MichaelA
 
16160 3 MichaelA
2971 : ca               [ 2]         dex
16161
2972 : 10df             [ 3]         bpl tror2
16162
2974 : a203             [ 2]         ldx #3
16163
2976 :                       tror3
16164 2 MichaelA
                                     set_z zp1,$ff-fc
16165
                            >            load_flag $ff-fc
16166 3 MichaelA
2976 : a9fe             [ 2]>            lda #$ff-fc             ;allow test to change I-flag (no mask)
16167 2 MichaelA
                            >
16168 3 MichaelA
2978 : 48               [ 3]>            pha         ;use stack to load status
16169
2979 : b5b9             [ 4]>            lda zp1,x    ;load to zeropage
16170
297b : 85b2             [ 3]>            sta zpt
16171
297d : 28               [ 4]>            plp
16172 2 MichaelA
 
16173 3 MichaelA
297e : 66b2             [ 5]         ror zpt
16174 2 MichaelA
                                     tst_z rROR,fROR,$ff-fnzc
16175 3 MichaelA
2980 : 08               [ 3]>            php         ;save flags
16176
2981 : a5b2             [ 3]>            lda zpt
16177
2983 : dd1902           [ 4]>            cmp rROR,x    ;test result
16178 2 MichaelA
                            >            trap_ne
16179 3 MichaelA
2986 : f002             [ 3]>        beq skip2449
16180
                            >        trap           ;failed equal (zero)
16181
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16182
2988 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16183
2989 : 1e                   >        db      test_num
16184 2 MichaelA
                            >
16185 3 MichaelA
298a :                      >skip2449
16186
                            >
16187
298a : 68               [ 4]>            pla         ;load status
16188 2 MichaelA
                            >            eor_flag $ff-fnzc
16189 3 MichaelA
298b : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
16190 2 MichaelA
                            >
16191 3 MichaelA
298d : dd2902           [ 4]>            cmp fROR,x    ;test flags
16192 2 MichaelA
                            >            trap_ne
16193 3 MichaelA
2990 : f002             [ 3]>        beq skip2452
16194
                            >        trap           ;failed equal (zero)
16195
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16196
2992 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16197
2993 : 1e                   >        db      test_num
16198 2 MichaelA
                            >
16199 3 MichaelA
2994 :                      >skip2452
16200
                            >
16201 2 MichaelA
 
16202 3 MichaelA
2994 : ca               [ 2]         dex
16203
2995 : 10df             [ 3]         bpl tror3
16204 2 MichaelA
 
16205 3 MichaelA
2997 : a203             [ 2]         ldx #3
16206
2999 :                       trorc2
16207 2 MichaelA
                                     set_z zp1,fc
16208 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  281
16209
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16210
 
16211 2 MichaelA
                            >            load_flag fc
16212 3 MichaelA
2999 : a901             [ 2]>            lda #fc             ;allow test to change I-flag (no mask)
16213 2 MichaelA
                            >
16214 3 MichaelA
299b : 48               [ 3]>            pha         ;use stack to load status
16215
299c : b5b9             [ 4]>            lda zp1,x    ;load to zeropage
16216
299e : 85b2             [ 3]>            sta zpt
16217
29a0 : 28               [ 4]>            plp
16218 2 MichaelA
 
16219 3 MichaelA
29a1 : 66b2             [ 5]         ror zpt
16220 2 MichaelA
                                     tst_z rRORc,fRORc,0
16221 3 MichaelA
29a3 : 08               [ 3]>            php         ;save flags
16222
29a4 : a5b2             [ 3]>            lda zpt
16223
29a6 : dd1d02           [ 4]>            cmp rRORc,x    ;test result
16224 2 MichaelA
                            >            trap_ne
16225 3 MichaelA
29a9 : f002             [ 3]>        beq skip2457
16226
                            >        trap           ;failed equal (zero)
16227
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16228
29ab : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16229
29ac : 1e                   >        db      test_num
16230 2 MichaelA
                            >
16231 3 MichaelA
29ad :                      >skip2457
16232
                            >
16233
29ad : 68               [ 4]>            pla         ;load status
16234 2 MichaelA
                            >            eor_flag 0
16235 3 MichaelA
29ae : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
16236 2 MichaelA
                            >
16237 3 MichaelA
29b0 : dd2d02           [ 4]>            cmp fRORc,x    ;test flags
16238 2 MichaelA
                            >            trap_ne
16239 3 MichaelA
29b3 : f002             [ 3]>        beq skip2460
16240
                            >        trap           ;failed equal (zero)
16241
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16242
29b5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16243
29b6 : 1e                   >        db      test_num
16244 2 MichaelA
                            >
16245 3 MichaelA
29b7 :                      >skip2460
16246
                            >
16247 2 MichaelA
 
16248 3 MichaelA
29b7 : ca               [ 2]         dex
16249
29b8 : 10df             [ 3]         bpl trorc2
16250
29ba : a203             [ 2]         ldx #3
16251
29bc :                       trorc3
16252 2 MichaelA
                                     set_z zp1,$ff
16253
                            >            load_flag $ff
16254 3 MichaelA
29bc : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
16255 2 MichaelA
                            >
16256 3 MichaelA
29be : 48               [ 3]>            pha         ;use stack to load status
16257
29bf : b5b9             [ 4]>            lda zp1,x    ;load to zeropage
16258
29c1 : 85b2             [ 3]>            sta zpt
16259
29c3 : 28               [ 4]>            plp
16260 2 MichaelA
 
16261 3 MichaelA
29c4 : 66b2             [ 5]         ror zpt
16262 2 MichaelA
                                     tst_z rRORc,fRORc,$ff-fnzc
16263 3 MichaelA
29c6 : 08               [ 3]>            php         ;save flags
16264
29c7 : a5b2             [ 3]>            lda zpt
16265
29c9 : dd1d02           [ 4]>            cmp rRORc,x    ;test result
16266
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  282
16267
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16268
 
16269 2 MichaelA
                            >            trap_ne
16270 3 MichaelA
29cc : f002             [ 3]>        beq skip2465
16271
                            >        trap           ;failed equal (zero)
16272
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16273
29ce : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16274
29cf : 1e                   >        db      test_num
16275 2 MichaelA
                            >
16276 3 MichaelA
29d0 :                      >skip2465
16277
                            >
16278
29d0 : 68               [ 4]>            pla         ;load status
16279 2 MichaelA
                            >            eor_flag $ff-fnzc
16280 3 MichaelA
29d1 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
16281 2 MichaelA
                            >
16282 3 MichaelA
29d3 : dd2d02           [ 4]>            cmp fRORc,x    ;test flags
16283 2 MichaelA
                            >            trap_ne
16284 3 MichaelA
29d6 : f002             [ 3]>        beq skip2468
16285
                            >        trap           ;failed equal (zero)
16286
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16287
29d8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16288
29d9 : 1e                   >        db      test_num
16289 2 MichaelA
                            >
16290 3 MichaelA
29da :                      >skip2468
16291
                            >
16292 2 MichaelA
 
16293 3 MichaelA
29da : ca               [ 2]         dex
16294
29db : 10df             [ 3]         bpl trorc3
16295 2 MichaelA
                                     next_test
16296 3 MichaelA
29dd : ad0002           [ 4]>            lda test_case   ;previous test
16297
29e0 : c91e             [ 2]>            cmp #test_num
16298 2 MichaelA
                            >            trap_ne         ;test is out of sequence
16299 3 MichaelA
29e2 : f002             [ 3]>        beq skip2471
16300
                            >        trap           ;failed equal (zero)
16301
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16302
29e4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16303
29e5 : 1e                   >        db      test_num
16304 2 MichaelA
                            >
16305 3 MichaelA
29e6 :                      >skip2471
16306
                            >
16307 2 MichaelA
001f =                      >test_num = test_num + 1
16308 3 MichaelA
29e6 : a91f             [ 2]>            lda #test_num   ;*** this tests' number
16309
29e8 : 8d0002           [ 4]>            sta test_case
16310 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
16311
 
16312
 
16313
                             ; shifts - absolute
16314 3 MichaelA
 
16315
29eb : a203             [ 2]         ldx #3
16316
29ed :                       tasl4
16317 2 MichaelA
                                     set_abs zp1,0
16318
                            >            load_flag 0
16319 3 MichaelA
29ed : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
16320 2 MichaelA
                            >
16321 3 MichaelA
29ef : 48               [ 3]>            pha         ;use stack to load status
16322
29f0 : b5b9             [ 4]>            lda zp1,x    ;load to memory
16323
29f2 : 8d0302           [ 4]>            sta abst
16324
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  283
16325
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16326
 
16327
29f5 : 28               [ 4]>            plp
16328 2 MichaelA
 
16329 3 MichaelA
29f6 : 0e0302           [ 6]         asl abst
16330 2 MichaelA
                                     tst_abs rASL,fASL,0
16331 3 MichaelA
29f9 : 08               [ 3]>            php         ;save flags
16332
29fa : ad0302           [ 4]>            lda abst
16333
29fd : dd1102           [ 4]>            cmp rASL,x    ;test result
16334 2 MichaelA
                            >            trap_ne
16335 3 MichaelA
2a00 : f002             [ 3]>        beq skip2476
16336
                            >        trap           ;failed equal (zero)
16337
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16338
2a02 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16339
2a03 : 1f                   >        db      test_num
16340 2 MichaelA
                            >
16341 3 MichaelA
2a04 :                      >skip2476
16342
                            >
16343
2a04 : 68               [ 4]>            pla         ;load status
16344 2 MichaelA
                            >            eor_flag 0
16345 3 MichaelA
2a05 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
16346 2 MichaelA
                            >
16347 3 MichaelA
2a07 : dd2102           [ 4]>            cmp fASL,x    ;test flags
16348 2 MichaelA
                            >            trap_ne
16349 3 MichaelA
2a0a : f002             [ 3]>        beq skip2479
16350
                            >        trap           ;failed equal (zero)
16351
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16352
2a0c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16353
2a0d : 1f                   >        db      test_num
16354 2 MichaelA
                            >
16355 3 MichaelA
2a0e :                      >skip2479
16356
                            >
16357 2 MichaelA
 
16358 3 MichaelA
2a0e : ca               [ 2]         dex
16359
2a0f : 10dc             [ 4]         bpl tasl4
16360
2a11 : a203             [ 2]         ldx #3
16361
2a13 :                       tasl5
16362 2 MichaelA
                                     set_abs zp1,$ff
16363
                            >            load_flag $ff
16364 3 MichaelA
2a13 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
16365 2 MichaelA
                            >
16366 3 MichaelA
2a15 : 48               [ 3]>            pha         ;use stack to load status
16367
2a16 : b5b9             [ 4]>            lda zp1,x    ;load to memory
16368
2a18 : 8d0302           [ 4]>            sta abst
16369
2a1b : 28               [ 4]>            plp
16370 2 MichaelA
 
16371 3 MichaelA
2a1c : 0e0302           [ 6]         asl abst
16372 2 MichaelA
                                     tst_abs rASL,fASL,$ff-fnzc
16373 3 MichaelA
2a1f : 08               [ 3]>            php         ;save flags
16374
2a20 : ad0302           [ 4]>            lda abst
16375
2a23 : dd1102           [ 4]>            cmp rASL,x    ;test result
16376 2 MichaelA
                            >            trap_ne
16377 3 MichaelA
2a26 : f002             [ 3]>        beq skip2484
16378
                            >        trap           ;failed equal (zero)
16379
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16380
2a28 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16381
2a29 : 1f                   >        db      test_num
16382
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  284
16383
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16384
 
16385 2 MichaelA
                            >
16386 3 MichaelA
2a2a :                      >skip2484
16387
                            >
16388
2a2a : 68               [ 4]>            pla         ;load status
16389 2 MichaelA
                            >            eor_flag $ff-fnzc
16390 3 MichaelA
2a2b : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
16391 2 MichaelA
                            >
16392 3 MichaelA
2a2d : dd2102           [ 4]>            cmp fASL,x    ;test flags
16393 2 MichaelA
                            >            trap_ne
16394 3 MichaelA
2a30 : f002             [ 3]>        beq skip2487
16395
                            >        trap           ;failed equal (zero)
16396
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16397
2a32 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16398
2a33 : 1f                   >        db      test_num
16399 2 MichaelA
                            >
16400 3 MichaelA
2a34 :                      >skip2487
16401
                            >
16402 2 MichaelA
 
16403 3 MichaelA
2a34 : ca               [ 2]         dex
16404
2a35 : 10dc             [ 3]         bpl tasl5
16405 2 MichaelA
 
16406 3 MichaelA
2a37 : a203             [ 2]         ldx #3
16407
2a39 :                       tlsr4
16408 2 MichaelA
                                     set_abs zp1,0
16409
                            >            load_flag 0
16410 3 MichaelA
2a39 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
16411 2 MichaelA
                            >
16412 3 MichaelA
2a3b : 48               [ 3]>            pha         ;use stack to load status
16413
2a3c : b5b9             [ 4]>            lda zp1,x    ;load to memory
16414
2a3e : 8d0302           [ 4]>            sta abst
16415
2a41 : 28               [ 4]>            plp
16416 2 MichaelA
 
16417 3 MichaelA
2a42 : 4e0302           [ 6]         lsr abst
16418 2 MichaelA
                                     tst_abs rLSR,fLSR,0
16419 3 MichaelA
2a45 : 08               [ 3]>            php         ;save flags
16420
2a46 : ad0302           [ 4]>            lda abst
16421
2a49 : dd1902           [ 4]>            cmp rLSR,x    ;test result
16422 2 MichaelA
                            >            trap_ne
16423 3 MichaelA
2a4c : f002             [ 3]>        beq skip2492
16424
                            >        trap           ;failed equal (zero)
16425
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16426
2a4e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16427
2a4f : 1f                   >        db      test_num
16428 2 MichaelA
                            >
16429 3 MichaelA
2a50 :                      >skip2492
16430
                            >
16431
2a50 : 68               [ 4]>            pla         ;load status
16432 2 MichaelA
                            >            eor_flag 0
16433 3 MichaelA
2a51 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
16434 2 MichaelA
                            >
16435 3 MichaelA
2a53 : dd2902           [ 4]>            cmp fLSR,x    ;test flags
16436 2 MichaelA
                            >            trap_ne
16437 3 MichaelA
2a56 : f002             [ 3]>        beq skip2495
16438
                            >        trap           ;failed equal (zero)
16439
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16440
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  285
16441
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16442
 
16443
2a58 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16444
2a59 : 1f                   >        db      test_num
16445 2 MichaelA
                            >
16446 3 MichaelA
2a5a :                      >skip2495
16447
                            >
16448 2 MichaelA
 
16449 3 MichaelA
2a5a : ca               [ 2]         dex
16450
2a5b : 10dc             [ 3]         bpl tlsr4
16451
2a5d : a203             [ 2]         ldx #3
16452
2a5f :                       tlsr5
16453 2 MichaelA
                                     set_abs zp1,$ff
16454
                            >            load_flag $ff
16455 3 MichaelA
2a5f : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
16456 2 MichaelA
                            >
16457 3 MichaelA
2a61 : 48               [ 3]>            pha         ;use stack to load status
16458
2a62 : b5b9             [ 4]>            lda zp1,x    ;load to memory
16459
2a64 : 8d0302           [ 4]>            sta abst
16460
2a67 : 28               [ 4]>            plp
16461 2 MichaelA
 
16462 3 MichaelA
2a68 : 4e0302           [ 6]         lsr abst
16463 2 MichaelA
                                     tst_abs rLSR,fLSR,$ff-fnzc
16464 3 MichaelA
2a6b : 08               [ 3]>            php         ;save flags
16465
2a6c : ad0302           [ 4]>            lda abst
16466
2a6f : dd1902           [ 4]>            cmp rLSR,x    ;test result
16467 2 MichaelA
                            >            trap_ne
16468 3 MichaelA
2a72 : f002             [ 3]>        beq skip2500
16469
                            >        trap           ;failed equal (zero)
16470
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16471
2a74 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16472
2a75 : 1f                   >        db      test_num
16473 2 MichaelA
                            >
16474 3 MichaelA
2a76 :                      >skip2500
16475
                            >
16476
2a76 : 68               [ 4]>            pla         ;load status
16477 2 MichaelA
                            >            eor_flag $ff-fnzc
16478 3 MichaelA
2a77 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
16479 2 MichaelA
                            >
16480 3 MichaelA
2a79 : dd2902           [ 4]>            cmp fLSR,x    ;test flags
16481 2 MichaelA
                            >            trap_ne
16482 3 MichaelA
2a7c : f002             [ 3]>        beq skip2503
16483
                            >        trap           ;failed equal (zero)
16484
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16485
2a7e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16486
2a7f : 1f                   >        db      test_num
16487 2 MichaelA
                            >
16488 3 MichaelA
2a80 :                      >skip2503
16489
                            >
16490 2 MichaelA
 
16491 3 MichaelA
2a80 : ca               [ 2]         dex
16492
2a81 : 10dc             [ 3]         bpl tlsr5
16493 2 MichaelA
 
16494 3 MichaelA
2a83 : a203             [ 2]         ldx #3
16495
2a85 :                       trol4
16496 2 MichaelA
                                     set_abs zp1,0
16497 3 MichaelA
                            >            load_flag 0
16498
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  286
16499 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16500
 
16501 3 MichaelA
2a85 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
16502 2 MichaelA
                            >
16503 3 MichaelA
2a87 : 48               [ 3]>            pha         ;use stack to load status
16504
2a88 : b5b9             [ 4]>            lda zp1,x    ;load to memory
16505
2a8a : 8d0302           [ 4]>            sta abst
16506
2a8d : 28               [ 4]>            plp
16507 2 MichaelA
 
16508 3 MichaelA
2a8e : 2e0302           [ 6]         rol abst
16509 2 MichaelA
                                     tst_abs rROL,fROL,0
16510 3 MichaelA
2a91 : 08               [ 3]>            php         ;save flags
16511
2a92 : ad0302           [ 4]>            lda abst
16512
2a95 : dd1102           [ 4]>            cmp rROL,x    ;test result
16513 2 MichaelA
                            >            trap_ne
16514 3 MichaelA
2a98 : f002             [ 3]>        beq skip2508
16515
                            >        trap           ;failed equal (zero)
16516
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16517
2a9a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16518
2a9b : 1f                   >        db      test_num
16519 2 MichaelA
                            >
16520 3 MichaelA
2a9c :                      >skip2508
16521
                            >
16522
2a9c : 68               [ 4]>            pla         ;load status
16523 2 MichaelA
                            >            eor_flag 0
16524 3 MichaelA
2a9d : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
16525 2 MichaelA
                            >
16526 3 MichaelA
2a9f : dd2102           [ 4]>            cmp fROL,x    ;test flags
16527 2 MichaelA
                            >            trap_ne
16528 3 MichaelA
2aa2 : f002             [ 3]>        beq skip2511
16529
                            >        trap           ;failed equal (zero)
16530
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16531
2aa4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16532
2aa5 : 1f                   >        db      test_num
16533 2 MichaelA
                            >
16534 3 MichaelA
2aa6 :                      >skip2511
16535
                            >
16536 2 MichaelA
 
16537 3 MichaelA
2aa6 : ca               [ 2]         dex
16538
2aa7 : 10dc             [ 3]         bpl trol4
16539
2aa9 : a203             [ 2]         ldx #3
16540
2aab :                       trol5
16541 2 MichaelA
                                     set_abs zp1,$ff-fc
16542
                            >            load_flag $ff-fc
16543 3 MichaelA
2aab : a9fe             [ 2]>            lda #$ff-fc             ;allow test to change I-flag (no mask)
16544 2 MichaelA
                            >
16545 3 MichaelA
2aad : 48               [ 3]>            pha         ;use stack to load status
16546
2aae : b5b9             [ 4]>            lda zp1,x    ;load to memory
16547
2ab0 : 8d0302           [ 4]>            sta abst
16548
2ab3 : 28               [ 4]>            plp
16549 2 MichaelA
 
16550 3 MichaelA
2ab4 : 2e0302           [ 6]         rol abst
16551 2 MichaelA
                                     tst_abs rROL,fROL,$ff-fnzc
16552 3 MichaelA
2ab7 : 08               [ 3]>            php         ;save flags
16553
2ab8 : ad0302           [ 4]>            lda abst
16554
2abb : dd1102           [ 4]>            cmp rROL,x    ;test result
16555 2 MichaelA
                            >            trap_ne
16556 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  287
16557
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16558
 
16559
2abe : f002             [ 3]>        beq skip2516
16560
                            >        trap           ;failed equal (zero)
16561
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16562
2ac0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16563
2ac1 : 1f                   >        db      test_num
16564 2 MichaelA
                            >
16565 3 MichaelA
2ac2 :                      >skip2516
16566
                            >
16567
2ac2 : 68               [ 4]>            pla         ;load status
16568 2 MichaelA
                            >            eor_flag $ff-fnzc
16569 3 MichaelA
2ac3 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
16570 2 MichaelA
                            >
16571 3 MichaelA
2ac5 : dd2102           [ 4]>            cmp fROL,x    ;test flags
16572 2 MichaelA
                            >            trap_ne
16573 3 MichaelA
2ac8 : f002             [ 3]>        beq skip2519
16574
                            >        trap           ;failed equal (zero)
16575
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16576
2aca : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16577
2acb : 1f                   >        db      test_num
16578 2 MichaelA
                            >
16579 3 MichaelA
2acc :                      >skip2519
16580
                            >
16581 2 MichaelA
 
16582 3 MichaelA
2acc : ca               [ 2]         dex
16583
2acd : 10dc             [ 3]         bpl trol5
16584 2 MichaelA
 
16585 3 MichaelA
2acf : a203             [ 2]         ldx #3
16586
2ad1 :                       trolc4
16587 2 MichaelA
                                     set_abs zp1,fc
16588
                            >            load_flag fc
16589 3 MichaelA
2ad1 : a901             [ 2]>            lda #fc             ;allow test to change I-flag (no mask)
16590 2 MichaelA
                            >
16591 3 MichaelA
2ad3 : 48               [ 3]>            pha         ;use stack to load status
16592
2ad4 : b5b9             [ 4]>            lda zp1,x    ;load to memory
16593
2ad6 : 8d0302           [ 4]>            sta abst
16594
2ad9 : 28               [ 4]>            plp
16595 2 MichaelA
 
16596 3 MichaelA
2ada : 2e0302           [ 6]         rol abst
16597 2 MichaelA
                                     tst_abs rROLc,fROLc,0
16598 3 MichaelA
2add : 08               [ 3]>            php         ;save flags
16599
2ade : ad0302           [ 4]>            lda abst
16600
2ae1 : dd1502           [ 4]>            cmp rROLc,x    ;test result
16601 2 MichaelA
                            >            trap_ne
16602 3 MichaelA
2ae4 : f002             [ 3]>        beq skip2524
16603
                            >        trap           ;failed equal (zero)
16604
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16605
2ae6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16606
2ae7 : 1f                   >        db      test_num
16607 2 MichaelA
                            >
16608 3 MichaelA
2ae8 :                      >skip2524
16609
                            >
16610
2ae8 : 68               [ 4]>            pla         ;load status
16611 2 MichaelA
                            >            eor_flag 0
16612 3 MichaelA
2ae9 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
16613 2 MichaelA
                            >
16614 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  288
16615
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16616
 
16617
2aeb : dd2502           [ 4]>            cmp fROLc,x    ;test flags
16618 2 MichaelA
                            >            trap_ne
16619 3 MichaelA
2aee : f002             [ 3]>        beq skip2527
16620
                            >        trap           ;failed equal (zero)
16621
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16622
2af0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16623
2af1 : 1f                   >        db      test_num
16624 2 MichaelA
                            >
16625 3 MichaelA
2af2 :                      >skip2527
16626
                            >
16627 2 MichaelA
 
16628 3 MichaelA
2af2 : ca               [ 2]         dex
16629
2af3 : 10dc             [ 3]         bpl trolc4
16630
2af5 : a203             [ 2]         ldx #3
16631
2af7 :                       trolc5
16632 2 MichaelA
                                     set_abs zp1,$ff
16633
                            >            load_flag $ff
16634 3 MichaelA
2af7 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
16635 2 MichaelA
                            >
16636 3 MichaelA
2af9 : 48               [ 3]>            pha         ;use stack to load status
16637
2afa : b5b9             [ 4]>            lda zp1,x    ;load to memory
16638
2afc : 8d0302           [ 4]>            sta abst
16639
2aff : 28               [ 4]>            plp
16640 2 MichaelA
 
16641 3 MichaelA
2b00 : 2e0302           [ 6]         rol abst
16642 2 MichaelA
                                     tst_abs rROLc,fROLc,$ff-fnzc
16643 3 MichaelA
2b03 : 08               [ 3]>            php         ;save flags
16644
2b04 : ad0302           [ 4]>            lda abst
16645
2b07 : dd1502           [ 4]>            cmp rROLc,x    ;test result
16646 2 MichaelA
                            >            trap_ne
16647 3 MichaelA
2b0a : f002             [ 3]>        beq skip2532
16648
                            >        trap           ;failed equal (zero)
16649
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16650
2b0c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16651
2b0d : 1f                   >        db      test_num
16652 2 MichaelA
                            >
16653 3 MichaelA
2b0e :                      >skip2532
16654
                            >
16655
2b0e : 68               [ 4]>            pla         ;load status
16656 2 MichaelA
                            >            eor_flag $ff-fnzc
16657 3 MichaelA
2b0f : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
16658 2 MichaelA
                            >
16659 3 MichaelA
2b11 : dd2502           [ 4]>            cmp fROLc,x    ;test flags
16660 2 MichaelA
                            >            trap_ne
16661 3 MichaelA
2b14 : f002             [ 3]>        beq skip2535
16662
                            >        trap           ;failed equal (zero)
16663
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16664
2b16 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16665
2b17 : 1f                   >        db      test_num
16666 2 MichaelA
                            >
16667 3 MichaelA
2b18 :                      >skip2535
16668
                            >
16669 2 MichaelA
 
16670 3 MichaelA
2b18 : ca               [ 2]         dex
16671
2b19 : 10dc             [ 4]         bpl trolc5
16672
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  289
16673
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16674
 
16675 2 MichaelA
 
16676 3 MichaelA
2b1b : a203             [ 2]         ldx #3
16677
2b1d :                       tror4
16678 2 MichaelA
                                     set_abs zp1,0
16679
                            >            load_flag 0
16680 3 MichaelA
2b1d : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
16681 2 MichaelA
                            >
16682 3 MichaelA
2b1f : 48               [ 3]>            pha         ;use stack to load status
16683
2b20 : b5b9             [ 4]>            lda zp1,x    ;load to memory
16684
2b22 : 8d0302           [ 4]>            sta abst
16685
2b25 : 28               [ 4]>            plp
16686 2 MichaelA
 
16687 3 MichaelA
2b26 : 6e0302           [ 6]         ror abst
16688 2 MichaelA
                                     tst_abs rROR,fROR,0
16689 3 MichaelA
2b29 : 08               [ 3]>            php         ;save flags
16690
2b2a : ad0302           [ 4]>            lda abst
16691
2b2d : dd1902           [ 4]>            cmp rROR,x    ;test result
16692 2 MichaelA
                            >            trap_ne
16693 3 MichaelA
2b30 : f002             [ 3]>        beq skip2540
16694
                            >        trap           ;failed equal (zero)
16695
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16696
2b32 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16697
2b33 : 1f                   >        db      test_num
16698 2 MichaelA
                            >
16699 3 MichaelA
2b34 :                      >skip2540
16700
                            >
16701
2b34 : 68               [ 4]>            pla         ;load status
16702 2 MichaelA
                            >            eor_flag 0
16703 3 MichaelA
2b35 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
16704 2 MichaelA
                            >
16705 3 MichaelA
2b37 : dd2902           [ 4]>            cmp fROR,x    ;test flags
16706 2 MichaelA
                            >            trap_ne
16707 3 MichaelA
2b3a : f002             [ 3]>        beq skip2543
16708
                            >        trap           ;failed equal (zero)
16709
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16710
2b3c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16711
2b3d : 1f                   >        db      test_num
16712 2 MichaelA
                            >
16713 3 MichaelA
2b3e :                      >skip2543
16714
                            >
16715 2 MichaelA
 
16716 3 MichaelA
2b3e : ca               [ 2]         dex
16717
2b3f : 10dc             [ 3]         bpl tror4
16718
2b41 : a203             [ 2]         ldx #3
16719
2b43 :                       tror5
16720 2 MichaelA
                                     set_abs zp1,$ff-fc
16721
                            >            load_flag $ff-fc
16722 3 MichaelA
2b43 : a9fe             [ 2]>            lda #$ff-fc             ;allow test to change I-flag (no mask)
16723 2 MichaelA
                            >
16724 3 MichaelA
2b45 : 48               [ 3]>            pha         ;use stack to load status
16725
2b46 : b5b9             [ 4]>            lda zp1,x    ;load to memory
16726
2b48 : 8d0302           [ 4]>            sta abst
16727
2b4b : 28               [ 4]>            plp
16728 2 MichaelA
 
16729 3 MichaelA
2b4c : 6e0302           [ 6]         ror abst
16730
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  290
16731 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16732
 
16733 3 MichaelA
                                     tst_abs rROR,fROR,$ff-fnzc
16734
2b4f : 08               [ 3]>            php         ;save flags
16735
2b50 : ad0302           [ 4]>            lda abst
16736
2b53 : dd1902           [ 4]>            cmp rROR,x    ;test result
16737 2 MichaelA
                            >            trap_ne
16738 3 MichaelA
2b56 : f002             [ 3]>        beq skip2548
16739
                            >        trap           ;failed equal (zero)
16740
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16741
2b58 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16742
2b59 : 1f                   >        db      test_num
16743 2 MichaelA
                            >
16744 3 MichaelA
2b5a :                      >skip2548
16745
                            >
16746
2b5a : 68               [ 4]>            pla         ;load status
16747 2 MichaelA
                            >            eor_flag $ff-fnzc
16748 3 MichaelA
2b5b : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
16749 2 MichaelA
                            >
16750 3 MichaelA
2b5d : dd2902           [ 4]>            cmp fROR,x    ;test flags
16751 2 MichaelA
                            >            trap_ne
16752 3 MichaelA
2b60 : f002             [ 3]>        beq skip2551
16753
                            >        trap           ;failed equal (zero)
16754
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16755
2b62 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16756
2b63 : 1f                   >        db      test_num
16757 2 MichaelA
                            >
16758 3 MichaelA
2b64 :                      >skip2551
16759
                            >
16760 2 MichaelA
 
16761 3 MichaelA
2b64 : ca               [ 2]         dex
16762
2b65 : 10dc             [ 3]         bpl tror5
16763 2 MichaelA
 
16764 3 MichaelA
2b67 : a203             [ 2]         ldx #3
16765
2b69 :                       trorc4
16766 2 MichaelA
                                     set_abs zp1,fc
16767
                            >            load_flag fc
16768 3 MichaelA
2b69 : a901             [ 2]>            lda #fc             ;allow test to change I-flag (no mask)
16769 2 MichaelA
                            >
16770 3 MichaelA
2b6b : 48               [ 3]>            pha         ;use stack to load status
16771
2b6c : b5b9             [ 4]>            lda zp1,x    ;load to memory
16772
2b6e : 8d0302           [ 4]>            sta abst
16773
2b71 : 28               [ 4]>            plp
16774 2 MichaelA
 
16775 3 MichaelA
2b72 : 6e0302           [ 6]         ror abst
16776 2 MichaelA
                                     tst_abs rRORc,fRORc,0
16777 3 MichaelA
2b75 : 08               [ 3]>            php         ;save flags
16778
2b76 : ad0302           [ 4]>            lda abst
16779
2b79 : dd1d02           [ 4]>            cmp rRORc,x    ;test result
16780 2 MichaelA
                            >            trap_ne
16781 3 MichaelA
2b7c : f002             [ 3]>        beq skip2556
16782
                            >        trap           ;failed equal (zero)
16783
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16784
2b7e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16785
2b7f : 1f                   >        db      test_num
16786 2 MichaelA
                            >
16787 3 MichaelA
2b80 :                      >skip2556
16788
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  291
16789
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16790
 
16791
                            >
16792
2b80 : 68               [ 4]>            pla         ;load status
16793 2 MichaelA
                            >            eor_flag 0
16794 3 MichaelA
2b81 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
16795 2 MichaelA
                            >
16796 3 MichaelA
2b83 : dd2d02           [ 4]>            cmp fRORc,x    ;test flags
16797 2 MichaelA
                            >            trap_ne
16798 3 MichaelA
2b86 : f002             [ 3]>        beq skip2559
16799
                            >        trap           ;failed equal (zero)
16800
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16801
2b88 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16802
2b89 : 1f                   >        db      test_num
16803 2 MichaelA
                            >
16804 3 MichaelA
2b8a :                      >skip2559
16805
                            >
16806 2 MichaelA
 
16807 3 MichaelA
2b8a : ca               [ 2]         dex
16808
2b8b : 10dc             [ 3]         bpl trorc4
16809
2b8d : a203             [ 2]         ldx #3
16810
2b8f :                       trorc5
16811 2 MichaelA
                                     set_abs zp1,$ff
16812
                            >            load_flag $ff
16813 3 MichaelA
2b8f : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
16814 2 MichaelA
                            >
16815 3 MichaelA
2b91 : 48               [ 3]>            pha         ;use stack to load status
16816
2b92 : b5b9             [ 4]>            lda zp1,x    ;load to memory
16817
2b94 : 8d0302           [ 4]>            sta abst
16818
2b97 : 28               [ 4]>            plp
16819 2 MichaelA
 
16820 3 MichaelA
2b98 : 6e0302           [ 6]         ror abst
16821 2 MichaelA
                                     tst_abs rRORc,fRORc,$ff-fnzc
16822 3 MichaelA
2b9b : 08               [ 3]>            php         ;save flags
16823
2b9c : ad0302           [ 4]>            lda abst
16824
2b9f : dd1d02           [ 4]>            cmp rRORc,x    ;test result
16825 2 MichaelA
                            >            trap_ne
16826 3 MichaelA
2ba2 : f002             [ 3]>        beq skip2564
16827
                            >        trap           ;failed equal (zero)
16828
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16829
2ba4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16830
2ba5 : 1f                   >        db      test_num
16831 2 MichaelA
                            >
16832 3 MichaelA
2ba6 :                      >skip2564
16833
                            >
16834
2ba6 : 68               [ 4]>            pla         ;load status
16835 2 MichaelA
                            >            eor_flag $ff-fnzc
16836 3 MichaelA
2ba7 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
16837 2 MichaelA
                            >
16838 3 MichaelA
2ba9 : dd2d02           [ 4]>            cmp fRORc,x    ;test flags
16839 2 MichaelA
                            >            trap_ne
16840 3 MichaelA
2bac : f002             [ 3]>        beq skip2567
16841
                            >        trap           ;failed equal (zero)
16842
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16843
2bae : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16844
2baf : 1f                   >        db      test_num
16845 2 MichaelA
                            >
16846 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  292
16847
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16848
 
16849
2bb0 :                      >skip2567
16850
                            >
16851 2 MichaelA
 
16852 3 MichaelA
2bb0 : ca               [ 2]         dex
16853
2bb1 : 10dc             [ 3]         bpl trorc5
16854 2 MichaelA
                                     next_test
16855 3 MichaelA
2bb3 : ad0002           [ 4]>            lda test_case   ;previous test
16856
2bb6 : c91f             [ 2]>            cmp #test_num
16857 2 MichaelA
                            >            trap_ne         ;test is out of sequence
16858 3 MichaelA
2bb8 : f002             [ 3]>        beq skip2570
16859
                            >        trap           ;failed equal (zero)
16860
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16861
2bba : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16862
2bbb : 1f                   >        db      test_num
16863 2 MichaelA
                            >
16864 3 MichaelA
2bbc :                      >skip2570
16865
                            >
16866 2 MichaelA
0020 =                      >test_num = test_num + 1
16867 3 MichaelA
2bbc : a920             [ 2]>            lda #test_num   ;*** this tests' number
16868
2bbe : 8d0002           [ 4]>            sta test_case
16869 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
16870
 
16871
 
16872
                             ; shifts - zp indexed
16873 3 MichaelA
 
16874
2bc1 : a203             [ 2]         ldx #3
16875
2bc3 :                       tasl6
16876 2 MichaelA
                                     set_zx zp1,0
16877
                            >            load_flag 0
16878 3 MichaelA
2bc3 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
16879 2 MichaelA
                            >
16880 3 MichaelA
2bc5 : 48               [ 3]>            pha         ;use stack to load status
16881
2bc6 : b5b9             [ 4]>            lda zp1,x    ;load to indexed zeropage
16882
2bc8 : 95b2             [ 4]>            sta zpt,x
16883
2bca : 28               [ 4]>            plp
16884 2 MichaelA
 
16885 3 MichaelA
2bcb : 16b2             [ 6]         asl zpt,x
16886 2 MichaelA
                                     tst_zx rASL,fASL,0
16887 3 MichaelA
2bcd : 08               [ 3]>            php         ;save flags
16888
2bce : b5b2             [ 4]>            lda zpt,x
16889
2bd0 : dd1102           [ 4]>            cmp rASL,x    ;test result
16890 2 MichaelA
                            >            trap_ne
16891 3 MichaelA
2bd3 : f002             [ 3]>        beq skip2575
16892
                            >        trap           ;failed equal (zero)
16893
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16894
2bd5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16895
2bd6 : 20                   >        db      test_num
16896 2 MichaelA
                            >
16897 3 MichaelA
2bd7 :                      >skip2575
16898
                            >
16899
2bd7 : 68               [ 4]>            pla         ;load status
16900 2 MichaelA
                            >            eor_flag 0
16901 3 MichaelA
2bd8 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
16902
                            >
16903
2bda : dd2102           [ 4]>            cmp fASL,x    ;test flags
16904
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  293
16905 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16906
 
16907
                            >            trap_ne
16908 3 MichaelA
2bdd : f002             [ 3]>        beq skip2578
16909
                            >        trap           ;failed equal (zero)
16910
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16911
2bdf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16912
2be0 : 20                   >        db      test_num
16913 2 MichaelA
                            >
16914 3 MichaelA
2be1 :                      >skip2578
16915
                            >
16916 2 MichaelA
 
16917 3 MichaelA
2be1 : ca               [ 2]         dex
16918
2be2 : 10df             [ 3]         bpl tasl6
16919
2be4 : a203             [ 2]         ldx #3
16920
2be6 :                       tasl7
16921 2 MichaelA
                                     set_zx zp1,$ff
16922
                            >            load_flag $ff
16923 3 MichaelA
2be6 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
16924 2 MichaelA
                            >
16925 3 MichaelA
2be8 : 48               [ 3]>            pha         ;use stack to load status
16926
2be9 : b5b9             [ 4]>            lda zp1,x    ;load to indexed zeropage
16927
2beb : 95b2             [ 4]>            sta zpt,x
16928
2bed : 28               [ 4]>            plp
16929 2 MichaelA
 
16930 3 MichaelA
2bee : 16b2             [ 6]         asl zpt,x
16931 2 MichaelA
                                     tst_zx rASL,fASL,$ff-fnzc
16932 3 MichaelA
2bf0 : 08               [ 3]>            php         ;save flags
16933
2bf1 : b5b2             [ 4]>            lda zpt,x
16934
2bf3 : dd1102           [ 4]>            cmp rASL,x    ;test result
16935 2 MichaelA
                            >            trap_ne
16936 3 MichaelA
2bf6 : f002             [ 3]>        beq skip2583
16937
                            >        trap           ;failed equal (zero)
16938
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16939
2bf8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16940
2bf9 : 20                   >        db      test_num
16941 2 MichaelA
                            >
16942 3 MichaelA
2bfa :                      >skip2583
16943
                            >
16944
2bfa : 68               [ 4]>            pla         ;load status
16945 2 MichaelA
                            >            eor_flag $ff-fnzc
16946 3 MichaelA
2bfb : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
16947 2 MichaelA
                            >
16948 3 MichaelA
2bfd : dd2102           [ 4]>            cmp fASL,x    ;test flags
16949 2 MichaelA
                            >            trap_ne
16950 3 MichaelA
2c00 : f002             [ 3]>        beq skip2586
16951
                            >        trap           ;failed equal (zero)
16952
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16953
2c02 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16954
2c03 : 20                   >        db      test_num
16955 2 MichaelA
                            >
16956 3 MichaelA
2c04 :                      >skip2586
16957
                            >
16958 2 MichaelA
 
16959 3 MichaelA
2c04 : ca               [ 2]         dex
16960
2c05 : 10df             [ 4]         bpl tasl7
16961 2 MichaelA
 
16962 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  294
16963
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
16964
 
16965
2c07 : a203             [ 2]         ldx #3
16966
2c09 :                       tlsr6
16967 2 MichaelA
                                     set_zx zp1,0
16968
                            >            load_flag 0
16969 3 MichaelA
2c09 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
16970 2 MichaelA
                            >
16971 3 MichaelA
2c0b : 48               [ 3]>            pha         ;use stack to load status
16972
2c0c : b5b9             [ 4]>            lda zp1,x    ;load to indexed zeropage
16973
2c0e : 95b2             [ 4]>            sta zpt,x
16974
2c10 : 28               [ 4]>            plp
16975 2 MichaelA
 
16976 3 MichaelA
2c11 : 56b2             [ 6]         lsr zpt,x
16977 2 MichaelA
                                     tst_zx rLSR,fLSR,0
16978 3 MichaelA
2c13 : 08               [ 3]>            php         ;save flags
16979
2c14 : b5b2             [ 4]>            lda zpt,x
16980
2c16 : dd1902           [ 4]>            cmp rLSR,x    ;test result
16981 2 MichaelA
                            >            trap_ne
16982 3 MichaelA
2c19 : f002             [ 3]>        beq skip2591
16983
                            >        trap           ;failed equal (zero)
16984
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16985
2c1b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
16986
2c1c : 20                   >        db      test_num
16987 2 MichaelA
                            >
16988 3 MichaelA
2c1d :                      >skip2591
16989
                            >
16990
2c1d : 68               [ 4]>            pla         ;load status
16991 2 MichaelA
                            >            eor_flag 0
16992 3 MichaelA
2c1e : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
16993 2 MichaelA
                            >
16994 3 MichaelA
2c20 : dd2902           [ 4]>            cmp fLSR,x    ;test flags
16995 2 MichaelA
                            >            trap_ne
16996 3 MichaelA
2c23 : f002             [ 3]>        beq skip2594
16997
                            >        trap           ;failed equal (zero)
16998
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
16999
2c25 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17000
2c26 : 20                   >        db      test_num
17001 2 MichaelA
                            >
17002 3 MichaelA
2c27 :                      >skip2594
17003
                            >
17004 2 MichaelA
 
17005 3 MichaelA
2c27 : ca               [ 2]         dex
17006
2c28 : 10df             [ 3]         bpl tlsr6
17007
2c2a : a203             [ 2]         ldx #3
17008
2c2c :                       tlsr7
17009 2 MichaelA
                                     set_zx zp1,$ff
17010
                            >            load_flag $ff
17011 3 MichaelA
2c2c : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
17012 2 MichaelA
                            >
17013 3 MichaelA
2c2e : 48               [ 3]>            pha         ;use stack to load status
17014
2c2f : b5b9             [ 4]>            lda zp1,x    ;load to indexed zeropage
17015
2c31 : 95b2             [ 4]>            sta zpt,x
17016
2c33 : 28               [ 4]>            plp
17017 2 MichaelA
 
17018 3 MichaelA
2c34 : 56b2             [ 6]         lsr zpt,x
17019 2 MichaelA
                                     tst_zx rLSR,fLSR,$ff-fnzc
17020 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  295
17021
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17022
 
17023
2c36 : 08               [ 3]>            php         ;save flags
17024
2c37 : b5b2             [ 4]>            lda zpt,x
17025
2c39 : dd1902           [ 4]>            cmp rLSR,x    ;test result
17026 2 MichaelA
                            >            trap_ne
17027 3 MichaelA
2c3c : f002             [ 3]>        beq skip2599
17028
                            >        trap           ;failed equal (zero)
17029
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17030
2c3e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17031
2c3f : 20                   >        db      test_num
17032 2 MichaelA
                            >
17033 3 MichaelA
2c40 :                      >skip2599
17034
                            >
17035
2c40 : 68               [ 4]>            pla         ;load status
17036 2 MichaelA
                            >            eor_flag $ff-fnzc
17037 3 MichaelA
2c41 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
17038 2 MichaelA
                            >
17039 3 MichaelA
2c43 : dd2902           [ 4]>            cmp fLSR,x    ;test flags
17040 2 MichaelA
                            >            trap_ne
17041 3 MichaelA
2c46 : f002             [ 3]>        beq skip2602
17042
                            >        trap           ;failed equal (zero)
17043
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17044
2c48 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17045
2c49 : 20                   >        db      test_num
17046 2 MichaelA
                            >
17047 3 MichaelA
2c4a :                      >skip2602
17048
                            >
17049 2 MichaelA
 
17050 3 MichaelA
2c4a : ca               [ 2]         dex
17051
2c4b : 10df             [ 3]         bpl tlsr7
17052 2 MichaelA
 
17053 3 MichaelA
2c4d : a203             [ 2]         ldx #3
17054
2c4f :                       trol6
17055 2 MichaelA
                                     set_zx zp1,0
17056
                            >            load_flag 0
17057 3 MichaelA
2c4f : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
17058 2 MichaelA
                            >
17059 3 MichaelA
2c51 : 48               [ 3]>            pha         ;use stack to load status
17060
2c52 : b5b9             [ 4]>            lda zp1,x    ;load to indexed zeropage
17061
2c54 : 95b2             [ 4]>            sta zpt,x
17062
2c56 : 28               [ 4]>            plp
17063 2 MichaelA
 
17064 3 MichaelA
2c57 : 36b2             [ 6]         rol zpt,x
17065 2 MichaelA
                                     tst_zx rROL,fROL,0
17066 3 MichaelA
2c59 : 08               [ 3]>            php         ;save flags
17067
2c5a : b5b2             [ 4]>            lda zpt,x
17068
2c5c : dd1102           [ 4]>            cmp rROL,x    ;test result
17069 2 MichaelA
                            >            trap_ne
17070 3 MichaelA
2c5f : f002             [ 3]>        beq skip2607
17071
                            >        trap           ;failed equal (zero)
17072
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17073
2c61 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17074
2c62 : 20                   >        db      test_num
17075 2 MichaelA
                            >
17076 3 MichaelA
2c63 :                      >skip2607
17077
                            >
17078
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  296
17079
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17080
 
17081
2c63 : 68               [ 4]>            pla         ;load status
17082 2 MichaelA
                            >            eor_flag 0
17083 3 MichaelA
2c64 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
17084 2 MichaelA
                            >
17085 3 MichaelA
2c66 : dd2102           [ 4]>            cmp fROL,x    ;test flags
17086 2 MichaelA
                            >            trap_ne
17087 3 MichaelA
2c69 : f002             [ 3]>        beq skip2610
17088
                            >        trap           ;failed equal (zero)
17089
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17090
2c6b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17091
2c6c : 20                   >        db      test_num
17092 2 MichaelA
                            >
17093 3 MichaelA
2c6d :                      >skip2610
17094
                            >
17095 2 MichaelA
 
17096 3 MichaelA
2c6d : ca               [ 2]         dex
17097
2c6e : 10df             [ 3]         bpl trol6
17098
2c70 : a203             [ 2]         ldx #3
17099
2c72 :                       trol7
17100 2 MichaelA
                                     set_zx zp1,$ff-fc
17101
                            >            load_flag $ff-fc
17102 3 MichaelA
2c72 : a9fe             [ 2]>            lda #$ff-fc             ;allow test to change I-flag (no mask)
17103 2 MichaelA
                            >
17104 3 MichaelA
2c74 : 48               [ 3]>            pha         ;use stack to load status
17105
2c75 : b5b9             [ 4]>            lda zp1,x    ;load to indexed zeropage
17106
2c77 : 95b2             [ 4]>            sta zpt,x
17107
2c79 : 28               [ 4]>            plp
17108 2 MichaelA
 
17109 3 MichaelA
2c7a : 36b2             [ 6]         rol zpt,x
17110 2 MichaelA
                                     tst_zx rROL,fROL,$ff-fnzc
17111 3 MichaelA
2c7c : 08               [ 3]>            php         ;save flags
17112
2c7d : b5b2             [ 4]>            lda zpt,x
17113
2c7f : dd1102           [ 4]>            cmp rROL,x    ;test result
17114 2 MichaelA
                            >            trap_ne
17115 3 MichaelA
2c82 : f002             [ 3]>        beq skip2615
17116
                            >        trap           ;failed equal (zero)
17117
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17118
2c84 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17119
2c85 : 20                   >        db      test_num
17120 2 MichaelA
                            >
17121 3 MichaelA
2c86 :                      >skip2615
17122
                            >
17123
2c86 : 68               [ 4]>            pla         ;load status
17124 2 MichaelA
                            >            eor_flag $ff-fnzc
17125 3 MichaelA
2c87 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
17126 2 MichaelA
                            >
17127 3 MichaelA
2c89 : dd2102           [ 4]>            cmp fROL,x    ;test flags
17128 2 MichaelA
                            >            trap_ne
17129 3 MichaelA
2c8c : f002             [ 3]>        beq skip2618
17130
                            >        trap           ;failed equal (zero)
17131
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17132
2c8e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17133
2c8f : 20                   >        db      test_num
17134 2 MichaelA
                            >
17135 3 MichaelA
2c90 :                      >skip2618
17136
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  297
17137
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17138
 
17139
                            >
17140 2 MichaelA
 
17141 3 MichaelA
2c90 : ca               [ 2]         dex
17142
2c91 : 10df             [ 3]         bpl trol7
17143 2 MichaelA
 
17144 3 MichaelA
2c93 : a203             [ 2]         ldx #3
17145
2c95 :                       trolc6
17146 2 MichaelA
                                     set_zx zp1,fc
17147
                            >            load_flag fc
17148 3 MichaelA
2c95 : a901             [ 2]>            lda #fc             ;allow test to change I-flag (no mask)
17149 2 MichaelA
                            >
17150 3 MichaelA
2c97 : 48               [ 3]>            pha         ;use stack to load status
17151
2c98 : b5b9             [ 4]>            lda zp1,x    ;load to indexed zeropage
17152
2c9a : 95b2             [ 4]>            sta zpt,x
17153
2c9c : 28               [ 4]>            plp
17154 2 MichaelA
 
17155 3 MichaelA
2c9d : 36b2             [ 6]         rol zpt,x
17156 2 MichaelA
                                     tst_zx rROLc,fROLc,0
17157 3 MichaelA
2c9f : 08               [ 3]>            php         ;save flags
17158
2ca0 : b5b2             [ 4]>            lda zpt,x
17159
2ca2 : dd1502           [ 4]>            cmp rROLc,x    ;test result
17160 2 MichaelA
                            >            trap_ne
17161 3 MichaelA
2ca5 : f002             [ 3]>        beq skip2623
17162
                            >        trap           ;failed equal (zero)
17163
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17164
2ca7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17165
2ca8 : 20                   >        db      test_num
17166 2 MichaelA
                            >
17167 3 MichaelA
2ca9 :                      >skip2623
17168
                            >
17169
2ca9 : 68               [ 4]>            pla         ;load status
17170 2 MichaelA
                            >            eor_flag 0
17171 3 MichaelA
2caa : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
17172 2 MichaelA
                            >
17173 3 MichaelA
2cac : dd2502           [ 4]>            cmp fROLc,x    ;test flags
17174 2 MichaelA
                            >            trap_ne
17175 3 MichaelA
2caf : f002             [ 3]>        beq skip2626
17176
                            >        trap           ;failed equal (zero)
17177
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17178
2cb1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17179
2cb2 : 20                   >        db      test_num
17180 2 MichaelA
                            >
17181 3 MichaelA
2cb3 :                      >skip2626
17182
                            >
17183 2 MichaelA
 
17184 3 MichaelA
2cb3 : ca               [ 2]         dex
17185
2cb4 : 10df             [ 3]         bpl trolc6
17186
2cb6 : a203             [ 2]         ldx #3
17187
2cb8 :                       trolc7
17188 2 MichaelA
                                     set_zx zp1,$ff
17189
                            >            load_flag $ff
17190 3 MichaelA
2cb8 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
17191 2 MichaelA
                            >
17192 3 MichaelA
2cba : 48               [ 3]>            pha         ;use stack to load status
17193
2cbb : b5b9             [ 4]>            lda zp1,x    ;load to indexed zeropage
17194
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  298
17195
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17196
 
17197
2cbd : 95b2             [ 4]>            sta zpt,x
17198
2cbf : 28               [ 4]>            plp
17199 2 MichaelA
 
17200 3 MichaelA
2cc0 : 36b2             [ 6]         rol zpt,x
17201 2 MichaelA
                                     tst_zx rROLc,fROLc,$ff-fnzc
17202 3 MichaelA
2cc2 : 08               [ 3]>            php         ;save flags
17203
2cc3 : b5b2             [ 4]>            lda zpt,x
17204
2cc5 : dd1502           [ 4]>            cmp rROLc,x    ;test result
17205 2 MichaelA
                            >            trap_ne
17206 3 MichaelA
2cc8 : f002             [ 3]>        beq skip2631
17207
                            >        trap           ;failed equal (zero)
17208
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17209
2cca : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17210
2ccb : 20                   >        db      test_num
17211 2 MichaelA
                            >
17212 3 MichaelA
2ccc :                      >skip2631
17213
                            >
17214
2ccc : 68               [ 4]>            pla         ;load status
17215 2 MichaelA
                            >            eor_flag $ff-fnzc
17216 3 MichaelA
2ccd : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
17217 2 MichaelA
                            >
17218 3 MichaelA
2ccf : dd2502           [ 4]>            cmp fROLc,x    ;test flags
17219 2 MichaelA
                            >            trap_ne
17220 3 MichaelA
2cd2 : f002             [ 3]>        beq skip2634
17221
                            >        trap           ;failed equal (zero)
17222
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17223
2cd4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17224
2cd5 : 20                   >        db      test_num
17225 2 MichaelA
                            >
17226 3 MichaelA
2cd6 :                      >skip2634
17227
                            >
17228 2 MichaelA
 
17229 3 MichaelA
2cd6 : ca               [ 2]         dex
17230
2cd7 : 10df             [ 3]         bpl trolc7
17231 2 MichaelA
 
17232 3 MichaelA
2cd9 : a203             [ 2]         ldx #3
17233
2cdb :                       tror6
17234 2 MichaelA
                                     set_zx zp1,0
17235
                            >            load_flag 0
17236 3 MichaelA
2cdb : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
17237 2 MichaelA
                            >
17238 3 MichaelA
2cdd : 48               [ 3]>            pha         ;use stack to load status
17239
2cde : b5b9             [ 4]>            lda zp1,x    ;load to indexed zeropage
17240
2ce0 : 95b2             [ 4]>            sta zpt,x
17241
2ce2 : 28               [ 4]>            plp
17242 2 MichaelA
 
17243 3 MichaelA
2ce3 : 76b2             [ 6]         ror zpt,x
17244 2 MichaelA
                                     tst_zx rROR,fROR,0
17245 3 MichaelA
2ce5 : 08               [ 3]>            php         ;save flags
17246
2ce6 : b5b2             [ 4]>            lda zpt,x
17247
2ce8 : dd1902           [ 4]>            cmp rROR,x    ;test result
17248 2 MichaelA
                            >            trap_ne
17249 3 MichaelA
2ceb : f002             [ 3]>        beq skip2639
17250
                            >        trap           ;failed equal (zero)
17251
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17252
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  299
17253
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17254
 
17255
2ced : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17256
2cee : 20                   >        db      test_num
17257 2 MichaelA
                            >
17258 3 MichaelA
2cef :                      >skip2639
17259
                            >
17260
2cef : 68               [ 4]>            pla         ;load status
17261 2 MichaelA
                            >            eor_flag 0
17262 3 MichaelA
2cf0 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
17263 2 MichaelA
                            >
17264 3 MichaelA
2cf2 : dd2902           [ 4]>            cmp fROR,x    ;test flags
17265 2 MichaelA
                            >            trap_ne
17266 3 MichaelA
2cf5 : f002             [ 3]>        beq skip2642
17267
                            >        trap           ;failed equal (zero)
17268
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17269
2cf7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17270
2cf8 : 20                   >        db      test_num
17271 2 MichaelA
                            >
17272 3 MichaelA
2cf9 :                      >skip2642
17273
                            >
17274 2 MichaelA
 
17275 3 MichaelA
2cf9 : ca               [ 2]         dex
17276
2cfa : 10df             [ 3]         bpl tror6
17277
2cfc : a203             [ 2]         ldx #3
17278
2cfe :                       tror7
17279 2 MichaelA
                                     set_zx zp1,$ff-fc
17280
                            >            load_flag $ff-fc
17281 3 MichaelA
2cfe : a9fe             [ 2]>            lda #$ff-fc             ;allow test to change I-flag (no mask)
17282 2 MichaelA
                            >
17283 3 MichaelA
2d00 : 48               [ 3]>            pha         ;use stack to load status
17284
2d01 : b5b9             [ 4]>            lda zp1,x    ;load to indexed zeropage
17285
2d03 : 95b2             [ 4]>            sta zpt,x
17286
2d05 : 28               [ 4]>            plp
17287 2 MichaelA
 
17288 3 MichaelA
2d06 : 76b2             [ 6]         ror zpt,x
17289 2 MichaelA
                                     tst_zx rROR,fROR,$ff-fnzc
17290 3 MichaelA
2d08 : 08               [ 3]>            php         ;save flags
17291
2d09 : b5b2             [ 4]>            lda zpt,x
17292
2d0b : dd1902           [ 4]>            cmp rROR,x    ;test result
17293 2 MichaelA
                            >            trap_ne
17294 3 MichaelA
2d0e : f002             [ 3]>        beq skip2647
17295
                            >        trap           ;failed equal (zero)
17296
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17297
2d10 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17298
2d11 : 20                   >        db      test_num
17299 2 MichaelA
                            >
17300 3 MichaelA
2d12 :                      >skip2647
17301
                            >
17302
2d12 : 68               [ 4]>            pla         ;load status
17303 2 MichaelA
                            >            eor_flag $ff-fnzc
17304 3 MichaelA
2d13 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
17305 2 MichaelA
                            >
17306 3 MichaelA
2d15 : dd2902           [ 4]>            cmp fROR,x    ;test flags
17307
                            >            trap_ne
17308
2d18 : f002             [ 3]>        beq skip2650
17309
                            >        trap           ;failed equal (zero)
17310
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  300
17311 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17312
 
17313 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17314
2d1a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17315
2d1b : 20                   >        db      test_num
17316 2 MichaelA
                            >
17317 3 MichaelA
2d1c :                      >skip2650
17318
                            >
17319 2 MichaelA
 
17320 3 MichaelA
2d1c : ca               [ 2]         dex
17321
2d1d : 10df             [ 4]         bpl tror7
17322 2 MichaelA
 
17323 3 MichaelA
2d1f : a203             [ 2]         ldx #3
17324
2d21 :                       trorc6
17325 2 MichaelA
                                     set_zx zp1,fc
17326
                            >            load_flag fc
17327 3 MichaelA
2d21 : a901             [ 2]>            lda #fc             ;allow test to change I-flag (no mask)
17328 2 MichaelA
                            >
17329 3 MichaelA
2d23 : 48               [ 3]>            pha         ;use stack to load status
17330
2d24 : b5b9             [ 4]>            lda zp1,x    ;load to indexed zeropage
17331
2d26 : 95b2             [ 4]>            sta zpt,x
17332
2d28 : 28               [ 4]>            plp
17333 2 MichaelA
 
17334 3 MichaelA
2d29 : 76b2             [ 6]         ror zpt,x
17335 2 MichaelA
                                     tst_zx rRORc,fRORc,0
17336 3 MichaelA
2d2b : 08               [ 3]>            php         ;save flags
17337
2d2c : b5b2             [ 4]>            lda zpt,x
17338
2d2e : dd1d02           [ 4]>            cmp rRORc,x    ;test result
17339 2 MichaelA
                            >            trap_ne
17340 3 MichaelA
2d31 : f002             [ 3]>        beq skip2655
17341
                            >        trap           ;failed equal (zero)
17342
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17343
2d33 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17344
2d34 : 20                   >        db      test_num
17345 2 MichaelA
                            >
17346 3 MichaelA
2d35 :                      >skip2655
17347
                            >
17348
2d35 : 68               [ 4]>            pla         ;load status
17349 2 MichaelA
                            >            eor_flag 0
17350 3 MichaelA
2d36 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
17351 2 MichaelA
                            >
17352 3 MichaelA
2d38 : dd2d02           [ 4]>            cmp fRORc,x    ;test flags
17353 2 MichaelA
                            >            trap_ne
17354 3 MichaelA
2d3b : f002             [ 3]>        beq skip2658
17355
                            >        trap           ;failed equal (zero)
17356
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17357
2d3d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17358
2d3e : 20                   >        db      test_num
17359 2 MichaelA
                            >
17360 3 MichaelA
2d3f :                      >skip2658
17361
                            >
17362 2 MichaelA
 
17363 3 MichaelA
2d3f : ca               [ 2]         dex
17364
2d40 : 10df             [ 3]         bpl trorc6
17365
2d42 : a203             [ 2]         ldx #3
17366
2d44 :                       trorc7
17367 2 MichaelA
                                     set_zx zp1,$ff
17368 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  301
17369
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17370
 
17371 2 MichaelA
                            >            load_flag $ff
17372 3 MichaelA
2d44 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
17373 2 MichaelA
                            >
17374 3 MichaelA
2d46 : 48               [ 3]>            pha         ;use stack to load status
17375
2d47 : b5b9             [ 4]>            lda zp1,x    ;load to indexed zeropage
17376
2d49 : 95b2             [ 4]>            sta zpt,x
17377
2d4b : 28               [ 4]>            plp
17378 2 MichaelA
 
17379 3 MichaelA
2d4c : 76b2             [ 6]         ror zpt,x
17380 2 MichaelA
                                     tst_zx rRORc,fRORc,$ff-fnzc
17381 3 MichaelA
2d4e : 08               [ 3]>            php         ;save flags
17382
2d4f : b5b2             [ 4]>            lda zpt,x
17383
2d51 : dd1d02           [ 4]>            cmp rRORc,x    ;test result
17384 2 MichaelA
                            >            trap_ne
17385 3 MichaelA
2d54 : f002             [ 3]>        beq skip2663
17386
                            >        trap           ;failed equal (zero)
17387
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17388
2d56 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17389
2d57 : 20                   >        db      test_num
17390 2 MichaelA
                            >
17391 3 MichaelA
2d58 :                      >skip2663
17392
                            >
17393
2d58 : 68               [ 4]>            pla         ;load status
17394 2 MichaelA
                            >            eor_flag $ff-fnzc
17395 3 MichaelA
2d59 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
17396 2 MichaelA
                            >
17397 3 MichaelA
2d5b : dd2d02           [ 4]>            cmp fRORc,x    ;test flags
17398 2 MichaelA
                            >            trap_ne
17399 3 MichaelA
2d5e : f002             [ 3]>        beq skip2666
17400
                            >        trap           ;failed equal (zero)
17401
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17402
2d60 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17403
2d61 : 20                   >        db      test_num
17404 2 MichaelA
                            >
17405 3 MichaelA
2d62 :                      >skip2666
17406
                            >
17407 2 MichaelA
 
17408 3 MichaelA
2d62 : ca               [ 2]         dex
17409
2d63 : 10df             [ 3]         bpl trorc7
17410 2 MichaelA
                                     next_test
17411 3 MichaelA
2d65 : ad0002           [ 4]>            lda test_case   ;previous test
17412
2d68 : c920             [ 2]>            cmp #test_num
17413 2 MichaelA
                            >            trap_ne         ;test is out of sequence
17414 3 MichaelA
2d6a : f002             [ 3]>        beq skip2669
17415
                            >        trap           ;failed equal (zero)
17416
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17417
2d6c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17418
2d6d : 20                   >        db      test_num
17419 2 MichaelA
                            >
17420 3 MichaelA
2d6e :                      >skip2669
17421
                            >
17422 2 MichaelA
0021 =                      >test_num = test_num + 1
17423 3 MichaelA
2d6e : a921             [ 2]>            lda #test_num   ;*** this tests' number
17424
2d70 : 8d0002           [ 4]>            sta test_case
17425 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
17426 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  302
17427
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17428
 
17429 2 MichaelA
 
17430
 
17431
                             ; shifts - abs indexed
17432 3 MichaelA
 
17433
2d73 : a203             [ 2]         ldx #3
17434
2d75 :                       tasl8
17435 2 MichaelA
                                     set_absx zp1,0
17436
                            >            load_flag 0
17437 3 MichaelA
2d75 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
17438 2 MichaelA
                            >
17439 3 MichaelA
2d77 : 48               [ 3]>            pha         ;use stack to load status
17440
2d78 : b5b9             [ 4]>            lda zp1,x    ;load to indexed memory
17441
2d7a : 9d0302           [ 5]>            sta abst,x
17442
2d7d : 28               [ 4]>            plp
17443 2 MichaelA
 
17444 3 MichaelA
2d7e : 1e0302           [ 7]         asl abst,x
17445 2 MichaelA
                                     tst_absx rASL,fASL,0
17446 3 MichaelA
2d81 : 08               [ 3]>            php         ;save flags
17447
2d82 : bd0302           [ 4]>            lda abst,x
17448
2d85 : dd1102           [ 4]>            cmp rASL,x    ;test result
17449 2 MichaelA
                            >            trap_ne
17450 3 MichaelA
2d88 : f002             [ 3]>        beq skip2674
17451
                            >        trap           ;failed equal (zero)
17452
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17453
2d8a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17454
2d8b : 21                   >        db      test_num
17455 2 MichaelA
                            >
17456 3 MichaelA
2d8c :                      >skip2674
17457
                            >
17458
2d8c : 68               [ 4]>            pla         ;load status
17459 2 MichaelA
                            >            eor_flag 0
17460 3 MichaelA
2d8d : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
17461 2 MichaelA
                            >
17462 3 MichaelA
2d8f : dd2102           [ 4]>            cmp fASL,x    ;test flags
17463 2 MichaelA
                            >            trap_ne
17464 3 MichaelA
2d92 : f002             [ 3]>        beq skip2677
17465
                            >        trap           ;failed equal (zero)
17466
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17467
2d94 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17468
2d95 : 21                   >        db      test_num
17469 2 MichaelA
                            >
17470 3 MichaelA
2d96 :                      >skip2677
17471
                            >
17472 2 MichaelA
 
17473 3 MichaelA
2d96 : ca               [ 2]         dex
17474
2d97 : 10dc             [ 3]         bpl tasl8
17475
2d99 : a203             [ 2]         ldx #3
17476
2d9b :                       tasl9
17477 2 MichaelA
                                     set_absx zp1,$ff
17478
                            >            load_flag $ff
17479 3 MichaelA
2d9b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
17480 2 MichaelA
                            >
17481 3 MichaelA
2d9d : 48               [ 3]>            pha         ;use stack to load status
17482
2d9e : b5b9             [ 4]>            lda zp1,x    ;load to indexed memory
17483
2da0 : 9d0302           [ 5]>            sta abst,x
17484
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  303
17485
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17486
 
17487
2da3 : 28               [ 4]>            plp
17488 2 MichaelA
 
17489 3 MichaelA
2da4 : 1e0302           [ 7]         asl abst,x
17490 2 MichaelA
                                     tst_absx rASL,fASL,$ff-fnzc
17491 3 MichaelA
2da7 : 08               [ 3]>            php         ;save flags
17492
2da8 : bd0302           [ 4]>            lda abst,x
17493
2dab : dd1102           [ 4]>            cmp rASL,x    ;test result
17494 2 MichaelA
                            >            trap_ne
17495 3 MichaelA
2dae : f002             [ 3]>        beq skip2682
17496
                            >        trap           ;failed equal (zero)
17497
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17498
2db0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17499
2db1 : 21                   >        db      test_num
17500 2 MichaelA
                            >
17501 3 MichaelA
2db2 :                      >skip2682
17502
                            >
17503
2db2 : 68               [ 4]>            pla         ;load status
17504 2 MichaelA
                            >            eor_flag $ff-fnzc
17505 3 MichaelA
2db3 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
17506 2 MichaelA
                            >
17507 3 MichaelA
2db5 : dd2102           [ 4]>            cmp fASL,x    ;test flags
17508 2 MichaelA
                            >            trap_ne
17509 3 MichaelA
2db8 : f002             [ 3]>        beq skip2685
17510
                            >        trap           ;failed equal (zero)
17511
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17512
2dba : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17513
2dbb : 21                   >        db      test_num
17514 2 MichaelA
                            >
17515 3 MichaelA
2dbc :                      >skip2685
17516
                            >
17517 2 MichaelA
 
17518 3 MichaelA
2dbc : ca               [ 2]         dex
17519
2dbd : 10dc             [ 3]         bpl tasl9
17520 2 MichaelA
 
17521 3 MichaelA
2dbf : a203             [ 2]         ldx #3
17522
2dc1 :                       tlsr8
17523 2 MichaelA
                                     set_absx zp1,0
17524
                            >            load_flag 0
17525 3 MichaelA
2dc1 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
17526 2 MichaelA
                            >
17527 3 MichaelA
2dc3 : 48               [ 3]>            pha         ;use stack to load status
17528
2dc4 : b5b9             [ 4]>            lda zp1,x    ;load to indexed memory
17529
2dc6 : 9d0302           [ 5]>            sta abst,x
17530
2dc9 : 28               [ 4]>            plp
17531 2 MichaelA
 
17532 3 MichaelA
2dca : 5e0302           [ 7]         lsr abst,x
17533 2 MichaelA
                                     tst_absx rLSR,fLSR,0
17534 3 MichaelA
2dcd : 08               [ 3]>            php         ;save flags
17535
2dce : bd0302           [ 4]>            lda abst,x
17536
2dd1 : dd1902           [ 4]>            cmp rLSR,x    ;test result
17537 2 MichaelA
                            >            trap_ne
17538 3 MichaelA
2dd4 : f002             [ 3]>        beq skip2690
17539
                            >        trap           ;failed equal (zero)
17540
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17541
2dd6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17542
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  304
17543
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17544
 
17545
2dd7 : 21                   >        db      test_num
17546 2 MichaelA
                            >
17547 3 MichaelA
2dd8 :                      >skip2690
17548
                            >
17549
2dd8 : 68               [ 4]>            pla         ;load status
17550 2 MichaelA
                            >            eor_flag 0
17551 3 MichaelA
2dd9 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
17552 2 MichaelA
                            >
17553 3 MichaelA
2ddb : dd2902           [ 4]>            cmp fLSR,x    ;test flags
17554 2 MichaelA
                            >            trap_ne
17555 3 MichaelA
2dde : f002             [ 3]>        beq skip2693
17556
                            >        trap           ;failed equal (zero)
17557
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17558
2de0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17559
2de1 : 21                   >        db      test_num
17560 2 MichaelA
                            >
17561 3 MichaelA
2de2 :                      >skip2693
17562
                            >
17563 2 MichaelA
 
17564 3 MichaelA
2de2 : ca               [ 2]         dex
17565
2de3 : 10dc             [ 3]         bpl tlsr8
17566
2de5 : a203             [ 2]         ldx #3
17567
2de7 :                       tlsr9
17568 2 MichaelA
                                     set_absx zp1,$ff
17569
                            >            load_flag $ff
17570 3 MichaelA
2de7 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
17571 2 MichaelA
                            >
17572 3 MichaelA
2de9 : 48               [ 3]>            pha         ;use stack to load status
17573
2dea : b5b9             [ 4]>            lda zp1,x    ;load to indexed memory
17574
2dec : 9d0302           [ 5]>            sta abst,x
17575
2def : 28               [ 4]>            plp
17576 2 MichaelA
 
17577 3 MichaelA
2df0 : 5e0302           [ 7]         lsr abst,x
17578 2 MichaelA
                                     tst_absx rLSR,fLSR,$ff-fnzc
17579 3 MichaelA
2df3 : 08               [ 3]>            php         ;save flags
17580
2df4 : bd0302           [ 4]>            lda abst,x
17581
2df7 : dd1902           [ 4]>            cmp rLSR,x    ;test result
17582 2 MichaelA
                            >            trap_ne
17583 3 MichaelA
2dfa : f002             [ 3]>        beq skip2698
17584
                            >        trap           ;failed equal (zero)
17585
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17586
2dfc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17587
2dfd : 21                   >        db      test_num
17588 2 MichaelA
                            >
17589 3 MichaelA
2dfe :                      >skip2698
17590
                            >
17591
2dfe : 68               [ 4]>            pla         ;load status
17592 2 MichaelA
                            >            eor_flag $ff-fnzc
17593 3 MichaelA
2dff : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
17594 2 MichaelA
                            >
17595 3 MichaelA
2e01 : dd2902           [ 4]>            cmp fLSR,x    ;test flags
17596 2 MichaelA
                            >            trap_ne
17597 3 MichaelA
2e04 : f002             [ 3]>        beq skip2701
17598
                            >        trap           ;failed equal (zero)
17599
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17600
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  305
17601
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17602
 
17603
2e06 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17604
2e07 : 21                   >        db      test_num
17605 2 MichaelA
                            >
17606 3 MichaelA
2e08 :                      >skip2701
17607
                            >
17608 2 MichaelA
 
17609 3 MichaelA
2e08 : ca               [ 2]         dex
17610
2e09 : 10dc             [ 4]         bpl tlsr9
17611 2 MichaelA
 
17612 3 MichaelA
2e0b : a203             [ 2]         ldx #3
17613
2e0d :                       trol8
17614 2 MichaelA
                                     set_absx zp1,0
17615
                            >            load_flag 0
17616 3 MichaelA
2e0d : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
17617 2 MichaelA
                            >
17618 3 MichaelA
2e0f : 48               [ 3]>            pha         ;use stack to load status
17619
2e10 : b5b9             [ 4]>            lda zp1,x    ;load to indexed memory
17620
2e12 : 9d0302           [ 5]>            sta abst,x
17621
2e15 : 28               [ 4]>            plp
17622 2 MichaelA
 
17623 3 MichaelA
2e16 : 3e0302           [ 7]         rol abst,x
17624 2 MichaelA
                                     tst_absx rROL,fROL,0
17625 3 MichaelA
2e19 : 08               [ 3]>            php         ;save flags
17626
2e1a : bd0302           [ 4]>            lda abst,x
17627
2e1d : dd1102           [ 4]>            cmp rROL,x    ;test result
17628 2 MichaelA
                            >            trap_ne
17629 3 MichaelA
2e20 : f002             [ 3]>        beq skip2706
17630
                            >        trap           ;failed equal (zero)
17631
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17632
2e22 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17633
2e23 : 21                   >        db      test_num
17634 2 MichaelA
                            >
17635 3 MichaelA
2e24 :                      >skip2706
17636
                            >
17637
2e24 : 68               [ 4]>            pla         ;load status
17638 2 MichaelA
                            >            eor_flag 0
17639 3 MichaelA
2e25 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
17640 2 MichaelA
                            >
17641 3 MichaelA
2e27 : dd2102           [ 4]>            cmp fROL,x    ;test flags
17642 2 MichaelA
                            >            trap_ne
17643 3 MichaelA
2e2a : f002             [ 3]>        beq skip2709
17644
                            >        trap           ;failed equal (zero)
17645
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17646
2e2c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17647
2e2d : 21                   >        db      test_num
17648 2 MichaelA
                            >
17649 3 MichaelA
2e2e :                      >skip2709
17650
                            >
17651 2 MichaelA
 
17652 3 MichaelA
2e2e : ca               [ 2]         dex
17653
2e2f : 10dc             [ 3]         bpl trol8
17654
2e31 : a203             [ 2]         ldx #3
17655
2e33 :                       trol9
17656 2 MichaelA
                                     set_absx zp1,$ff-fc
17657
                            >            load_flag $ff-fc
17658 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  306
17659
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17660
 
17661
2e33 : a9fe             [ 2]>            lda #$ff-fc             ;allow test to change I-flag (no mask)
17662 2 MichaelA
                            >
17663 3 MichaelA
2e35 : 48               [ 3]>            pha         ;use stack to load status
17664
2e36 : b5b9             [ 4]>            lda zp1,x    ;load to indexed memory
17665
2e38 : 9d0302           [ 5]>            sta abst,x
17666
2e3b : 28               [ 4]>            plp
17667 2 MichaelA
 
17668 3 MichaelA
2e3c : 3e0302           [ 7]         rol abst,x
17669 2 MichaelA
                                     tst_absx rROL,fROL,$ff-fnzc
17670 3 MichaelA
2e3f : 08               [ 3]>            php         ;save flags
17671
2e40 : bd0302           [ 4]>            lda abst,x
17672
2e43 : dd1102           [ 4]>            cmp rROL,x    ;test result
17673 2 MichaelA
                            >            trap_ne
17674 3 MichaelA
2e46 : f002             [ 3]>        beq skip2714
17675
                            >        trap           ;failed equal (zero)
17676
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17677
2e48 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17678
2e49 : 21                   >        db      test_num
17679 2 MichaelA
                            >
17680 3 MichaelA
2e4a :                      >skip2714
17681
                            >
17682
2e4a : 68               [ 4]>            pla         ;load status
17683 2 MichaelA
                            >            eor_flag $ff-fnzc
17684 3 MichaelA
2e4b : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
17685 2 MichaelA
                            >
17686 3 MichaelA
2e4d : dd2102           [ 4]>            cmp fROL,x    ;test flags
17687 2 MichaelA
                            >            trap_ne
17688 3 MichaelA
2e50 : f002             [ 3]>        beq skip2717
17689
                            >        trap           ;failed equal (zero)
17690
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17691
2e52 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17692
2e53 : 21                   >        db      test_num
17693 2 MichaelA
                            >
17694 3 MichaelA
2e54 :                      >skip2717
17695
                            >
17696 2 MichaelA
 
17697 3 MichaelA
2e54 : ca               [ 2]         dex
17698
2e55 : 10dc             [ 3]         bpl trol9
17699 2 MichaelA
 
17700 3 MichaelA
2e57 : a203             [ 2]         ldx #3
17701
2e59 :                       trolc8
17702 2 MichaelA
                                     set_absx zp1,fc
17703
                            >            load_flag fc
17704 3 MichaelA
2e59 : a901             [ 2]>            lda #fc             ;allow test to change I-flag (no mask)
17705 2 MichaelA
                            >
17706 3 MichaelA
2e5b : 48               [ 3]>            pha         ;use stack to load status
17707
2e5c : b5b9             [ 4]>            lda zp1,x    ;load to indexed memory
17708
2e5e : 9d0302           [ 5]>            sta abst,x
17709
2e61 : 28               [ 4]>            plp
17710 2 MichaelA
 
17711 3 MichaelA
2e62 : 3e0302           [ 7]         rol abst,x
17712
                                     tst_absx rROLc,fROLc,0
17713
2e65 : 08               [ 3]>            php         ;save flags
17714
2e66 : bd0302           [ 4]>            lda abst,x
17715
2e69 : dd1502           [ 4]>            cmp rROLc,x    ;test result
17716
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  307
17717 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17718
 
17719
                            >            trap_ne
17720 3 MichaelA
2e6c : f002             [ 3]>        beq skip2722
17721
                            >        trap           ;failed equal (zero)
17722
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17723
2e6e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17724
2e6f : 21                   >        db      test_num
17725 2 MichaelA
                            >
17726 3 MichaelA
2e70 :                      >skip2722
17727
                            >
17728
2e70 : 68               [ 4]>            pla         ;load status
17729 2 MichaelA
                            >            eor_flag 0
17730 3 MichaelA
2e71 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
17731 2 MichaelA
                            >
17732 3 MichaelA
2e73 : dd2502           [ 4]>            cmp fROLc,x    ;test flags
17733 2 MichaelA
                            >            trap_ne
17734 3 MichaelA
2e76 : f002             [ 3]>        beq skip2725
17735
                            >        trap           ;failed equal (zero)
17736
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17737
2e78 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17738
2e79 : 21                   >        db      test_num
17739 2 MichaelA
                            >
17740 3 MichaelA
2e7a :                      >skip2725
17741
                            >
17742 2 MichaelA
 
17743 3 MichaelA
2e7a : ca               [ 2]         dex
17744
2e7b : 10dc             [ 3]         bpl trolc8
17745
2e7d : a203             [ 2]         ldx #3
17746
2e7f :                       trolc9
17747 2 MichaelA
                                     set_absx zp1,$ff
17748
                            >            load_flag $ff
17749 3 MichaelA
2e7f : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
17750 2 MichaelA
                            >
17751 3 MichaelA
2e81 : 48               [ 3]>            pha         ;use stack to load status
17752
2e82 : b5b9             [ 4]>            lda zp1,x    ;load to indexed memory
17753
2e84 : 9d0302           [ 5]>            sta abst,x
17754
2e87 : 28               [ 4]>            plp
17755 2 MichaelA
 
17756 3 MichaelA
2e88 : 3e0302           [ 7]         rol abst,x
17757 2 MichaelA
                                     tst_absx rROLc,fROLc,$ff-fnzc
17758 3 MichaelA
2e8b : 08               [ 3]>            php         ;save flags
17759
2e8c : bd0302           [ 4]>            lda abst,x
17760
2e8f : dd1502           [ 4]>            cmp rROLc,x    ;test result
17761 2 MichaelA
                            >            trap_ne
17762 3 MichaelA
2e92 : f002             [ 3]>        beq skip2730
17763
                            >        trap           ;failed equal (zero)
17764
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17765
2e94 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17766
2e95 : 21                   >        db      test_num
17767 2 MichaelA
                            >
17768 3 MichaelA
2e96 :                      >skip2730
17769
                            >
17770
2e96 : 68               [ 4]>            pla         ;load status
17771 2 MichaelA
                            >            eor_flag $ff-fnzc
17772 3 MichaelA
2e97 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
17773 2 MichaelA
                            >
17774 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  308
17775
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17776
 
17777
2e99 : dd2502           [ 4]>            cmp fROLc,x    ;test flags
17778 2 MichaelA
                            >            trap_ne
17779 3 MichaelA
2e9c : f002             [ 3]>        beq skip2733
17780
                            >        trap           ;failed equal (zero)
17781
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17782
2e9e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17783
2e9f : 21                   >        db      test_num
17784 2 MichaelA
                            >
17785 3 MichaelA
2ea0 :                      >skip2733
17786
                            >
17787 2 MichaelA
 
17788 3 MichaelA
2ea0 : ca               [ 2]         dex
17789
2ea1 : 10dc             [ 3]         bpl trolc9
17790 2 MichaelA
 
17791 3 MichaelA
2ea3 : a203             [ 2]         ldx #3
17792
2ea5 :                       tror8
17793 2 MichaelA
                                     set_absx zp1,0
17794
                            >            load_flag 0
17795 3 MichaelA
2ea5 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
17796 2 MichaelA
                            >
17797 3 MichaelA
2ea7 : 48               [ 3]>            pha         ;use stack to load status
17798
2ea8 : b5b9             [ 4]>            lda zp1,x    ;load to indexed memory
17799
2eaa : 9d0302           [ 5]>            sta abst,x
17800
2ead : 28               [ 4]>            plp
17801 2 MichaelA
 
17802 3 MichaelA
2eae : 7e0302           [ 7]         ror abst,x
17803 2 MichaelA
                                     tst_absx rROR,fROR,0
17804 3 MichaelA
2eb1 : 08               [ 3]>            php         ;save flags
17805
2eb2 : bd0302           [ 4]>            lda abst,x
17806
2eb5 : dd1902           [ 4]>            cmp rROR,x    ;test result
17807 2 MichaelA
                            >            trap_ne
17808 3 MichaelA
2eb8 : f002             [ 3]>        beq skip2738
17809
                            >        trap           ;failed equal (zero)
17810
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17811
2eba : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17812
2ebb : 21                   >        db      test_num
17813 2 MichaelA
                            >
17814 3 MichaelA
2ebc :                      >skip2738
17815
                            >
17816
2ebc : 68               [ 4]>            pla         ;load status
17817 2 MichaelA
                            >            eor_flag 0
17818 3 MichaelA
2ebd : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
17819 2 MichaelA
                            >
17820 3 MichaelA
2ebf : dd2902           [ 4]>            cmp fROR,x    ;test flags
17821 2 MichaelA
                            >            trap_ne
17822 3 MichaelA
2ec2 : f002             [ 3]>        beq skip2741
17823
                            >        trap           ;failed equal (zero)
17824
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17825
2ec4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17826
2ec5 : 21                   >        db      test_num
17827 2 MichaelA
                            >
17828 3 MichaelA
2ec6 :                      >skip2741
17829
                            >
17830 2 MichaelA
 
17831 3 MichaelA
2ec6 : ca               [ 2]         dex
17832
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  309
17833
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17834
 
17835
2ec7 : 10dc             [ 3]         bpl tror8
17836
2ec9 : a203             [ 2]         ldx #3
17837
2ecb :                       tror9
17838 2 MichaelA
                                     set_absx zp1,$ff-fc
17839
                            >            load_flag $ff-fc
17840 3 MichaelA
2ecb : a9fe             [ 2]>            lda #$ff-fc             ;allow test to change I-flag (no mask)
17841 2 MichaelA
                            >
17842 3 MichaelA
2ecd : 48               [ 3]>            pha         ;use stack to load status
17843
2ece : b5b9             [ 4]>            lda zp1,x    ;load to indexed memory
17844
2ed0 : 9d0302           [ 5]>            sta abst,x
17845
2ed3 : 28               [ 4]>            plp
17846 2 MichaelA
 
17847 3 MichaelA
2ed4 : 7e0302           [ 7]         ror abst,x
17848 2 MichaelA
                                     tst_absx rROR,fROR,$ff-fnzc
17849 3 MichaelA
2ed7 : 08               [ 3]>            php         ;save flags
17850
2ed8 : bd0302           [ 4]>            lda abst,x
17851
2edb : dd1902           [ 4]>            cmp rROR,x    ;test result
17852 2 MichaelA
                            >            trap_ne
17853 3 MichaelA
2ede : f002             [ 3]>        beq skip2746
17854
                            >        trap           ;failed equal (zero)
17855
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17856
2ee0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17857
2ee1 : 21                   >        db      test_num
17858 2 MichaelA
                            >
17859 3 MichaelA
2ee2 :                      >skip2746
17860
                            >
17861
2ee2 : 68               [ 4]>            pla         ;load status
17862 2 MichaelA
                            >            eor_flag $ff-fnzc
17863 3 MichaelA
2ee3 : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
17864 2 MichaelA
                            >
17865 3 MichaelA
2ee5 : dd2902           [ 4]>            cmp fROR,x    ;test flags
17866 2 MichaelA
                            >            trap_ne
17867 3 MichaelA
2ee8 : f002             [ 3]>        beq skip2749
17868
                            >        trap           ;failed equal (zero)
17869
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17870
2eea : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17871
2eeb : 21                   >        db      test_num
17872 2 MichaelA
                            >
17873 3 MichaelA
2eec :                      >skip2749
17874
                            >
17875 2 MichaelA
 
17876 3 MichaelA
2eec : ca               [ 2]         dex
17877
2eed : 10dc             [ 3]         bpl tror9
17878 2 MichaelA
 
17879 3 MichaelA
2eef : a203             [ 2]         ldx #3
17880
2ef1 :                       trorc8
17881 2 MichaelA
                                     set_absx zp1,fc
17882
                            >            load_flag fc
17883 3 MichaelA
2ef1 : a901             [ 2]>            lda #fc             ;allow test to change I-flag (no mask)
17884 2 MichaelA
                            >
17885 3 MichaelA
2ef3 : 48               [ 3]>            pha         ;use stack to load status
17886
2ef4 : b5b9             [ 4]>            lda zp1,x    ;load to indexed memory
17887
2ef6 : 9d0302           [ 5]>            sta abst,x
17888
2ef9 : 28               [ 4]>            plp
17889 2 MichaelA
 
17890 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  310
17891
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17892
 
17893
2efa : 7e0302           [ 7]         ror abst,x
17894 2 MichaelA
                                     tst_absx rRORc,fRORc,0
17895 3 MichaelA
2efd : 08               [ 3]>            php         ;save flags
17896
2efe : bd0302           [ 4]>            lda abst,x
17897
2f01 : dd1d02           [ 4]>            cmp rRORc,x    ;test result
17898 2 MichaelA
                            >            trap_ne
17899 3 MichaelA
2f04 : f002             [ 3]>        beq skip2754
17900
                            >        trap           ;failed equal (zero)
17901
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17902
2f06 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17903
2f07 : 21                   >        db      test_num
17904 2 MichaelA
                            >
17905 3 MichaelA
2f08 :                      >skip2754
17906
                            >
17907
2f08 : 68               [ 4]>            pla         ;load status
17908 2 MichaelA
                            >            eor_flag 0
17909 3 MichaelA
2f09 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
17910 2 MichaelA
                            >
17911 3 MichaelA
2f0b : dd2d02           [ 4]>            cmp fRORc,x    ;test flags
17912 2 MichaelA
                            >            trap_ne
17913 3 MichaelA
2f0e : f002             [ 3]>        beq skip2757
17914
                            >        trap           ;failed equal (zero)
17915
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17916
2f10 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17917
2f11 : 21                   >        db      test_num
17918 2 MichaelA
                            >
17919 3 MichaelA
2f12 :                      >skip2757
17920
                            >
17921 2 MichaelA
 
17922 3 MichaelA
2f12 : ca               [ 2]         dex
17923
2f13 : 10dc             [ 4]         bpl trorc8
17924
2f15 : a203             [ 2]         ldx #3
17925
2f17 :                       trorc9
17926 2 MichaelA
                                     set_absx zp1,$ff
17927
                            >            load_flag $ff
17928 3 MichaelA
2f17 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
17929 2 MichaelA
                            >
17930 3 MichaelA
2f19 : 48               [ 3]>            pha         ;use stack to load status
17931
2f1a : b5b9             [ 4]>            lda zp1,x    ;load to indexed memory
17932
2f1c : 9d0302           [ 5]>            sta abst,x
17933
2f1f : 28               [ 4]>            plp
17934 2 MichaelA
 
17935 3 MichaelA
2f20 : 7e0302           [ 7]         ror abst,x
17936 2 MichaelA
                                     tst_absx rRORc,fRORc,$ff-fnzc
17937 3 MichaelA
2f23 : 08               [ 3]>            php         ;save flags
17938
2f24 : bd0302           [ 4]>            lda abst,x
17939
2f27 : dd1d02           [ 4]>            cmp rRORc,x    ;test result
17940 2 MichaelA
                            >            trap_ne
17941 3 MichaelA
2f2a : f002             [ 3]>        beq skip2762
17942
                            >        trap           ;failed equal (zero)
17943
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17944
2f2c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17945
2f2d : 21                   >        db      test_num
17946 2 MichaelA
                            >
17947 3 MichaelA
2f2e :                      >skip2762
17948
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  311
17949
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
17950
 
17951
                            >
17952
2f2e : 68               [ 4]>            pla         ;load status
17953 2 MichaelA
                            >            eor_flag $ff-fnzc
17954 3 MichaelA
2f2f : 497c             [ 2]>            eor #$ff-fnzc|fao         ;invert expected flags + always on bits
17955 2 MichaelA
                            >
17956 3 MichaelA
2f31 : dd2d02           [ 4]>            cmp fRORc,x    ;test flags
17957 2 MichaelA
                            >            trap_ne
17958 3 MichaelA
2f34 : f002             [ 3]>        beq skip2765
17959
                            >        trap           ;failed equal (zero)
17960
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17961
2f36 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17962
2f37 : 21                   >        db      test_num
17963 2 MichaelA
                            >
17964 3 MichaelA
2f38 :                      >skip2765
17965
                            >
17966 2 MichaelA
 
17967 3 MichaelA
2f38 : ca               [ 2]         dex
17968
2f39 : 10dc             [ 3]         bpl trorc9
17969 2 MichaelA
                                     next_test
17970 3 MichaelA
2f3b : ad0002           [ 4]>            lda test_case   ;previous test
17971
2f3e : c921             [ 2]>            cmp #test_num
17972 2 MichaelA
                            >            trap_ne         ;test is out of sequence
17973 3 MichaelA
2f40 : f002             [ 3]>        beq skip2768
17974
                            >        trap           ;failed equal (zero)
17975
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
17976
2f42 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
17977
2f43 : 21                   >        db      test_num
17978 2 MichaelA
                            >
17979 3 MichaelA
2f44 :                      >skip2768
17980
                            >
17981 2 MichaelA
0022 =                      >test_num = test_num + 1
17982 3 MichaelA
2f44 : a922             [ 2]>            lda #test_num   ;*** this tests' number
17983
2f46 : 8d0002           [ 4]>            sta test_case
17984 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
17985
 
17986
 
17987
                             ; testing memory increment/decrement - INC DEC all addressing modes
17988
                             ; zeropage
17989 3 MichaelA
 
17990
2f49 : a200             [ 2]         ldx #0
17991
2f4b : a97e             [ 2]         lda #$7e
17992
2f4d : 85b2             [ 3]         sta zpt
17993
2f4f :                       tinc
17994 2 MichaelA
                                     set_stat 0
17995
                            >            load_flag 0
17996 3 MichaelA
2f4f : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
17997 2 MichaelA
                            >
17998 3 MichaelA
2f51 : 48               [ 3]>            pha         ;use stack to load status
17999
2f52 : 28               [ 4]>            plp
18000 2 MichaelA
 
18001 3 MichaelA
2f53 : e6b2             [ 5]         inc zpt
18002 2 MichaelA
                                     tst_z rINC,fINC,0
18003 3 MichaelA
2f55 : 08               [ 3]>            php         ;save flags
18004
2f56 : a5b2             [ 3]>            lda zpt
18005
2f58 : dd3102           [ 4]>            cmp rINC,x    ;test result
18006
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  312
18007
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18008
 
18009 2 MichaelA
                            >            trap_ne
18010 3 MichaelA
2f5b : f002             [ 3]>        beq skip2773
18011
                            >        trap           ;failed equal (zero)
18012
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18013
2f5d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18014
2f5e : 22                   >        db      test_num
18015 2 MichaelA
                            >
18016 3 MichaelA
2f5f :                      >skip2773
18017
                            >
18018
2f5f : 68               [ 4]>            pla         ;load status
18019 2 MichaelA
                            >            eor_flag 0
18020 3 MichaelA
2f60 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
18021 2 MichaelA
                            >
18022 3 MichaelA
2f62 : dd3602           [ 4]>            cmp fINC,x    ;test flags
18023 2 MichaelA
                            >            trap_ne
18024 3 MichaelA
2f65 : f002             [ 3]>        beq skip2776
18025
                            >        trap           ;failed equal (zero)
18026
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18027
2f67 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18028
2f68 : 22                   >        db      test_num
18029 2 MichaelA
                            >
18030 3 MichaelA
2f69 :                      >skip2776
18031
                            >
18032 2 MichaelA
 
18033 3 MichaelA
2f69 : e8               [ 2]         inx
18034
2f6a : e002             [ 2]         cpx #2
18035
2f6c : d004             [ 3]         bne tinc1
18036
2f6e : a9fe             [ 2]         lda #$fe
18037
2f70 : 85b2             [ 3]         sta zpt
18038
2f72 : e005             [ 2] tinc1   cpx #5
18039
2f74 : d0d9             [ 3]         bne tinc
18040
2f76 : ca               [ 2]         dex
18041
2f77 : e6b2             [ 5]         inc zpt
18042
2f79 :                       tdec
18043 2 MichaelA
                                     set_stat 0
18044
                            >            load_flag 0
18045 3 MichaelA
2f79 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
18046 2 MichaelA
                            >
18047 3 MichaelA
2f7b : 48               [ 3]>            pha         ;use stack to load status
18048
2f7c : 28               [ 4]>            plp
18049 2 MichaelA
 
18050 3 MichaelA
2f7d : c6b2             [ 5]         dec zpt
18051 2 MichaelA
                                     tst_z rINC,fINC,0
18052 3 MichaelA
2f7f : 08               [ 3]>            php         ;save flags
18053
2f80 : a5b2             [ 3]>            lda zpt
18054
2f82 : dd3102           [ 4]>            cmp rINC,x    ;test result
18055 2 MichaelA
                            >            trap_ne
18056 3 MichaelA
2f85 : f002             [ 3]>        beq skip2781
18057
                            >        trap           ;failed equal (zero)
18058
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18059
2f87 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18060
2f88 : 22                   >        db      test_num
18061 2 MichaelA
                            >
18062 3 MichaelA
2f89 :                      >skip2781
18063
                            >
18064
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  313
18065
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18066
 
18067
2f89 : 68               [ 4]>            pla         ;load status
18068 2 MichaelA
                            >            eor_flag 0
18069 3 MichaelA
2f8a : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
18070 2 MichaelA
                            >
18071 3 MichaelA
2f8c : dd3602           [ 4]>            cmp fINC,x    ;test flags
18072 2 MichaelA
                            >            trap_ne
18073 3 MichaelA
2f8f : f002             [ 3]>        beq skip2784
18074
                            >        trap           ;failed equal (zero)
18075
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18076
2f91 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18077
2f92 : 22                   >        db      test_num
18078 2 MichaelA
                            >
18079 3 MichaelA
2f93 :                      >skip2784
18080
                            >
18081 2 MichaelA
 
18082 3 MichaelA
2f93 : ca               [ 2]         dex
18083
2f94 : 300a             [ 3]         bmi tdec1
18084
2f96 : e001             [ 2]         cpx #1
18085
2f98 : d0df             [ 3]         bne tdec
18086
2f9a : a981             [ 2]         lda #$81
18087
2f9c : 85b2             [ 3]         sta zpt
18088
2f9e : d0d9             [ 3]         bne tdec
18089
2fa0 :                       tdec1
18090
2fa0 : a200             [ 2]         ldx #0
18091
2fa2 : a97e             [ 2]         lda #$7e
18092
2fa4 : 85b2             [ 3]         sta zpt
18093
2fa6 :                       tinc10
18094 2 MichaelA
                                     set_stat $ff
18095
                            >            load_flag $ff
18096 3 MichaelA
2fa6 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
18097 2 MichaelA
                            >
18098 3 MichaelA
2fa8 : 48               [ 3]>            pha         ;use stack to load status
18099
2fa9 : 28               [ 4]>            plp
18100 2 MichaelA
 
18101 3 MichaelA
2faa : e6b2             [ 5]         inc zpt
18102 2 MichaelA
                                     tst_z rINC,fINC,$ff-fnz
18103 3 MichaelA
2fac : 08               [ 3]>            php         ;save flags
18104
2fad : a5b2             [ 3]>            lda zpt
18105
2faf : dd3102           [ 4]>            cmp rINC,x    ;test result
18106 2 MichaelA
                            >            trap_ne
18107 3 MichaelA
2fb2 : f002             [ 3]>        beq skip2789
18108
                            >        trap           ;failed equal (zero)
18109
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18110
2fb4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18111
2fb5 : 22                   >        db      test_num
18112 2 MichaelA
                            >
18113 3 MichaelA
2fb6 :                      >skip2789
18114
                            >
18115
2fb6 : 68               [ 4]>            pla         ;load status
18116 2 MichaelA
                            >            eor_flag $ff-fnz
18117 3 MichaelA
2fb7 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
18118 2 MichaelA
                            >
18119 3 MichaelA
2fb9 : dd3602           [ 4]>            cmp fINC,x    ;test flags
18120 2 MichaelA
                            >            trap_ne
18121 3 MichaelA
2fbc : f002             [ 3]>        beq skip2792
18122
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  314
18123
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18124
 
18125
                            >        trap           ;failed equal (zero)
18126
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18127
2fbe : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18128
2fbf : 22                   >        db      test_num
18129 2 MichaelA
                            >
18130 3 MichaelA
2fc0 :                      >skip2792
18131
                            >
18132 2 MichaelA
 
18133 3 MichaelA
2fc0 : e8               [ 2]         inx
18134
2fc1 : e002             [ 2]         cpx #2
18135
2fc3 : d004             [ 3]         bne tinc11
18136
2fc5 : a9fe             [ 2]         lda #$fe
18137
2fc7 : 85b2             [ 3]         sta zpt
18138
2fc9 : e005             [ 2] tinc11  cpx #5
18139
2fcb : d0d9             [ 3]         bne tinc10
18140
2fcd : ca               [ 2]         dex
18141
2fce : e6b2             [ 5]         inc zpt
18142
2fd0 :                       tdec10
18143 2 MichaelA
                                     set_stat $ff
18144
                            >            load_flag $ff
18145 3 MichaelA
2fd0 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
18146 2 MichaelA
                            >
18147 3 MichaelA
2fd2 : 48               [ 3]>            pha         ;use stack to load status
18148
2fd3 : 28               [ 4]>            plp
18149 2 MichaelA
 
18150 3 MichaelA
2fd4 : c6b2             [ 5]         dec zpt
18151 2 MichaelA
                                     tst_z rINC,fINC,$ff-fnz
18152 3 MichaelA
2fd6 : 08               [ 3]>            php         ;save flags
18153
2fd7 : a5b2             [ 3]>            lda zpt
18154
2fd9 : dd3102           [ 4]>            cmp rINC,x    ;test result
18155 2 MichaelA
                            >            trap_ne
18156 3 MichaelA
2fdc : f002             [ 3]>        beq skip2797
18157
                            >        trap           ;failed equal (zero)
18158
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18159
2fde : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18160
2fdf : 22                   >        db      test_num
18161 2 MichaelA
                            >
18162 3 MichaelA
2fe0 :                      >skip2797
18163
                            >
18164
2fe0 : 68               [ 4]>            pla         ;load status
18165 2 MichaelA
                            >            eor_flag $ff-fnz
18166 3 MichaelA
2fe1 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
18167 2 MichaelA
                            >
18168 3 MichaelA
2fe3 : dd3602           [ 4]>            cmp fINC,x    ;test flags
18169 2 MichaelA
                            >            trap_ne
18170 3 MichaelA
2fe6 : f002             [ 3]>        beq skip2800
18171
                            >        trap           ;failed equal (zero)
18172
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18173
2fe8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18174
2fe9 : 22                   >        db      test_num
18175 2 MichaelA
                            >
18176 3 MichaelA
2fea :                      >skip2800
18177
                            >
18178 2 MichaelA
 
18179 3 MichaelA
2fea : ca               [ 2]         dex
18180
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  315
18181
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18182
 
18183
2feb : 300a             [ 3]         bmi tdec11
18184
2fed : e001             [ 2]         cpx #1
18185
2fef : d0df             [ 3]         bne tdec10
18186
2ff1 : a981             [ 2]         lda #$81
18187
2ff3 : 85b2             [ 3]         sta zpt
18188
2ff5 : d0d9             [ 3]         bne tdec10
18189
2ff7 :                       tdec11
18190 2 MichaelA
                                     next_test
18191 3 MichaelA
2ff7 : ad0002           [ 4]>            lda test_case   ;previous test
18192
2ffa : c922             [ 2]>            cmp #test_num
18193 2 MichaelA
                            >            trap_ne         ;test is out of sequence
18194 3 MichaelA
2ffc : f002             [ 4]>        beq skip2803
18195
                            >        trap           ;failed equal (zero)
18196
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18197
2ffe : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18198
2fff : 22                   >        db      test_num
18199 2 MichaelA
                            >
18200 3 MichaelA
3000 :                      >skip2803
18201
                            >
18202 2 MichaelA
0023 =                      >test_num = test_num + 1
18203 3 MichaelA
3000 : a923             [ 2]>            lda #test_num   ;*** this tests' number
18204
3002 : 8d0002           [ 4]>            sta test_case
18205 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
18206
 
18207
 
18208
                             ; absolute memory
18209 3 MichaelA
 
18210
3005 : a200             [ 2]         ldx #0
18211
3007 : a97e             [ 2]         lda #$7e
18212
3009 : 8d0302           [ 4]         sta abst
18213
300c :                       tinc2
18214 2 MichaelA
                                     set_stat 0
18215
                            >            load_flag 0
18216 3 MichaelA
300c : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
18217 2 MichaelA
                            >
18218 3 MichaelA
300e : 48               [ 3]>            pha         ;use stack to load status
18219
300f : 28               [ 4]>            plp
18220 2 MichaelA
 
18221 3 MichaelA
3010 : ee0302           [ 6]         inc abst
18222 2 MichaelA
                                     tst_abs rINC,fINC,0
18223 3 MichaelA
3013 : 08               [ 3]>            php         ;save flags
18224
3014 : ad0302           [ 4]>            lda abst
18225
3017 : dd3102           [ 4]>            cmp rINC,x    ;test result
18226 2 MichaelA
                            >            trap_ne
18227 3 MichaelA
301a : f002             [ 3]>        beq skip2808
18228
                            >        trap           ;failed equal (zero)
18229
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18230
301c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18231
301d : 23                   >        db      test_num
18232 2 MichaelA
                            >
18233 3 MichaelA
301e :                      >skip2808
18234
                            >
18235
301e : 68               [ 4]>            pla         ;load status
18236 2 MichaelA
                            >            eor_flag 0
18237 3 MichaelA
301f : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
18238
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  316
18239
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18240
 
18241 2 MichaelA
                            >
18242 3 MichaelA
3021 : dd3602           [ 4]>            cmp fINC,x    ;test flags
18243 2 MichaelA
                            >            trap_ne
18244 3 MichaelA
3024 : f002             [ 3]>        beq skip2811
18245
                            >        trap           ;failed equal (zero)
18246
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18247
3026 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18248
3027 : 23                   >        db      test_num
18249 2 MichaelA
                            >
18250 3 MichaelA
3028 :                      >skip2811
18251
                            >
18252 2 MichaelA
 
18253 3 MichaelA
3028 : e8               [ 2]         inx
18254
3029 : e002             [ 2]         cpx #2
18255
302b : d005             [ 3]         bne tinc3
18256
302d : a9fe             [ 2]         lda #$fe
18257
302f : 8d0302           [ 4]         sta abst
18258
3032 : e005             [ 2] tinc3   cpx #5
18259
3034 : d0d6             [ 3]         bne tinc2
18260
3036 : ca               [ 2]         dex
18261
3037 : ee0302           [ 6]         inc abst
18262
303a :                       tdec2
18263 2 MichaelA
                                     set_stat 0
18264
                            >            load_flag 0
18265 3 MichaelA
303a : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
18266 2 MichaelA
                            >
18267 3 MichaelA
303c : 48               [ 3]>            pha         ;use stack to load status
18268
303d : 28               [ 4]>            plp
18269 2 MichaelA
 
18270 3 MichaelA
303e : ce0302           [ 6]         dec abst
18271 2 MichaelA
                                     tst_abs rINC,fINC,0
18272 3 MichaelA
3041 : 08               [ 3]>            php         ;save flags
18273
3042 : ad0302           [ 4]>            lda abst
18274
3045 : dd3102           [ 4]>            cmp rINC,x    ;test result
18275 2 MichaelA
                            >            trap_ne
18276 3 MichaelA
3048 : f002             [ 3]>        beq skip2816
18277
                            >        trap           ;failed equal (zero)
18278
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18279
304a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18280
304b : 23                   >        db      test_num
18281 2 MichaelA
                            >
18282 3 MichaelA
304c :                      >skip2816
18283
                            >
18284
304c : 68               [ 4]>            pla         ;load status
18285 2 MichaelA
                            >            eor_flag 0
18286 3 MichaelA
304d : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
18287 2 MichaelA
                            >
18288 3 MichaelA
304f : dd3602           [ 4]>            cmp fINC,x    ;test flags
18289 2 MichaelA
                            >            trap_ne
18290 3 MichaelA
3052 : f002             [ 3]>        beq skip2819
18291
                            >        trap           ;failed equal (zero)
18292
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18293
3054 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18294
3055 : 23                   >        db      test_num
18295 2 MichaelA
                            >
18296 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  317
18297
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18298
 
18299
3056 :                      >skip2819
18300
                            >
18301 2 MichaelA
 
18302 3 MichaelA
3056 : ca               [ 2]         dex
18303
3057 : 300b             [ 3]         bmi tdec3
18304
3059 : e001             [ 2]         cpx #1
18305
305b : d0dd             [ 3]         bne tdec2
18306
305d : a981             [ 2]         lda #$81
18307
305f : 8d0302           [ 4]         sta abst
18308
3062 : d0d6             [ 3]         bne tdec2
18309
3064 :                       tdec3
18310
3064 : a200             [ 2]         ldx #0
18311
3066 : a97e             [ 2]         lda #$7e
18312
3068 : 8d0302           [ 4]         sta abst
18313
306b :                       tinc12
18314 2 MichaelA
                                     set_stat $ff
18315
                            >            load_flag $ff
18316 3 MichaelA
306b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
18317 2 MichaelA
                            >
18318 3 MichaelA
306d : 48               [ 3]>            pha         ;use stack to load status
18319
306e : 28               [ 4]>            plp
18320 2 MichaelA
 
18321 3 MichaelA
306f : ee0302           [ 6]         inc abst
18322 2 MichaelA
                                     tst_abs rINC,fINC,$ff-fnz
18323 3 MichaelA
3072 : 08               [ 3]>            php         ;save flags
18324
3073 : ad0302           [ 4]>            lda abst
18325
3076 : dd3102           [ 4]>            cmp rINC,x    ;test result
18326 2 MichaelA
                            >            trap_ne
18327 3 MichaelA
3079 : f002             [ 3]>        beq skip2824
18328
                            >        trap           ;failed equal (zero)
18329
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18330
307b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18331
307c : 23                   >        db      test_num
18332 2 MichaelA
                            >
18333 3 MichaelA
307d :                      >skip2824
18334
                            >
18335
307d : 68               [ 4]>            pla         ;load status
18336 2 MichaelA
                            >            eor_flag $ff-fnz
18337 3 MichaelA
307e : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
18338 2 MichaelA
                            >
18339 3 MichaelA
3080 : dd3602           [ 4]>            cmp fINC,x    ;test flags
18340 2 MichaelA
                            >            trap_ne
18341 3 MichaelA
3083 : f002             [ 3]>        beq skip2827
18342
                            >        trap           ;failed equal (zero)
18343
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18344
3085 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18345
3086 : 23                   >        db      test_num
18346 2 MichaelA
                            >
18347 3 MichaelA
3087 :                      >skip2827
18348
                            >
18349 2 MichaelA
 
18350 3 MichaelA
3087 : e8               [ 2]         inx
18351
3088 : e002             [ 2]         cpx #2
18352
308a : d005             [ 3]         bne tinc13
18353
308c : a9fe             [ 2]         lda #$fe
18354
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  318
18355 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18356
 
18357 3 MichaelA
308e : 8d0302           [ 4]         sta abst
18358
3091 : e005             [ 2] tinc13   cpx #5
18359
3093 : d0d6             [ 3]         bne tinc12
18360
3095 : ca               [ 2]         dex
18361
3096 : ee0302           [ 6]         inc abst
18362
3099 :                       tdec12
18363 2 MichaelA
                                     set_stat $ff
18364
                            >            load_flag $ff
18365 3 MichaelA
3099 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
18366 2 MichaelA
                            >
18367 3 MichaelA
309b : 48               [ 3]>            pha         ;use stack to load status
18368
309c : 28               [ 4]>            plp
18369 2 MichaelA
 
18370 3 MichaelA
309d : ce0302           [ 6]         dec abst
18371 2 MichaelA
                                     tst_abs rINC,fINC,$ff-fnz
18372 3 MichaelA
30a0 : 08               [ 3]>            php         ;save flags
18373
30a1 : ad0302           [ 4]>            lda abst
18374
30a4 : dd3102           [ 4]>            cmp rINC,x    ;test result
18375 2 MichaelA
                            >            trap_ne
18376 3 MichaelA
30a7 : f002             [ 3]>        beq skip2832
18377
                            >        trap           ;failed equal (zero)
18378
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18379
30a9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18380
30aa : 23                   >        db      test_num
18381 2 MichaelA
                            >
18382 3 MichaelA
30ab :                      >skip2832
18383
                            >
18384
30ab : 68               [ 4]>            pla         ;load status
18385 2 MichaelA
                            >            eor_flag $ff-fnz
18386 3 MichaelA
30ac : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
18387 2 MichaelA
                            >
18388 3 MichaelA
30ae : dd3602           [ 4]>            cmp fINC,x    ;test flags
18389 2 MichaelA
                            >            trap_ne
18390 3 MichaelA
30b1 : f002             [ 3]>        beq skip2835
18391
                            >        trap           ;failed equal (zero)
18392
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18393
30b3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18394
30b4 : 23                   >        db      test_num
18395 2 MichaelA
                            >
18396 3 MichaelA
30b5 :                      >skip2835
18397
                            >
18398 2 MichaelA
 
18399 3 MichaelA
30b5 : ca               [ 2]         dex
18400
30b6 : 300b             [ 3]         bmi tdec13
18401
30b8 : e001             [ 2]         cpx #1
18402
30ba : d0dd             [ 3]         bne tdec12
18403
30bc : a981             [ 2]         lda #$81
18404
30be : 8d0302           [ 4]         sta abst
18405
30c1 : d0d6             [ 3]         bne tdec12
18406
30c3 :                       tdec13
18407 2 MichaelA
                                     next_test
18408 3 MichaelA
30c3 : ad0002           [ 4]>            lda test_case   ;previous test
18409
30c6 : c923             [ 2]>            cmp #test_num
18410 2 MichaelA
                            >            trap_ne         ;test is out of sequence
18411 3 MichaelA
30c8 : f002             [ 3]>        beq skip2838
18412
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  319
18413
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18414
 
18415
                            >        trap           ;failed equal (zero)
18416
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18417
30ca : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18418
30cb : 23                   >        db      test_num
18419 2 MichaelA
                            >
18420 3 MichaelA
30cc :                      >skip2838
18421
                            >
18422 2 MichaelA
0024 =                      >test_num = test_num + 1
18423 3 MichaelA
30cc : a924             [ 2]>            lda #test_num   ;*** this tests' number
18424
30ce : 8d0002           [ 4]>            sta test_case
18425 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
18426
 
18427
 
18428
                             ; zeropage indexed
18429 3 MichaelA
 
18430
30d1 : a200             [ 2]         ldx #0
18431
30d3 : a97e             [ 2]         lda #$7e
18432
30d5 : 95b2             [ 4] tinc4   sta zpt,x
18433 2 MichaelA
                                     set_stat 0
18434
                            >            load_flag 0
18435 3 MichaelA
30d7 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
18436 2 MichaelA
                            >
18437 3 MichaelA
30d9 : 48               [ 3]>            pha         ;use stack to load status
18438
30da : 28               [ 4]>            plp
18439 2 MichaelA
 
18440 3 MichaelA
30db : f6b2             [ 6]         inc zpt,x
18441 2 MichaelA
                                     tst_zx rINC,fINC,0
18442 3 MichaelA
30dd : 08               [ 3]>            php         ;save flags
18443
30de : b5b2             [ 4]>            lda zpt,x
18444
30e0 : dd3102           [ 4]>            cmp rINC,x    ;test result
18445 2 MichaelA
                            >            trap_ne
18446 3 MichaelA
30e3 : f002             [ 3]>        beq skip2843
18447
                            >        trap           ;failed equal (zero)
18448
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18449
30e5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18450
30e6 : 24                   >        db      test_num
18451 2 MichaelA
                            >
18452 3 MichaelA
30e7 :                      >skip2843
18453
                            >
18454
30e7 : 68               [ 4]>            pla         ;load status
18455 2 MichaelA
                            >            eor_flag 0
18456 3 MichaelA
30e8 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
18457 2 MichaelA
                            >
18458 3 MichaelA
30ea : dd3602           [ 4]>            cmp fINC,x    ;test flags
18459 2 MichaelA
                            >            trap_ne
18460 3 MichaelA
30ed : f002             [ 3]>        beq skip2846
18461
                            >        trap           ;failed equal (zero)
18462
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18463
30ef : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18464
30f0 : 24                   >        db      test_num
18465 2 MichaelA
                            >
18466 3 MichaelA
30f1 :                      >skip2846
18467
                            >
18468 2 MichaelA
 
18469 3 MichaelA
30f1 : b5b2             [ 4]         lda zpt,x
18470
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  320
18471
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18472
 
18473
30f3 : e8               [ 2]         inx
18474
30f4 : e002             [ 2]         cpx #2
18475
30f6 : d002             [ 3]         bne tinc5
18476
30f8 : a9fe             [ 2]         lda #$fe
18477
30fa : e005             [ 2] tinc5   cpx #5
18478
30fc : d0d7             [ 3]         bne tinc4
18479
30fe : ca               [ 2]         dex
18480
30ff : a902             [ 2]         lda #2
18481
3101 : 95b2             [ 4] tdec4   sta zpt,x
18482 2 MichaelA
                                     set_stat 0
18483
                            >            load_flag 0
18484 3 MichaelA
3103 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
18485 2 MichaelA
                            >
18486 3 MichaelA
3105 : 48               [ 3]>            pha         ;use stack to load status
18487
3106 : 28               [ 4]>            plp
18488 2 MichaelA
 
18489 3 MichaelA
3107 : d6b2             [ 6]         dec zpt,x
18490 2 MichaelA
                                     tst_zx rINC,fINC,0
18491 3 MichaelA
3109 : 08               [ 3]>            php         ;save flags
18492
310a : b5b2             [ 4]>            lda zpt,x
18493
310c : dd3102           [ 4]>            cmp rINC,x    ;test result
18494 2 MichaelA
                            >            trap_ne
18495 3 MichaelA
310f : f002             [ 3]>        beq skip2851
18496
                            >        trap           ;failed equal (zero)
18497
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18498
3111 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18499
3112 : 24                   >        db      test_num
18500 2 MichaelA
                            >
18501 3 MichaelA
3113 :                      >skip2851
18502
                            >
18503
3113 : 68               [ 4]>            pla         ;load status
18504 2 MichaelA
                            >            eor_flag 0
18505 3 MichaelA
3114 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
18506 2 MichaelA
                            >
18507 3 MichaelA
3116 : dd3602           [ 4]>            cmp fINC,x    ;test flags
18508 2 MichaelA
                            >            trap_ne
18509 3 MichaelA
3119 : f002             [ 3]>        beq skip2854
18510
                            >        trap           ;failed equal (zero)
18511
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18512
311b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18513
311c : 24                   >        db      test_num
18514
                            >
18515
311d :                      >skip2854
18516
                            >
18517
 
18518
311d : b5b2             [ 4]         lda zpt,x
18519
311f : ca               [ 2]         dex
18520
3120 : 3008             [ 3]         bmi tdec5
18521
3122 : e001             [ 2]         cpx #1
18522
3124 : d0db             [ 3]         bne tdec4
18523
3126 : a981             [ 2]         lda #$81
18524
3128 : d0d7             [ 3]         bne tdec4
18525
312a :                       tdec5
18526
312a : a200             [ 2]         ldx #0
18527
312c : a97e             [ 2]         lda #$7e
18528
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  321
18529 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18530
 
18531 3 MichaelA
312e : 95b2             [ 4] tinc14  sta zpt,x
18532 2 MichaelA
                                     set_stat $ff
18533
                            >            load_flag $ff
18534 3 MichaelA
3130 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
18535 2 MichaelA
                            >
18536 3 MichaelA
3132 : 48               [ 3]>            pha         ;use stack to load status
18537
3133 : 28               [ 4]>            plp
18538 2 MichaelA
 
18539 3 MichaelA
3134 : f6b2             [ 6]         inc zpt,x
18540 2 MichaelA
                                     tst_zx rINC,fINC,$ff-fnz
18541 3 MichaelA
3136 : 08               [ 3]>            php         ;save flags
18542
3137 : b5b2             [ 4]>            lda zpt,x
18543
3139 : dd3102           [ 4]>            cmp rINC,x    ;test result
18544 2 MichaelA
                            >            trap_ne
18545 3 MichaelA
313c : f002             [ 3]>        beq skip2859
18546
                            >        trap           ;failed equal (zero)
18547
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18548
313e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18549
313f : 24                   >        db      test_num
18550 2 MichaelA
                            >
18551 3 MichaelA
3140 :                      >skip2859
18552
                            >
18553
3140 : 68               [ 4]>            pla         ;load status
18554 2 MichaelA
                            >            eor_flag $ff-fnz
18555 3 MichaelA
3141 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
18556 2 MichaelA
                            >
18557 3 MichaelA
3143 : dd3602           [ 4]>            cmp fINC,x    ;test flags
18558 2 MichaelA
                            >            trap_ne
18559 3 MichaelA
3146 : f002             [ 3]>        beq skip2862
18560
                            >        trap           ;failed equal (zero)
18561
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18562
3148 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18563
3149 : 24                   >        db      test_num
18564 2 MichaelA
                            >
18565 3 MichaelA
314a :                      >skip2862
18566
                            >
18567 2 MichaelA
 
18568 3 MichaelA
314a : b5b2             [ 4]         lda zpt,x
18569
314c : e8               [ 2]         inx
18570
314d : e002             [ 2]         cpx #2
18571
314f : d002             [ 3]         bne tinc15
18572
3151 : a9fe             [ 2]         lda #$fe
18573
3153 : e005             [ 2] tinc15  cpx #5
18574
3155 : d0d7             [ 3]         bne tinc14
18575
3157 : ca               [ 2]         dex
18576
3158 : a902             [ 2]         lda #2
18577
315a : 95b2             [ 4] tdec14  sta zpt,x
18578 2 MichaelA
                                     set_stat $ff
18579
                            >            load_flag $ff
18580 3 MichaelA
315c : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
18581 2 MichaelA
                            >
18582 3 MichaelA
315e : 48               [ 3]>            pha         ;use stack to load status
18583
315f : 28               [ 4]>            plp
18584 2 MichaelA
 
18585 3 MichaelA
3160 : d6b2             [ 6]         dec zpt,x
18586
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  322
18587 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18588
 
18589
                                     tst_zx rINC,fINC,$ff-fnz
18590 3 MichaelA
3162 : 08               [ 3]>            php         ;save flags
18591
3163 : b5b2             [ 4]>            lda zpt,x
18592
3165 : dd3102           [ 4]>            cmp rINC,x    ;test result
18593 2 MichaelA
                            >            trap_ne
18594 3 MichaelA
3168 : f002             [ 3]>        beq skip2867
18595
                            >        trap           ;failed equal (zero)
18596
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18597
316a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18598
316b : 24                   >        db      test_num
18599 2 MichaelA
                            >
18600 3 MichaelA
316c :                      >skip2867
18601
                            >
18602
316c : 68               [ 4]>            pla         ;load status
18603 2 MichaelA
                            >            eor_flag $ff-fnz
18604 3 MichaelA
316d : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
18605 2 MichaelA
                            >
18606 3 MichaelA
316f : dd3602           [ 4]>            cmp fINC,x    ;test flags
18607 2 MichaelA
                            >            trap_ne
18608 3 MichaelA
3172 : f002             [ 3]>        beq skip2870
18609
                            >        trap           ;failed equal (zero)
18610
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18611
3174 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18612
3175 : 24                   >        db      test_num
18613 2 MichaelA
                            >
18614 3 MichaelA
3176 :                      >skip2870
18615
                            >
18616 2 MichaelA
 
18617 3 MichaelA
3176 : b5b2             [ 4]         lda zpt,x
18618
3178 : ca               [ 2]         dex
18619
3179 : 3008             [ 3]         bmi tdec15
18620
317b : e001             [ 2]         cpx #1
18621
317d : d0db             [ 3]         bne tdec14
18622
317f : a981             [ 2]         lda #$81
18623
3181 : d0d7             [ 3]         bne tdec14
18624
3183 :                       tdec15
18625 2 MichaelA
                                     next_test
18626 3 MichaelA
3183 : ad0002           [ 4]>            lda test_case   ;previous test
18627
3186 : c924             [ 2]>            cmp #test_num
18628 2 MichaelA
                            >            trap_ne         ;test is out of sequence
18629 3 MichaelA
3188 : f002             [ 3]>        beq skip2873
18630
                            >        trap           ;failed equal (zero)
18631
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18632
318a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18633
318b : 24                   >        db      test_num
18634 2 MichaelA
                            >
18635 3 MichaelA
318c :                      >skip2873
18636
                            >
18637 2 MichaelA
0025 =                      >test_num = test_num + 1
18638 3 MichaelA
318c : a925             [ 2]>            lda #test_num   ;*** this tests' number
18639
318e : 8d0002           [ 4]>            sta test_case
18640 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
18641
 
18642
 
18643
                             ; memory indexed
18644 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  323
18645
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18646
 
18647
 
18648
3191 : a200             [ 2]         ldx #0
18649
3193 : a97e             [ 2]         lda #$7e
18650
3195 : 9d0302           [ 5] tinc6   sta abst,x
18651 2 MichaelA
                                     set_stat 0
18652
                            >            load_flag 0
18653 3 MichaelA
3198 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
18654 2 MichaelA
                            >
18655 3 MichaelA
319a : 48               [ 3]>            pha         ;use stack to load status
18656
319b : 28               [ 4]>            plp
18657 2 MichaelA
 
18658 3 MichaelA
319c : fe0302           [ 7]         inc abst,x
18659 2 MichaelA
                                     tst_absx rINC,fINC,0
18660 3 MichaelA
319f : 08               [ 3]>            php         ;save flags
18661
31a0 : bd0302           [ 4]>            lda abst,x
18662
31a3 : dd3102           [ 4]>            cmp rINC,x    ;test result
18663 2 MichaelA
                            >            trap_ne
18664 3 MichaelA
31a6 : f002             [ 3]>        beq skip2878
18665
                            >        trap           ;failed equal (zero)
18666
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18667
31a8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18668
31a9 : 25                   >        db      test_num
18669 2 MichaelA
                            >
18670 3 MichaelA
31aa :                      >skip2878
18671
                            >
18672
31aa : 68               [ 4]>            pla         ;load status
18673 2 MichaelA
                            >            eor_flag 0
18674 3 MichaelA
31ab : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
18675 2 MichaelA
                            >
18676 3 MichaelA
31ad : dd3602           [ 4]>            cmp fINC,x    ;test flags
18677 2 MichaelA
                            >            trap_ne
18678 3 MichaelA
31b0 : f002             [ 3]>        beq skip2881
18679
                            >        trap           ;failed equal (zero)
18680
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18681
31b2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18682
31b3 : 25                   >        db      test_num
18683 2 MichaelA
                            >
18684 3 MichaelA
31b4 :                      >skip2881
18685
                            >
18686 2 MichaelA
 
18687 3 MichaelA
31b4 : bd0302           [ 4]         lda abst,x
18688
31b7 : e8               [ 2]         inx
18689
31b8 : e002             [ 2]         cpx #2
18690
31ba : d002             [ 3]         bne tinc7
18691
31bc : a9fe             [ 2]         lda #$fe
18692
31be : e005             [ 2] tinc7   cpx #5
18693
31c0 : d0d3             [ 3]         bne tinc6
18694
31c2 : ca               [ 2]         dex
18695
31c3 : a902             [ 2]         lda #2
18696
31c5 : 9d0302           [ 5] tdec6   sta abst,x
18697 2 MichaelA
                                     set_stat 0
18698
                            >            load_flag 0
18699 3 MichaelA
31c8 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
18700 2 MichaelA
                            >
18701 3 MichaelA
31ca : 48               [ 3]>            pha         ;use stack to load status
18702
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  324
18703
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18704
 
18705
31cb : 28               [ 4]>            plp
18706 2 MichaelA
 
18707 3 MichaelA
31cc : de0302           [ 7]         dec abst,x
18708 2 MichaelA
                                     tst_absx rINC,fINC,0
18709 3 MichaelA
31cf : 08               [ 3]>            php         ;save flags
18710
31d0 : bd0302           [ 4]>            lda abst,x
18711
31d3 : dd3102           [ 4]>            cmp rINC,x    ;test result
18712 2 MichaelA
                            >            trap_ne
18713 3 MichaelA
31d6 : f002             [ 3]>        beq skip2886
18714
                            >        trap           ;failed equal (zero)
18715
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18716
31d8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18717
31d9 : 25                   >        db      test_num
18718 2 MichaelA
                            >
18719 3 MichaelA
31da :                      >skip2886
18720
                            >
18721
31da : 68               [ 4]>            pla         ;load status
18722 2 MichaelA
                            >            eor_flag 0
18723 3 MichaelA
31db : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
18724 2 MichaelA
                            >
18725 3 MichaelA
31dd : dd3602           [ 4]>            cmp fINC,x    ;test flags
18726 2 MichaelA
                            >            trap_ne
18727 3 MichaelA
31e0 : f002             [ 3]>        beq skip2889
18728
                            >        trap           ;failed equal (zero)
18729
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18730
31e2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18731
31e3 : 25                   >        db      test_num
18732 2 MichaelA
                            >
18733 3 MichaelA
31e4 :                      >skip2889
18734
                            >
18735 2 MichaelA
 
18736 3 MichaelA
31e4 : bd0302           [ 4]         lda abst,x
18737
31e7 : ca               [ 2]         dex
18738
31e8 : 3008             [ 3]         bmi tdec7
18739
31ea : e001             [ 2]         cpx #1
18740
31ec : d0d7             [ 3]         bne tdec6
18741
31ee : a981             [ 2]         lda #$81
18742
31f0 : d0d3             [ 3]         bne tdec6
18743
31f2 :                       tdec7
18744
31f2 : a200             [ 2]         ldx #0
18745
31f4 : a97e             [ 2]         lda #$7e
18746
31f6 : 9d0302           [ 5] tinc16  sta abst,x
18747 2 MichaelA
                                     set_stat $ff
18748
                            >            load_flag $ff
18749 3 MichaelA
31f9 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
18750 2 MichaelA
                            >
18751 3 MichaelA
31fb : 48               [ 3]>            pha         ;use stack to load status
18752
31fc : 28               [ 4]>            plp
18753 2 MichaelA
 
18754 3 MichaelA
31fd : fe0302           [ 7]         inc abst,x
18755 2 MichaelA
                                     tst_absx rINC,fINC,$ff-fnz
18756 3 MichaelA
3200 : 08               [ 3]>            php         ;save flags
18757
3201 : bd0302           [ 4]>            lda abst,x
18758
3204 : dd3102           [ 4]>            cmp rINC,x    ;test result
18759 2 MichaelA
                            >            trap_ne
18760 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  325
18761
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18762
 
18763
3207 : f002             [ 3]>        beq skip2894
18764
                            >        trap           ;failed equal (zero)
18765
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18766
3209 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18767
320a : 25                   >        db      test_num
18768 2 MichaelA
                            >
18769 3 MichaelA
320b :                      >skip2894
18770
                            >
18771
320b : 68               [ 4]>            pla         ;load status
18772 2 MichaelA
                            >            eor_flag $ff-fnz
18773 3 MichaelA
320c : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
18774 2 MichaelA
                            >
18775 3 MichaelA
320e : dd3602           [ 4]>            cmp fINC,x    ;test flags
18776 2 MichaelA
                            >            trap_ne
18777 3 MichaelA
3211 : f002             [ 3]>        beq skip2897
18778
                            >        trap           ;failed equal (zero)
18779
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18780
3213 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18781
3214 : 25                   >        db      test_num
18782 2 MichaelA
                            >
18783 3 MichaelA
3215 :                      >skip2897
18784
                            >
18785 2 MichaelA
 
18786 3 MichaelA
3215 : bd0302           [ 4]         lda abst,x
18787
3218 : e8               [ 2]         inx
18788
3219 : e002             [ 2]         cpx #2
18789
321b : d002             [ 3]         bne tinc17
18790
321d : a9fe             [ 2]         lda #$fe
18791
321f : e005             [ 2] tinc17  cpx #5
18792
3221 : d0d3             [ 4]         bne tinc16
18793
3223 : ca               [ 2]         dex
18794
3224 : a902             [ 2]         lda #2
18795
3226 : 9d0302           [ 5] tdec16  sta abst,x
18796 2 MichaelA
                                     set_stat $ff
18797
                            >            load_flag $ff
18798 3 MichaelA
3229 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
18799 2 MichaelA
                            >
18800 3 MichaelA
322b : 48               [ 3]>            pha         ;use stack to load status
18801
322c : 28               [ 4]>            plp
18802 2 MichaelA
 
18803 3 MichaelA
322d : de0302           [ 7]         dec abst,x
18804 2 MichaelA
                                     tst_absx rINC,fINC,$ff-fnz
18805 3 MichaelA
3230 : 08               [ 3]>            php         ;save flags
18806
3231 : bd0302           [ 4]>            lda abst,x
18807
3234 : dd3102           [ 4]>            cmp rINC,x    ;test result
18808 2 MichaelA
                            >            trap_ne
18809 3 MichaelA
3237 : f002             [ 3]>        beq skip2902
18810
                            >        trap           ;failed equal (zero)
18811
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18812
3239 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18813
323a : 25                   >        db      test_num
18814 2 MichaelA
                            >
18815 3 MichaelA
323b :                      >skip2902
18816 2 MichaelA
                            >
18817 3 MichaelA
323b : 68               [ 4]>            pla         ;load status
18818
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  326
18819 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18820
 
18821 3 MichaelA
                            >            eor_flag $ff-fnz
18822
323c : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
18823 2 MichaelA
                            >
18824 3 MichaelA
323e : dd3602           [ 4]>            cmp fINC,x    ;test flags
18825
                            >            trap_ne
18826
3241 : f002             [ 3]>        beq skip2905
18827
                            >        trap           ;failed equal (zero)
18828
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18829
3243 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18830
3244 : 25                   >        db      test_num
18831
                            >
18832
3245 :                      >skip2905
18833
                            >
18834 2 MichaelA
 
18835 3 MichaelA
3245 : bd0302           [ 4]         lda abst,x
18836
3248 : ca               [ 2]         dex
18837
3249 : 3008             [ 3]         bmi tdec17
18838
324b : e001             [ 2]         cpx #1
18839
324d : d0d7             [ 3]         bne tdec16
18840
324f : a981             [ 2]         lda #$81
18841
3251 : d0d3             [ 3]         bne tdec16
18842
3253 :                       tdec17
18843 2 MichaelA
                                     next_test
18844 3 MichaelA
3253 : ad0002           [ 4]>            lda test_case   ;previous test
18845
3256 : c925             [ 2]>            cmp #test_num
18846 2 MichaelA
                            >            trap_ne         ;test is out of sequence
18847 3 MichaelA
3258 : f002             [ 3]>        beq skip2908
18848
                            >        trap           ;failed equal (zero)
18849
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18850
325a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18851
325b : 25                   >        db      test_num
18852 2 MichaelA
                            >
18853 3 MichaelA
325c :                      >skip2908
18854
                            >
18855 2 MichaelA
0026 =                      >test_num = test_num + 1
18856 3 MichaelA
325c : a926             [ 2]>            lda #test_num   ;*** this tests' number
18857
325e : 8d0002           [ 4]>            sta test_case
18858 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
18859
 
18860
 
18861
                             ; testing logical instructions - AND EOR ORA all addressing modes
18862
                             ; AND
18863 3 MichaelA
 
18864
3261 : a203             [ 2]         ldx #3      ;immediate - self modifying code
18865
3263 : b5c2             [ 4] tand    lda zpAN,x
18866
3265 : 8d7032           [ 4]         sta tandi1
18867 2 MichaelA
                                     set_ax  absANa,0
18868
                            >            load_flag 0
18869 3 MichaelA
3268 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
18870 2 MichaelA
                            >
18871 3 MichaelA
326a : 48               [ 3]>            pha         ;use stack to load status
18872
326b : bd4b02           [ 4]>            lda absANa,x    ;precharge accu
18873
326e : 28               [ 4]>            plp
18874 2 MichaelA
 
18875 3 MichaelA
3270 =                       tandi1  equ *+1     ;target for immediate operand
18876
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  327
18877
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18878
 
18879
326f : 2963             [ 2]         and #99
18880 2 MichaelA
                                     tst_ax  absrlo,absflo,0
18881 3 MichaelA
3271 : 08               [ 3]>            php         ;save flags
18882
3272 : dd5302           [ 4]>            cmp absrlo,x    ;test result
18883 2 MichaelA
                            >            trap_ne
18884 3 MichaelA
3275 : f002             [ 3]>        beq skip2913
18885
                            >        trap           ;failed equal (zero)
18886
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18887
3277 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18888
3278 : 26                   >        db      test_num
18889 2 MichaelA
                            >
18890 3 MichaelA
3279 :                      >skip2913
18891
                            >
18892
3279 : 68               [ 4]>            pla         ;load status
18893 2 MichaelA
                            >            eor_flag 0
18894 3 MichaelA
327a : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
18895 2 MichaelA
                            >
18896 3 MichaelA
327c : dd5702           [ 4]>            cmp absflo,x    ;test flags
18897 2 MichaelA
                            >            trap_ne     ;
18898 3 MichaelA
327f : f002             [ 3]>        beq skip2916
18899
                            >        trap           ;failed equal (zero)
18900
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18901
3281 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18902
3282 : 26                   >        db      test_num
18903 2 MichaelA
                            >
18904 3 MichaelA
3283 :                      >skip2916
18905
                            >
18906 2 MichaelA
 
18907 3 MichaelA
3283 : ca               [ 2]         dex
18908
3284 : 10dd             [ 3]         bpl tand
18909
3286 : a203             [ 2]         ldx #3
18910
3288 : b5c2             [ 4] tand1   lda zpAN,x
18911
328a : 8d9532           [ 4]         sta tandi2
18912 2 MichaelA
                                     set_ax  absANa,$ff
18913
                            >            load_flag $ff
18914 3 MichaelA
328d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
18915 2 MichaelA
                            >
18916 3 MichaelA
328f : 48               [ 3]>            pha         ;use stack to load status
18917
3290 : bd4b02           [ 4]>            lda absANa,x    ;precharge accu
18918
3293 : 28               [ 4]>            plp
18919 2 MichaelA
 
18920 3 MichaelA
3295 =                       tandi2  equ *+1     ;target for immediate operand
18921
3294 : 2963             [ 2]         and #99
18922 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
18923 3 MichaelA
3296 : 08               [ 3]>            php         ;save flags
18924
3297 : dd5302           [ 4]>            cmp absrlo,x    ;test result
18925 2 MichaelA
                            >            trap_ne
18926 3 MichaelA
329a : f002             [ 3]>        beq skip2921
18927
                            >        trap           ;failed equal (zero)
18928
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18929
329c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18930
329d : 26                   >        db      test_num
18931 2 MichaelA
                            >
18932 3 MichaelA
329e :                      >skip2921
18933
                            >
18934
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  328
18935
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18936
 
18937
329e : 68               [ 4]>            pla         ;load status
18938 2 MichaelA
                            >            eor_flag $ff-fnz
18939 3 MichaelA
329f : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
18940 2 MichaelA
                            >
18941 3 MichaelA
32a1 : dd5702           [ 4]>            cmp absflo,x    ;test flags
18942 2 MichaelA
                            >            trap_ne     ;
18943 3 MichaelA
32a4 : f002             [ 3]>        beq skip2924
18944
                            >        trap           ;failed equal (zero)
18945
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18946
32a6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18947
32a7 : 26                   >        db      test_num
18948 2 MichaelA
                            >
18949 3 MichaelA
32a8 :                      >skip2924
18950
                            >
18951 2 MichaelA
 
18952 3 MichaelA
32a8 : ca               [ 2]         dex
18953
32a9 : 10dd             [ 3]         bpl tand1
18954 2 MichaelA
 
18955 3 MichaelA
32ab : a203             [ 2]         ldx #3      ;zp
18956
32ad : b5c2             [ 4] tand2    lda zpAN,x
18957
32af : 85b2             [ 3]         sta zpt
18958 2 MichaelA
                                     set_ax  absANa,0
18959
                            >            load_flag 0
18960 3 MichaelA
32b1 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
18961 2 MichaelA
                            >
18962 3 MichaelA
32b3 : 48               [ 3]>            pha         ;use stack to load status
18963
32b4 : bd4b02           [ 4]>            lda absANa,x    ;precharge accu
18964
32b7 : 28               [ 4]>            plp
18965 2 MichaelA
 
18966 3 MichaelA
32b8 : 25b2             [ 3]         and zpt
18967 2 MichaelA
                                     tst_ax  absrlo,absflo,0
18968 3 MichaelA
32ba : 08               [ 3]>            php         ;save flags
18969
32bb : dd5302           [ 4]>            cmp absrlo,x    ;test result
18970 2 MichaelA
                            >            trap_ne
18971 3 MichaelA
32be : f002             [ 3]>        beq skip2929
18972
                            >        trap           ;failed equal (zero)
18973
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18974
32c0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18975
32c1 : 26                   >        db      test_num
18976 2 MichaelA
                            >
18977 3 MichaelA
32c2 :                      >skip2929
18978
                            >
18979
32c2 : 68               [ 4]>            pla         ;load status
18980 2 MichaelA
                            >            eor_flag 0
18981 3 MichaelA
32c3 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
18982 2 MichaelA
                            >
18983 3 MichaelA
32c5 : dd5702           [ 4]>            cmp absflo,x    ;test flags
18984 2 MichaelA
                            >            trap_ne     ;
18985 3 MichaelA
32c8 : f002             [ 3]>        beq skip2932
18986
                            >        trap           ;failed equal (zero)
18987
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
18988
32ca : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
18989
32cb : 26                   >        db      test_num
18990
                            >
18991
32cc :                      >skip2932
18992
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  329
18993 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
18994
 
18995
                            >
18996
 
18997 3 MichaelA
32cc : ca               [ 2]         dex
18998
32cd : 10de             [ 3]         bpl tand2
18999
32cf : a203             [ 2]         ldx #3
19000
32d1 : b5c2             [ 4] tand3   lda zpAN,x
19001
32d3 : 85b2             [ 3]         sta zpt
19002 2 MichaelA
                                     set_ax  absANa,$ff
19003
                            >            load_flag $ff
19004 3 MichaelA
32d5 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
19005 2 MichaelA
                            >
19006 3 MichaelA
32d7 : 48               [ 3]>            pha         ;use stack to load status
19007
32d8 : bd4b02           [ 4]>            lda absANa,x    ;precharge accu
19008
32db : 28               [ 4]>            plp
19009 2 MichaelA
 
19010 3 MichaelA
32dc : 25b2             [ 3]         and zpt
19011 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
19012 3 MichaelA
32de : 08               [ 3]>            php         ;save flags
19013
32df : dd5302           [ 4]>            cmp absrlo,x    ;test result
19014 2 MichaelA
                            >            trap_ne
19015 3 MichaelA
32e2 : f002             [ 3]>        beq skip2937
19016
                            >        trap           ;failed equal (zero)
19017
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19018
32e4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19019
32e5 : 26                   >        db      test_num
19020 2 MichaelA
                            >
19021 3 MichaelA
32e6 :                      >skip2937
19022
                            >
19023
32e6 : 68               [ 4]>            pla         ;load status
19024 2 MichaelA
                            >            eor_flag $ff-fnz
19025 3 MichaelA
32e7 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
19026 2 MichaelA
                            >
19027 3 MichaelA
32e9 : dd5702           [ 4]>            cmp absflo,x    ;test flags
19028 2 MichaelA
                            >            trap_ne     ;
19029 3 MichaelA
32ec : f002             [ 3]>        beq skip2940
19030
                            >        trap           ;failed equal (zero)
19031
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19032
32ee : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19033
32ef : 26                   >        db      test_num
19034 2 MichaelA
                            >
19035 3 MichaelA
32f0 :                      >skip2940
19036
                            >
19037 2 MichaelA
 
19038 3 MichaelA
32f0 : ca               [ 2]         dex
19039
32f1 : 10de             [ 3]         bpl tand3
19040 2 MichaelA
 
19041 3 MichaelA
32f3 : a203             [ 2]         ldx #3      ;abs
19042
32f5 : b5c2             [ 4] tand4   lda zpAN,x
19043
32f7 : 8d0302           [ 4]         sta abst
19044 2 MichaelA
                                     set_ax  absANa,0
19045
                            >            load_flag 0
19046 3 MichaelA
32fa : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
19047 2 MichaelA
                            >
19048 3 MichaelA
32fc : 48               [ 3]>            pha         ;use stack to load status
19049
32fd : bd4b02           [ 4]>            lda absANa,x    ;precharge accu
19050
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  330
19051
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19052
 
19053
3300 : 28               [ 4]>            plp
19054 2 MichaelA
 
19055 3 MichaelA
3301 : 2d0302           [ 4]         and abst
19056 2 MichaelA
                                     tst_ax  absrlo,absflo,0
19057 3 MichaelA
3304 : 08               [ 3]>            php         ;save flags
19058
3305 : dd5302           [ 4]>            cmp absrlo,x    ;test result
19059 2 MichaelA
                            >            trap_ne
19060 3 MichaelA
3308 : f002             [ 3]>        beq skip2945
19061
                            >        trap           ;failed equal (zero)
19062
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19063
330a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19064
330b : 26                   >        db      test_num
19065 2 MichaelA
                            >
19066 3 MichaelA
330c :                      >skip2945
19067
                            >
19068
330c : 68               [ 4]>            pla         ;load status
19069 2 MichaelA
                            >            eor_flag 0
19070 3 MichaelA
330d : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
19071 2 MichaelA
                            >
19072 3 MichaelA
330f : dd5702           [ 4]>            cmp absflo,x    ;test flags
19073 2 MichaelA
                            >            trap_ne     ;
19074 3 MichaelA
3312 : f002             [ 3]>        beq skip2948
19075
                            >        trap           ;failed equal (zero)
19076
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19077
3314 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19078
3315 : 26                   >        db      test_num
19079 2 MichaelA
                            >
19080 3 MichaelA
3316 :                      >skip2948
19081
                            >
19082 2 MichaelA
 
19083 3 MichaelA
3316 : ca               [ 2]         dex
19084
3317 : 10dc             [ 4]         bpl tand4
19085
3319 : a203             [ 2]         ldx #3
19086
331b : b5c2             [ 4] tand5   lda zpAN,x
19087
331d : 8d0302           [ 4]         sta abst
19088 2 MichaelA
                                     set_ax  absANa,$ff
19089
                            >            load_flag $ff
19090 3 MichaelA
3320 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
19091 2 MichaelA
                            >
19092 3 MichaelA
3322 : 48               [ 3]>            pha         ;use stack to load status
19093
3323 : bd4b02           [ 4]>            lda absANa,x    ;precharge accu
19094
3326 : 28               [ 4]>            plp
19095 2 MichaelA
 
19096 3 MichaelA
3327 : 2d0302           [ 4]         and abst
19097 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
19098 3 MichaelA
332a : 08               [ 3]>            php         ;save flags
19099
332b : dd5302           [ 4]>            cmp absrlo,x    ;test result
19100 2 MichaelA
                            >            trap_ne
19101 3 MichaelA
332e : f002             [ 3]>        beq skip2953
19102
                            >        trap           ;failed equal (zero)
19103
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19104
3330 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19105
3331 : 26                   >        db      test_num
19106 2 MichaelA
                            >
19107 3 MichaelA
3332 :                      >skip2953
19108
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  331
19109
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19110
 
19111
                            >
19112
3332 : 68               [ 4]>            pla         ;load status
19113 2 MichaelA
                            >            eor_flag $ff-fnz
19114 3 MichaelA
3333 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
19115 2 MichaelA
                            >
19116 3 MichaelA
3335 : dd5702           [ 4]>            cmp absflo,x    ;test flags
19117 2 MichaelA
                            >            trap_ne     ;
19118 3 MichaelA
3338 : f002             [ 3]>        beq skip2956
19119
                            >        trap           ;failed equal (zero)
19120
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19121
333a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19122
333b : 26                   >        db      test_num
19123 2 MichaelA
                            >
19124 3 MichaelA
333c :                      >skip2956
19125
                            >
19126 2 MichaelA
 
19127 3 MichaelA
333c : ca               [ 2]         dex
19128
333d : 1002             [ 3]         bpl tand6
19129 2 MichaelA
 
19130 3 MichaelA
333f : a203             [ 2]         ldx #3      ;zp,x
19131
3341 :                       tand6
19132 2 MichaelA
                                     set_ax  absANa,0
19133
                            >            load_flag 0
19134 3 MichaelA
3341 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
19135 2 MichaelA
                            >
19136 3 MichaelA
3343 : 48               [ 3]>            pha         ;use stack to load status
19137
3344 : bd4b02           [ 4]>            lda absANa,x    ;precharge accu
19138
3347 : 28               [ 4]>            plp
19139 2 MichaelA
 
19140 3 MichaelA
3348 : 35c2             [ 4]         and zpAN,x
19141 2 MichaelA
                                     tst_ax  absrlo,absflo,0
19142 3 MichaelA
334a : 08               [ 3]>            php         ;save flags
19143
334b : dd5302           [ 4]>            cmp absrlo,x    ;test result
19144 2 MichaelA
                            >            trap_ne
19145 3 MichaelA
334e : f002             [ 3]>        beq skip2961
19146
                            >        trap           ;failed equal (zero)
19147
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19148
3350 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19149
3351 : 26                   >        db      test_num
19150 2 MichaelA
                            >
19151 3 MichaelA
3352 :                      >skip2961
19152
                            >
19153
3352 : 68               [ 4]>            pla         ;load status
19154 2 MichaelA
                            >            eor_flag 0
19155 3 MichaelA
3353 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
19156 2 MichaelA
                            >
19157 3 MichaelA
3355 : dd5702           [ 4]>            cmp absflo,x    ;test flags
19158 2 MichaelA
                            >            trap_ne     ;
19159 3 MichaelA
3358 : f002             [ 3]>        beq skip2964
19160
                            >        trap           ;failed equal (zero)
19161
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19162
335a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19163
335b : 26                   >        db      test_num
19164 2 MichaelA
                            >
19165 3 MichaelA
335c :                      >skip2964
19166
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  332
19167
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19168
 
19169
                            >
19170 2 MichaelA
 
19171 3 MichaelA
335c : ca               [ 2]         dex
19172
335d : 10e2             [ 3]         bpl tand6
19173
335f : a203             [ 2]         ldx #3
19174
3361 :                       tand7
19175 2 MichaelA
                                     set_ax  absANa,$ff
19176
                            >            load_flag $ff
19177 3 MichaelA
3361 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
19178 2 MichaelA
                            >
19179 3 MichaelA
3363 : 48               [ 3]>            pha         ;use stack to load status
19180
3364 : bd4b02           [ 4]>            lda absANa,x    ;precharge accu
19181
3367 : 28               [ 4]>            plp
19182 2 MichaelA
 
19183 3 MichaelA
3368 : 35c2             [ 4]         and zpAN,x
19184 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
19185 3 MichaelA
336a : 08               [ 3]>            php         ;save flags
19186
336b : dd5302           [ 4]>            cmp absrlo,x    ;test result
19187 2 MichaelA
                            >            trap_ne
19188 3 MichaelA
336e : f002             [ 3]>        beq skip2969
19189
                            >        trap           ;failed equal (zero)
19190
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19191
3370 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19192
3371 : 26                   >        db      test_num
19193 2 MichaelA
                            >
19194 3 MichaelA
3372 :                      >skip2969
19195
                            >
19196
3372 : 68               [ 4]>            pla         ;load status
19197 2 MichaelA
                            >            eor_flag $ff-fnz
19198 3 MichaelA
3373 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
19199 2 MichaelA
                            >
19200 3 MichaelA
3375 : dd5702           [ 4]>            cmp absflo,x    ;test flags
19201 2 MichaelA
                            >            trap_ne     ;
19202 3 MichaelA
3378 : f002             [ 3]>        beq skip2972
19203
                            >        trap           ;failed equal (zero)
19204
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19205
337a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19206
337b : 26                   >        db      test_num
19207 2 MichaelA
                            >
19208 3 MichaelA
337c :                      >skip2972
19209
                            >
19210 2 MichaelA
 
19211 3 MichaelA
337c : ca               [ 2]         dex
19212
337d : 10e2             [ 3]         bpl tand7
19213 2 MichaelA
 
19214 3 MichaelA
337f : a203             [ 2]         ldx #3      ;abs,x
19215
3381 :                       tand8
19216 2 MichaelA
                                     set_ax  absANa,0
19217
                            >            load_flag 0
19218 3 MichaelA
3381 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
19219 2 MichaelA
                            >
19220 3 MichaelA
3383 : 48               [ 3]>            pha         ;use stack to load status
19221
3384 : bd4b02           [ 4]>            lda absANa,x    ;precharge accu
19222
3387 : 28               [ 4]>            plp
19223 2 MichaelA
 
19224 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  333
19225
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19226
 
19227
3388 : 3d3f02           [ 4]         and absAN,x
19228 2 MichaelA
                                     tst_ax  absrlo,absflo,0
19229 3 MichaelA
338b : 08               [ 3]>            php         ;save flags
19230
338c : dd5302           [ 4]>            cmp absrlo,x    ;test result
19231 2 MichaelA
                            >            trap_ne
19232 3 MichaelA
338f : f002             [ 3]>        beq skip2977
19233
                            >        trap           ;failed equal (zero)
19234
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19235
3391 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19236
3392 : 26                   >        db      test_num
19237 2 MichaelA
                            >
19238 3 MichaelA
3393 :                      >skip2977
19239
                            >
19240
3393 : 68               [ 4]>            pla         ;load status
19241 2 MichaelA
                            >            eor_flag 0
19242 3 MichaelA
3394 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
19243 2 MichaelA
                            >
19244 3 MichaelA
3396 : dd5702           [ 4]>            cmp absflo,x    ;test flags
19245 2 MichaelA
                            >            trap_ne     ;
19246 3 MichaelA
3399 : f002             [ 3]>        beq skip2980
19247
                            >        trap           ;failed equal (zero)
19248
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19249
339b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19250
339c : 26                   >        db      test_num
19251 2 MichaelA
                            >
19252 3 MichaelA
339d :                      >skip2980
19253
                            >
19254 2 MichaelA
 
19255 3 MichaelA
339d : ca               [ 2]         dex
19256
339e : 10e1             [ 3]         bpl tand8
19257
33a0 : a203             [ 2]         ldx #3
19258
33a2 :                       tand9
19259 2 MichaelA
                                     set_ax  absANa,$ff
19260
                            >            load_flag $ff
19261 3 MichaelA
33a2 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
19262 2 MichaelA
                            >
19263 3 MichaelA
33a4 : 48               [ 3]>            pha         ;use stack to load status
19264
33a5 : bd4b02           [ 4]>            lda absANa,x    ;precharge accu
19265
33a8 : 28               [ 4]>            plp
19266 2 MichaelA
 
19267 3 MichaelA
33a9 : 3d3f02           [ 4]         and absAN,x
19268 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
19269 3 MichaelA
33ac : 08               [ 3]>            php         ;save flags
19270
33ad : dd5302           [ 4]>            cmp absrlo,x    ;test result
19271 2 MichaelA
                            >            trap_ne
19272 3 MichaelA
33b0 : f002             [ 3]>        beq skip2985
19273
                            >        trap           ;failed equal (zero)
19274
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19275
33b2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19276
33b3 : 26                   >        db      test_num
19277 2 MichaelA
                            >
19278 3 MichaelA
33b4 :                      >skip2985
19279
                            >
19280
33b4 : 68               [ 4]>            pla         ;load status
19281 2 MichaelA
                            >            eor_flag $ff-fnz
19282 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  334
19283
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19284
 
19285
33b5 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
19286 2 MichaelA
                            >
19287 3 MichaelA
33b7 : dd5702           [ 4]>            cmp absflo,x    ;test flags
19288 2 MichaelA
                            >            trap_ne     ;
19289 3 MichaelA
33ba : f002             [ 3]>        beq skip2988
19290
                            >        trap           ;failed equal (zero)
19291
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19292
33bc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19293
33bd : 26                   >        db      test_num
19294 2 MichaelA
                            >
19295 3 MichaelA
33be :                      >skip2988
19296
                            >
19297 2 MichaelA
 
19298 3 MichaelA
33be : ca               [ 2]         dex
19299
33bf : 10e1             [ 3]         bpl tand9
19300 2 MichaelA
 
19301 3 MichaelA
33c1 : a003             [ 2]         ldy #3      ;abs,y
19302
33c3 :                       tand10
19303 2 MichaelA
                                     set_ay  absANa,0
19304
                            >            load_flag 0
19305 3 MichaelA
33c3 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
19306 2 MichaelA
                            >
19307 3 MichaelA
33c5 : 48               [ 3]>            pha         ;use stack to load status
19308
33c6 : b94b02           [ 4]>            lda absANa,y    ;precharge accu
19309
33c9 : 28               [ 4]>            plp
19310 2 MichaelA
 
19311 3 MichaelA
33ca : 393f02           [ 4]         and absAN,y
19312 2 MichaelA
                                     tst_ay  absrlo,absflo,0
19313 3 MichaelA
33cd : 08               [ 3]>            php         ;save flags
19314
33ce : d95302           [ 4]>            cmp absrlo,y    ;test result
19315 2 MichaelA
                            >            trap_ne     ;
19316 3 MichaelA
33d1 : f002             [ 3]>        beq skip2993
19317
                            >        trap           ;failed equal (zero)
19318
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19319
33d3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19320
33d4 : 26                   >        db      test_num
19321 2 MichaelA
                            >
19322 3 MichaelA
33d5 :                      >skip2993
19323
                            >
19324
33d5 : 68               [ 4]>            pla         ;load status
19325 2 MichaelA
                            >            eor_flag 0
19326 3 MichaelA
33d6 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
19327 2 MichaelA
                            >
19328 3 MichaelA
33d8 : d95702           [ 4]>            cmp absflo,y    ;test flags
19329 2 MichaelA
                            >            trap_ne
19330 3 MichaelA
33db : f002             [ 3]>        beq skip2996
19331
                            >        trap           ;failed equal (zero)
19332
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19333
33dd : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19334
33de : 26                   >        db      test_num
19335 2 MichaelA
                            >
19336 3 MichaelA
33df :                      >skip2996
19337
                            >
19338 2 MichaelA
 
19339 3 MichaelA
33df : 88               [ 2]         dey
19340
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  335
19341
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19342
 
19343
33e0 : 10e1             [ 3]         bpl tand10
19344
33e2 : a003             [ 2]         ldy #3
19345
33e4 :                       tand11
19346 2 MichaelA
                                     set_ay  absANa,$ff
19347
                            >            load_flag $ff
19348 3 MichaelA
33e4 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
19349 2 MichaelA
                            >
19350 3 MichaelA
33e6 : 48               [ 3]>            pha         ;use stack to load status
19351
33e7 : b94b02           [ 4]>            lda absANa,y    ;precharge accu
19352
33ea : 28               [ 4]>            plp
19353 2 MichaelA
 
19354 3 MichaelA
33eb : 393f02           [ 4]         and absAN,y
19355 2 MichaelA
                                     tst_ay  absrlo,absflo,$ff-fnz
19356 3 MichaelA
33ee : 08               [ 3]>            php         ;save flags
19357
33ef : d95302           [ 4]>            cmp absrlo,y    ;test result
19358 2 MichaelA
                            >            trap_ne     ;
19359 3 MichaelA
33f2 : f002             [ 3]>        beq skip3001
19360
                            >        trap           ;failed equal (zero)
19361
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19362
33f4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19363
33f5 : 26                   >        db      test_num
19364 2 MichaelA
                            >
19365 3 MichaelA
33f6 :                      >skip3001
19366
                            >
19367
33f6 : 68               [ 4]>            pla         ;load status
19368 2 MichaelA
                            >            eor_flag $ff-fnz
19369 3 MichaelA
33f7 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
19370 2 MichaelA
                            >
19371 3 MichaelA
33f9 : d95702           [ 4]>            cmp absflo,y    ;test flags
19372 2 MichaelA
                            >            trap_ne
19373 3 MichaelA
33fc : f002             [ 4]>        beq skip3004
19374
                            >        trap           ;failed equal (zero)
19375
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19376
33fe : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19377
33ff : 26                   >        db      test_num
19378 2 MichaelA
                            >
19379 3 MichaelA
3400 :                      >skip3004
19380
                            >
19381 2 MichaelA
 
19382 3 MichaelA
3400 : 88               [ 2]         dey
19383
3401 : 10e1             [ 4]         bpl tand11
19384 2 MichaelA
 
19385 3 MichaelA
3403 : a206             [ 2]         ldx #6      ;(zp,x)
19386
3405 : a003             [ 2]         ldy #3
19387
3407 :                       tand12
19388 2 MichaelA
                                     set_ay  absANa,0
19389
                            >            load_flag 0
19390 3 MichaelA
3407 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
19391 2 MichaelA
                            >
19392 3 MichaelA
3409 : 48               [ 3]>            pha         ;use stack to load status
19393
340a : b94b02           [ 4]>            lda absANa,y    ;precharge accu
19394
340d : 28               [ 4]>            plp
19395 2 MichaelA
 
19396 3 MichaelA
340e : 21e0             [ 6]         and (indAN,x)
19397
                                     tst_ay  absrlo,absflo,0
19398
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  336
19399 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19400
 
19401 3 MichaelA
3410 : 08               [ 3]>            php         ;save flags
19402
3411 : d95302           [ 4]>            cmp absrlo,y    ;test result
19403 2 MichaelA
                            >            trap_ne     ;
19404 3 MichaelA
3414 : f002             [ 3]>        beq skip3009
19405
                            >        trap           ;failed equal (zero)
19406
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19407
3416 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19408
3417 : 26                   >        db      test_num
19409 2 MichaelA
                            >
19410 3 MichaelA
3418 :                      >skip3009
19411
                            >
19412
3418 : 68               [ 4]>            pla         ;load status
19413 2 MichaelA
                            >            eor_flag 0
19414 3 MichaelA
3419 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
19415 2 MichaelA
                            >
19416 3 MichaelA
341b : d95702           [ 4]>            cmp absflo,y    ;test flags
19417 2 MichaelA
                            >            trap_ne
19418 3 MichaelA
341e : f002             [ 3]>        beq skip3012
19419
                            >        trap           ;failed equal (zero)
19420
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19421
3420 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19422
3421 : 26                   >        db      test_num
19423 2 MichaelA
                            >
19424 3 MichaelA
3422 :                      >skip3012
19425
                            >
19426 2 MichaelA
 
19427 3 MichaelA
3422 : ca               [ 2]         dex
19428
3423 : ca               [ 2]         dex
19429
3424 : 88               [ 2]         dey
19430
3425 : 10e0             [ 3]         bpl tand12
19431
3427 : a206             [ 2]         ldx #6
19432
3429 : a003             [ 2]         ldy #3
19433
342b :                       tand13
19434 2 MichaelA
                                     set_ay  absANa,$ff
19435
                            >            load_flag $ff
19436 3 MichaelA
342b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
19437 2 MichaelA
                            >
19438 3 MichaelA
342d : 48               [ 3]>            pha         ;use stack to load status
19439
342e : b94b02           [ 4]>            lda absANa,y    ;precharge accu
19440
3431 : 28               [ 4]>            plp
19441 2 MichaelA
 
19442 3 MichaelA
3432 : 21e0             [ 6]         and (indAN,x)
19443 2 MichaelA
                                     tst_ay  absrlo,absflo,$ff-fnz
19444 3 MichaelA
3434 : 08               [ 3]>            php         ;save flags
19445
3435 : d95302           [ 4]>            cmp absrlo,y    ;test result
19446 2 MichaelA
                            >            trap_ne     ;
19447 3 MichaelA
3438 : f002             [ 3]>        beq skip3017
19448
                            >        trap           ;failed equal (zero)
19449
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19450
343a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19451
343b : 26                   >        db      test_num
19452 2 MichaelA
                            >
19453 3 MichaelA
343c :                      >skip3017
19454
                            >
19455
343c : 68               [ 4]>            pla         ;load status
19456
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  337
19457
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19458
 
19459 2 MichaelA
                            >            eor_flag $ff-fnz
19460 3 MichaelA
343d : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
19461 2 MichaelA
                            >
19462 3 MichaelA
343f : d95702           [ 4]>            cmp absflo,y    ;test flags
19463 2 MichaelA
                            >            trap_ne
19464 3 MichaelA
3442 : f002             [ 3]>        beq skip3020
19465
                            >        trap           ;failed equal (zero)
19466
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19467
3444 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19468
3445 : 26                   >        db      test_num
19469 2 MichaelA
                            >
19470 3 MichaelA
3446 :                      >skip3020
19471
                            >
19472 2 MichaelA
 
19473 3 MichaelA
3446 : ca               [ 2]         dex
19474
3447 : ca               [ 2]         dex
19475
3448 : 88               [ 2]         dey
19476
3449 : 10e0             [ 3]         bpl tand13
19477 2 MichaelA
 
19478 3 MichaelA
344b : a003             [ 2]         ldy #3      ;(zp),y
19479
344d :                       tand14
19480 2 MichaelA
                                     set_ay  absANa,0
19481
                            >            load_flag 0
19482 3 MichaelA
344d : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
19483 2 MichaelA
                            >
19484 3 MichaelA
344f : 48               [ 3]>            pha         ;use stack to load status
19485
3450 : b94b02           [ 4]>            lda absANa,y    ;precharge accu
19486
3453 : 28               [ 4]>            plp
19487 2 MichaelA
 
19488 3 MichaelA
3454 : 31e0             [ 5]         and (indAN),y
19489 2 MichaelA
                                     tst_ay  absrlo,absflo,0
19490 3 MichaelA
3456 : 08               [ 3]>            php         ;save flags
19491
3457 : d95302           [ 4]>            cmp absrlo,y    ;test result
19492 2 MichaelA
                            >            trap_ne     ;
19493 3 MichaelA
345a : f002             [ 3]>        beq skip3025
19494
                            >        trap           ;failed equal (zero)
19495
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19496
345c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19497
345d : 26                   >        db      test_num
19498 2 MichaelA
                            >
19499 3 MichaelA
345e :                      >skip3025
19500
                            >
19501
345e : 68               [ 4]>            pla         ;load status
19502 2 MichaelA
                            >            eor_flag 0
19503 3 MichaelA
345f : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
19504 2 MichaelA
                            >
19505 3 MichaelA
3461 : d95702           [ 4]>            cmp absflo,y    ;test flags
19506 2 MichaelA
                            >            trap_ne
19507 3 MichaelA
3464 : f002             [ 3]>        beq skip3028
19508
                            >        trap           ;failed equal (zero)
19509
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19510
3466 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19511
3467 : 26                   >        db      test_num
19512 2 MichaelA
                            >
19513 3 MichaelA
3468 :                      >skip3028
19514
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  338
19515
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19516
 
19517
                            >
19518 2 MichaelA
 
19519 3 MichaelA
3468 : 88               [ 2]         dey
19520
3469 : 10e2             [ 3]         bpl tand14
19521
346b : a003             [ 2]         ldy #3
19522
346d :                       tand15
19523 2 MichaelA
                                     set_ay  absANa,$ff
19524
                            >            load_flag $ff
19525 3 MichaelA
346d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
19526 2 MichaelA
                            >
19527 3 MichaelA
346f : 48               [ 3]>            pha         ;use stack to load status
19528
3470 : b94b02           [ 4]>            lda absANa,y    ;precharge accu
19529
3473 : 28               [ 4]>            plp
19530 2 MichaelA
 
19531 3 MichaelA
3474 : 31e0             [ 5]         and (indAN),y
19532 2 MichaelA
                                     tst_ay  absrlo,absflo,$ff-fnz
19533 3 MichaelA
3476 : 08               [ 3]>            php         ;save flags
19534
3477 : d95302           [ 4]>            cmp absrlo,y    ;test result
19535 2 MichaelA
                            >            trap_ne     ;
19536 3 MichaelA
347a : f002             [ 3]>        beq skip3033
19537
                            >        trap           ;failed equal (zero)
19538
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19539
347c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19540
347d : 26                   >        db      test_num
19541 2 MichaelA
                            >
19542 3 MichaelA
347e :                      >skip3033
19543
                            >
19544
347e : 68               [ 4]>            pla         ;load status
19545 2 MichaelA
                            >            eor_flag $ff-fnz
19546 3 MichaelA
347f : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
19547 2 MichaelA
                            >
19548 3 MichaelA
3481 : d95702           [ 4]>            cmp absflo,y    ;test flags
19549 2 MichaelA
                            >            trap_ne
19550 3 MichaelA
3484 : f002             [ 3]>        beq skip3036
19551
                            >        trap           ;failed equal (zero)
19552
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19553
3486 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19554
3487 : 26                   >        db      test_num
19555 2 MichaelA
                            >
19556 3 MichaelA
3488 :                      >skip3036
19557
                            >
19558 2 MichaelA
 
19559 3 MichaelA
3488 : 88               [ 2]         dey
19560
3489 : 10e2             [ 3]         bpl tand15
19561 2 MichaelA
                                     next_test
19562 3 MichaelA
348b : ad0002           [ 4]>            lda test_case   ;previous test
19563
348e : c926             [ 2]>            cmp #test_num
19564
                            >            trap_ne         ;test is out of sequence
19565
3490 : f002             [ 3]>        beq skip3039
19566
                            >        trap           ;failed equal (zero)
19567
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19568
3492 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19569
3493 : 26                   >        db      test_num
19570
                            >
19571
3494 :                      >skip3039
19572
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  339
19573 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19574
 
19575
                            >
19576
0027 =                      >test_num = test_num + 1
19577 3 MichaelA
3494 : a927             [ 2]>            lda #test_num   ;*** this tests' number
19578
3496 : 8d0002           [ 4]>            sta test_case
19579 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
19580
 
19581
 
19582
                             ; EOR
19583 3 MichaelA
 
19584
3499 : a203             [ 2]         ldx #3      ;immediate - self modifying code
19585
349b : b5c6             [ 4] teor    lda zpEO,x
19586
349d : 8da834           [ 4]         sta teori1
19587 2 MichaelA
                                     set_ax  absEOa,0
19588
                            >            load_flag 0
19589 3 MichaelA
34a0 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
19590 2 MichaelA
                            >
19591 3 MichaelA
34a2 : 48               [ 3]>            pha         ;use stack to load status
19592
34a3 : bd4f02           [ 4]>            lda absEOa,x    ;precharge accu
19593
34a6 : 28               [ 4]>            plp
19594 2 MichaelA
 
19595 3 MichaelA
34a8 =                       teori1  equ *+1     ;target for immediate operand
19596
34a7 : 4963             [ 2]         eor #99
19597 2 MichaelA
                                     tst_ax  absrlo,absflo,0
19598 3 MichaelA
34a9 : 08               [ 3]>            php         ;save flags
19599
34aa : dd5302           [ 4]>            cmp absrlo,x    ;test result
19600 2 MichaelA
                            >            trap_ne
19601 3 MichaelA
34ad : f002             [ 3]>        beq skip3044
19602
                            >        trap           ;failed equal (zero)
19603
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19604
34af : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19605
34b0 : 27                   >        db      test_num
19606 2 MichaelA
                            >
19607 3 MichaelA
34b1 :                      >skip3044
19608
                            >
19609
34b1 : 68               [ 4]>            pla         ;load status
19610 2 MichaelA
                            >            eor_flag 0
19611 3 MichaelA
34b2 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
19612 2 MichaelA
                            >
19613 3 MichaelA
34b4 : dd5702           [ 4]>            cmp absflo,x    ;test flags
19614 2 MichaelA
                            >            trap_ne     ;
19615 3 MichaelA
34b7 : f002             [ 3]>        beq skip3047
19616
                            >        trap           ;failed equal (zero)
19617
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19618
34b9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19619
34ba : 27                   >        db      test_num
19620 2 MichaelA
                            >
19621 3 MichaelA
34bb :                      >skip3047
19622
                            >
19623 2 MichaelA
 
19624 3 MichaelA
34bb : ca               [ 2]         dex
19625
34bc : 10dd             [ 3]         bpl teor
19626
34be : a203             [ 2]         ldx #3
19627
34c0 : b5c6             [ 4] teor1   lda zpEO,x
19628
34c2 : 8dcd34           [ 4]         sta teori2
19629 2 MichaelA
                                     set_ax  absEOa,$ff
19630 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  340
19631
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19632
 
19633 2 MichaelA
                            >            load_flag $ff
19634 3 MichaelA
34c5 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
19635 2 MichaelA
                            >
19636 3 MichaelA
34c7 : 48               [ 3]>            pha         ;use stack to load status
19637
34c8 : bd4f02           [ 4]>            lda absEOa,x    ;precharge accu
19638
34cb : 28               [ 4]>            plp
19639 2 MichaelA
 
19640 3 MichaelA
34cd =                       teori2  equ *+1     ;target for immediate operand
19641
34cc : 4963             [ 2]         eor #99
19642 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
19643 3 MichaelA
34ce : 08               [ 3]>            php         ;save flags
19644
34cf : dd5302           [ 4]>            cmp absrlo,x    ;test result
19645 2 MichaelA
                            >            trap_ne
19646 3 MichaelA
34d2 : f002             [ 3]>        beq skip3052
19647
                            >        trap           ;failed equal (zero)
19648
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19649
34d4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19650
34d5 : 27                   >        db      test_num
19651 2 MichaelA
                            >
19652 3 MichaelA
34d6 :                      >skip3052
19653
                            >
19654
34d6 : 68               [ 4]>            pla         ;load status
19655 2 MichaelA
                            >            eor_flag $ff-fnz
19656 3 MichaelA
34d7 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
19657 2 MichaelA
                            >
19658 3 MichaelA
34d9 : dd5702           [ 4]>            cmp absflo,x    ;test flags
19659 2 MichaelA
                            >            trap_ne     ;
19660 3 MichaelA
34dc : f002             [ 3]>        beq skip3055
19661
                            >        trap           ;failed equal (zero)
19662
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19663
34de : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19664
34df : 27                   >        db      test_num
19665 2 MichaelA
                            >
19666 3 MichaelA
34e0 :                      >skip3055
19667
                            >
19668 2 MichaelA
 
19669 3 MichaelA
34e0 : ca               [ 2]         dex
19670
34e1 : 10dd             [ 3]         bpl teor1
19671 2 MichaelA
 
19672 3 MichaelA
34e3 : a203             [ 2]         ldx #3      ;zp
19673
34e5 : b5c6             [ 4] teor2    lda zpEO,x
19674
34e7 : 85b2             [ 3]         sta zpt
19675 2 MichaelA
                                     set_ax  absEOa,0
19676
                            >            load_flag 0
19677 3 MichaelA
34e9 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
19678 2 MichaelA
                            >
19679 3 MichaelA
34eb : 48               [ 3]>            pha         ;use stack to load status
19680
34ec : bd4f02           [ 4]>            lda absEOa,x    ;precharge accu
19681
34ef : 28               [ 4]>            plp
19682 2 MichaelA
 
19683 3 MichaelA
34f0 : 45b2             [ 3]         eor zpt
19684 2 MichaelA
                                     tst_ax  absrlo,absflo,0
19685 3 MichaelA
34f2 : 08               [ 3]>            php         ;save flags
19686
34f3 : dd5302           [ 4]>            cmp absrlo,x    ;test result
19687 2 MichaelA
                            >            trap_ne
19688 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  341
19689
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19690
 
19691
34f6 : f002             [ 3]>        beq skip3060
19692
                            >        trap           ;failed equal (zero)
19693
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19694
34f8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19695
34f9 : 27                   >        db      test_num
19696 2 MichaelA
                            >
19697 3 MichaelA
34fa :                      >skip3060
19698
                            >
19699
34fa : 68               [ 4]>            pla         ;load status
19700 2 MichaelA
                            >            eor_flag 0
19701 3 MichaelA
34fb : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
19702 2 MichaelA
                            >
19703 3 MichaelA
34fd : dd5702           [ 4]>            cmp absflo,x    ;test flags
19704 2 MichaelA
                            >            trap_ne     ;
19705 3 MichaelA
3500 : f002             [ 3]>        beq skip3063
19706
                            >        trap           ;failed equal (zero)
19707
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19708
3502 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19709
3503 : 27                   >        db      test_num
19710 2 MichaelA
                            >
19711 3 MichaelA
3504 :                      >skip3063
19712
                            >
19713 2 MichaelA
 
19714 3 MichaelA
3504 : ca               [ 2]         dex
19715
3505 : 10de             [ 4]         bpl teor2
19716
3507 : a203             [ 2]         ldx #3
19717
3509 : b5c6             [ 4] teor3   lda zpEO,x
19718
350b : 85b2             [ 3]         sta zpt
19719 2 MichaelA
                                     set_ax  absEOa,$ff
19720
                            >            load_flag $ff
19721 3 MichaelA
350d : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
19722 2 MichaelA
                            >
19723 3 MichaelA
350f : 48               [ 3]>            pha         ;use stack to load status
19724
3510 : bd4f02           [ 4]>            lda absEOa,x    ;precharge accu
19725
3513 : 28               [ 4]>            plp
19726 2 MichaelA
 
19727 3 MichaelA
3514 : 45b2             [ 3]         eor zpt
19728 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
19729 3 MichaelA
3516 : 08               [ 3]>            php         ;save flags
19730
3517 : dd5302           [ 4]>            cmp absrlo,x    ;test result
19731 2 MichaelA
                            >            trap_ne
19732 3 MichaelA
351a : f002             [ 3]>        beq skip3068
19733
                            >        trap           ;failed equal (zero)
19734
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19735
351c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19736
351d : 27                   >        db      test_num
19737 2 MichaelA
                            >
19738 3 MichaelA
351e :                      >skip3068
19739
                            >
19740
351e : 68               [ 4]>            pla         ;load status
19741 2 MichaelA
                            >            eor_flag $ff-fnz
19742 3 MichaelA
351f : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
19743 2 MichaelA
                            >
19744 3 MichaelA
3521 : dd5702           [ 4]>            cmp absflo,x    ;test flags
19745 2 MichaelA
                            >            trap_ne     ;
19746 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  342
19747
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19748
 
19749
3524 : f002             [ 3]>        beq skip3071
19750
                            >        trap           ;failed equal (zero)
19751
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19752
3526 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19753
3527 : 27                   >        db      test_num
19754 2 MichaelA
                            >
19755 3 MichaelA
3528 :                      >skip3071
19756
                            >
19757 2 MichaelA
 
19758 3 MichaelA
3528 : ca               [ 2]         dex
19759
3529 : 10de             [ 3]         bpl teor3
19760 2 MichaelA
 
19761 3 MichaelA
352b : a203             [ 2]         ldx #3      ;abs
19762
352d : b5c6             [ 4] teor4   lda zpEO,x
19763
352f : 8d0302           [ 4]         sta abst
19764 2 MichaelA
                                     set_ax  absEOa,0
19765
                            >            load_flag 0
19766 3 MichaelA
3532 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
19767 2 MichaelA
                            >
19768 3 MichaelA
3534 : 48               [ 3]>            pha         ;use stack to load status
19769
3535 : bd4f02           [ 4]>            lda absEOa,x    ;precharge accu
19770
3538 : 28               [ 4]>            plp
19771 2 MichaelA
 
19772 3 MichaelA
3539 : 4d0302           [ 4]         eor abst
19773 2 MichaelA
                                     tst_ax  absrlo,absflo,0
19774 3 MichaelA
353c : 08               [ 3]>            php         ;save flags
19775
353d : dd5302           [ 4]>            cmp absrlo,x    ;test result
19776 2 MichaelA
                            >            trap_ne
19777 3 MichaelA
3540 : f002             [ 3]>        beq skip3076
19778
                            >        trap           ;failed equal (zero)
19779
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19780
3542 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19781
3543 : 27                   >        db      test_num
19782 2 MichaelA
                            >
19783 3 MichaelA
3544 :                      >skip3076
19784
                            >
19785
3544 : 68               [ 4]>            pla         ;load status
19786 2 MichaelA
                            >            eor_flag 0
19787 3 MichaelA
3545 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
19788 2 MichaelA
                            >
19789 3 MichaelA
3547 : dd5702           [ 4]>            cmp absflo,x    ;test flags
19790 2 MichaelA
                            >            trap_ne     ;
19791 3 MichaelA
354a : f002             [ 3]>        beq skip3079
19792
                            >        trap           ;failed equal (zero)
19793
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19794
354c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19795
354d : 27                   >        db      test_num
19796 2 MichaelA
                            >
19797 3 MichaelA
354e :                      >skip3079
19798
                            >
19799 2 MichaelA
 
19800 3 MichaelA
354e : ca               [ 2]         dex
19801
354f : 10dc             [ 3]         bpl teor4
19802
3551 : a203             [ 2]         ldx #3
19803
3553 : b5c6             [ 4] teor5   lda zpEO,x
19804
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  343
19805
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19806
 
19807
3555 : 8d0302           [ 4]         sta abst
19808 2 MichaelA
                                     set_ax  absEOa,$ff
19809
                            >            load_flag $ff
19810 3 MichaelA
3558 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
19811 2 MichaelA
                            >
19812 3 MichaelA
355a : 48               [ 3]>            pha         ;use stack to load status
19813
355b : bd4f02           [ 4]>            lda absEOa,x    ;precharge accu
19814
355e : 28               [ 4]>            plp
19815 2 MichaelA
 
19816 3 MichaelA
355f : 4d0302           [ 4]         eor abst
19817 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
19818 3 MichaelA
3562 : 08               [ 3]>            php         ;save flags
19819
3563 : dd5302           [ 4]>            cmp absrlo,x    ;test result
19820 2 MichaelA
                            >            trap_ne
19821 3 MichaelA
3566 : f002             [ 3]>        beq skip3084
19822
                            >        trap           ;failed equal (zero)
19823
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19824
3568 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19825
3569 : 27                   >        db      test_num
19826 2 MichaelA
                            >
19827 3 MichaelA
356a :                      >skip3084
19828
                            >
19829
356a : 68               [ 4]>            pla         ;load status
19830 2 MichaelA
                            >            eor_flag $ff-fnz
19831 3 MichaelA
356b : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
19832 2 MichaelA
                            >
19833 3 MichaelA
356d : dd5702           [ 4]>            cmp absflo,x    ;test flags
19834 2 MichaelA
                            >            trap_ne     ;
19835 3 MichaelA
3570 : f002             [ 3]>        beq skip3087
19836
                            >        trap           ;failed equal (zero)
19837
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19838
3572 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19839
3573 : 27                   >        db      test_num
19840 2 MichaelA
                            >
19841 3 MichaelA
3574 :                      >skip3087
19842
                            >
19843 2 MichaelA
 
19844 3 MichaelA
3574 : ca               [ 2]         dex
19845
3575 : 1002             [ 3]         bpl teor6
19846 2 MichaelA
 
19847 3 MichaelA
3577 : a203             [ 2]         ldx #3      ;zp,x
19848
3579 :                       teor6
19849 2 MichaelA
                                     set_ax  absEOa,0
19850
                            >            load_flag 0
19851 3 MichaelA
3579 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
19852 2 MichaelA
                            >
19853 3 MichaelA
357b : 48               [ 3]>            pha         ;use stack to load status
19854
357c : bd4f02           [ 4]>            lda absEOa,x    ;precharge accu
19855
357f : 28               [ 4]>            plp
19856 2 MichaelA
 
19857 3 MichaelA
3580 : 55c6             [ 4]         eor zpEO,x
19858 2 MichaelA
                                     tst_ax  absrlo,absflo,0
19859 3 MichaelA
3582 : 08               [ 3]>            php         ;save flags
19860
3583 : dd5302           [ 4]>            cmp absrlo,x    ;test result
19861 2 MichaelA
                            >            trap_ne
19862 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  344
19863
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19864
 
19865
3586 : f002             [ 3]>        beq skip3092
19866
                            >        trap           ;failed equal (zero)
19867
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19868
3588 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19869
3589 : 27                   >        db      test_num
19870 2 MichaelA
                            >
19871 3 MichaelA
358a :                      >skip3092
19872
                            >
19873
358a : 68               [ 4]>            pla         ;load status
19874 2 MichaelA
                            >            eor_flag 0
19875 3 MichaelA
358b : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
19876 2 MichaelA
                            >
19877 3 MichaelA
358d : dd5702           [ 4]>            cmp absflo,x    ;test flags
19878 2 MichaelA
                            >            trap_ne     ;
19879 3 MichaelA
3590 : f002             [ 3]>        beq skip3095
19880
                            >        trap           ;failed equal (zero)
19881
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19882
3592 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19883
3593 : 27                   >        db      test_num
19884 2 MichaelA
                            >
19885 3 MichaelA
3594 :                      >skip3095
19886
                            >
19887 2 MichaelA
 
19888 3 MichaelA
3594 : ca               [ 2]         dex
19889
3595 : 10e2             [ 3]         bpl teor6
19890
3597 : a203             [ 2]         ldx #3
19891
3599 :                       teor7
19892 2 MichaelA
                                     set_ax  absEOa,$ff
19893
                            >            load_flag $ff
19894 3 MichaelA
3599 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
19895 2 MichaelA
                            >
19896 3 MichaelA
359b : 48               [ 3]>            pha         ;use stack to load status
19897
359c : bd4f02           [ 4]>            lda absEOa,x    ;precharge accu
19898
359f : 28               [ 4]>            plp
19899 2 MichaelA
 
19900 3 MichaelA
35a0 : 55c6             [ 4]         eor zpEO,x
19901 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
19902 3 MichaelA
35a2 : 08               [ 3]>            php         ;save flags
19903
35a3 : dd5302           [ 4]>            cmp absrlo,x    ;test result
19904 2 MichaelA
                            >            trap_ne
19905 3 MichaelA
35a6 : f002             [ 3]>        beq skip3100
19906
                            >        trap           ;failed equal (zero)
19907
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19908
35a8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19909
35a9 : 27                   >        db      test_num
19910 2 MichaelA
                            >
19911 3 MichaelA
35aa :                      >skip3100
19912
                            >
19913
35aa : 68               [ 4]>            pla         ;load status
19914 2 MichaelA
                            >            eor_flag $ff-fnz
19915 3 MichaelA
35ab : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
19916 2 MichaelA
                            >
19917 3 MichaelA
35ad : dd5702           [ 4]>            cmp absflo,x    ;test flags
19918 2 MichaelA
                            >            trap_ne     ;
19919 3 MichaelA
35b0 : f002             [ 3]>        beq skip3103
19920
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  345
19921
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19922
 
19923
                            >        trap           ;failed equal (zero)
19924
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19925
35b2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19926
35b3 : 27                   >        db      test_num
19927 2 MichaelA
                            >
19928 3 MichaelA
35b4 :                      >skip3103
19929
                            >
19930 2 MichaelA
 
19931 3 MichaelA
35b4 : ca               [ 2]         dex
19932
35b5 : 10e2             [ 3]         bpl teor7
19933 2 MichaelA
 
19934 3 MichaelA
35b7 : a203             [ 2]         ldx #3      ;abs,x
19935
35b9 :                       teor8
19936 2 MichaelA
                                     set_ax  absEOa,0
19937
                            >            load_flag 0
19938 3 MichaelA
35b9 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
19939 2 MichaelA
                            >
19940 3 MichaelA
35bb : 48               [ 3]>            pha         ;use stack to load status
19941
35bc : bd4f02           [ 4]>            lda absEOa,x    ;precharge accu
19942
35bf : 28               [ 4]>            plp
19943 2 MichaelA
 
19944 3 MichaelA
35c0 : 5d4302           [ 4]         eor absEO,x
19945 2 MichaelA
                                     tst_ax  absrlo,absflo,0
19946 3 MichaelA
35c3 : 08               [ 3]>            php         ;save flags
19947
35c4 : dd5302           [ 4]>            cmp absrlo,x    ;test result
19948 2 MichaelA
                            >            trap_ne
19949 3 MichaelA
35c7 : f002             [ 3]>        beq skip3108
19950
                            >        trap           ;failed equal (zero)
19951
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19952
35c9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19953
35ca : 27                   >        db      test_num
19954 2 MichaelA
                            >
19955 3 MichaelA
35cb :                      >skip3108
19956
                            >
19957
35cb : 68               [ 4]>            pla         ;load status
19958 2 MichaelA
                            >            eor_flag 0
19959 3 MichaelA
35cc : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
19960 2 MichaelA
                            >
19961 3 MichaelA
35ce : dd5702           [ 4]>            cmp absflo,x    ;test flags
19962 2 MichaelA
                            >            trap_ne     ;
19963 3 MichaelA
35d1 : f002             [ 3]>        beq skip3111
19964
                            >        trap           ;failed equal (zero)
19965
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19966
35d3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19967
35d4 : 27                   >        db      test_num
19968 2 MichaelA
                            >
19969 3 MichaelA
35d5 :                      >skip3111
19970
                            >
19971 2 MichaelA
 
19972 3 MichaelA
35d5 : ca               [ 2]         dex
19973
35d6 : 10e1             [ 3]         bpl teor8
19974
35d8 : a203             [ 2]         ldx #3
19975
35da :                       teor9
19976
                                     set_ax  absEOa,$ff
19977
                            >            load_flag $ff
19978
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  346
19979 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
19980
 
19981 3 MichaelA
35da : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
19982 2 MichaelA
                            >
19983 3 MichaelA
35dc : 48               [ 3]>            pha         ;use stack to load status
19984
35dd : bd4f02           [ 4]>            lda absEOa,x    ;precharge accu
19985
35e0 : 28               [ 4]>            plp
19986 2 MichaelA
 
19987 3 MichaelA
35e1 : 5d4302           [ 4]         eor absEO,x
19988 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
19989 3 MichaelA
35e4 : 08               [ 3]>            php         ;save flags
19990
35e5 : dd5302           [ 4]>            cmp absrlo,x    ;test result
19991 2 MichaelA
                            >            trap_ne
19992 3 MichaelA
35e8 : f002             [ 3]>        beq skip3116
19993
                            >        trap           ;failed equal (zero)
19994
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
19995
35ea : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
19996
35eb : 27                   >        db      test_num
19997 2 MichaelA
                            >
19998 3 MichaelA
35ec :                      >skip3116
19999
                            >
20000
35ec : 68               [ 4]>            pla         ;load status
20001 2 MichaelA
                            >            eor_flag $ff-fnz
20002 3 MichaelA
35ed : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
20003 2 MichaelA
                            >
20004 3 MichaelA
35ef : dd5702           [ 4]>            cmp absflo,x    ;test flags
20005 2 MichaelA
                            >            trap_ne     ;
20006 3 MichaelA
35f2 : f002             [ 3]>        beq skip3119
20007
                            >        trap           ;failed equal (zero)
20008
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20009
35f4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20010
35f5 : 27                   >        db      test_num
20011 2 MichaelA
                            >
20012 3 MichaelA
35f6 :                      >skip3119
20013
                            >
20014 2 MichaelA
 
20015 3 MichaelA
35f6 : ca               [ 2]         dex
20016
35f7 : 10e1             [ 3]         bpl teor9
20017 2 MichaelA
 
20018 3 MichaelA
35f9 : a003             [ 2]         ldy #3      ;abs,y
20019
35fb :                       teor10
20020 2 MichaelA
                                     set_ay  absEOa,0
20021
                            >            load_flag 0
20022 3 MichaelA
35fb : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
20023 2 MichaelA
                            >
20024 3 MichaelA
35fd : 48               [ 3]>            pha         ;use stack to load status
20025
35fe : b94f02           [ 4]>            lda absEOa,y    ;precharge accu
20026
3601 : 28               [ 4]>            plp
20027 2 MichaelA
 
20028 3 MichaelA
3602 : 594302           [ 4]         eor absEO,y
20029 2 MichaelA
                                     tst_ay  absrlo,absflo,0
20030 3 MichaelA
3605 : 08               [ 3]>            php         ;save flags
20031
3606 : d95302           [ 4]>            cmp absrlo,y    ;test result
20032 2 MichaelA
                            >            trap_ne     ;
20033 3 MichaelA
3609 : f002             [ 3]>        beq skip3124
20034
                            >        trap           ;failed equal (zero)
20035
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20036
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  347
20037
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20038
 
20039
360b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20040
360c : 27                   >        db      test_num
20041 2 MichaelA
                            >
20042 3 MichaelA
360d :                      >skip3124
20043
                            >
20044
360d : 68               [ 4]>            pla         ;load status
20045 2 MichaelA
                            >            eor_flag 0
20046 3 MichaelA
360e : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
20047 2 MichaelA
                            >
20048 3 MichaelA
3610 : d95702           [ 4]>            cmp absflo,y    ;test flags
20049 2 MichaelA
                            >            trap_ne
20050 3 MichaelA
3613 : f002             [ 3]>        beq skip3127
20051
                            >        trap           ;failed equal (zero)
20052
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20053
3615 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20054
3616 : 27                   >        db      test_num
20055 2 MichaelA
                            >
20056 3 MichaelA
3617 :                      >skip3127
20057
                            >
20058 2 MichaelA
 
20059 3 MichaelA
3617 : 88               [ 2]         dey
20060
3618 : 10e1             [ 4]         bpl teor10
20061
361a : a003             [ 2]         ldy #3
20062
361c :                       teor11
20063 2 MichaelA
                                     set_ay  absEOa,$ff
20064
                            >            load_flag $ff
20065 3 MichaelA
361c : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
20066 2 MichaelA
                            >
20067 3 MichaelA
361e : 48               [ 3]>            pha         ;use stack to load status
20068
361f : b94f02           [ 4]>            lda absEOa,y    ;precharge accu
20069
3622 : 28               [ 4]>            plp
20070 2 MichaelA
 
20071 3 MichaelA
3623 : 594302           [ 4]         eor absEO,y
20072 2 MichaelA
                                     tst_ay  absrlo,absflo,$ff-fnz
20073 3 MichaelA
3626 : 08               [ 3]>            php         ;save flags
20074
3627 : d95302           [ 4]>            cmp absrlo,y    ;test result
20075 2 MichaelA
                            >            trap_ne     ;
20076 3 MichaelA
362a : f002             [ 3]>        beq skip3132
20077
                            >        trap           ;failed equal (zero)
20078
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20079
362c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20080
362d : 27                   >        db      test_num
20081 2 MichaelA
                            >
20082 3 MichaelA
362e :                      >skip3132
20083
                            >
20084
362e : 68               [ 4]>            pla         ;load status
20085 2 MichaelA
                            >            eor_flag $ff-fnz
20086 3 MichaelA
362f : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
20087 2 MichaelA
                            >
20088 3 MichaelA
3631 : d95702           [ 4]>            cmp absflo,y    ;test flags
20089 2 MichaelA
                            >            trap_ne
20090 3 MichaelA
3634 : f002             [ 3]>        beq skip3135
20091
                            >        trap           ;failed equal (zero)
20092
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20093
3636 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20094
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  348
20095
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20096
 
20097
3637 : 27                   >        db      test_num
20098 2 MichaelA
                            >
20099 3 MichaelA
3638 :                      >skip3135
20100
                            >
20101 2 MichaelA
 
20102 3 MichaelA
3638 : 88               [ 2]         dey
20103
3639 : 10e1             [ 3]         bpl teor11
20104 2 MichaelA
 
20105 3 MichaelA
363b : a206             [ 2]         ldx #6      ;(zp,x)
20106
363d : a003             [ 2]         ldy #3
20107
363f :                       teor12
20108 2 MichaelA
                                     set_ay  absEOa,0
20109
                            >            load_flag 0
20110 3 MichaelA
363f : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
20111 2 MichaelA
                            >
20112 3 MichaelA
3641 : 48               [ 3]>            pha         ;use stack to load status
20113
3642 : b94f02           [ 4]>            lda absEOa,y    ;precharge accu
20114
3645 : 28               [ 4]>            plp
20115 2 MichaelA
 
20116 3 MichaelA
3646 : 41e8             [ 6]         eor (indEO,x)
20117 2 MichaelA
                                     tst_ay  absrlo,absflo,0
20118 3 MichaelA
3648 : 08               [ 3]>            php         ;save flags
20119
3649 : d95302           [ 4]>            cmp absrlo,y    ;test result
20120 2 MichaelA
                            >            trap_ne     ;
20121 3 MichaelA
364c : f002             [ 3]>        beq skip3140
20122
                            >        trap           ;failed equal (zero)
20123
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20124
364e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20125
364f : 27                   >        db      test_num
20126 2 MichaelA
                            >
20127 3 MichaelA
3650 :                      >skip3140
20128
                            >
20129
3650 : 68               [ 4]>            pla         ;load status
20130 2 MichaelA
                            >            eor_flag 0
20131 3 MichaelA
3651 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
20132 2 MichaelA
                            >
20133 3 MichaelA
3653 : d95702           [ 4]>            cmp absflo,y    ;test flags
20134 2 MichaelA
                            >            trap_ne
20135 3 MichaelA
3656 : f002             [ 3]>        beq skip3143
20136
                            >        trap           ;failed equal (zero)
20137
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20138
3658 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20139
3659 : 27                   >        db      test_num
20140 2 MichaelA
                            >
20141 3 MichaelA
365a :                      >skip3143
20142
                            >
20143 2 MichaelA
 
20144 3 MichaelA
365a : ca               [ 2]         dex
20145
365b : ca               [ 2]         dex
20146
365c : 88               [ 2]         dey
20147
365d : 10e0             [ 3]         bpl teor12
20148
365f : a206             [ 2]         ldx #6
20149
3661 : a003             [ 2]         ldy #3
20150
3663 :                       teor13
20151 2 MichaelA
                                     set_ay  absEOa,$ff
20152 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  349
20153
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20154
 
20155 2 MichaelA
                            >            load_flag $ff
20156 3 MichaelA
3663 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
20157 2 MichaelA
                            >
20158 3 MichaelA
3665 : 48               [ 3]>            pha         ;use stack to load status
20159
3666 : b94f02           [ 4]>            lda absEOa,y    ;precharge accu
20160
3669 : 28               [ 4]>            plp
20161 2 MichaelA
 
20162 3 MichaelA
366a : 41e8             [ 6]         eor (indEO,x)
20163 2 MichaelA
                                     tst_ay  absrlo,absflo,$ff-fnz
20164 3 MichaelA
366c : 08               [ 3]>            php         ;save flags
20165
366d : d95302           [ 4]>            cmp absrlo,y    ;test result
20166 2 MichaelA
                            >            trap_ne     ;
20167 3 MichaelA
3670 : f002             [ 3]>        beq skip3148
20168
                            >        trap           ;failed equal (zero)
20169
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20170
3672 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20171
3673 : 27                   >        db      test_num
20172 2 MichaelA
                            >
20173 3 MichaelA
3674 :                      >skip3148
20174
                            >
20175
3674 : 68               [ 4]>            pla         ;load status
20176 2 MichaelA
                            >            eor_flag $ff-fnz
20177 3 MichaelA
3675 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
20178 2 MichaelA
                            >
20179 3 MichaelA
3677 : d95702           [ 4]>            cmp absflo,y    ;test flags
20180 2 MichaelA
                            >            trap_ne
20181 3 MichaelA
367a : f002             [ 3]>        beq skip3151
20182
                            >        trap           ;failed equal (zero)
20183
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20184
367c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20185
367d : 27                   >        db      test_num
20186 2 MichaelA
                            >
20187 3 MichaelA
367e :                      >skip3151
20188
                            >
20189 2 MichaelA
 
20190 3 MichaelA
367e : ca               [ 2]         dex
20191
367f : ca               [ 2]         dex
20192
3680 : 88               [ 2]         dey
20193
3681 : 10e0             [ 3]         bpl teor13
20194 2 MichaelA
 
20195 3 MichaelA
3683 : a003             [ 2]         ldy #3      ;(zp),y
20196
3685 :                       teor14
20197 2 MichaelA
                                     set_ay  absEOa,0
20198
                            >            load_flag 0
20199 3 MichaelA
3685 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
20200 2 MichaelA
                            >
20201 3 MichaelA
3687 : 48               [ 3]>            pha         ;use stack to load status
20202
3688 : b94f02           [ 4]>            lda absEOa,y    ;precharge accu
20203
368b : 28               [ 4]>            plp
20204 2 MichaelA
 
20205 3 MichaelA
368c : 51e8             [ 5]         eor (indEO),y
20206 2 MichaelA
                                     tst_ay  absrlo,absflo,0
20207 3 MichaelA
368e : 08               [ 3]>            php         ;save flags
20208
368f : d95302           [ 4]>            cmp absrlo,y    ;test result
20209 2 MichaelA
                            >            trap_ne     ;
20210 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  350
20211 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20212
 
20213 3 MichaelA
3692 : f002             [ 3]>        beq skip3156
20214
                            >        trap           ;failed equal (zero)
20215
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20216
3694 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20217
3695 : 27                   >        db      test_num
20218 2 MichaelA
                            >
20219 3 MichaelA
3696 :                      >skip3156
20220
                            >
20221
3696 : 68               [ 4]>            pla         ;load status
20222 2 MichaelA
                            >            eor_flag 0
20223 3 MichaelA
3697 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
20224 2 MichaelA
                            >
20225 3 MichaelA
3699 : d95702           [ 4]>            cmp absflo,y    ;test flags
20226 2 MichaelA
                            >            trap_ne
20227 3 MichaelA
369c : f002             [ 3]>        beq skip3159
20228
                            >        trap           ;failed equal (zero)
20229
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20230
369e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20231
369f : 27                   >        db      test_num
20232 2 MichaelA
                            >
20233 3 MichaelA
36a0 :                      >skip3159
20234
                            >
20235 2 MichaelA
 
20236 3 MichaelA
36a0 : 88               [ 2]         dey
20237
36a1 : 10e2             [ 3]         bpl teor14
20238
36a3 : a003             [ 2]         ldy #3
20239
36a5 :                       teor15
20240 2 MichaelA
                                     set_ay  absEOa,$ff
20241
                            >            load_flag $ff
20242 3 MichaelA
36a5 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
20243 2 MichaelA
                            >
20244 3 MichaelA
36a7 : 48               [ 3]>            pha         ;use stack to load status
20245
36a8 : b94f02           [ 4]>            lda absEOa,y    ;precharge accu
20246
36ab : 28               [ 4]>            plp
20247 2 MichaelA
 
20248 3 MichaelA
36ac : 51e8             [ 5]         eor (indEO),y
20249 2 MichaelA
                                     tst_ay  absrlo,absflo,$ff-fnz
20250 3 MichaelA
36ae : 08               [ 3]>            php         ;save flags
20251
36af : d95302           [ 4]>            cmp absrlo,y    ;test result
20252 2 MichaelA
                            >            trap_ne     ;
20253 3 MichaelA
36b2 : f002             [ 3]>        beq skip3164
20254
                            >        trap           ;failed equal (zero)
20255
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20256
36b4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20257
36b5 : 27                   >        db      test_num
20258 2 MichaelA
                            >
20259 3 MichaelA
36b6 :                      >skip3164
20260
                            >
20261
36b6 : 68               [ 4]>            pla         ;load status
20262 2 MichaelA
                            >            eor_flag $ff-fnz
20263 3 MichaelA
36b7 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
20264 2 MichaelA
                            >
20265 3 MichaelA
36b9 : d95702           [ 4]>            cmp absflo,y    ;test flags
20266 2 MichaelA
                            >            trap_ne
20267 3 MichaelA
36bc : f002             [ 3]>        beq skip3167
20268
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  351
20269
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20270
 
20271
                            >        trap           ;failed equal (zero)
20272
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20273
36be : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20274
36bf : 27                   >        db      test_num
20275 2 MichaelA
                            >
20276 3 MichaelA
36c0 :                      >skip3167
20277
                            >
20278 2 MichaelA
 
20279 3 MichaelA
36c0 : 88               [ 2]         dey
20280
36c1 : 10e2             [ 3]         bpl teor15
20281 2 MichaelA
                                     next_test
20282 3 MichaelA
36c3 : ad0002           [ 4]>            lda test_case   ;previous test
20283
36c6 : c927             [ 2]>            cmp #test_num
20284 2 MichaelA
                            >            trap_ne         ;test is out of sequence
20285 3 MichaelA
36c8 : f002             [ 3]>        beq skip3170
20286
                            >        trap           ;failed equal (zero)
20287
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20288
36ca : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20289
36cb : 27                   >        db      test_num
20290 2 MichaelA
                            >
20291 3 MichaelA
36cc :                      >skip3170
20292
                            >
20293 2 MichaelA
0028 =                      >test_num = test_num + 1
20294 3 MichaelA
36cc : a928             [ 2]>            lda #test_num   ;*** this tests' number
20295
36ce : 8d0002           [ 4]>            sta test_case
20296 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
20297
 
20298
 
20299
                             ; OR
20300 3 MichaelA
 
20301
36d1 : a203             [ 2]         ldx #3      ;immediate - self modifying code
20302
36d3 : b5be             [ 4] tora    lda zpOR,x
20303
36d5 : 8de036           [ 4]         sta torai1
20304 2 MichaelA
                                     set_ax  absORa,0
20305
                            >            load_flag 0
20306 3 MichaelA
36d8 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
20307 2 MichaelA
                            >
20308 3 MichaelA
36da : 48               [ 3]>            pha         ;use stack to load status
20309
36db : bd4702           [ 4]>            lda absORa,x    ;precharge accu
20310
36de : 28               [ 4]>            plp
20311 2 MichaelA
 
20312 3 MichaelA
36e0 =                       torai1  equ *+1     ;target for immediate operand
20313
36df : 0963             [ 2]         ora #99
20314 2 MichaelA
                                     tst_ax  absrlo,absflo,0
20315 3 MichaelA
36e1 : 08               [ 3]>            php         ;save flags
20316
36e2 : dd5302           [ 4]>            cmp absrlo,x    ;test result
20317 2 MichaelA
                            >            trap_ne
20318 3 MichaelA
36e5 : f002             [ 3]>        beq skip3175
20319
                            >        trap           ;failed equal (zero)
20320
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20321
36e7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20322
36e8 : 28                   >        db      test_num
20323 2 MichaelA
                            >
20324 3 MichaelA
36e9 :                      >skip3175
20325
                            >
20326
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  352
20327
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20328
 
20329
36e9 : 68               [ 4]>            pla         ;load status
20330 2 MichaelA
                            >            eor_flag 0
20331 3 MichaelA
36ea : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
20332 2 MichaelA
                            >
20333 3 MichaelA
36ec : dd5702           [ 4]>            cmp absflo,x    ;test flags
20334 2 MichaelA
                            >            trap_ne     ;
20335 3 MichaelA
36ef : f002             [ 3]>        beq skip3178
20336
                            >        trap           ;failed equal (zero)
20337
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20338
36f1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20339
36f2 : 28                   >        db      test_num
20340 2 MichaelA
                            >
20341 3 MichaelA
36f3 :                      >skip3178
20342
                            >
20343 2 MichaelA
 
20344 3 MichaelA
36f3 : ca               [ 2]         dex
20345
36f4 : 10dd             [ 3]         bpl tora
20346
36f6 : a203             [ 2]         ldx #3
20347
36f8 : b5be             [ 4] tora1   lda zpOR,x
20348
36fa : 8d0537           [ 4]         sta torai2
20349 2 MichaelA
                                     set_ax  absORa,$ff
20350
                            >            load_flag $ff
20351 3 MichaelA
36fd : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
20352 2 MichaelA
                            >
20353 3 MichaelA
36ff : 48               [ 3]>            pha         ;use stack to load status
20354
3700 : bd4702           [ 4]>            lda absORa,x    ;precharge accu
20355
3703 : 28               [ 4]>            plp
20356 2 MichaelA
 
20357 3 MichaelA
3705 =                       torai2  equ *+1     ;target for immediate operand
20358
3704 : 0963             [ 2]         ora #99
20359 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
20360 3 MichaelA
3706 : 08               [ 3]>            php         ;save flags
20361
3707 : dd5302           [ 4]>            cmp absrlo,x    ;test result
20362 2 MichaelA
                            >            trap_ne
20363 3 MichaelA
370a : f002             [ 3]>        beq skip3183
20364
                            >        trap           ;failed equal (zero)
20365
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20366
370c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20367
370d : 28                   >        db      test_num
20368 2 MichaelA
                            >
20369 3 MichaelA
370e :                      >skip3183
20370
                            >
20371
370e : 68               [ 4]>            pla         ;load status
20372 2 MichaelA
                            >            eor_flag $ff-fnz
20373 3 MichaelA
370f : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
20374 2 MichaelA
                            >
20375 3 MichaelA
3711 : dd5702           [ 4]>            cmp absflo,x    ;test flags
20376 2 MichaelA
                            >            trap_ne     ;
20377 3 MichaelA
3714 : f002             [ 3]>        beq skip3186
20378
                            >        trap           ;failed equal (zero)
20379
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20380
3716 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20381
3717 : 28                   >        db      test_num
20382 2 MichaelA
                            >
20383 3 MichaelA
3718 :                      >skip3186
20384
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  353
20385 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20386
 
20387 3 MichaelA
                            >
20388 2 MichaelA
 
20389 3 MichaelA
3718 : ca               [ 2]         dex
20390
3719 : 10dd             [ 4]         bpl tora1
20391 2 MichaelA
 
20392 3 MichaelA
371b : a203             [ 2]         ldx #3      ;zp
20393
371d : b5be             [ 4] tora2    lda zpOR,x
20394
371f : 85b2             [ 3]         sta zpt
20395 2 MichaelA
                                     set_ax  absORa,0
20396
                            >            load_flag 0
20397 3 MichaelA
3721 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
20398 2 MichaelA
                            >
20399 3 MichaelA
3723 : 48               [ 3]>            pha         ;use stack to load status
20400
3724 : bd4702           [ 4]>            lda absORa,x    ;precharge accu
20401
3727 : 28               [ 4]>            plp
20402 2 MichaelA
 
20403 3 MichaelA
3728 : 05b2             [ 3]         ora zpt
20404 2 MichaelA
                                     tst_ax  absrlo,absflo,0
20405 3 MichaelA
372a : 08               [ 3]>            php         ;save flags
20406
372b : dd5302           [ 4]>            cmp absrlo,x    ;test result
20407 2 MichaelA
                            >            trap_ne
20408 3 MichaelA
372e : f002             [ 3]>        beq skip3191
20409
                            >        trap           ;failed equal (zero)
20410
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20411
3730 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20412
3731 : 28                   >        db      test_num
20413 2 MichaelA
                            >
20414 3 MichaelA
3732 :                      >skip3191
20415
                            >
20416
3732 : 68               [ 4]>            pla         ;load status
20417 2 MichaelA
                            >            eor_flag 0
20418 3 MichaelA
3733 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
20419 2 MichaelA
                            >
20420 3 MichaelA
3735 : dd5702           [ 4]>            cmp absflo,x    ;test flags
20421 2 MichaelA
                            >            trap_ne     ;
20422 3 MichaelA
3738 : f002             [ 3]>        beq skip3194
20423
                            >        trap           ;failed equal (zero)
20424
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20425
373a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20426
373b : 28                   >        db      test_num
20427 2 MichaelA
                            >
20428 3 MichaelA
373c :                      >skip3194
20429
                            >
20430 2 MichaelA
 
20431 3 MichaelA
373c : ca               [ 2]         dex
20432
373d : 10de             [ 3]         bpl tora2
20433
373f : a203             [ 2]         ldx #3
20434
3741 : b5be             [ 4] tora3   lda zpOR,x
20435
3743 : 85b2             [ 3]         sta zpt
20436 2 MichaelA
                                     set_ax  absORa,$ff
20437
                            >            load_flag $ff
20438 3 MichaelA
3745 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
20439 2 MichaelA
                            >
20440 3 MichaelA
3747 : 48               [ 3]>            pha         ;use stack to load status
20441
3748 : bd4702           [ 4]>            lda absORa,x    ;precharge accu
20442
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  354
20443
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20444
 
20445
374b : 28               [ 4]>            plp
20446 2 MichaelA
 
20447 3 MichaelA
374c : 05b2             [ 3]         ora zpt
20448 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
20449 3 MichaelA
374e : 08               [ 3]>            php         ;save flags
20450
374f : dd5302           [ 4]>            cmp absrlo,x    ;test result
20451 2 MichaelA
                            >            trap_ne
20452 3 MichaelA
3752 : f002             [ 3]>        beq skip3199
20453
                            >        trap           ;failed equal (zero)
20454
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20455
3754 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20456
3755 : 28                   >        db      test_num
20457 2 MichaelA
                            >
20458 3 MichaelA
3756 :                      >skip3199
20459
                            >
20460
3756 : 68               [ 4]>            pla         ;load status
20461 2 MichaelA
                            >            eor_flag $ff-fnz
20462 3 MichaelA
3757 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
20463 2 MichaelA
                            >
20464 3 MichaelA
3759 : dd5702           [ 4]>            cmp absflo,x    ;test flags
20465 2 MichaelA
                            >            trap_ne     ;
20466 3 MichaelA
375c : f002             [ 3]>        beq skip3202
20467
                            >        trap           ;failed equal (zero)
20468
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20469
375e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20470
375f : 28                   >        db      test_num
20471 2 MichaelA
                            >
20472 3 MichaelA
3760 :                      >skip3202
20473
                            >
20474 2 MichaelA
 
20475 3 MichaelA
3760 : ca               [ 2]         dex
20476
3761 : 10de             [ 3]         bpl tora3
20477 2 MichaelA
 
20478 3 MichaelA
3763 : a203             [ 2]         ldx #3      ;abs
20479
3765 : b5be             [ 4] tora4   lda zpOR,x
20480
3767 : 8d0302           [ 4]         sta abst
20481 2 MichaelA
                                     set_ax  absORa,0
20482
                            >            load_flag 0
20483 3 MichaelA
376a : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
20484 2 MichaelA
                            >
20485 3 MichaelA
376c : 48               [ 3]>            pha         ;use stack to load status
20486
376d : bd4702           [ 4]>            lda absORa,x    ;precharge accu
20487
3770 : 28               [ 4]>            plp
20488 2 MichaelA
 
20489 3 MichaelA
3771 : 0d0302           [ 4]         ora abst
20490 2 MichaelA
                                     tst_ax  absrlo,absflo,0
20491 3 MichaelA
3774 : 08               [ 3]>            php         ;save flags
20492
3775 : dd5302           [ 4]>            cmp absrlo,x    ;test result
20493 2 MichaelA
                            >            trap_ne
20494 3 MichaelA
3778 : f002             [ 3]>        beq skip3207
20495
                            >        trap           ;failed equal (zero)
20496
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20497
377a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20498
377b : 28                   >        db      test_num
20499 2 MichaelA
                            >
20500 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  355
20501
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20502
 
20503
377c :                      >skip3207
20504
                            >
20505
377c : 68               [ 4]>            pla         ;load status
20506 2 MichaelA
                            >            eor_flag 0
20507 3 MichaelA
377d : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
20508 2 MichaelA
                            >
20509 3 MichaelA
377f : dd5702           [ 4]>            cmp absflo,x    ;test flags
20510 2 MichaelA
                            >            trap_ne     ;
20511 3 MichaelA
3782 : f002             [ 3]>        beq skip3210
20512
                            >        trap           ;failed equal (zero)
20513
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20514
3784 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20515
3785 : 28                   >        db      test_num
20516 2 MichaelA
                            >
20517 3 MichaelA
3786 :                      >skip3210
20518
                            >
20519 2 MichaelA
 
20520 3 MichaelA
3786 : ca               [ 2]         dex
20521
3787 : 10dc             [ 3]         bpl tora4
20522
3789 : a203             [ 2]         ldx #3
20523
378b : b5be             [ 4] tora5   lda zpOR,x
20524
378d : 8d0302           [ 4]         sta abst
20525 2 MichaelA
                                     set_ax  absORa,$ff
20526
                            >            load_flag $ff
20527 3 MichaelA
3790 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
20528 2 MichaelA
                            >
20529 3 MichaelA
3792 : 48               [ 3]>            pha         ;use stack to load status
20530
3793 : bd4702           [ 4]>            lda absORa,x    ;precharge accu
20531
3796 : 28               [ 4]>            plp
20532 2 MichaelA
 
20533 3 MichaelA
3797 : 0d0302           [ 4]         ora abst
20534 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
20535 3 MichaelA
379a : 08               [ 3]>            php         ;save flags
20536
379b : dd5302           [ 4]>            cmp absrlo,x    ;test result
20537 2 MichaelA
                            >            trap_ne
20538 3 MichaelA
379e : f002             [ 3]>        beq skip3215
20539
                            >        trap           ;failed equal (zero)
20540
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20541
37a0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20542
37a1 : 28                   >        db      test_num
20543 2 MichaelA
                            >
20544 3 MichaelA
37a2 :                      >skip3215
20545
                            >
20546
37a2 : 68               [ 4]>            pla         ;load status
20547 2 MichaelA
                            >            eor_flag $ff-fnz
20548 3 MichaelA
37a3 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
20549 2 MichaelA
                            >
20550 3 MichaelA
37a5 : dd5702           [ 4]>            cmp absflo,x    ;test flags
20551 2 MichaelA
                            >            trap_ne     ;
20552 3 MichaelA
37a8 : f002             [ 3]>        beq skip3218
20553
                            >        trap           ;failed equal (zero)
20554
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20555
37aa : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20556
37ab : 28                   >        db      test_num
20557 2 MichaelA
                            >
20558 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  356
20559
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20560
 
20561
37ac :                      >skip3218
20562
                            >
20563 2 MichaelA
 
20564 3 MichaelA
37ac : ca               [ 2]         dex
20565
37ad : 1002             [ 3]         bpl tora6
20566 2 MichaelA
 
20567 3 MichaelA
37af : a203             [ 2]         ldx #3      ;zp,x
20568
37b1 :                       tora6
20569 2 MichaelA
                                     set_ax  absORa,0
20570
                            >            load_flag 0
20571 3 MichaelA
37b1 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
20572 2 MichaelA
                            >
20573 3 MichaelA
37b3 : 48               [ 3]>            pha         ;use stack to load status
20574
37b4 : bd4702           [ 4]>            lda absORa,x    ;precharge accu
20575
37b7 : 28               [ 4]>            plp
20576 2 MichaelA
 
20577 3 MichaelA
37b8 : 15be             [ 4]         ora zpOR,x
20578 2 MichaelA
                                     tst_ax  absrlo,absflo,0
20579 3 MichaelA
37ba : 08               [ 3]>            php         ;save flags
20580
37bb : dd5302           [ 4]>            cmp absrlo,x    ;test result
20581 2 MichaelA
                            >            trap_ne
20582 3 MichaelA
37be : f002             [ 3]>        beq skip3223
20583
                            >        trap           ;failed equal (zero)
20584
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20585
37c0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20586
37c1 : 28                   >        db      test_num
20587 2 MichaelA
                            >
20588 3 MichaelA
37c2 :                      >skip3223
20589
                            >
20590
37c2 : 68               [ 4]>            pla         ;load status
20591 2 MichaelA
                            >            eor_flag 0
20592 3 MichaelA
37c3 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
20593 2 MichaelA
                            >
20594 3 MichaelA
37c5 : dd5702           [ 4]>            cmp absflo,x    ;test flags
20595 2 MichaelA
                            >            trap_ne     ;
20596 3 MichaelA
37c8 : f002             [ 3]>        beq skip3226
20597
                            >        trap           ;failed equal (zero)
20598
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20599
37ca : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20600
37cb : 28                   >        db      test_num
20601 2 MichaelA
                            >
20602 3 MichaelA
37cc :                      >skip3226
20603
                            >
20604 2 MichaelA
 
20605 3 MichaelA
37cc : ca               [ 2]         dex
20606
37cd : 10e2             [ 3]         bpl tora6
20607
37cf : a203             [ 2]         ldx #3
20608
37d1 :                       tora7
20609 2 MichaelA
                                     set_ax  absORa,$ff
20610
                            >            load_flag $ff
20611 3 MichaelA
37d1 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
20612 2 MichaelA
                            >
20613 3 MichaelA
37d3 : 48               [ 3]>            pha         ;use stack to load status
20614
37d4 : bd4702           [ 4]>            lda absORa,x    ;precharge accu
20615
37d7 : 28               [ 4]>            plp
20616
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  357
20617
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20618
 
20619 2 MichaelA
 
20620 3 MichaelA
37d8 : 15be             [ 4]         ora zpOR,x
20621 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
20622 3 MichaelA
37da : 08               [ 3]>            php         ;save flags
20623
37db : dd5302           [ 4]>            cmp absrlo,x    ;test result
20624 2 MichaelA
                            >            trap_ne
20625 3 MichaelA
37de : f002             [ 3]>        beq skip3231
20626
                            >        trap           ;failed equal (zero)
20627
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20628
37e0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20629
37e1 : 28                   >        db      test_num
20630 2 MichaelA
                            >
20631 3 MichaelA
37e2 :                      >skip3231
20632
                            >
20633
37e2 : 68               [ 4]>            pla         ;load status
20634 2 MichaelA
                            >            eor_flag $ff-fnz
20635 3 MichaelA
37e3 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
20636 2 MichaelA
                            >
20637 3 MichaelA
37e5 : dd5702           [ 4]>            cmp absflo,x    ;test flags
20638 2 MichaelA
                            >            trap_ne     ;
20639 3 MichaelA
37e8 : f002             [ 3]>        beq skip3234
20640
                            >        trap           ;failed equal (zero)
20641
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20642
37ea : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20643
37eb : 28                   >        db      test_num
20644 2 MichaelA
                            >
20645 3 MichaelA
37ec :                      >skip3234
20646
                            >
20647 2 MichaelA
 
20648 3 MichaelA
37ec : ca               [ 2]         dex
20649
37ed : 10e2             [ 3]         bpl tora7
20650 2 MichaelA
 
20651 3 MichaelA
37ef : a203             [ 2]         ldx #3      ;abs,x
20652
37f1 :                       tora8
20653 2 MichaelA
                                     set_ax  absORa,0
20654
                            >            load_flag 0
20655 3 MichaelA
37f1 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
20656 2 MichaelA
                            >
20657 3 MichaelA
37f3 : 48               [ 3]>            pha         ;use stack to load status
20658
37f4 : bd4702           [ 4]>            lda absORa,x    ;precharge accu
20659
37f7 : 28               [ 4]>            plp
20660 2 MichaelA
 
20661 3 MichaelA
37f8 : 1d3b02           [ 4]         ora absOR,x
20662 2 MichaelA
                                     tst_ax  absrlo,absflo,0
20663 3 MichaelA
37fb : 08               [ 3]>            php         ;save flags
20664
37fc : dd5302           [ 4]>            cmp absrlo,x    ;test result
20665 2 MichaelA
                            >            trap_ne
20666 3 MichaelA
37ff : f002             [ 4]>        beq skip3239
20667
                            >        trap           ;failed equal (zero)
20668
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20669
3801 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20670
3802 : 28                   >        db      test_num
20671 2 MichaelA
                            >
20672 3 MichaelA
3803 :                      >skip3239
20673
                            >
20674
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  358
20675
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20676
 
20677
3803 : 68               [ 4]>            pla         ;load status
20678 2 MichaelA
                            >            eor_flag 0
20679 3 MichaelA
3804 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
20680 2 MichaelA
                            >
20681 3 MichaelA
3806 : dd5702           [ 4]>            cmp absflo,x    ;test flags
20682 2 MichaelA
                            >            trap_ne     ;
20683 3 MichaelA
3809 : f002             [ 3]>        beq skip3242
20684
                            >        trap           ;failed equal (zero)
20685
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20686
380b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20687
380c : 28                   >        db      test_num
20688 2 MichaelA
                            >
20689 3 MichaelA
380d :                      >skip3242
20690
                            >
20691 2 MichaelA
 
20692 3 MichaelA
380d : ca               [ 2]         dex
20693
380e : 10e1             [ 4]         bpl tora8
20694
3810 : a203             [ 2]         ldx #3
20695
3812 :                       tora9
20696 2 MichaelA
                                     set_ax  absORa,$ff
20697
                            >            load_flag $ff
20698 3 MichaelA
3812 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
20699 2 MichaelA
                            >
20700 3 MichaelA
3814 : 48               [ 3]>            pha         ;use stack to load status
20701
3815 : bd4702           [ 4]>            lda absORa,x    ;precharge accu
20702
3818 : 28               [ 4]>            plp
20703 2 MichaelA
 
20704 3 MichaelA
3819 : 1d3b02           [ 4]         ora absOR,x
20705 2 MichaelA
                                     tst_ax  absrlo,absflo,$ff-fnz
20706 3 MichaelA
381c : 08               [ 3]>            php         ;save flags
20707
381d : dd5302           [ 4]>            cmp absrlo,x    ;test result
20708 2 MichaelA
                            >            trap_ne
20709 3 MichaelA
3820 : f002             [ 3]>        beq skip3247
20710
                            >        trap           ;failed equal (zero)
20711
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20712
3822 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20713
3823 : 28                   >        db      test_num
20714 2 MichaelA
                            >
20715 3 MichaelA
3824 :                      >skip3247
20716
                            >
20717
3824 : 68               [ 4]>            pla         ;load status
20718 2 MichaelA
                            >            eor_flag $ff-fnz
20719 3 MichaelA
3825 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
20720 2 MichaelA
                            >
20721 3 MichaelA
3827 : dd5702           [ 4]>            cmp absflo,x    ;test flags
20722 2 MichaelA
                            >            trap_ne     ;
20723 3 MichaelA
382a : f002             [ 3]>        beq skip3250
20724
                            >        trap           ;failed equal (zero)
20725
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20726
382c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20727
382d : 28                   >        db      test_num
20728 2 MichaelA
                            >
20729 3 MichaelA
382e :                      >skip3250
20730
                            >
20731 2 MichaelA
 
20732 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  359
20733
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20734
 
20735
382e : ca               [ 2]         dex
20736
382f : 10e1             [ 3]         bpl tora9
20737 2 MichaelA
 
20738 3 MichaelA
3831 : a003             [ 2]         ldy #3      ;abs,y
20739
3833 :                       tora10
20740 2 MichaelA
                                     set_ay  absORa,0
20741
                            >            load_flag 0
20742 3 MichaelA
3833 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
20743 2 MichaelA
                            >
20744 3 MichaelA
3835 : 48               [ 3]>            pha         ;use stack to load status
20745
3836 : b94702           [ 4]>            lda absORa,y    ;precharge accu
20746
3839 : 28               [ 4]>            plp
20747 2 MichaelA
 
20748 3 MichaelA
383a : 193b02           [ 4]         ora absOR,y
20749 2 MichaelA
                                     tst_ay  absrlo,absflo,0
20750 3 MichaelA
383d : 08               [ 3]>            php         ;save flags
20751
383e : d95302           [ 4]>            cmp absrlo,y    ;test result
20752 2 MichaelA
                            >            trap_ne     ;
20753 3 MichaelA
3841 : f002             [ 3]>        beq skip3255
20754
                            >        trap           ;failed equal (zero)
20755
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20756
3843 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20757
3844 : 28                   >        db      test_num
20758 2 MichaelA
                            >
20759 3 MichaelA
3845 :                      >skip3255
20760
                            >
20761
3845 : 68               [ 4]>            pla         ;load status
20762 2 MichaelA
                            >            eor_flag 0
20763 3 MichaelA
3846 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
20764 2 MichaelA
                            >
20765 3 MichaelA
3848 : d95702           [ 4]>            cmp absflo,y    ;test flags
20766 2 MichaelA
                            >            trap_ne
20767 3 MichaelA
384b : f002             [ 3]>        beq skip3258
20768
                            >        trap           ;failed equal (zero)
20769
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20770
384d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20771
384e : 28                   >        db      test_num
20772 2 MichaelA
                            >
20773 3 MichaelA
384f :                      >skip3258
20774
                            >
20775 2 MichaelA
 
20776 3 MichaelA
384f : 88               [ 2]         dey
20777
3850 : 10e1             [ 3]         bpl tora10
20778
3852 : a003             [ 2]         ldy #3
20779
3854 :                       tora11
20780 2 MichaelA
                                     set_ay  absORa,$ff
20781
                            >            load_flag $ff
20782 3 MichaelA
3854 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
20783 2 MichaelA
                            >
20784 3 MichaelA
3856 : 48               [ 3]>            pha         ;use stack to load status
20785
3857 : b94702           [ 4]>            lda absORa,y    ;precharge accu
20786
385a : 28               [ 4]>            plp
20787 2 MichaelA
 
20788 3 MichaelA
385b : 193b02           [ 4]         ora absOR,y
20789
                                     tst_ay  absrlo,absflo,$ff-fnz
20790
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  360
20791 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20792
 
20793 3 MichaelA
385e : 08               [ 3]>            php         ;save flags
20794
385f : d95302           [ 4]>            cmp absrlo,y    ;test result
20795 2 MichaelA
                            >            trap_ne     ;
20796 3 MichaelA
3862 : f002             [ 3]>        beq skip3263
20797
                            >        trap           ;failed equal (zero)
20798
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20799
3864 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20800
3865 : 28                   >        db      test_num
20801 2 MichaelA
                            >
20802 3 MichaelA
3866 :                      >skip3263
20803
                            >
20804
3866 : 68               [ 4]>            pla         ;load status
20805 2 MichaelA
                            >            eor_flag $ff-fnz
20806 3 MichaelA
3867 : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
20807 2 MichaelA
                            >
20808 3 MichaelA
3869 : d95702           [ 4]>            cmp absflo,y    ;test flags
20809 2 MichaelA
                            >            trap_ne
20810 3 MichaelA
386c : f002             [ 3]>        beq skip3266
20811
                            >        trap           ;failed equal (zero)
20812
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20813
386e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20814
386f : 28                   >        db      test_num
20815 2 MichaelA
                            >
20816 3 MichaelA
3870 :                      >skip3266
20817
                            >
20818 2 MichaelA
 
20819 3 MichaelA
3870 : 88               [ 2]         dey
20820
3871 : 10e1             [ 3]         bpl tora11
20821 2 MichaelA
 
20822 3 MichaelA
3873 : a206             [ 2]         ldx #6      ;(zp,x)
20823
3875 : a003             [ 2]         ldy #3
20824
3877 :                       tora12
20825 2 MichaelA
                                     set_ay  absORa,0
20826
                            >            load_flag 0
20827 3 MichaelA
3877 : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
20828 2 MichaelA
                            >
20829 3 MichaelA
3879 : 48               [ 3]>            pha         ;use stack to load status
20830
387a : b94702           [ 4]>            lda absORa,y    ;precharge accu
20831
387d : 28               [ 4]>            plp
20832 2 MichaelA
 
20833 3 MichaelA
387e : 01f0             [ 6]         ora (indOR,x)
20834 2 MichaelA
                                     tst_ay  absrlo,absflo,0
20835 3 MichaelA
3880 : 08               [ 3]>            php         ;save flags
20836
3881 : d95302           [ 4]>            cmp absrlo,y    ;test result
20837 2 MichaelA
                            >            trap_ne     ;
20838 3 MichaelA
3884 : f002             [ 3]>        beq skip3271
20839
                            >        trap           ;failed equal (zero)
20840
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20841
3886 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20842
3887 : 28                   >        db      test_num
20843 2 MichaelA
                            >
20844 3 MichaelA
3888 :                      >skip3271
20845
                            >
20846
3888 : 68               [ 4]>            pla         ;load status
20847 2 MichaelA
                            >            eor_flag 0
20848 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  361
20849
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20850
 
20851
3889 : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
20852 2 MichaelA
                            >
20853 3 MichaelA
388b : d95702           [ 4]>            cmp absflo,y    ;test flags
20854 2 MichaelA
                            >            trap_ne
20855 3 MichaelA
388e : f002             [ 3]>        beq skip3274
20856
                            >        trap           ;failed equal (zero)
20857
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20858
3890 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20859
3891 : 28                   >        db      test_num
20860 2 MichaelA
                            >
20861 3 MichaelA
3892 :                      >skip3274
20862
                            >
20863 2 MichaelA
 
20864 3 MichaelA
3892 : ca               [ 2]         dex
20865
3893 : ca               [ 2]         dex
20866
3894 : 88               [ 2]         dey
20867
3895 : 10e0             [ 3]         bpl tora12
20868
3897 : a206             [ 2]         ldx #6
20869
3899 : a003             [ 2]         ldy #3
20870
389b :                       tora13
20871 2 MichaelA
                                     set_ay  absORa,$ff
20872
                            >            load_flag $ff
20873 3 MichaelA
389b : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
20874 2 MichaelA
                            >
20875 3 MichaelA
389d : 48               [ 3]>            pha         ;use stack to load status
20876
389e : b94702           [ 4]>            lda absORa,y    ;precharge accu
20877
38a1 : 28               [ 4]>            plp
20878 2 MichaelA
 
20879 3 MichaelA
38a2 : 01f0             [ 6]         ora (indOR,x)
20880 2 MichaelA
                                     tst_ay  absrlo,absflo,$ff-fnz
20881 3 MichaelA
38a4 : 08               [ 3]>            php         ;save flags
20882
38a5 : d95302           [ 4]>            cmp absrlo,y    ;test result
20883 2 MichaelA
                            >            trap_ne     ;
20884 3 MichaelA
38a8 : f002             [ 3]>        beq skip3279
20885
                            >        trap           ;failed equal (zero)
20886
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20887
38aa : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20888
38ab : 28                   >        db      test_num
20889 2 MichaelA
                            >
20890 3 MichaelA
38ac :                      >skip3279
20891
                            >
20892
38ac : 68               [ 4]>            pla         ;load status
20893 2 MichaelA
                            >            eor_flag $ff-fnz
20894 3 MichaelA
38ad : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
20895 2 MichaelA
                            >
20896 3 MichaelA
38af : d95702           [ 4]>            cmp absflo,y    ;test flags
20897 2 MichaelA
                            >            trap_ne
20898 3 MichaelA
38b2 : f002             [ 3]>        beq skip3282
20899
                            >        trap           ;failed equal (zero)
20900
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20901
38b4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20902
38b5 : 28                   >        db      test_num
20903 2 MichaelA
                            >
20904 3 MichaelA
38b6 :                      >skip3282
20905
                            >
20906
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  362
20907
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20908
 
20909 2 MichaelA
 
20910 3 MichaelA
38b6 : ca               [ 2]         dex
20911
38b7 : ca               [ 2]         dex
20912
38b8 : 88               [ 2]         dey
20913
38b9 : 10e0             [ 3]         bpl tora13
20914 2 MichaelA
 
20915 3 MichaelA
38bb : a003             [ 2]         ldy #3      ;(zp),y
20916
38bd :                       tora14
20917 2 MichaelA
                                     set_ay  absORa,0
20918
                            >            load_flag 0
20919 3 MichaelA
38bd : a900             [ 2]>            lda #0             ;allow test to change I-flag (no mask)
20920 2 MichaelA
                            >
20921 3 MichaelA
38bf : 48               [ 3]>            pha         ;use stack to load status
20922
38c0 : b94702           [ 4]>            lda absORa,y    ;precharge accu
20923
38c3 : 28               [ 4]>            plp
20924 2 MichaelA
 
20925 3 MichaelA
38c4 : 11f0             [ 5]         ora (indOR),y
20926 2 MichaelA
                                     tst_ay  absrlo,absflo,0
20927 3 MichaelA
38c6 : 08               [ 3]>            php         ;save flags
20928
38c7 : d95302           [ 4]>            cmp absrlo,y    ;test result
20929 2 MichaelA
                            >            trap_ne     ;
20930 3 MichaelA
38ca : f002             [ 3]>        beq skip3287
20931
                            >        trap           ;failed equal (zero)
20932
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20933
38cc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20934
38cd : 28                   >        db      test_num
20935 2 MichaelA
                            >
20936 3 MichaelA
38ce :                      >skip3287
20937
                            >
20938
38ce : 68               [ 4]>            pla         ;load status
20939 2 MichaelA
                            >            eor_flag 0
20940 3 MichaelA
38cf : 4930             [ 2]>            eor #0|fao         ;invert expected flags + always on bits
20941 2 MichaelA
                            >
20942 3 MichaelA
38d1 : d95702           [ 4]>            cmp absflo,y    ;test flags
20943 2 MichaelA
                            >            trap_ne
20944 3 MichaelA
38d4 : f002             [ 3]>        beq skip3290
20945
                            >        trap           ;failed equal (zero)
20946
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20947
38d6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20948
38d7 : 28                   >        db      test_num
20949 2 MichaelA
                            >
20950 3 MichaelA
38d8 :                      >skip3290
20951
                            >
20952 2 MichaelA
 
20953 3 MichaelA
38d8 : 88               [ 2]         dey
20954
38d9 : 10e2             [ 3]         bpl tora14
20955
38db : a003             [ 2]         ldy #3
20956
38dd :                       tora15
20957 2 MichaelA
                                     set_ay  absORa,$ff
20958
                            >            load_flag $ff
20959 3 MichaelA
38dd : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
20960 2 MichaelA
                            >
20961 3 MichaelA
38df : 48               [ 3]>            pha         ;use stack to load status
20962
38e0 : b94702           [ 4]>            lda absORa,y    ;precharge accu
20963
38e3 : 28               [ 4]>            plp
20964
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  363
20965
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
20966
 
20967 2 MichaelA
 
20968 3 MichaelA
38e4 : 11f0             [ 5]         ora (indOR),y
20969 2 MichaelA
                                     tst_ay  absrlo,absflo,$ff-fnz
20970 3 MichaelA
38e6 : 08               [ 3]>            php         ;save flags
20971
38e7 : d95302           [ 4]>            cmp absrlo,y    ;test result
20972 2 MichaelA
                            >            trap_ne     ;
20973 3 MichaelA
38ea : f002             [ 3]>        beq skip3295
20974
                            >        trap           ;failed equal (zero)
20975
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20976
38ec : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20977
38ed : 28                   >        db      test_num
20978 2 MichaelA
                            >
20979 3 MichaelA
38ee :                      >skip3295
20980
                            >
20981
38ee : 68               [ 4]>            pla         ;load status
20982 2 MichaelA
                            >            eor_flag $ff-fnz
20983 3 MichaelA
38ef : 497d             [ 2]>            eor #$ff-fnz|fao         ;invert expected flags + always on bits
20984 2 MichaelA
                            >
20985 3 MichaelA
38f1 : d95702           [ 4]>            cmp absflo,y    ;test flags
20986 2 MichaelA
                            >            trap_ne
20987 3 MichaelA
38f4 : f002             [ 3]>        beq skip3298
20988
                            >        trap           ;failed equal (zero)
20989
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
20990
38f6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
20991
38f7 : 28                   >        db      test_num
20992 2 MichaelA
                            >
20993 3 MichaelA
38f8 :                      >skip3298
20994
                            >
20995 2 MichaelA
 
20996 3 MichaelA
38f8 : 88               [ 2]         dey
20997
38f9 : 10e2             [ 3]         bpl tora15
20998
 
20999 2 MichaelA
                                 if I_flag = 3
21000 3 MichaelA
 
21001
38fb : 58               [ 2]         cli
21002
 
21003 2 MichaelA
                                 endif
21004
 
21005 3 MichaelA
38fc :                       bin_test
21006 2 MichaelA
                                 if skip_bin_test = 1
21007 3 MichaelA
 
21008
                                     jmp dec_test
21009
 
21010 2 MichaelA
                                 else
21011 3 MichaelA
 
21012
38fc : a928             [ 2]         lda #test_num
21013
38fe : 8d0002           [ 4]         sta test_case
21014
 
21015 2 MichaelA
                                 endif
21016
 
21017
                                     next_test
21018 3 MichaelA
3901 : ad0002           [ 4]>            lda test_case   ;previous test
21019
3904 : c928             [ 2]>            cmp #test_num
21020 2 MichaelA
                            >            trap_ne         ;test is out of sequence
21021 3 MichaelA
3906 : f002             [ 3]>        beq skip3301
21022
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  364
21023
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21024
 
21025
                            >        trap           ;failed equal (zero)
21026
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21027
3908 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21028
3909 : 28                   >        db      test_num
21029 2 MichaelA
                            >
21030 3 MichaelA
390a :                      >skip3301
21031
                            >
21032 2 MichaelA
0029 =                      >test_num = test_num + 1
21033 3 MichaelA
390a : a929             [ 2]>            lda #test_num   ;*** this tests' number
21034
390c : 8d0002           [ 4]>            sta test_case
21035 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
21036
 
21037
 
21038
                             ; full binary add/subtract test
21039
                             ; iterates through all combinations of operands and carry input
21040
                             ; uses increments/decrements to predict result & result flags
21041 3 MichaelA
 
21042
390f : d8               [ 2]         cld
21043
3910 : a2b4             [ 2]         ldx #ad2        ;for indexed test
21044
3912 : a0ff             [ 2]         ldy #$ff        ;max range
21045
3914 : a900             [ 2]         lda #0          ;start with adding zeroes & no carry
21046
3916 : 85b2             [ 3]         sta adfc        ;carry in - for diag
21047
3918 : 85b3             [ 3]         sta ad1         ;operand 1 - accumulator
21048
391a : 85b4             [ 3]         sta ad2         ;operand 2 - memory or immediate
21049
391c : 8d0302           [ 4]         sta ada2        ;non zp
21050
391f : 85b5             [ 3]         sta adrl        ;expected result bits 0-7
21051
3921 : 85b6             [ 3]         sta adrh        ;expected result bit 8 (carry out)
21052
3923 : a9ff             [ 2]         lda #$ff        ;complemented operand 2 for subtract
21053
3925 : 85b8             [ 3]         sta sb2
21054
3927 : 8d0402           [ 4]         sta sba2        ;non zp
21055
392a : a902             [ 2]         lda #2          ;expected Z-flag
21056
392c : 85b7             [ 3]         sta adrf
21057
392e : 18               [ 2] tadd    clc             ;test with carry clear
21058
392f : 20903b           [ 6]         jsr chkadd
21059
3932 : e6b2             [ 5]         inc adfc        ;now with carry
21060
3934 : e6b5             [ 5]         inc adrl        ;result +1
21061
3936 : 08               [ 3]         php             ;save N & Z from low result
21062
3937 : 08               [ 3]         php
21063
3938 : 68               [ 4]         pla             ;accu holds expected flags
21064
3939 : 2982             [ 2]         and #$82        ;mask N & Z
21065
393b : 28               [ 4]         plp
21066
393c : d002             [ 3]         bne tadd1
21067
393e : e6b6             [ 5]         inc adrh        ;result bit 8 - carry
21068
3940 : 05b6             [ 3] tadd1   ora adrh        ;merge C to expected flags
21069
3942 : 85b7             [ 3]         sta adrf        ;save expected flags except overflow
21070
3944 : 38               [ 2]         sec             ;test with carry set
21071
3945 : 20903b           [ 6]         jsr chkadd
21072
3948 : c6b2             [ 5]         dec adfc        ;same for operand +1 but no carry
21073
394a : e6b3             [ 5]         inc ad1
21074
394c : d0e0             [ 3]         bne tadd        ;iterate op1
21075
394e : a900             [ 2]         lda #0          ;preset result to op2 when op1 = 0
21076
3950 : 85b6             [ 3]         sta adrh
21077
3952 : ee0302           [ 6]         inc ada2
21078
3955 : e6b4             [ 5]         inc ad2
21079
3957 : 08               [ 3]         php             ;save NZ as operand 2 becomes the new result
21080
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  365
21081 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21082
 
21083 3 MichaelA
3958 : 68               [ 4]         pla
21084
3959 : 2982             [ 2]         and #$82        ;mask N00000Z0
21085
395b : 85b7             [ 3]         sta adrf        ;no need to check carry as we are adding to 0
21086
395d : c6b8             [ 5]         dec sb2         ;complement subtract operand 2
21087
395f : ce0402           [ 6]         dec sba2
21088
3962 : a5b4             [ 3]         lda ad2
21089
3964 : 85b5             [ 3]         sta adrl
21090
3966 : d0c6             [ 3]         bne tadd        ;iterate op2
21091 2 MichaelA
 
21092 3 MichaelA
3968 :                       dec_test
21093
 
21094 2 MichaelA
                                 if skip_dec_test = 1
21095 3 MichaelA
 
21096
                                     success
21097
 
21098 2 MichaelA
                                 else
21099 3 MichaelA
 
21100
3968 : a929             [ 2]         lda #test_num
21101
396a : 8d0002           [ 4]         sta test_case
21102
 
21103 2 MichaelA
                                 endif
21104
 
21105
                                     next_test
21106 3 MichaelA
396d : ad0002           [ 4]>            lda test_case   ;previous test
21107
3970 : c929             [ 2]>            cmp #test_num
21108 2 MichaelA
                            >            trap_ne         ;test is out of sequence
21109 3 MichaelA
3972 : f002             [ 3]>        beq skip3304
21110
                            >        trap           ;failed equal (zero)
21111
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21112
3974 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21113
3975 : 29                   >        db      test_num
21114 2 MichaelA
                            >
21115 3 MichaelA
3976 :                      >skip3304
21116
                            >
21117 2 MichaelA
002a =                      >test_num = test_num + 1
21118 3 MichaelA
3976 : a92a             [ 2]>            lda #test_num   ;*** this tests' number
21119
3978 : 8d0002           [ 4]>            sta test_case
21120 2 MichaelA
                            >            ;check_ram       ;uncomment to find altered RAM after each test
21121
 
21122
 
21123
                             ; decimal add/subtract test
21124
                             ; *** WARNING - tests documented behavior only! ***
21125
                             ;   only valid BCD operands are tested, N V Z flags are ignored
21126
                             ; iterates through all valid combinations of operands and carry input
21127
                             ; uses increments/decrements to predict result & carry flag
21128 3 MichaelA
 
21129
397b : f8               [ 2]         sed
21130
397c : a2b4             [ 2]         ldx #ad2        ;for indexed test
21131
397e : a0ff             [ 2]         ldy #$ff        ;max range
21132
3980 : a999             [ 2]         lda #$99        ;start with adding 99 to 99 with carry
21133
3982 : 85b3             [ 3]         sta ad1         ;operand 1 - accumulator
21134
3984 : 85b4             [ 3]         sta ad2         ;operand 2 - memory or immediate
21135
3986 : 8d0302           [ 4]         sta ada2        ;non zp
21136
3989 : 85b5             [ 3]         sta adrl        ;expected result bits 0-7
21137
398b : a901             [ 2]         lda #1          ;set carry in & out
21138
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  366
21139 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21140
 
21141 3 MichaelA
398d : 85b2             [ 3]         sta adfc        ;carry in - for diag
21142
398f : 85b6             [ 3]         sta adrh        ;expected result bit 8 (carry out)
21143
3991 : a900             [ 2]         lda #0          ;complemented operand 2 for subtract
21144
3993 : 85b8             [ 3]         sta sb2
21145
3995 : 8d0402           [ 4]         sta sba2        ;non zp
21146
3998 : 38               [ 2] tdad    sec             ;test with carry set
21147
3999 : 201f3a           [ 6]         jsr chkdad
21148
399c : c6b2             [ 5]         dec adfc        ;now with carry clear
21149
399e : a5b5             [ 3]         lda adrl        ;decimal adjust result
21150
39a0 : d008             [ 3]         bne tdad1       ;skip clear carry & preset result 99 (9A-1)
21151
39a2 : c6b6             [ 5]         dec adrh
21152
39a4 : a999             [ 2]         lda #$99
21153
39a6 : 85b5             [ 3]         sta adrl
21154
39a8 : d012             [ 3]         bne tdad3
21155
39aa : 290f             [ 2] tdad1   and #$f         ;lower nibble mask
21156
39ac : d00c             [ 3]         bne tdad2       ;no decimal adjust needed
21157
39ae : c6b5             [ 5]         dec adrl        ;decimal adjust (?0-6)
21158
39b0 : c6b5             [ 5]         dec adrl
21159
39b2 : c6b5             [ 5]         dec adrl
21160
39b4 : c6b5             [ 5]         dec adrl
21161
39b6 : c6b5             [ 5]         dec adrl
21162
39b8 : c6b5             [ 5]         dec adrl
21163
39ba : c6b5             [ 5] tdad2   dec adrl        ;result -1
21164
39bc : 18               [ 2] tdad3   clc             ;test with carry clear
21165
39bd : 201f3a           [ 6]         jsr chkdad
21166
39c0 : e6b2             [ 5]         inc adfc        ;same for operand -1 but with carry
21167
39c2 : a5b3             [ 3]         lda ad1         ;decimal adjust operand 1
21168
39c4 : f015             [ 3]         beq tdad5       ;iterate operand 2
21169
39c6 : 290f             [ 2]         and #$f         ;lower nibble mask
21170
39c8 : d00c             [ 3]         bne tdad4       ;skip decimal adjust
21171
39ca : c6b3             [ 5]         dec ad1         ;decimal adjust (?0-6)
21172
39cc : c6b3             [ 5]         dec ad1
21173
39ce : c6b3             [ 5]         dec ad1
21174
39d0 : c6b3             [ 5]         dec ad1
21175
39d2 : c6b3             [ 5]         dec ad1
21176
39d4 : c6b3             [ 5]         dec ad1
21177
39d6 : c6b3             [ 5] tdad4   dec ad1         ;operand 1 -1
21178
39d8 : 4c9839           [ 3]         jmp tdad        ;iterate op1
21179 2 MichaelA
 
21180 3 MichaelA
39db : a999             [ 2] tdad5   lda #$99        ;precharge op1 max
21181
39dd : 85b3             [ 3]         sta ad1
21182
39df : a5b4             [ 3]         lda ad2         ;decimal adjust operand 2
21183
39e1 : f030             [ 4]         beq tdad7       ;end of iteration
21184
39e3 : 290f             [ 2]         and #$f         ;lower nibble mask
21185
39e5 : d018             [ 3]         bne tdad6       ;skip decimal adjust
21186
39e7 : c6b4             [ 5]         dec ad2         ;decimal adjust (?0-6)
21187
39e9 : c6b4             [ 5]         dec ad2
21188
39eb : c6b4             [ 5]         dec ad2
21189
39ed : c6b4             [ 5]         dec ad2
21190
39ef : c6b4             [ 5]         dec ad2
21191
39f1 : c6b4             [ 5]         dec ad2
21192
39f3 : e6b8             [ 5]         inc sb2         ;complemented decimal adjust for subtract (?9+6)
21193
39f5 : e6b8             [ 5]         inc sb2
21194
39f7 : e6b8             [ 5]         inc sb2
21195
39f9 : e6b8             [ 5]         inc sb2
21196
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  367
21197
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21198
 
21199
39fb : e6b8             [ 5]         inc sb2
21200
39fd : e6b8             [ 5]         inc sb2
21201
39ff : c6b4             [ 5] tdad6   dec ad2         ;operand 2 -1
21202
3a01 : e6b8             [ 5]         inc sb2         ;complemented operand for subtract
21203
3a03 : a5b8             [ 3]         lda sb2
21204
3a05 : 8d0402           [ 4]         sta sba2        ;copy as non zp operand
21205
3a08 : a5b4             [ 3]         lda ad2
21206
3a0a : 8d0302           [ 4]         sta ada2        ;copy as non zp operand
21207
3a0d : 85b5             [ 3]         sta adrl        ;new result since op1+carry=00+carry +op2=op2
21208
3a0f : e6b6             [ 5]         inc adrh        ;result carry
21209
3a11 : d085             [ 4]         bne tdad        ;iterate op2
21210
3a13 : d8               [ 2] tdad7   cld
21211 2 MichaelA
 
21212 3 MichaelA
3a14 : ad0002           [ 4]         lda test_case
21213
3a17 : c92a             [ 2]         cmp #test_num
21214 2 MichaelA
                                     trap_ne         ;test is out of sequence
21215 3 MichaelA
3a19 : f002             [ 3]>        beq skip3306
21216
                            >        trap           ;failed equal (zero)
21217
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21218
3a1b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21219
3a1c : 2a                   >        db      test_num
21220
                            >
21221
3a1d :                      >skip3306
21222 2 MichaelA
 
21223
 
21224
                             ; final RAM integrity test
21225
                             ;   verifies that none of the previous tests has altered RAM outside of the
21226
                             ;   designated write areas.
21227 3 MichaelA
 
21228 2 MichaelA
                                     check_ram
21229
                            >            ;RAM check disabled - RAM size not set
21230
 
21231 3 MichaelA
 
21232 2 MichaelA
                             ; *** DEBUG INFO ***
21233 3 MichaelA
                             ;
21234 2 MichaelA
                             ; to debug checksum errors uncomment check_ram in the next_test macro to
21235
                             ; narrow down the responsible opcode.
21236
                             ; may give false errors when monitor, OS or other background activity is
21237
                             ; allowed during previous tests.
21238
 
21239 3 MichaelA
                             ; S U C C E S S ************************************************
21240
                             ; -------------
21241 2 MichaelA
 
21242 3 MichaelA
                             ;success    jmp start       ;if you get here everything went well
21243
                                         success
21244
3a1d : 00               [ 7]>        brk
21245
3a1e : 2b                   >        db      test_num+1
21246 2 MichaelA
 
21247
                             ; -------------
21248
                             ; S U C C E S S ************************************************
21249
 
21250
                             ; core subroutine of the decimal add/subtract test
21251 3 MichaelA
                             ;
21252 2 MichaelA
                             ; *** WARNING - tests documented behavior only! ***
21253
                             ;   only valid BCD operands are tested, N V Z flags are ignored
21254 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  368
21255
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21256
 
21257 2 MichaelA
                             ; iterates through all valid combinations of operands and carry input
21258
                             ; uses increments/decrements to predict result & carry flag
21259 3 MichaelA
 
21260
3a1f :                       chkdad
21261
 
21262 2 MichaelA
                             ; decimal ADC / SBC zp
21263 3 MichaelA
 
21264
3a1f : 08               [ 3]         php             ;save carry for subtract
21265
3a20 : a5b3             [ 3]         lda ad1
21266
3a22 : 65b4             [ 3]         adc ad2         ;perform add
21267
3a24 : 08               [ 3]         php
21268
3a25 : c5b5             [ 3]         cmp adrl        ;check result
21269 2 MichaelA
                                     trap_ne         ;bad result
21270 3 MichaelA
3a27 : f002             [ 3]>        beq skip3310
21271
                            >        trap           ;failed equal (zero)
21272
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21273
3a29 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21274
3a2a : 2a                   >        db      test_num
21275
                            >
21276
3a2b :                      >skip3310
21277 2 MichaelA
 
21278 3 MichaelA
3a2b : 68               [ 4]         pla             ;check flags
21279
3a2c : 2901             [ 2]         and #1          ;mask carry
21280
3a2e : c5b6             [ 3]         cmp adrh
21281 2 MichaelA
                                     trap_ne         ;bad carry
21282 3 MichaelA
3a30 : f002             [ 3]>        beq skip3312
21283
                            >        trap           ;failed equal (zero)
21284
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21285
3a32 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21286
3a33 : 2a                   >        db      test_num
21287
                            >
21288
3a34 :                      >skip3312
21289 2 MichaelA
 
21290 3 MichaelA
3a34 : 28               [ 4]         plp
21291
3a35 : 08               [ 3]         php             ;save carry for next add
21292
3a36 : a5b3             [ 3]         lda ad1
21293
3a38 : e5b8             [ 3]         sbc sb2         ;perform subtract
21294
3a3a : 08               [ 3]         php
21295
3a3b : c5b5             [ 3]         cmp adrl        ;check result
21296 2 MichaelA
                                     trap_ne         ;bad result
21297 3 MichaelA
3a3d : f002             [ 3]>        beq skip3314
21298
                            >        trap           ;failed equal (zero)
21299
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21300
3a3f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21301
3a40 : 2a                   >        db      test_num
21302
                            >
21303
3a41 :                      >skip3314
21304 2 MichaelA
 
21305 3 MichaelA
3a41 : 68               [ 4]         pla             ;check flags
21306
3a42 : 2901             [ 2]         and #1          ;mask carry
21307
3a44 : c5b6             [ 3]         cmp adrh
21308 2 MichaelA
                                     trap_ne         ;bad flags
21309 3 MichaelA
3a46 : f002             [ 3]>        beq skip3316
21310
                            >        trap           ;failed equal (zero)
21311
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21312
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  369
21313
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21314
 
21315
3a48 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21316
3a49 : 2a                   >        db      test_num
21317
                            >
21318
3a4a :                      >skip3316
21319 2 MichaelA
 
21320 3 MichaelA
3a4a : 28               [ 4]         plp
21321
 
21322 2 MichaelA
                             ; decimal ADC / SBC abs
21323 3 MichaelA
 
21324
3a4b : 08               [ 3]         php             ;save carry for subtract
21325
3a4c : a5b3             [ 3]         lda ad1
21326
3a4e : 6d0302           [ 4]         adc ada2        ;perform add
21327
3a51 : 08               [ 3]         php
21328
3a52 : c5b5             [ 3]         cmp adrl        ;check result
21329 2 MichaelA
                                     trap_ne         ;bad result
21330 3 MichaelA
3a54 : f002             [ 3]>        beq skip3318
21331
                            >        trap           ;failed equal (zero)
21332
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21333
3a56 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21334
3a57 : 2a                   >        db      test_num
21335
                            >
21336
3a58 :                      >skip3318
21337 2 MichaelA
 
21338 3 MichaelA
3a58 : 68               [ 4]         pla             ;check flags
21339
3a59 : 2901             [ 2]         and #1          ;mask carry
21340
3a5b : c5b6             [ 3]         cmp adrh
21341 2 MichaelA
                                     trap_ne         ;bad carry
21342 3 MichaelA
3a5d : f002             [ 3]>        beq skip3320
21343
                            >        trap           ;failed equal (zero)
21344
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21345
3a5f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21346
3a60 : 2a                   >        db      test_num
21347
                            >
21348
3a61 :                      >skip3320
21349 2 MichaelA
 
21350 3 MichaelA
3a61 : 28               [ 4]         plp
21351
3a62 : 08               [ 3]         php             ;save carry for next add
21352
3a63 : a5b3             [ 3]         lda ad1
21353
3a65 : ed0402           [ 4]         sbc sba2        ;perform subtract
21354
3a68 : 08               [ 3]         php
21355
3a69 : c5b5             [ 3]         cmp adrl        ;check result
21356 2 MichaelA
                                     trap_ne         ;bad result
21357 3 MichaelA
3a6b : f002             [ 3]>        beq skip3322
21358
                            >        trap           ;failed equal (zero)
21359
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21360
3a6d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21361
3a6e : 2a                   >        db      test_num
21362
                            >
21363
3a6f :                      >skip3322
21364 2 MichaelA
 
21365 3 MichaelA
3a6f : 68               [ 4]         pla             ;check flags
21366
3a70 : 2901             [ 2]         and #1          ;mask carry
21367
3a72 : c5b6             [ 3]         cmp adrh
21368 2 MichaelA
                                     trap_ne         ;bad carry
21369 3 MichaelA
3a74 : f002             [ 3]>        beq skip3324
21370
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  370
21371
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21372
 
21373
                            >        trap           ;failed equal (zero)
21374
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21375
3a76 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21376
3a77 : 2a                   >        db      test_num
21377
                            >
21378
3a78 :                      >skip3324
21379 2 MichaelA
 
21380 3 MichaelA
3a78 : 28               [ 4]         plp
21381
 
21382 2 MichaelA
                             ; decimal ADC / SBC #
21383 3 MichaelA
 
21384
3a79 : 08               [ 3]         php             ;save carry for subtract
21385
3a7a : a5b4             [ 3]         lda ad2
21386
3a7c : 8d823a           [ 4]         sta chkdadi     ;self modify immediate
21387
3a7f : a5b3             [ 3]         lda ad1
21388
 
21389
3a82 =                       chkdadi = * + 1         ;operand of the immediate ADC
21390
 
21391
3a81 : 6900             [ 2]         adc #0          ;perform add
21392
3a83 : 08               [ 3]         php
21393
3a84 : c5b5             [ 3]         cmp adrl        ;check result
21394 2 MichaelA
                                     trap_ne         ;bad result
21395 3 MichaelA
3a86 : f002             [ 3]>        beq skip3326
21396
                            >        trap           ;failed equal (zero)
21397
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21398
3a88 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21399
3a89 : 2a                   >        db      test_num
21400
                            >
21401
3a8a :                      >skip3326
21402 2 MichaelA
 
21403 3 MichaelA
3a8a : 68               [ 4]         pla             ;check flags
21404
3a8b : 2901             [ 2]         and #1          ;mask carry
21405
3a8d : c5b6             [ 3]         cmp adrh
21406 2 MichaelA
                                     trap_ne         ;bad carry
21407 3 MichaelA
3a8f : f002             [ 3]>        beq skip3328
21408
                            >        trap           ;failed equal (zero)
21409
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21410
3a91 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21411
3a92 : 2a                   >        db      test_num
21412
                            >
21413
3a93 :                      >skip3328
21414 2 MichaelA
 
21415 3 MichaelA
3a93 : 28               [ 4]         plp
21416
3a94 : 08               [ 3]         php             ;save carry for next add
21417
3a95 : a5b8             [ 3]         lda sb2
21418
3a97 : 8d9d3a           [ 4]         sta chkdsbi     ;self modify immediate
21419
3a9a : a5b3             [ 3]         lda ad1
21420
 
21421
3a9d =                       chkdsbi = * + 1         ;operand of the immediate SBC
21422
 
21423
3a9c : e900             [ 2]         sbc #0          ;perform subtract
21424
3a9e : 08               [ 3]         php
21425
3a9f : c5b5             [ 3]         cmp adrl        ;check result
21426 2 MichaelA
                                     trap_ne         ;bad result
21427 3 MichaelA
3aa1 : f002             [ 3]>        beq skip3330
21428
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  371
21429 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21430
 
21431 3 MichaelA
                            >        trap           ;failed equal (zero)
21432
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21433
3aa3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21434
3aa4 : 2a                   >        db      test_num
21435
                            >
21436
3aa5 :                      >skip3330
21437
 
21438
3aa5 : 68               [ 4]         pla             ;check flags
21439
3aa6 : 2901             [ 2]         and #1          ;mask carry
21440
3aa8 : c5b6             [ 3]         cmp adrh
21441 2 MichaelA
                                     trap_ne         ;bad carry
21442 3 MichaelA
3aaa : f002             [ 3]>        beq skip3332
21443
                            >        trap           ;failed equal (zero)
21444
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21445
3aac : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21446
3aad : 2a                   >        db      test_num
21447
                            >
21448
3aae :                      >skip3332
21449 2 MichaelA
 
21450 3 MichaelA
3aae : 28               [ 4]         plp
21451
 
21452 2 MichaelA
                             ; decimal ADC / SBC zp,x
21453 3 MichaelA
 
21454
3aaf : 08               [ 3]         php             ;save carry for subtract
21455
3ab0 : a5b3             [ 3]         lda ad1
21456
3ab2 : 7500             [ 4]         adc 0,x         ;perform add
21457
3ab4 : 08               [ 3]         php
21458
3ab5 : c5b5             [ 3]         cmp adrl        ;check result
21459 2 MichaelA
                                     trap_ne         ;bad result
21460 3 MichaelA
3ab7 : f002             [ 3]>        beq skip3334
21461
                            >        trap           ;failed equal (zero)
21462
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21463
3ab9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21464
3aba : 2a                   >        db      test_num
21465
                            >
21466
3abb :                      >skip3334
21467 2 MichaelA
 
21468 3 MichaelA
3abb : 68               [ 4]         pla             ;check flags
21469
3abc : 2901             [ 2]         and #1          ;mask carry
21470
3abe : c5b6             [ 3]         cmp adrh
21471 2 MichaelA
                                     trap_ne         ;bad carry
21472 3 MichaelA
3ac0 : f002             [ 3]>        beq skip3336
21473
                            >        trap           ;failed equal (zero)
21474
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21475
3ac2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21476
3ac3 : 2a                   >        db      test_num
21477
                            >
21478
3ac4 :                      >skip3336
21479 2 MichaelA
 
21480 3 MichaelA
3ac4 : 28               [ 4]         plp
21481
3ac5 : 08               [ 3]         php             ;save carry for next add
21482
3ac6 : a5b3             [ 3]         lda ad1
21483
3ac8 : f504             [ 4]         sbc sb2-ad2,x   ;perform subtract
21484
3aca : 08               [ 3]         php
21485
3acb : c5b5             [ 3]         cmp adrl        ;check result
21486
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  372
21487
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21488
 
21489 2 MichaelA
                                     trap_ne         ;bad result
21490 3 MichaelA
3acd : f002             [ 3]>        beq skip3338
21491
                            >        trap           ;failed equal (zero)
21492
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21493
3acf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21494
3ad0 : 2a                   >        db      test_num
21495
                            >
21496
3ad1 :                      >skip3338
21497 2 MichaelA
 
21498 3 MichaelA
3ad1 : 68               [ 4]         pla             ;check flags
21499
3ad2 : 2901             [ 2]         and #1          ;mask carry
21500
3ad4 : c5b6             [ 3]         cmp adrh
21501 2 MichaelA
                                     trap_ne         ;bad carry
21502 3 MichaelA
3ad6 : f002             [ 3]>        beq skip3340
21503
                            >        trap           ;failed equal (zero)
21504
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21505
3ad8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21506
3ad9 : 2a                   >        db      test_num
21507
                            >
21508
3ada :                      >skip3340
21509 2 MichaelA
 
21510 3 MichaelA
3ada : 28               [ 4]         plp
21511
 
21512 2 MichaelA
                             ; decimal ADC / SBC abs,x
21513 3 MichaelA
 
21514
3adb : 08               [ 3]         php             ;save carry for subtract
21515
3adc : a5b3             [ 3]         lda ad1
21516
3ade : 7d4f01           [ 4]         adc ada2-ad2,x  ;perform add
21517
3ae1 : 08               [ 3]         php
21518
3ae2 : c5b5             [ 3]         cmp adrl        ;check result
21519 2 MichaelA
                                     trap_ne         ;bad result
21520 3 MichaelA
3ae4 : f002             [ 3]>        beq skip3342
21521
                            >        trap           ;failed equal (zero)
21522
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21523
3ae6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21524
3ae7 : 2a                   >        db      test_num
21525
                            >
21526
3ae8 :                      >skip3342
21527 2 MichaelA
 
21528 3 MichaelA
3ae8 : 68               [ 4]         pla             ;check flags
21529
3ae9 : 2901             [ 2]         and #1          ;mask carry
21530
3aeb : c5b6             [ 3]         cmp adrh
21531 2 MichaelA
                                     trap_ne         ;bad carry
21532 3 MichaelA
3aed : f002             [ 3]>        beq skip3344
21533
                            >        trap           ;failed equal (zero)
21534
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21535
3aef : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21536
3af0 : 2a                   >        db      test_num
21537
                            >
21538
3af1 :                      >skip3344
21539 2 MichaelA
 
21540 3 MichaelA
3af1 : 28               [ 4]         plp
21541
3af2 : 08               [ 3]         php             ;save carry for next add
21542
3af3 : a5b3             [ 3]         lda ad1
21543
3af5 : fd5001           [ 4]         sbc sba2-ad2,x  ;perform subtract
21544
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  373
21545 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21546
 
21547 3 MichaelA
3af8 : 08               [ 3]         php
21548
3af9 : c5b5             [ 3]         cmp adrl        ;check result
21549 2 MichaelA
                                     trap_ne         ;bad result
21550 3 MichaelA
3afb : f002             [ 3]>        beq skip3346
21551
                            >        trap           ;failed equal (zero)
21552
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21553
3afd : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21554
3afe : 2a                   >        db      test_num
21555
                            >
21556
3aff :                      >skip3346
21557 2 MichaelA
 
21558 3 MichaelA
3aff : 68               [ 4]         pla             ;check flags
21559
3b00 : 2901             [ 2]         and #1          ;mask carry
21560
3b02 : c5b6             [ 3]         cmp adrh
21561 2 MichaelA
                                     trap_ne         ;bad carry
21562 3 MichaelA
3b04 : f002             [ 3]>        beq skip3348
21563
                            >        trap           ;failed equal (zero)
21564
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21565
3b06 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21566
3b07 : 2a                   >        db      test_num
21567
                            >
21568
3b08 :                      >skip3348
21569 2 MichaelA
 
21570 3 MichaelA
3b08 : 28               [ 4]         plp
21571
 
21572 2 MichaelA
                             ; decimal ADC / SBC abs,y
21573 3 MichaelA
 
21574
3b09 : 08               [ 3]         php             ;save carry for subtract
21575
3b0a : a5b3             [ 3]         lda ad1
21576
3b0c : 790401           [ 4]         adc ada2-$ff,y  ;perform add
21577
3b0f : 08               [ 3]         php
21578
3b10 : c5b5             [ 3]         cmp adrl        ;check result
21579 2 MichaelA
                                     trap_ne         ;bad result
21580 3 MichaelA
3b12 : f002             [ 3]>        beq skip3350
21581
                            >        trap           ;failed equal (zero)
21582
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21583
3b14 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21584
3b15 : 2a                   >        db      test_num
21585
                            >
21586
3b16 :                      >skip3350
21587 2 MichaelA
 
21588 3 MichaelA
3b16 : 68               [ 4]         pla             ;check flags
21589
3b17 : 2901             [ 2]         and #1          ;mask carry
21590
3b19 : c5b6             [ 3]         cmp adrh
21591 2 MichaelA
                                     trap_ne         ;bad carry
21592 3 MichaelA
3b1b : f002             [ 3]>        beq skip3352
21593
                            >        trap           ;failed equal (zero)
21594
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21595
3b1d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21596
3b1e : 2a                   >        db      test_num
21597
                            >
21598
3b1f :                      >skip3352
21599 2 MichaelA
 
21600 3 MichaelA
3b1f : 28               [ 4]         plp
21601
3b20 : 08               [ 3]         php             ;save carry for next add
21602
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  374
21603
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21604
 
21605
3b21 : a5b3             [ 3]         lda ad1
21606
3b23 : f90501           [ 4]         sbc sba2-$ff,y  ;perform subtract
21607
3b26 : 08               [ 3]         php
21608
3b27 : c5b5             [ 3]         cmp adrl        ;check result
21609 2 MichaelA
                                     trap_ne         ;bad result
21610 3 MichaelA
3b29 : f002             [ 3]>        beq skip3354
21611
                            >        trap           ;failed equal (zero)
21612
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21613
3b2b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21614
3b2c : 2a                   >        db      test_num
21615
                            >
21616
3b2d :                      >skip3354
21617 2 MichaelA
 
21618 3 MichaelA
3b2d : 68               [ 4]         pla             ;check flags
21619
3b2e : 2901             [ 2]         and #1          ;mask carry
21620
3b30 : c5b6             [ 3]         cmp adrh
21621 2 MichaelA
                                     trap_ne         ;bad carry
21622 3 MichaelA
3b32 : f002             [ 3]>        beq skip3356
21623
                            >        trap           ;failed equal (zero)
21624
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21625
3b34 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21626
3b35 : 2a                   >        db      test_num
21627
                            >
21628
3b36 :                      >skip3356
21629 2 MichaelA
 
21630 3 MichaelA
3b36 : 28               [ 4]         plp
21631
 
21632 2 MichaelA
                             ; decimal ADC / SBC (zp,x)
21633 3 MichaelA
 
21634
3b37 : 08               [ 3]         php             ;save carry for subtract
21635
3b38 : a5b3             [ 3]         lda ad1
21636
3b3a : 6144             [ 6]         adc (lo adi2-ad2,x) ;perform add
21637
3b3c : 08               [ 3]         php
21638
3b3d : c5b5             [ 3]         cmp adrl        ;check result
21639 2 MichaelA
                                     trap_ne         ;bad result
21640 3 MichaelA
3b3f : f002             [ 3]>        beq skip3358
21641
                            >        trap           ;failed equal (zero)
21642
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21643
3b41 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21644
3b42 : 2a                   >        db      test_num
21645
                            >
21646
3b43 :                      >skip3358
21647 2 MichaelA
 
21648 3 MichaelA
3b43 : 68               [ 4]         pla             ;check flags
21649
3b44 : 2901             [ 2]         and #1          ;mask carry
21650
3b46 : c5b6             [ 3]         cmp adrh
21651
                                     trap_ne         ;bad carry
21652
3b48 : f002             [ 3]>        beq skip3360
21653
                            >        trap           ;failed equal (zero)
21654
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21655
3b4a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21656
3b4b : 2a                   >        db      test_num
21657
                            >
21658
3b4c :                      >skip3360
21659
 
21660
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  375
21661 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21662
 
21663 3 MichaelA
3b4c : 28               [ 4]         plp
21664
3b4d : 08               [ 3]         php             ;save carry for next add
21665
3b4e : a5b3             [ 3]         lda ad1
21666
3b50 : e146             [ 6]         sbc (lo sbi2-ad2,x) ;perform subtract
21667
3b52 : 08               [ 3]         php
21668
3b53 : c5b5             [ 3]         cmp adrl        ;check result
21669 2 MichaelA
                                     trap_ne         ;bad result
21670 3 MichaelA
3b55 : f002             [ 3]>        beq skip3362
21671
                            >        trap           ;failed equal (zero)
21672
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21673
3b57 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21674
3b58 : 2a                   >        db      test_num
21675
                            >
21676
3b59 :                      >skip3362
21677 2 MichaelA
 
21678 3 MichaelA
3b59 : 68               [ 4]         pla             ;check flags
21679
3b5a : 2901             [ 2]         and #1          ;mask carry
21680
3b5c : c5b6             [ 3]         cmp adrh
21681 2 MichaelA
                                     trap_ne         ;bad carry
21682 3 MichaelA
3b5e : f002             [ 3]>        beq skip3364
21683
                            >        trap           ;failed equal (zero)
21684
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21685
3b60 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21686
3b61 : 2a                   >        db      test_num
21687
                            >
21688
3b62 :                      >skip3364
21689 2 MichaelA
 
21690 3 MichaelA
3b62 : 28               [ 4]         plp
21691
 
21692 2 MichaelA
                             ; decimal ADC / SBC (abs),y
21693 3 MichaelA
 
21694
3b63 : 08               [ 3]         php             ;save carry for subtract
21695
3b64 : a5b3             [ 3]         lda ad1
21696
3b66 : 71fc             [ 5]         adc (adiy2),y   ;perform add
21697
3b68 : 08               [ 3]         php
21698
3b69 : c5b5             [ 3]         cmp adrl        ;check result
21699 2 MichaelA
                                     trap_ne         ;bad result
21700 3 MichaelA
3b6b : f002             [ 3]>        beq skip3366
21701
                            >        trap           ;failed equal (zero)
21702
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21703
3b6d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21704
3b6e : 2a                   >        db      test_num
21705
                            >
21706
3b6f :                      >skip3366
21707 2 MichaelA
 
21708 3 MichaelA
3b6f : 68               [ 4]         pla             ;check flags
21709
3b70 : 2901             [ 2]         and #1          ;mask carry
21710
3b72 : c5b6             [ 3]         cmp adrh
21711 2 MichaelA
                                     trap_ne         ;bad carry
21712 3 MichaelA
3b74 : f002             [ 3]>        beq skip3368
21713
                            >        trap           ;failed equal (zero)
21714
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21715
3b76 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21716
3b77 : 2a                   >        db      test_num
21717
                            >
21718
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  376
21719
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21720
 
21721
3b78 :                      >skip3368
21722 2 MichaelA
 
21723 3 MichaelA
3b78 : 28               [ 4]         plp
21724
3b79 : 08               [ 3]         php             ;save carry for next add
21725
3b7a : a5b3             [ 3]         lda ad1
21726
3b7c : f1fe             [ 5]         sbc (sbiy2),y   ;perform subtract
21727
3b7e : 08               [ 3]         php
21728
3b7f : c5b5             [ 3]         cmp adrl        ;check result
21729 2 MichaelA
                                     trap_ne         ;bad result
21730 3 MichaelA
3b81 : f002             [ 3]>        beq skip3370
21731
                            >        trap           ;failed equal (zero)
21732
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21733
3b83 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21734
3b84 : 2a                   >        db      test_num
21735
                            >
21736
3b85 :                      >skip3370
21737 2 MichaelA
 
21738 3 MichaelA
3b85 : 68               [ 4]         pla             ;check flags
21739
3b86 : 2901             [ 2]         and #1          ;mask carry
21740
3b88 : c5b6             [ 3]         cmp adrh
21741 2 MichaelA
                                     trap_ne         ;bad carry
21742 3 MichaelA
3b8a : f002             [ 3]>        beq skip3372
21743
                            >        trap           ;failed equal (zero)
21744
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21745
3b8c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21746
3b8d : 2a                   >        db      test_num
21747
                            >
21748
3b8e :                      >skip3372
21749 2 MichaelA
 
21750 3 MichaelA
3b8e : 28               [ 4]         plp
21751
3b8f : 60               [ 6]         rts
21752 2 MichaelA
 
21753
                             ; core subroutine of the full binary add/subtract test
21754
                             ; iterates through all combinations of operands and carry input
21755
                             ; uses increments/decrements to predict result & result flags
21756 3 MichaelA
 
21757
3b90 : a5b7             [ 3] chkadd  lda adrf        ;add V-flag if overflow
21758
3b92 : 2983             [ 2]         and #$83        ;keep N-----ZC / clear V
21759
3b94 : 48               [ 3]         pha
21760
3b95 : a5b3             [ 3]         lda ad1         ;test sign unequal between operands
21761
3b97 : 45b4             [ 3]         eor ad2
21762
3b99 : 300a             [ 3]         bmi ckad1       ;no overflow possible - operands have different sign
21763
3b9b : a5b3             [ 3]         lda ad1         ;test sign equal between operands and result
21764
3b9d : 45b5             [ 3]         eor adrl
21765
3b9f : 1004             [ 3]         bpl ckad1       ;no overflow occured - operand and result have same sign
21766
3ba1 : 68               [ 4]         pla
21767
3ba2 : 0940             [ 2]         ora #$40        ;set V
21768
3ba4 : 48               [ 3]         pha
21769
3ba5 : 68               [ 4] ckad1   pla
21770
3ba6 : 85b7             [ 3]         sta adrf        ;save expected flags
21771
 
21772
                             ; binary ADC / SBC zp
21773
 
21774
3ba8 : 08               [ 3]         php             ;save carry for subtract
21775
3ba9 : a5b3             [ 3]         lda ad1
21776
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  377
21777 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21778
 
21779 3 MichaelA
3bab : 65b4             [ 3]         adc ad2         ;perform add
21780
3bad : 08               [ 3]         php
21781
3bae : c5b5             [ 3]         cmp adrl        ;check result
21782 2 MichaelA
                                     trap_ne         ;bad result
21783 3 MichaelA
3bb0 : f002             [ 3]>        beq skip3374
21784
                            >        trap           ;failed equal (zero)
21785
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21786
3bb2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21787
3bb3 : 2a                   >        db      test_num
21788
                            >
21789
3bb4 :                      >skip3374
21790 2 MichaelA
 
21791 3 MichaelA
3bb4 : 68               [ 4]         pla             ;check flags
21792
3bb5 : 29c3             [ 2]         and #$c3        ;mask NV----ZC
21793
3bb7 : c5b7             [ 3]         cmp adrf
21794 2 MichaelA
                                     trap_ne         ;bad flags
21795 3 MichaelA
3bb9 : f002             [ 3]>        beq skip3376
21796
                            >        trap           ;failed equal (zero)
21797
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21798
3bbb : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21799
3bbc : 2a                   >        db      test_num
21800
                            >
21801
3bbd :                      >skip3376
21802 2 MichaelA
 
21803 3 MichaelA
3bbd : 28               [ 4]         plp
21804
3bbe : 08               [ 3]         php             ;save carry for next add
21805
3bbf : a5b3             [ 3]         lda ad1
21806
3bc1 : e5b8             [ 3]         sbc sb2         ;perform subtract
21807
3bc3 : 08               [ 3]         php
21808
3bc4 : c5b5             [ 3]         cmp adrl        ;check result
21809 2 MichaelA
                                     trap_ne         ;bad result
21810 3 MichaelA
3bc6 : f002             [ 3]>        beq skip3378
21811
                            >        trap           ;failed equal (zero)
21812
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21813
3bc8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21814
3bc9 : 2a                   >        db      test_num
21815
                            >
21816
3bca :                      >skip3378
21817 2 MichaelA
 
21818 3 MichaelA
3bca : 68               [ 4]         pla             ;check flags
21819
3bcb : 29c3             [ 2]         and #$c3        ;mask NV----ZC
21820
3bcd : c5b7             [ 3]         cmp adrf
21821 2 MichaelA
                                     trap_ne         ;bad flags
21822 3 MichaelA
3bcf : f002             [ 3]>        beq skip3380
21823
                            >        trap           ;failed equal (zero)
21824
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21825
3bd1 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21826
3bd2 : 2a                   >        db      test_num
21827
                            >
21828
3bd3 :                      >skip3380
21829 2 MichaelA
 
21830 3 MichaelA
3bd3 : 28               [ 4]         plp
21831
 
21832 2 MichaelA
                             ; binary ADC / SBC abs
21833
 
21834 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  378
21835 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21836
 
21837 3 MichaelA
3bd4 : 08               [ 3]         php             ;save carry for subtract
21838
3bd5 : a5b3             [ 3]         lda ad1
21839
3bd7 : 6d0302           [ 4]         adc ada2        ;perform add
21840
3bda : 08               [ 3]         php
21841
3bdb : c5b5             [ 3]         cmp adrl        ;check result
21842
                                     trap_ne         ;bad result
21843
3bdd : f002             [ 3]>        beq skip3382
21844
                            >        trap           ;failed equal (zero)
21845
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21846
3bdf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21847
3be0 : 2a                   >        db      test_num
21848
                            >
21849
3be1 :                      >skip3382
21850
 
21851
3be1 : 68               [ 4]         pla             ;check flags
21852
3be2 : 29c3             [ 2]         and #$c3        ;mask NV----ZC
21853
3be4 : c5b7             [ 3]         cmp adrf
21854 2 MichaelA
                                     trap_ne         ;bad flags
21855 3 MichaelA
3be6 : f002             [ 3]>        beq skip3384
21856
                            >        trap           ;failed equal (zero)
21857
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21858
3be8 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21859
3be9 : 2a                   >        db      test_num
21860
                            >
21861
3bea :                      >skip3384
21862 2 MichaelA
 
21863 3 MichaelA
3bea : 28               [ 4]         plp
21864
3beb : 08               [ 3]         php             ;save carry for next add
21865
3bec : a5b3             [ 3]         lda ad1
21866
3bee : ed0402           [ 4]         sbc sba2        ;perform subtract
21867
3bf1 : 08               [ 3]         php
21868
3bf2 : c5b5             [ 3]         cmp adrl        ;check result
21869 2 MichaelA
                                     trap_ne         ;bad result
21870 3 MichaelA
3bf4 : f002             [ 3]>        beq skip3386
21871
                            >        trap           ;failed equal (zero)
21872
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21873
3bf6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21874
3bf7 : 2a                   >        db      test_num
21875
                            >
21876
3bf8 :                      >skip3386
21877 2 MichaelA
 
21878 3 MichaelA
3bf8 : 68               [ 4]         pla             ;check flags
21879
3bf9 : 29c3             [ 2]         and #$c3        ;mask NV----ZC
21880
3bfb : c5b7             [ 3]         cmp adrf
21881 2 MichaelA
                                     trap_ne         ;bad flags
21882 3 MichaelA
3bfd : f002             [ 4]>        beq skip3388
21883
                            >        trap           ;failed equal (zero)
21884
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21885
3bff : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21886
3c00 : 2a                   >        db      test_num
21887
                            >
21888
3c01 :                      >skip3388
21889 2 MichaelA
 
21890 3 MichaelA
3c01 : 28               [ 4]         plp
21891
 
21892
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  379
21893
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21894
 
21895 2 MichaelA
                             ; binary ADC / SBC #
21896 3 MichaelA
 
21897
3c02 : 08               [ 3]         php             ;save carry for subtract
21898
3c03 : a5b4             [ 3]         lda ad2
21899
3c05 : 8d0b3c           [ 4]         sta chkadi      ;self modify immediate
21900
3c08 : a5b3             [ 3]         lda ad1
21901
 
21902
3c0b =                       chkadi  = * + 1         ;operand of the immediate ADC
21903
 
21904
3c0a : 6900             [ 2]         adc #0          ;perform add
21905
3c0c : 08               [ 3]         php
21906
3c0d : c5b5             [ 3]         cmp adrl        ;check result
21907 2 MichaelA
                                     trap_ne         ;bad result
21908 3 MichaelA
3c0f : f002             [ 3]>        beq skip3390
21909
                            >        trap           ;failed equal (zero)
21910
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21911
3c11 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21912
3c12 : 2a                   >        db      test_num
21913
                            >
21914
3c13 :                      >skip3390
21915 2 MichaelA
 
21916 3 MichaelA
3c13 : 68               [ 4]         pla             ;check flags
21917
3c14 : 29c3             [ 2]         and #$c3        ;mask NV----ZC
21918
3c16 : c5b7             [ 3]         cmp adrf
21919 2 MichaelA
                                     trap_ne         ;bad flags
21920 3 MichaelA
3c18 : f002             [ 3]>        beq skip3392
21921
                            >        trap           ;failed equal (zero)
21922
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21923
3c1a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21924
3c1b : 2a                   >        db      test_num
21925
                            >
21926
3c1c :                      >skip3392
21927 2 MichaelA
 
21928 3 MichaelA
3c1c : 28               [ 4]         plp
21929
3c1d : 08               [ 3]         php             ;save carry for next add
21930
3c1e : a5b8             [ 3]         lda sb2
21931
3c20 : 8d263c           [ 4]         sta chksbi      ;self modify immediate
21932
3c23 : a5b3             [ 3]         lda ad1
21933
 
21934
3c26 =                       chksbi  = * + 1         ;operand of the immediate SBC
21935
 
21936
3c25 : e900             [ 2]         sbc #0          ;perform subtract
21937
3c27 : 08               [ 3]         php
21938
3c28 : c5b5             [ 3]         cmp adrl        ;check result
21939 2 MichaelA
                                     trap_ne         ;bad result
21940 3 MichaelA
3c2a : f002             [ 3]>        beq skip3394
21941
                            >        trap           ;failed equal (zero)
21942
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21943
3c2c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21944
3c2d : 2a                   >        db      test_num
21945
                            >
21946
3c2e :                      >skip3394
21947 2 MichaelA
 
21948 3 MichaelA
3c2e : 68               [ 4]         pla             ;check flags
21949
3c2f : 29c3             [ 2]         and #$c3        ;mask NV----ZC
21950
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  380
21951 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
21952
 
21953 3 MichaelA
3c31 : c5b7             [ 3]         cmp adrf
21954
                                     trap_ne         ;bad flags
21955
3c33 : f002             [ 3]>        beq skip3396
21956
                            >        trap           ;failed equal (zero)
21957
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21958
3c35 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21959
3c36 : 2a                   >        db      test_num
21960
                            >
21961
3c37 :                      >skip3396
21962 2 MichaelA
 
21963 3 MichaelA
3c37 : 28               [ 4]         plp
21964
 
21965 2 MichaelA
                             ; binary ADC / SBC zp,x
21966 3 MichaelA
 
21967
3c38 : 08               [ 3]         php             ;save carry for subtract
21968
3c39 : a5b3             [ 3]         lda ad1
21969
3c3b : 7500             [ 4]         adc 0,x         ;perform add
21970
3c3d : 08               [ 3]         php
21971
3c3e : c5b5             [ 3]         cmp adrl        ;check result
21972 2 MichaelA
                                     trap_ne         ;bad result
21973 3 MichaelA
3c40 : f002             [ 3]>        beq skip3398
21974
                            >        trap           ;failed equal (zero)
21975
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21976
3c42 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21977
3c43 : 2a                   >        db      test_num
21978
                            >
21979
3c44 :                      >skip3398
21980 2 MichaelA
 
21981 3 MichaelA
3c44 : 68               [ 4]         pla             ;check flags
21982
3c45 : 29c3             [ 2]         and #$c3        ;mask NV----ZC
21983
3c47 : c5b7             [ 3]         cmp adrf
21984 2 MichaelA
                                     trap_ne         ;bad flags
21985 3 MichaelA
3c49 : f002             [ 3]>        beq skip3400
21986
                            >        trap           ;failed equal (zero)
21987
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
21988
3c4b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
21989
3c4c : 2a                   >        db      test_num
21990
                            >
21991
3c4d :                      >skip3400
21992 2 MichaelA
 
21993 3 MichaelA
3c4d : 28               [ 4]         plp
21994
3c4e : 08               [ 3]         php             ;save carry for next add
21995
3c4f : a5b3             [ 3]         lda ad1
21996
3c51 : f504             [ 4]         sbc sb2-ad2,x   ;perform subtract
21997
3c53 : 08               [ 3]         php
21998
3c54 : c5b5             [ 3]         cmp adrl        ;check result
21999 2 MichaelA
                                     trap_ne         ;bad result
22000 3 MichaelA
3c56 : f002             [ 3]>        beq skip3402
22001
                            >        trap           ;failed equal (zero)
22002
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22003
3c58 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22004
3c59 : 2a                   >        db      test_num
22005
                            >
22006
3c5a :                      >skip3402
22007 2 MichaelA
 
22008 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  381
22009
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22010
 
22011
3c5a : 68               [ 4]         pla             ;check flags
22012
3c5b : 29c3             [ 2]         and #$c3        ;mask NV----ZC
22013
3c5d : c5b7             [ 3]         cmp adrf
22014 2 MichaelA
                                     trap_ne         ;bad flags
22015 3 MichaelA
3c5f : f002             [ 3]>        beq skip3404
22016
                            >        trap           ;failed equal (zero)
22017
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22018
3c61 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22019
3c62 : 2a                   >        db      test_num
22020
                            >
22021
3c63 :                      >skip3404
22022 2 MichaelA
 
22023 3 MichaelA
3c63 : 28               [ 4]         plp
22024
 
22025 2 MichaelA
                             ; binary ADC / SBC abs,x
22026 3 MichaelA
 
22027
3c64 : 08               [ 3]         php             ;save carry for subtract
22028
3c65 : a5b3             [ 3]         lda ad1
22029
3c67 : 7d4f01           [ 4]         adc ada2-ad2,x  ;perform add
22030
3c6a : 08               [ 3]         php
22031
3c6b : c5b5             [ 3]         cmp adrl        ;check result
22032 2 MichaelA
                                     trap_ne         ;bad result
22033 3 MichaelA
3c6d : f002             [ 3]>        beq skip3406
22034
                            >        trap           ;failed equal (zero)
22035
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22036
3c6f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22037
3c70 : 2a                   >        db      test_num
22038
                            >
22039
3c71 :                      >skip3406
22040 2 MichaelA
 
22041 3 MichaelA
3c71 : 68               [ 4]         pla             ;check flags
22042
3c72 : 29c3             [ 2]         and #$c3        ;mask NV----ZC
22043
3c74 : c5b7             [ 3]         cmp adrf
22044 2 MichaelA
                                     trap_ne         ;bad flags
22045 3 MichaelA
3c76 : f002             [ 3]>        beq skip3408
22046
                            >        trap           ;failed equal (zero)
22047
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22048
3c78 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22049
3c79 : 2a                   >        db      test_num
22050
                            >
22051
3c7a :                      >skip3408
22052 2 MichaelA
 
22053 3 MichaelA
3c7a : 28               [ 4]         plp
22054
3c7b : 08               [ 3]         php             ;save carry for next add
22055
3c7c : a5b3             [ 3]         lda ad1
22056
3c7e : fd5001           [ 4]         sbc sba2-ad2,x  ;perform subtract
22057
3c81 : 08               [ 3]         php
22058
3c82 : c5b5             [ 3]         cmp adrl        ;check result
22059
                                     trap_ne         ;bad result
22060
3c84 : f002             [ 3]>        beq skip3410
22061
                            >        trap           ;failed equal (zero)
22062
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22063
3c86 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22064
3c87 : 2a                   >        db      test_num
22065
                            >
22066
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  382
22067 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22068
 
22069 3 MichaelA
3c88 :                      >skip3410
22070 2 MichaelA
 
22071 3 MichaelA
3c88 : 68               [ 4]         pla             ;check flags
22072
3c89 : 29c3             [ 2]         and #$c3        ;mask NV----ZC
22073
3c8b : c5b7             [ 3]         cmp adrf
22074 2 MichaelA
                                     trap_ne         ;bad flags
22075 3 MichaelA
3c8d : f002             [ 3]>        beq skip3412
22076
                            >        trap           ;failed equal (zero)
22077
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22078
3c8f : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22079
3c90 : 2a                   >        db      test_num
22080
                            >
22081
3c91 :                      >skip3412
22082 2 MichaelA
 
22083 3 MichaelA
3c91 : 28               [ 4]         plp
22084
 
22085 2 MichaelA
                             ; binary ADC / SBC abs,y
22086 3 MichaelA
 
22087
3c92 : 08               [ 3]         php             ;save carry for subtract
22088
3c93 : a5b3             [ 3]         lda ad1
22089
3c95 : 790401           [ 4]         adc ada2-$ff,y  ;perform add
22090
3c98 : 08               [ 3]         php
22091
3c99 : c5b5             [ 3]         cmp adrl        ;check result
22092 2 MichaelA
                                     trap_ne         ;bad result
22093 3 MichaelA
3c9b : f002             [ 3]>        beq skip3414
22094
                            >        trap           ;failed equal (zero)
22095
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22096
3c9d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22097
3c9e : 2a                   >        db      test_num
22098
                            >
22099
3c9f :                      >skip3414
22100 2 MichaelA
 
22101 3 MichaelA
3c9f : 68               [ 4]         pla             ;check flags
22102
3ca0 : 29c3             [ 2]         and #$c3        ;mask NV----ZC
22103
3ca2 : c5b7             [ 3]         cmp adrf
22104 2 MichaelA
                                     trap_ne         ;bad flags
22105 3 MichaelA
3ca4 : f002             [ 3]>        beq skip3416
22106
                            >        trap           ;failed equal (zero)
22107
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22108
3ca6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22109
3ca7 : 2a                   >        db      test_num
22110
                            >
22111
3ca8 :                      >skip3416
22112 2 MichaelA
 
22113 3 MichaelA
3ca8 : 28               [ 4]         plp
22114
3ca9 : 08               [ 3]         php             ;save carry for next add
22115
3caa : a5b3             [ 3]         lda ad1
22116
3cac : f90501           [ 4]         sbc sba2-$ff,y  ;perform subtract
22117
3caf : 08               [ 3]         php
22118
3cb0 : c5b5             [ 3]         cmp adrl        ;check result
22119 2 MichaelA
                                     trap_ne         ;bad result
22120 3 MichaelA
3cb2 : f002             [ 3]>        beq skip3418
22121
                            >        trap           ;failed equal (zero)
22122
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22123
3cb4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22124
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  383
22125
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22126
 
22127
3cb5 : 2a                   >        db      test_num
22128
                            >
22129
3cb6 :                      >skip3418
22130 2 MichaelA
 
22131 3 MichaelA
3cb6 : 68               [ 4]         pla             ;check flags
22132
3cb7 : 29c3             [ 2]         and #$c3        ;mask NV----ZC
22133
3cb9 : c5b7             [ 3]         cmp adrf
22134 2 MichaelA
                                     trap_ne         ;bad flags
22135 3 MichaelA
3cbb : f002             [ 3]>        beq skip3420
22136
                            >        trap           ;failed equal (zero)
22137
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22138
3cbd : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22139
3cbe : 2a                   >        db      test_num
22140
                            >
22141
3cbf :                      >skip3420
22142 2 MichaelA
 
22143 3 MichaelA
3cbf : 28               [ 4]         plp
22144
 
22145 2 MichaelA
                             ; binary ADC / SBC (zp,x)
22146 3 MichaelA
 
22147
3cc0 : 08               [ 3]         php             ;save carry for subtract
22148
3cc1 : a5b3             [ 3]         lda ad1
22149
3cc3 : 6144             [ 6]         adc (lo adi2-ad2,x) ;perform add
22150
3cc5 : 08               [ 3]         php
22151
3cc6 : c5b5             [ 3]         cmp adrl        ;check result
22152 2 MichaelA
                                     trap_ne         ;bad result
22153 3 MichaelA
3cc8 : f002             [ 3]>        beq skip3422
22154
                            >        trap           ;failed equal (zero)
22155
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22156
3cca : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22157
3ccb : 2a                   >        db      test_num
22158
                            >
22159
3ccc :                      >skip3422
22160 2 MichaelA
 
22161 3 MichaelA
3ccc : 68               [ 4]         pla             ;check flags
22162
3ccd : 29c3             [ 2]         and #$c3        ;mask NV----ZC
22163
3ccf : c5b7             [ 3]         cmp adrf
22164 2 MichaelA
                                     trap_ne         ;bad flags
22165 3 MichaelA
3cd1 : f002             [ 3]>        beq skip3424
22166
                            >        trap           ;failed equal (zero)
22167
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22168
3cd3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22169
3cd4 : 2a                   >        db      test_num
22170
                            >
22171
3cd5 :                      >skip3424
22172
 
22173
3cd5 : 28               [ 4]         plp
22174
3cd6 : 08               [ 3]         php             ;save carry for next add
22175
3cd7 : a5b3             [ 3]         lda ad1
22176
3cd9 : e146             [ 6]         sbc (lo sbi2-ad2,x) ;perform subtract
22177
3cdb : 08               [ 3]         php
22178
3cdc : c5b5             [ 3]         cmp adrl        ;check result
22179
                                     trap_ne         ;bad result
22180
3cde : f002             [ 3]>        beq skip3426
22181
                            >        trap           ;failed equal (zero)
22182
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  384
22183 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22184
 
22185 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22186
3ce0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22187
3ce1 : 2a                   >        db      test_num
22188
                            >
22189
3ce2 :                      >skip3426
22190 2 MichaelA
 
22191 3 MichaelA
3ce2 : 68               [ 4]         pla             ;check flags
22192
3ce3 : 29c3             [ 2]         and #$c3        ;mask NV----ZC
22193
3ce5 : c5b7             [ 3]         cmp adrf
22194 2 MichaelA
                                     trap_ne         ;bad flags
22195 3 MichaelA
3ce7 : f002             [ 3]>        beq skip3428
22196
                            >        trap           ;failed equal (zero)
22197
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22198
3ce9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22199
3cea : 2a                   >        db      test_num
22200
                            >
22201
3ceb :                      >skip3428
22202 2 MichaelA
 
22203 3 MichaelA
3ceb : 28               [ 4]         plp
22204
 
22205 2 MichaelA
                             ; binary ADC / SBC (abs),y
22206 3 MichaelA
 
22207
3cec : 08               [ 3]         php             ;save carry for subtract
22208
3ced : a5b3             [ 3]         lda ad1
22209
3cef : 71fc             [ 5]         adc (adiy2),y   ;perform add
22210
3cf1 : 08               [ 3]         php
22211
3cf2 : c5b5             [ 3]         cmp adrl        ;check result
22212 2 MichaelA
                                     trap_ne         ;bad result
22213 3 MichaelA
3cf4 : f002             [ 3]>        beq skip3430
22214
                            >        trap           ;failed equal (zero)
22215
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22216
3cf6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22217
3cf7 : 2a                   >        db      test_num
22218
                            >
22219
3cf8 :                      >skip3430
22220 2 MichaelA
 
22221 3 MichaelA
3cf8 : 68               [ 4]         pla             ;check flags
22222
3cf9 : 29c3             [ 2]         and #$c3        ;mask NV----ZC
22223
3cfb : c5b7             [ 3]         cmp adrf
22224 2 MichaelA
                                     trap_ne         ;bad flags
22225 3 MichaelA
3cfd : f002             [ 4]>        beq skip3432
22226
                            >        trap           ;failed equal (zero)
22227
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22228
3cff : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22229
3d00 : 2a                   >        db      test_num
22230
                            >
22231
3d01 :                      >skip3432
22232 2 MichaelA
 
22233 3 MichaelA
3d01 : 28               [ 4]         plp
22234
3d02 : 08               [ 3]         php             ;save carry for next add
22235
3d03 : a5b3             [ 3]         lda ad1
22236
3d05 : f1fe             [ 5]         sbc (sbiy2),y   ;perform subtract
22237
3d07 : 08               [ 3]         php
22238
3d08 : c5b5             [ 3]         cmp adrl        ;check result
22239 2 MichaelA
                                     trap_ne         ;bad result
22240 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  385
22241
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22242
 
22243
3d0a : f002             [ 3]>        beq skip3434
22244
                            >        trap           ;failed equal (zero)
22245
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22246
3d0c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22247
3d0d : 2a                   >        db      test_num
22248
                            >
22249
3d0e :                      >skip3434
22250 2 MichaelA
 
22251 3 MichaelA
3d0e : 68               [ 4]         pla             ;check flags
22252
3d0f : 29c3             [ 2]         and #$c3        ;mask NV----ZC
22253
3d11 : c5b7             [ 3]         cmp adrf
22254 2 MichaelA
                                     trap_ne         ;bad flags
22255 3 MichaelA
3d13 : f002             [ 3]>        beq skip3436
22256
                            >        trap           ;failed equal (zero)
22257
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22258
3d15 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22259
3d16 : 2a                   >        db      test_num
22260
                            >
22261
3d17 :                      >skip3436
22262 2 MichaelA
 
22263 3 MichaelA
3d17 : 28               [ 4]         plp
22264
3d18 : 60               [ 6]         rts
22265 2 MichaelA
 
22266
                             ; target for the jump absolute test
22267 3 MichaelA
 
22268
3d19 : 88               [ 2]         dey
22269
3d1a : 88               [ 2]         dey
22270
3d1b :                       test_far
22271
3d1b : 08               [ 3]         php             ;either SP or Y count will fail, if we do not hit
22272
3d1c : 88               [ 2]         dey
22273
3d1d : 88               [ 2]         dey
22274
3d1e : 88               [ 2]         dey
22275
3d1f : 28               [ 4]         plp
22276 2 MichaelA
                                     trap_cs         ;flags loaded?
22277 3 MichaelA
3d20 : 9002             [ 3]>        bcc skip3438
22278
                            >        trap           ;failed equal (zero)
22279
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22280
3d22 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22281
3d23 : 2a                   >        db      test_num
22282
                            >
22283
3d24 :                      >skip3438
22284 2 MichaelA
 
22285
                                     trap_vs
22286 3 MichaelA
3d24 : 5002             [ 3]>        bvc skip3440
22287
                            >        trap           ;failed equal (zero)
22288
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22289
3d26 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22290
3d27 : 2a                   >        db      test_num
22291
                            >
22292
3d28 :                      >skip3440
22293 2 MichaelA
 
22294
                                     trap_mi
22295 3 MichaelA
3d28 : 1002             [ 3]>        bpl skip3442
22296
                            >        trap           ;failed equal (zero)
22297
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22298
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  386
22299
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22300
 
22301
3d2a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22302
3d2b : 2a                   >        db      test_num
22303
                            >
22304
3d2c :                      >skip3442
22305 2 MichaelA
 
22306
                                     trap_eq
22307 3 MichaelA
3d2c : d002             [ 3]>        bne skip3444
22308
                            >        trap           ;failed equal (zero)
22309
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22310
3d2e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22311
3d2f : 2a                   >        db      test_num
22312
                            >
22313
3d30 :                      >skip3444
22314 2 MichaelA
 
22315 3 MichaelA
3d30 : c946             [ 2]         cmp #'F'        ;registers loaded?
22316 2 MichaelA
                                     trap_ne
22317 3 MichaelA
3d32 : f002             [ 3]>        beq skip3446
22318
                            >        trap           ;failed equal (zero)
22319
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22320
3d34 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22321
3d35 : 2a                   >        db      test_num
22322
                            >
22323
3d36 :                      >skip3446
22324 2 MichaelA
 
22325 3 MichaelA
3d36 : e041             [ 2]         cpx #'A'
22326 2 MichaelA
                                     trap_ne
22327 3 MichaelA
3d38 : f002             [ 3]>        beq skip3448
22328
                            >        trap           ;failed equal (zero)
22329
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22330
3d3a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22331
3d3b : 2a                   >        db      test_num
22332
                            >
22333
3d3c :                      >skip3448
22334 2 MichaelA
 
22335 3 MichaelA
3d3c : c04f             [ 2]         cpy #('R'-3)
22336 2 MichaelA
                                     trap_ne
22337 3 MichaelA
3d3e : f002             [ 3]>        beq skip3450
22338
                            >        trap           ;failed equal (zero)
22339
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22340
3d40 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22341
3d41 : 2a                   >        db      test_num
22342
                            >
22343
3d42 :                      >skip3450
22344 2 MichaelA
 
22345 3 MichaelA
3d42 : 48               [ 3]         pha             ;save a,x
22346
3d43 : 8a               [ 2]         txa
22347
3d44 : 48               [ 3]         pha
22348
3d45 : ba               [ 2]         tsx
22349
3d46 : e0fd             [ 2]         cpx #$fd        ;check SP
22350 2 MichaelA
                                     trap_ne
22351 3 MichaelA
3d48 : f002             [ 3]>        beq skip3452
22352
                            >        trap           ;failed equal (zero)
22353
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22354
3d4a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22355
3d4b : 2a                   >        db      test_num
22356
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  387
22357
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22358
 
22359
                            >
22360
3d4c :                      >skip3452
22361 2 MichaelA
 
22362 3 MichaelA
3d4c : 68               [ 4]         pla             ;restore x
22363
3d4d : aa               [ 2]         tax
22364 2 MichaelA
                                     set_stat $ff
22365
                            >            load_flag $ff
22366 3 MichaelA
3d4e : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
22367 2 MichaelA
                            >
22368 3 MichaelA
3d50 : 48               [ 3]>            pha         ;use stack to load status
22369
3d51 : 28               [ 4]>            plp
22370 2 MichaelA
 
22371 3 MichaelA
3d52 : 68               [ 4]         pla             ;restore a
22372
3d53 : e8               [ 2]         inx             ;return registers with modifications
22373
3d54 : 49aa             [ 2]         eor #$aa        ;N=1, V=1, Z=0, C=1
22374
3d56 : 4ca808           [ 3]         jmp far_ret
22375 2 MichaelA
 
22376
                             ; target for the jump indirect test
22377 3 MichaelA
 
22378
3d59 : 00                            align
22379
 
22380
3d5a : 623d                  ptr_tst_ind dw test_ind
22381
3d5c : 1f09                  ptr_ind_ret dw ind_ret
22382
 
22383 2 MichaelA
                                     trap            ;runover protection
22384 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22385
3d5e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22386
3d5f : 2a                   >        db      test_num
22387 2 MichaelA
 
22388 3 MichaelA
3d60 : 88               [ 2]         dey
22389
3d61 : 88               [ 2]         dey
22390
3d62 :                       test_ind
22391
3d62 : 08               [ 3]         php             ;either SP or Y count will fail, if we do not hit
22392
3d63 : 88               [ 2]         dey
22393
3d64 : 88               [ 2]         dey
22394
3d65 : 88               [ 2]         dey
22395
3d66 : 28               [ 4]         plp
22396 2 MichaelA
                                     trap_cs         ;flags loaded?
22397 3 MichaelA
3d67 : 9002             [ 3]>        bcc skip3457
22398
                            >        trap           ;failed equal (zero)
22399
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22400
3d69 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22401
3d6a : 2a                   >        db      test_num
22402
                            >
22403
3d6b :                      >skip3457
22404 2 MichaelA
 
22405
                                     trap_vs
22406 3 MichaelA
3d6b : 5002             [ 3]>        bvc skip3459
22407
                            >        trap           ;failed equal (zero)
22408
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22409
3d6d : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22410
3d6e : 2a                   >        db      test_num
22411
                            >
22412
3d6f :                      >skip3459
22413 2 MichaelA
 
22414 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  388
22415
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22416
 
22417 2 MichaelA
                                     trap_mi
22418 3 MichaelA
3d6f : 1002             [ 3]>        bpl skip3461
22419
                            >        trap           ;failed equal (zero)
22420
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22421
3d71 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22422
3d72 : 2a                   >        db      test_num
22423
                            >
22424
3d73 :                      >skip3461
22425 2 MichaelA
 
22426
                                     trap_eq
22427 3 MichaelA
3d73 : d002             [ 3]>        bne skip3463
22428
                            >        trap           ;failed equal (zero)
22429
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22430
3d75 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22431
3d76 : 2a                   >        db      test_num
22432
                            >
22433
3d77 :                      >skip3463
22434 2 MichaelA
 
22435 3 MichaelA
3d77 : c949             [ 2]         cmp #'I'        ;registers loaded?
22436 2 MichaelA
                                     trap_ne
22437 3 MichaelA
3d79 : f002             [ 3]>        beq skip3465
22438
                            >        trap           ;failed equal (zero)
22439
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22440
3d7b : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22441
3d7c : 2a                   >        db      test_num
22442
                            >
22443
3d7d :                      >skip3465
22444 2 MichaelA
 
22445 3 MichaelA
3d7d : e04e             [ 2]         cpx #'N'
22446 2 MichaelA
                                     trap_ne
22447 3 MichaelA
3d7f : f002             [ 3]>        beq skip3467
22448
                            >        trap           ;failed equal (zero)
22449
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22450
3d81 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22451
3d82 : 2a                   >        db      test_num
22452
                            >
22453
3d83 :                      >skip3467
22454 2 MichaelA
 
22455 3 MichaelA
3d83 : c041             [ 2]         cpy #('D'-3)
22456 2 MichaelA
                                     trap_ne
22457 3 MichaelA
3d85 : f002             [ 3]>        beq skip3469
22458
                            >        trap           ;failed equal (zero)
22459
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22460
3d87 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22461
3d88 : 2a                   >        db      test_num
22462
                            >
22463
3d89 :                      >skip3469
22464 2 MichaelA
 
22465 3 MichaelA
3d89 : 48               [ 3]         pha             ;save a,x
22466
3d8a : 8a               [ 2]         txa
22467
3d8b : 48               [ 3]         pha
22468
3d8c : ba               [ 2]         tsx
22469
3d8d : e0fd             [ 2]         cpx #$fd        ;check SP
22470 2 MichaelA
                                     trap_ne
22471 3 MichaelA
3d8f : f002             [ 3]>        beq skip3471
22472
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  389
22473
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22474
 
22475
                            >        trap           ;failed equal (zero)
22476
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22477
3d91 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22478
3d92 : 2a                   >        db      test_num
22479
                            >
22480
3d93 :                      >skip3471
22481 2 MichaelA
 
22482 3 MichaelA
3d93 : 68               [ 4]         pla             ;restore x
22483
3d94 : aa               [ 2]         tax
22484 2 MichaelA
                                     set_stat $ff
22485
                            >            load_flag $ff
22486 3 MichaelA
3d95 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
22487 2 MichaelA
                            >
22488 3 MichaelA
3d97 : 48               [ 3]>            pha         ;use stack to load status
22489
3d98 : 28               [ 4]>            plp
22490 2 MichaelA
 
22491 3 MichaelA
3d99 : 68               [ 4]         pla             ;restore a
22492
3d9a : e8               [ 2]         inx             ;return registers with modifications
22493
3d9b : 49aa             [ 2]         eor #$aa        ;N=1, V=1, Z=0, C=1
22494
3d9d : 6c5c3d           [ 6]         jmp (ptr_ind_ret)
22495 2 MichaelA
                                     trap            ;runover protection
22496 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22497
3da0 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22498
3da1 : 2a                   >        db      test_num
22499 2 MichaelA
 
22500
 
22501
                             ; target for the jump subroutine test
22502 3 MichaelA
 
22503
3da2 : 88               [ 2]         dey
22504
3da3 : 88               [ 2]         dey
22505
3da4 :                       test_jsr
22506
3da4 : 08               [ 3]         php             ;either SP or Y count will fail, if we do not hit
22507
3da5 : 88               [ 2]         dey
22508
3da6 : 88               [ 2]         dey
22509
3da7 : 88               [ 2]         dey
22510
3da8 : 28               [ 4]         plp
22511 2 MichaelA
                                     trap_cs         ;flags loaded?
22512 3 MichaelA
3da9 : 9002             [ 3]>        bcc skip3476
22513
                            >        trap           ;failed equal (zero)
22514
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22515
3dab : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22516
3dac : 2a                   >        db      test_num
22517
                            >
22518
3dad :                      >skip3476
22519 2 MichaelA
 
22520
                                     trap_vs
22521 3 MichaelA
3dad : 5002             [ 3]>        bvc skip3478
22522
                            >        trap           ;failed equal (zero)
22523
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22524
3daf : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22525
3db0 : 2a                   >        db      test_num
22526
                            >
22527
3db1 :                      >skip3478
22528 2 MichaelA
 
22529
                                     trap_mi
22530 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  390
22531
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22532
 
22533
3db1 : 1002             [ 3]>        bpl skip3480
22534
                            >        trap           ;failed equal (zero)
22535
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22536
3db3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22537
3db4 : 2a                   >        db      test_num
22538
                            >
22539
3db5 :                      >skip3480
22540 2 MichaelA
 
22541
                                     trap_eq
22542 3 MichaelA
3db5 : d002             [ 3]>        bne skip3482
22543
                            >        trap           ;failed equal (zero)
22544
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22545
3db7 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22546
3db8 : 2a                   >        db      test_num
22547
                            >
22548
3db9 :                      >skip3482
22549 2 MichaelA
 
22550 3 MichaelA
3db9 : c94a             [ 2]         cmp #'J'        ;registers loaded?
22551 2 MichaelA
                                     trap_ne
22552 3 MichaelA
3dbb : f002             [ 3]>        beq skip3484
22553
                            >        trap           ;failed equal (zero)
22554
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22555
3dbd : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22556
3dbe : 2a                   >        db      test_num
22557
                            >
22558
3dbf :                      >skip3484
22559 2 MichaelA
 
22560 3 MichaelA
3dbf : e053             [ 2]         cpx #'S'
22561 2 MichaelA
                                     trap_ne
22562 3 MichaelA
3dc1 : f002             [ 3]>        beq skip3486
22563
                            >        trap           ;failed equal (zero)
22564
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22565
3dc3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22566
3dc4 : 2a                   >        db      test_num
22567
                            >
22568
3dc5 :                      >skip3486
22569 2 MichaelA
 
22570 3 MichaelA
3dc5 : c04f             [ 2]         cpy #('R'-3)
22571 2 MichaelA
                                     trap_ne
22572 3 MichaelA
3dc7 : f002             [ 3]>        beq skip3488
22573
                            >        trap           ;failed equal (zero)
22574
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22575
3dc9 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22576
3dca : 2a                   >        db      test_num
22577
                            >
22578
3dcb :                      >skip3488
22579 2 MichaelA
 
22580 3 MichaelA
3dcb : 48               [ 3]         pha             ;save a,x
22581
3dcc : 8a               [ 2]         txa
22582
3dcd : 48               [ 3]         pha
22583
3dce : ba               [ 2]         tsx             ;sp -4? (return addr,a,x)
22584
3dcf : e0fb             [ 2]         cpx #$fb
22585 2 MichaelA
                                     trap_ne
22586 3 MichaelA
3dd1 : f002             [ 3]>        beq skip3490
22587
                            >        trap           ;failed equal (zero)
22588
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  391
22589
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22590
 
22591
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22592
3dd3 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22593
3dd4 : 2a                   >        db      test_num
22594
                            >
22595
3dd5 :                      >skip3490
22596 2 MichaelA
 
22597 3 MichaelA
3dd5 : adff01           [ 4]         lda $1ff        ;propper return on stack
22598
3dd8 : c909             [ 2]         cmp #hi(jsr_ret)
22599 2 MichaelA
                                     trap_ne
22600 3 MichaelA
3dda : f002             [ 3]>        beq skip3492
22601
                            >        trap           ;failed equal (zero)
22602
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22603
3ddc : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22604
3ddd : 2a                   >        db      test_num
22605
                            >
22606
3dde :                      >skip3492
22607 2 MichaelA
 
22608 3 MichaelA
3dde : adfe01           [ 4]         lda $1fe
22609
3de1 : c967             [ 2]         cmp #lo(jsr_ret)
22610 2 MichaelA
                                     trap_ne
22611 3 MichaelA
3de3 : f002             [ 3]>        beq skip3494
22612
                            >        trap           ;failed equal (zero)
22613
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22614
3de5 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22615
3de6 : 2a                   >        db      test_num
22616
                            >
22617
3de7 :                      >skip3494
22618 2 MichaelA
 
22619
                                     set_stat $ff
22620
                            >            load_flag $ff
22621 3 MichaelA
3de7 : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
22622 2 MichaelA
                            >
22623 3 MichaelA
3de9 : 48               [ 3]>            pha         ;use stack to load status
22624
3dea : 28               [ 4]>            plp
22625 2 MichaelA
 
22626 3 MichaelA
3deb : 68               [ 4]         pla             ;pull x,a
22627
3dec : aa               [ 2]         tax
22628
3ded : 68               [ 4]         pla
22629
3dee : e8               [ 2]         inx             ;return registers with modifications
22630
3def : 49aa             [ 2]         eor #$aa        ;N=1, V=1, Z=0, C=1
22631
3df1 : 60               [ 6]         rts
22632 2 MichaelA
                                     trap            ;runover protection
22633 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22634
3df2 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22635
3df3 : 2a                   >        db      test_num
22636 2 MichaelA
 
22637
 
22638
                             ;trap in case of unexpected IRQ, NMI, BRK, RESET - BRK test target
22639 3 MichaelA
 
22640
3df4 :                       nmi_trap
22641 2 MichaelA
                                     trap            ;check stack for conditions at NMI
22642 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22643
3df4 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22644
3df5 : 2a                   >        db      test_num
22645 2 MichaelA
 
22646 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  392
22647
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22648
 
22649
3df6 :                       res_trap
22650 2 MichaelA
                                     trap            ;unexpected RESET
22651 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22652
3df6 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22653
3df7 : 2a                   >        db      test_num
22654 2 MichaelA
 
22655
 
22656 3 MichaelA
3df8 : 88               [ 2]         dey
22657
3df9 : 88               [ 2]         dey
22658
3dfa :                       irq_trap                ;BRK test or unextpected BRK or IRQ
22659
3dfa : 08               [ 3]         php             ;either SP or Y count will fail, if we do not hit
22660
3dfb : 88               [ 2]         dey
22661
3dfc : 88               [ 2]         dey
22662
3dfd : 88               [ 2]         dey
22663
 
22664 2 MichaelA
                                     ;next 4 traps could be caused by unexpected BRK or IRQ
22665
                                     ;check stack for BREAK and originating location
22666
                                     ;possible jump/branch into weeds (uninitialized space)
22667 3 MichaelA
 
22668
3dfe : c942             [ 2]         cmp #'B'        ;registers loaded?
22669 2 MichaelA
                                     trap_ne
22670 3 MichaelA
3e00 : f002             [ 3]>        beq skip3501
22671
                            >        trap           ;failed equal (zero)
22672
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22673
3e02 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22674
3e03 : 2a                   >        db      test_num
22675
                            >
22676
3e04 :                      >skip3501
22677 2 MichaelA
 
22678 3 MichaelA
3e04 : e052             [ 2]         cpx #'R'
22679 2 MichaelA
                                     trap_ne
22680 3 MichaelA
3e06 : f002             [ 3]>        beq skip3503
22681
                            >        trap           ;failed equal (zero)
22682
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22683
3e08 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22684
3e09 : 2a                   >        db      test_num
22685
                            >
22686
3e0a :                      >skip3503
22687 2 MichaelA
 
22688 3 MichaelA
3e0a : c048             [ 2]         cpy #('K'-3)
22689 2 MichaelA
                                     trap_ne
22690 3 MichaelA
3e0c : f002             [ 3]>        beq skip3505
22691
                            >        trap           ;failed equal (zero)
22692
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22693
3e0e : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22694
3e0f : 2a                   >        db      test_num
22695
                            >
22696
3e10 :                      >skip3505
22697 2 MichaelA
 
22698 3 MichaelA
3e10 : 85b0             [ 3]         sta irq_a       ;save registers during break test
22699
3e12 : 86b1             [ 3]         stx irq_x
22700
3e14 : ba               [ 2]         tsx             ;test break on stack
22701
3e15 : bd0201           [ 4]         lda $102,x
22702 2 MichaelA
                                     cmp_flag 0      ;break test should have B=1
22703 3 MichaelA
3e18 : c930             [ 2]>            cmp #(0      |fao)&m8    ;expected flags + always on bits
22704
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  393
22705 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22706
 
22707
 
22708
                                     trap_ne         ; - no break flag on stack
22709 3 MichaelA
3e1a : f002             [ 3]>        beq skip3508
22710
                            >        trap           ;failed equal (zero)
22711
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22712
3e1c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22713
3e1d : 2a                   >        db      test_num
22714
                            >
22715
3e1e :                      >skip3508
22716 2 MichaelA
 
22717 3 MichaelA
3e1e : 68               [ 4]         pla
22718
3e1f : c934             [ 2]         cmp #$34        ;should have added interrupt disable
22719 2 MichaelA
                                     trap_ne
22720 3 MichaelA
3e21 : f002             [ 3]>        beq skip3510
22721
                            >        trap           ;failed equal (zero)
22722
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22723
3e23 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22724
3e24 : 2a                   >        db      test_num
22725
                            >
22726
3e25 :                      >skip3510
22727 2 MichaelA
 
22728 3 MichaelA
3e25 : ba               [ 2]         tsx
22729
3e26 : e0fc             [ 2]         cpx #$fc        ;sp -3? (return addr, flags)
22730 2 MichaelA
                                     trap_ne
22731 3 MichaelA
3e28 : f002             [ 3]>        beq skip3512
22732
                            >        trap           ;failed equal (zero)
22733
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22734
3e2a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22735
3e2b : 2a                   >        db      test_num
22736
                            >
22737
3e2c :                      >skip3512
22738 2 MichaelA
 
22739 3 MichaelA
3e2c : adff01           [ 4]         lda $1ff        ;propper return on stack
22740
3e2f : c909             [ 2]         cmp #hi(brk_ret)
22741 2 MichaelA
                                     trap_ne
22742 3 MichaelA
3e31 : f002             [ 3]>        beq skip3514
22743
                            >        trap           ;failed equal (zero)
22744
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22745
3e33 : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22746
3e34 : 2a                   >        db      test_num
22747
                            >
22748
3e35 :                      >skip3514
22749 2 MichaelA
 
22750 3 MichaelA
3e35 : adfe01           [ 4]         lda $1fe
22751 2 MichaelA
                             ;        cmp #lo(brk_ret)
22752 3 MichaelA
3e38 : c9ba             [ 2]         cmp #lo(brk_ret - 1)    ; M65C02 treats JSR and traps (NMI, BRK/IRQ, RST) the same; add one to
22753 2 MichaelA
                                     trap_ne
22754 3 MichaelA
3e3a : f002             [ 3]>        beq skip3516
22755
                            >        trap           ;failed equal (zero)
22756
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22757
3e3c : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22758
3e3d : 2a                   >        db      test_num
22759
                            >
22760
3e3e :                      >skip3516
22761 2 MichaelA
 
22762 3 MichaelA
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  394
22763
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22764
 
22765 2 MichaelA
                                     set_stat $ff
22766
                            >            load_flag $ff
22767 3 MichaelA
3e3e : a9ff             [ 2]>            lda #$ff             ;allow test to change I-flag (no mask)
22768 2 MichaelA
                            >
22769 3 MichaelA
3e40 : 48               [ 3]>            pha         ;use stack to load status
22770
3e41 : 28               [ 4]>            plp
22771 2 MichaelA
 
22772 3 MichaelA
3e42 : a6b1             [ 3]         ldx irq_x
22773
3e44 : e8               [ 2]         inx             ;return registers with modifications
22774
3e45 : a5b0             [ 3]         lda irq_a
22775
3e47 : 49aa             [ 2]         eor #$aa        ;N=1, V=1, Z=0, C=1 but original flags should be restored
22776
3e49 : 40               [ 6]         rti
22777 2 MichaelA
                                     trap            ;runover protection
22778 3 MichaelA
                            >;        db      $db         ; M65C02/M65C02A SToP instruction
22779
3e4a : 00               [ 7]>        brk                 ; Use BRK to return to the monitor
22780
3e4b : 2a                   >        db      test_num
22781 2 MichaelA
 
22782
 
22783
                             ;copy of data to initialize BSS segment
22784 3 MichaelA
 
22785 2 MichaelA
                                 if load_data_direct != 1
22786 3 MichaelA
 
22787
3e4c :                       zp_init
22788
3e4c : c3824100              zp1_    db  $c3,$82,$41,0   ;test patterns for LDx BIT ROL ROR ASL LSR
22789
3e50 : 7f                    zp7f_   db  $7f             ;test pattern for compare
22790
 
22791 2 MichaelA
                             ;logical zeropage operands
22792 3 MichaelA
 
22793
3e51 : 001f7180              zpOR_   db  0,$1f,$71,$80   ;test pattern for OR
22794
3e55 : 0fff7f80              zpAN_   db  $0f,$ff,$7f,$80 ;test pattern for AND
22795
3e59 : ff0f8f8f              zpEO_   db  $ff,$0f,$8f,$8f ;test pattern for EOR
22796
 
22797 2 MichaelA
                             ;indirect addressing pointers
22798 3 MichaelA
 
22799
3e5d : 0802                  ind1_   dw  abs1            ;indirect pointer to pattern in absolute memory
22800
3e5f : 0902                          dw  abs1+1
22801
3e61 : 0a02                          dw  abs1+2
22802
3e63 : 0b02                          dw  abs1+3
22803
3e65 : 0c02                          dw  abs7f
22804
3e67 : 1001                  inw1_   dw  abs1-$f8        ;indirect pointer for wrap-test pattern
22805
3e69 : 0302                  indt_   dw  abst            ;indirect pointer to store area in absolute memory
22806
3e6b : 0402                          dw  abst+1
22807
3e6d : 0502                          dw  abst+2
22808
3e6f : 0602                          dw  abst+3
22809
3e71 : 0b01                  inwt_   dw  abst-$f8        ;indirect pointer for wrap-test store
22810
3e73 : 3f02                  indAN_  dw  absAN           ;indirect pointer to AND pattern in absolute memory
22811
3e75 : 4002                          dw  absAN+1
22812
3e77 : 4102                          dw  absAN+2
22813
3e79 : 4202                          dw  absAN+3
22814
3e7b : 4302                  indEO_  dw  absEO           ;indirect pointer to EOR pattern in absolute memory
22815
3e7d : 4402                          dw  absEO+1
22816
3e7f : 4502                          dw  absEO+2
22817
3e81 : 4602                          dw  absEO+3
22818
3e83 : 3b02                  indOR_  dw  absOR           ;indirect pointer to OR pattern in absolute memory
22819
3e85 : 3c02                          dw  absOR+1
22820
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  395
22821 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22822
 
22823 3 MichaelA
3e87 : 3d02                          dw  absOR+2
22824
3e89 : 3e02                          dw  absOR+3
22825
 
22826 2 MichaelA
                             ;add/subtract indirect pointers
22827 3 MichaelA
 
22828
3e8b : 0302                  adi2_   dw  ada2            ;indirect pointer to operand 2 in absolute memory
22829
3e8d : 0402                  sbi2_   dw  sba2            ;indirect pointer to complemented operand 2 (SBC)
22830
3e8f : 0401                  adiy2_  dw  ada2-$ff        ;with offset for indirect indexed
22831
3e91 : 0501                  sbiy2_  dw  sba2-$ff
22832
3e93 :                       zp_end
22833
 
22834 2 MichaelA
                                 if (zp_end - zp_init) != (zp_bss_end - zp_bss)
22835 3 MichaelA
 
22836 2 MichaelA
                                     ;force assembler error if size is different
22837
                                     ERROR ERROR ERROR   ;mismatch between bss and zeropage data
22838 3 MichaelA
 
22839 2 MichaelA
                                 endif
22840 3 MichaelA
 
22841
3e93 :                       data_init
22842
3e93 : c3824100              abs1_   db  $c3,$82,$41,0   ;test patterns for LDx BIT ROL ROR ASL LSR
22843
3e97 : 7f                    abs7f_  db  $7f             ;test pattern for compare
22844
 
22845 2 MichaelA
                             ;loads
22846 3 MichaelA
 
22847
3e98 : 80800002              fLDx_   db  fn,fn,0,fz      ;expected flags for load
22848
 
22849 2 MichaelA
                             ;shifts
22850 3 MichaelA
 
22851
3e9c :                       rASL_                       ;expected result ASL & ROL -carry
22852
3e9c : 86048200              rROL_   db  $86,$04,$82,0   ; "
22853
3ea0 : 87058301              rROLc_  db  $87,$05,$83,1   ;expected result ROL +carry
22854
3ea4 :                       rLSR_                       ;expected result LSR & ROR -carry
22855
3ea4 : 61412000              rROR_   db  $61,$41,$20,0   ; "
22856
3ea8 : e1c1a080              rRORc_  db  $e1,$c1,$a0,$80 ;expected result ROR +carry
22857
3eac :                       fASL_                       ;expected flags for shifts
22858
3eac : 81018002              fROL_   db  fnc,fc,fn,fz    ;no carry in
22859
3eb0 : 81018000              fROLc_  db  fnc,fc,fn,0     ;carry in
22860
3eb4 :                       fLSR_
22861
3eb4 : 01000102              fROR_   db  fc,0,fc,fz      ;no carry in
22862
3eb8 : 81808180              fRORc_  db  fnc,fn,fnc,fn   ;carry in
22863
 
22864 2 MichaelA
                             ;increments (decrements)
22865 3 MichaelA
 
22866
3ebc : 7f80ff0001            rINC_   db  $7f,$80,$ff,0,1 ;expected result for INC/DEC
22867
3ec1 : 0080800200            fINC_   db  0,fn,fn,fz,0    ;expected flags for INC/DEC
22868
 
22869 2 MichaelA
                             ;logical memory operand
22870 3 MichaelA
 
22871
3ec6 : 001f7180              absOR_  db  0,$1f,$71,$80   ;test pattern for OR
22872
3eca : 0fff7f80              absAN_  db  $0f,$ff,$7f,$80 ;test pattern for AND
22873
3ece : ff0f8f8f              absEO_  db  $ff,$0f,$8f,$8f ;test pattern for EOR
22874
 
22875 2 MichaelA
                             ;logical accu operand
22876 3 MichaelA
 
22877
3ed2 : 00f11f00              absORa_ db  0,$f1,$1f,0     ;test pattern for OR
22878
AS65 Assembler for R6502 [1.42].  Copyright 1994-2007, Frank A. Kingswood                                                 Page  396
22879 2 MichaelA
---------------------------------------------------------- 65c02_ft.a65 -----------------------------------------------------------
22880
 
22881 3 MichaelA
3ed6 : f0ffffff              absANa_ db  $f0,$ff,$ff,$ff ;test pattern for AND
22882
3eda : fff0f00f              absEOa_ db  $ff,$f0,$f0,$0f ;test pattern for EOR
22883
 
22884 2 MichaelA
                             ;logical results
22885 3 MichaelA
 
22886
3ede : 00ff7f80              absrlo_ db  0,$ff,$7f,$80
22887
3ee2 : 02800080              absflo_ db  fz,fn,0,fn
22888
 
22889
3ee6 :                       data_end
22890
 
22891 2 MichaelA
                                 if (data_end - data_init) != (data_bss_end - data_bss)
22892 3 MichaelA
 
22893 2 MichaelA
                                     ;force assembler error if size is different
22894
                                     ERROR ERROR ERROR   ;mismatch between bss and data
22895 3 MichaelA
 
22896 2 MichaelA
                                 endif
22897 3 MichaelA
                                     code
22898
3ffa =                               org $3FFA
22899
3ffa :                       vec_init
22900
3ffa : f43d                          dw  nmi_trap
22901
3ffc : f63d                          dw  res_trap
22902
3ffe : fa3d                          dw  irq_trap
22903
fffa =                       vec_bss equ $fffa
22904 2 MichaelA
 
22905 3 MichaelA
                                 endif                   ;end of RAM init data
22906
 
22907
                                 if (load_data_direct = 1) & (ROM_vectors = 1)
22908
 
22909
                                     org $fffa       ;vectors
22910
 
22911 2 MichaelA
                                     dw  nmi_trap
22912
                                     dw  res_trap
22913
                                     dw  irq_trap
22914 3 MichaelA
 
22915 2 MichaelA
                                 endif
22916
fffa =                               end start
22917
 
22918
No errors in pass 2.
22919 3 MichaelA
Wrote binary from address $0000 through $3fff.
22920
Total size 16384 bytes.
22921 2 MichaelA
Program start address is at $0400 (1024).
22922
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.