cpu/fame/famec_opcodes.h

   1
   2 #ifdef PICODRIVE_HACK
   3 #define NOT_POLLING g_m68kcontext->not_polling = 1;
   4 #else
   5 #define NOT_POLLING
   6 #endif
   7
   8 // ORI
   9 OPCODE(0x0000)
  10 {
  11         u32 adr, res;
  12         u32 src, dst;
  13
  14         FETCH_BYTE(src);
  15         res = DREGu8((Opcode >> 0) & 7);
  16         res |= src;
  17         flag_C = 0;
  18         flag_V = 0;
  19         flag_NotZ = res;
  20         flag_N = res;
  21         DREGu8((Opcode >> 0) & 7) = res;
  22 RET(8)
  23 }
  24
  25 // ORI
  26 OPCODE(0x0010)
  27 {
  28         u32 adr, res;
  29         u32 src, dst;
  30
  31         FETCH_BYTE(src);
  32         adr = AREG((Opcode >> 0) & 7);
  33         PRE_IO
  34         READ_BYTE_F(adr, res)
  35         res |= src;
  36         flag_C = 0;
  37         flag_V = 0;
  38         flag_NotZ = res;
  39         flag_N = res;
  40         WRITE_BYTE_F(adr, res)
  41         POST_IO
  42 RET(16)
  43 }
  44
  45 // ORI
  46 OPCODE(0x0018)
  47 {
  48         u32 adr, res;
  49         u32 src, dst;
  50
  51         FETCH_BYTE(src);
  52         adr = AREG((Opcode >> 0) & 7);
  53         AREG((Opcode >> 0) & 7) += 1;
  54         PRE_IO
  55         READ_BYTE_F(adr, res)
  56         res |= src;
  57         flag_C = 0;
  58         flag_V = 0;
  59         flag_NotZ = res;
  60         flag_N = res;
  61         WRITE_BYTE_F(adr, res)
  62         POST_IO
  63 RET(16)
  64 }
  65
  66 // ORI
  67 OPCODE(0x0020)
  68 {
  69         u32 adr, res;
  70         u32 src, dst;
  71
  72         FETCH_BYTE(src);
  73         adr = AREG((Opcode >> 0) & 7) - 1;
  74         AREG((Opcode >> 0) & 7) = adr;
  75         PRE_IO
  76         READ_BYTE_F(adr, res)
  77         res |= src;
  78         flag_C = 0;
  79         flag_V = 0;
  80         flag_NotZ = res;
  81         flag_N = res;
  82         WRITE_BYTE_F(adr, res)
  83         POST_IO
  84 RET(18)
  85 }
  86
  87 // ORI
  88 OPCODE(0x0028)
  89 {
  90         u32 adr, res;
  91         u32 src, dst;
  92
  93         FETCH_BYTE(src);
  94         FETCH_SWORD(adr);
  95         adr += AREG((Opcode >> 0) & 7);
  96         PRE_IO
  97         READ_BYTE_F(adr, res)
  98         res |= src;
  99         flag_C = 0;
 100         flag_V = 0;
 101         flag_NotZ = res;
 102         flag_N = res;
 103         WRITE_BYTE_F(adr, res)
 104         POST_IO
 105 RET(20)
 106 }
 107
 108 // ORI
 109 OPCODE(0x0030)
 110 {
 111         u32 adr, res;
 112         u32 src, dst;
 113
 114         FETCH_BYTE(src);
 115         adr = AREG((Opcode >> 0) & 7);
 116         DECODE_EXT_WORD
 117         PRE_IO
 118         READ_BYTE_F(adr, res)
 119         res |= src;
 120         flag_C = 0;
 121         flag_V = 0;
 122         flag_NotZ = res;
 123         flag_N = res;
 124         WRITE_BYTE_F(adr, res)
 125         POST_IO
 126 RET(22)
 127 }
 128
 129 // ORI
 130 OPCODE(0x0038)
 131 {
 132         u32 adr, res;
 133         u32 src, dst;
 134
 135         FETCH_BYTE(src);
 136         FETCH_SWORD(adr);
 137         PRE_IO
 138         READ_BYTE_F(adr, res)
 139         res |= src;
 140         flag_C = 0;
 141         flag_V = 0;
 142         flag_NotZ = res;
 143         flag_N = res;
 144         WRITE_BYTE_F(adr, res)
 145         POST_IO
 146 RET(20)
 147 }
 148
 149 // ORI
 150 OPCODE(0x0039)
 151 {
 152         u32 adr, res;
 153         u32 src, dst;
 154
 155         FETCH_BYTE(src);
 156         FETCH_LONG(adr);
 157         PRE_IO
 158         READ_BYTE_F(adr, res)
 159         res |= src;
 160         flag_C = 0;
 161         flag_V = 0;
 162         flag_NotZ = res;
 163         flag_N = res;
 164         WRITE_BYTE_F(adr, res)
 165         POST_IO
 166 RET(24)
 167 }
 168
 169 // ORI
 170 OPCODE(0x001F)
 171 {
 172         u32 adr, res;
 173         u32 src, dst;
 174
 175         FETCH_BYTE(src);
 176         adr = AREG(7);
 177         AREG(7) += 2;
 178         PRE_IO
 179         READ_BYTE_F(adr, res)
 180         res |= src;
 181         flag_C = 0;
 182         flag_V = 0;
 183         flag_NotZ = res;
 184         flag_N = res;
 185         WRITE_BYTE_F(adr, res)
 186         POST_IO
 187 RET(16)
 188 }
 189
 190 // ORI
 191 OPCODE(0x0027)
 192 {
 193         u32 adr, res;
 194         u32 src, dst;
 195
 196         FETCH_BYTE(src);
 197         adr = AREG(7) - 2;
 198         AREG(7) = adr;
 199         PRE_IO
 200         READ_BYTE_F(adr, res)
 201         res |= src;
 202         flag_C = 0;
 203         flag_V = 0;
 204         flag_NotZ = res;
 205         flag_N = res;
 206         WRITE_BYTE_F(adr, res)
 207         POST_IO
 208 RET(18)
 209 }
 210
 211 // ORI
 212 OPCODE(0x0040)
 213 {
 214         u32 adr, res;
 215         u32 src, dst;
 216
 217         FETCH_WORD(src);
 218         res = DREGu16((Opcode >> 0) & 7);
 219         res |= src;
 220         flag_C = 0;
 221         flag_V = 0;
 222         flag_NotZ = res;
 223         flag_N = res >> 8;
 224         DREGu16((Opcode >> 0) & 7) = res;
 225 RET(8)
 226 }
 227
 228 // ORI
 229 OPCODE(0x0050)
 230 {
 231         u32 adr, res;
 232         u32 src, dst;
 233
 234         FETCH_WORD(src);
 235         adr = AREG((Opcode >> 0) & 7);
 236         PRE_IO
 237         READ_WORD_F(adr, res)
 238         res |= src;
 239         flag_C = 0;
 240         flag_V = 0;
 241         flag_NotZ = res;
 242         flag_N = res >> 8;
 243         WRITE_WORD_F(adr, res)
 244         POST_IO
 245 RET(16)
 246 }
 247
 248 // ORI
 249 OPCODE(0x0058)
 250 {
 251         u32 adr, res;
 252         u32 src, dst;
 253
 254         FETCH_WORD(src);
 255         adr = AREG((Opcode >> 0) & 7);
 256         AREG((Opcode >> 0) & 7) += 2;
 257         PRE_IO
 258         READ_WORD_F(adr, res)
 259         res |= src;
 260         flag_C = 0;
 261         flag_V = 0;
 262         flag_NotZ = res;
 263         flag_N = res >> 8;
 264         WRITE_WORD_F(adr, res)
 265         POST_IO
 266 RET(16)
 267 }
 268
 269 // ORI
 270 OPCODE(0x0060)
 271 {
 272         u32 adr, res;
 273         u32 src, dst;
 274
 275         FETCH_WORD(src);
 276         adr = AREG((Opcode >> 0) & 7) - 2;
 277         AREG((Opcode >> 0) & 7) = adr;
 278         PRE_IO
 279         READ_WORD_F(adr, res)
 280         res |= src;
 281         flag_C = 0;
 282         flag_V = 0;
 283         flag_NotZ = res;
 284         flag_N = res >> 8;
 285         WRITE_WORD_F(adr, res)
 286         POST_IO
 287 RET(18)
 288 }
 289
 290 // ORI
 291 OPCODE(0x0068)
 292 {
 293         u32 adr, res;
 294         u32 src, dst;
 295
 296         FETCH_WORD(src);
 297         FETCH_SWORD(adr);
 298         adr += AREG((Opcode >> 0) & 7);
 299         PRE_IO
 300         READ_WORD_F(adr, res)
 301         res |= src;
 302         flag_C = 0;
 303         flag_V = 0;
 304         flag_NotZ = res;
 305         flag_N = res >> 8;
 306         WRITE_WORD_F(adr, res)
 307         POST_IO
 308 RET(20)
 309 }
 310
 311 // ORI
 312 OPCODE(0x0070)
 313 {
 314         u32 adr, res;
 315         u32 src, dst;
 316
 317         FETCH_WORD(src);
 318         adr = AREG((Opcode >> 0) & 7);
 319         DECODE_EXT_WORD
 320         PRE_IO
 321         READ_WORD_F(adr, res)
 322         res |= src;
 323         flag_C = 0;
 324         flag_V = 0;
 325         flag_NotZ = res;
 326         flag_N = res >> 8;
 327         WRITE_WORD_F(adr, res)
 328         POST_IO
 329 RET(22)
 330 }
 331
 332 // ORI
 333 OPCODE(0x0078)
 334 {
 335         u32 adr, res;
 336         u32 src, dst;
 337
 338         FETCH_WORD(src);
 339         FETCH_SWORD(adr);
 340         PRE_IO
 341         READ_WORD_F(adr, res)
 342         res |= src;
 343         flag_C = 0;
 344         flag_V = 0;
 345         flag_NotZ = res;
 346         flag_N = res >> 8;
 347         WRITE_WORD_F(adr, res)
 348         POST_IO
 349 RET(20)
 350 }
 351
 352 // ORI
 353 OPCODE(0x0079)
 354 {
 355         u32 adr, res;
 356         u32 src, dst;
 357
 358         FETCH_WORD(src);
 359         FETCH_LONG(adr);
 360         PRE_IO
 361         READ_WORD_F(adr, res)
 362         res |= src;
 363         flag_C = 0;
 364         flag_V = 0;
 365         flag_NotZ = res;
 366         flag_N = res >> 8;
 367         WRITE_WORD_F(adr, res)
 368         POST_IO
 369 RET(24)
 370 }
 371
 372 // ORI
 373 OPCODE(0x005F)
 374 {
 375         u32 adr, res;
 376         u32 src, dst;
 377
 378         FETCH_WORD(src);
 379         adr = AREG(7);
 380         AREG(7) += 2;
 381         PRE_IO
 382         READ_WORD_F(adr, res)
 383         res |= src;
 384         flag_C = 0;
 385         flag_V = 0;
 386         flag_NotZ = res;
 387         flag_N = res >> 8;
 388         WRITE_WORD_F(adr, res)
 389         POST_IO
 390 RET(16)
 391 }
 392
 393 // ORI
 394 OPCODE(0x0067)
 395 {
 396         u32 adr, res;
 397         u32 src, dst;
 398
 399         FETCH_WORD(src);
 400         adr = AREG(7) - 2;
 401         AREG(7) = adr;
 402         PRE_IO
 403         READ_WORD_F(adr, res)
 404         res |= src;
 405         flag_C = 0;
 406         flag_V = 0;
 407         flag_NotZ = res;
 408         flag_N = res >> 8;
 409         WRITE_WORD_F(adr, res)
 410         POST_IO
 411 RET(18)
 412 }
 413
 414 // ORI
 415 OPCODE(0x0080)
 416 {
 417         u32 adr, res;
 418         u32 src, dst;
 419
 420         FETCH_LONG(src);
 421         res = DREGu32((Opcode >> 0) & 7);
 422         res |= src;
 423         flag_C = 0;
 424         flag_V = 0;
 425         flag_NotZ = res;
 426         flag_N = res >> 24;
 427         DREGu32((Opcode >> 0) & 7) = res;
 428 RET(16)
 429 }
 430
 431 // ORI
 432 OPCODE(0x0090)
 433 {
 434         u32 adr, res;
 435         u32 src, dst;
 436
 437         FETCH_LONG(src);
 438         adr = AREG((Opcode >> 0) & 7);
 439         PRE_IO
 440         READ_LONG_F(adr, res)
 441         res |= src;
 442         flag_C = 0;
 443         flag_V = 0;
 444         flag_NotZ = res;
 445         flag_N = res >> 24;
 446         WRITE_LONG_F(adr, res)
 447         POST_IO
 448 RET(28)
 449 }
 450
 451 // ORI
 452 OPCODE(0x0098)
 453 {
 454         u32 adr, res;
 455         u32 src, dst;
 456
 457         FETCH_LONG(src);
 458         adr = AREG((Opcode >> 0) & 7);
 459         AREG((Opcode >> 0) & 7) += 4;
 460         PRE_IO
 461         READ_LONG_F(adr, res)
 462         res |= src;
 463         flag_C = 0;
 464         flag_V = 0;
 465         flag_NotZ = res;
 466         flag_N = res >> 24;
 467         WRITE_LONG_F(adr, res)
 468         POST_IO
 469 RET(28)
 470 }
 471
 472 // ORI
 473 OPCODE(0x00A0)
 474 {
 475         u32 adr, res;
 476         u32 src, dst;
 477
 478         FETCH_LONG(src);
 479         adr = AREG((Opcode >> 0) & 7) - 4;
 480         AREG((Opcode >> 0) & 7) = adr;
 481         PRE_IO
 482         READ_LONG_F(adr, res)
 483         res |= src;
 484         flag_C = 0;
 485         flag_V = 0;
 486         flag_NotZ = res;
 487         flag_N = res >> 24;
 488         WRITE_LONG_F(adr, res)
 489         POST_IO
 490 RET(30)
 491 }
 492
 493 // ORI
 494 OPCODE(0x00A8)
 495 {
 496         u32 adr, res;
 497         u32 src, dst;
 498
 499         FETCH_LONG(src);
 500         FETCH_SWORD(adr);
 501         adr += AREG((Opcode >> 0) & 7);
 502         PRE_IO
 503         READ_LONG_F(adr, res)
 504         res |= src;
 505         flag_C = 0;
 506         flag_V = 0;
 507         flag_NotZ = res;
 508         flag_N = res >> 24;
 509         WRITE_LONG_F(adr, res)
 510         POST_IO
 511 RET(32)
 512 }
 513
 514 // ORI
 515 OPCODE(0x00B0)
 516 {
 517         u32 adr, res;
 518         u32 src, dst;
 519
 520         FETCH_LONG(src);
 521         adr = AREG((Opcode >> 0) & 7);
 522         DECODE_EXT_WORD
 523         PRE_IO
 524         READ_LONG_F(adr, res)
 525         res |= src;
 526         flag_C = 0;
 527         flag_V = 0;
 528         flag_NotZ = res;
 529         flag_N = res >> 24;
 530         WRITE_LONG_F(adr, res)
 531         POST_IO
 532 RET(34)
 533 }
 534
 535 // ORI
 536 OPCODE(0x00B8)
 537 {
 538         u32 adr, res;
 539         u32 src, dst;
 540
 541         FETCH_LONG(src);
 542         FETCH_SWORD(adr);
 543         PRE_IO
 544         READ_LONG_F(adr, res)
 545         res |= src;
 546         flag_C = 0;
 547         flag_V = 0;
 548         flag_NotZ = res;
 549         flag_N = res >> 24;
 550         WRITE_LONG_F(adr, res)
 551         POST_IO
 552 RET(32)
 553 }
 554
 555 // ORI
 556 OPCODE(0x00B9)
 557 {
 558         u32 adr, res;
 559         u32 src, dst;
 560
 561         FETCH_LONG(src);
 562         FETCH_LONG(adr);
 563         PRE_IO
 564         READ_LONG_F(adr, res)
 565         res |= src;
 566         flag_C = 0;
 567         flag_V = 0;
 568         flag_NotZ = res;
 569         flag_N = res >> 24;
 570         WRITE_LONG_F(adr, res)
 571         POST_IO
 572 RET(36)
 573 }
 574
 575 // ORI
 576 OPCODE(0x009F)
 577 {
 578         u32 adr, res;
 579         u32 src, dst;
 580
 581         FETCH_LONG(src);
 582         adr = AREG(7);
 583         AREG(7) += 4;
 584         PRE_IO
 585         READ_LONG_F(adr, res)
 586         res |= src;
 587         flag_C = 0;
 588         flag_V = 0;
 589         flag_NotZ = res;
 590         flag_N = res >> 24;
 591         WRITE_LONG_F(adr, res)
 592         POST_IO
 593 RET(28)
 594 }
 595
 596 // ORI
 597 OPCODE(0x00A7)
 598 {
 599         u32 adr, res;
 600         u32 src, dst;
 601
 602         FETCH_LONG(src);
 603         adr = AREG(7) - 4;
 604         AREG(7) = adr;
 605         PRE_IO
 606         READ_LONG_F(adr, res)
 607         res |= src;
 608         flag_C = 0;
 609         flag_V = 0;
 610         flag_NotZ = res;
 611         flag_N = res >> 24;
 612         WRITE_LONG_F(adr, res)
 613         POST_IO
 614 RET(30)
 615 }
 616
 617 // ORICCR
 618 OPCODE(0x003C)
 619 {
 620         u32 adr, res;
 621         u32 src, dst;
 622
 623         FETCH_BYTE(res);
 624         res &= M68K_CCR_MASK;
 625         res |= GET_CCR;
 626         SET_CCR(res)
 627 RET(20)
 628 }
 629
 630 // ORISR
 631 OPCODE(0x007C)
 632 {
 633         u32 adr, res;
 634         u32 src, dst;
 635
 636         if (flag_S)
 637         {
 638                 u32 res;
 639                 FETCH_WORD(res);
 640                 res &= M68K_SR_MASK;
 641                 res |= GET_SR;
 642                 SET_SR(res)
 643                 CHECK_INT_TO_JUMP(20)
 644         }
 645         else
 646         {
 647                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
 648 #ifdef USE_CYCLONE_TIMING
 649                 RET(0)
 650 #else
 651                 RET(4)
 652 #endif
 653         }
 654 RET(20)
 655 }
 656
 657 // ANDI
 658 OPCODE(0x0200)
 659 {
 660         u32 adr, res;
 661         u32 src, dst;
 662
 663         FETCH_BYTE(src);
 664         res = DREGu8((Opcode >> 0) & 7);
 665         res &= src;
 666         flag_C = 0;
 667         flag_V = 0;
 668         flag_NotZ = res;
 669         flag_N = res;
 670         DREGu8((Opcode >> 0) & 7) = res;
 671 RET(8)
 672 }
 673
 674 // ANDI
 675 OPCODE(0x0210)
 676 {
 677         u32 adr, res;
 678         u32 src, dst;
 679
 680         FETCH_BYTE(src);
 681         adr = AREG((Opcode >> 0) & 7);
 682         PRE_IO
 683         READ_BYTE_F(adr, res)
 684         res &= src;
 685         flag_C = 0;
 686         flag_V = 0;
 687         flag_NotZ = res;
 688         flag_N = res;
 689         WRITE_BYTE_F(adr, res)
 690         POST_IO
 691 RET(16)
 692 }
 693
 694 // ANDI
 695 OPCODE(0x0218)
 696 {
 697         u32 adr, res;
 698         u32 src, dst;
 699
 700         FETCH_BYTE(src);
 701         adr = AREG((Opcode >> 0) & 7);
 702         AREG((Opcode >> 0) & 7) += 1;
 703         PRE_IO
 704         READ_BYTE_F(adr, res)
 705         res &= src;
 706         flag_C = 0;
 707         flag_V = 0;
 708         flag_NotZ = res;
 709         flag_N = res;
 710         WRITE_BYTE_F(adr, res)
 711         POST_IO
 712 RET(16)
 713 }
 714
 715 // ANDI
 716 OPCODE(0x0220)
 717 {
 718         u32 adr, res;
 719         u32 src, dst;
 720
 721         FETCH_BYTE(src);
 722         adr = AREG((Opcode >> 0) & 7) - 1;
 723         AREG((Opcode >> 0) & 7) = adr;
 724         PRE_IO
 725         READ_BYTE_F(adr, res)
 726         res &= src;
 727         flag_C = 0;
 728         flag_V = 0;
 729         flag_NotZ = res;
 730         flag_N = res;
 731         WRITE_BYTE_F(adr, res)
 732         POST_IO
 733 RET(18)
 734 }
 735
 736 // ANDI
 737 OPCODE(0x0228)
 738 {
 739         u32 adr, res;
 740         u32 src, dst;
 741
 742         FETCH_BYTE(src);
 743         FETCH_SWORD(adr);
 744         adr += AREG((Opcode >> 0) & 7);
 745         PRE_IO
 746         READ_BYTE_F(adr, res)
 747         res &= src;
 748         flag_C = 0;
 749         flag_V = 0;
 750         flag_NotZ = res;
 751         flag_N = res;
 752         WRITE_BYTE_F(adr, res)
 753         POST_IO
 754 RET(20)
 755 }
 756
 757 // ANDI
 758 OPCODE(0x0230)
 759 {
 760         u32 adr, res;
 761         u32 src, dst;
 762
 763         FETCH_BYTE(src);
 764         adr = AREG((Opcode >> 0) & 7);
 765         DECODE_EXT_WORD
 766         PRE_IO
 767         READ_BYTE_F(adr, res)
 768         res &= src;
 769         flag_C = 0;
 770         flag_V = 0;
 771         flag_NotZ = res;
 772         flag_N = res;
 773         WRITE_BYTE_F(adr, res)
 774         POST_IO
 775 RET(22)
 776 }
 777
 778 // ANDI
 779 OPCODE(0x0238)
 780 {
 781         u32 adr, res;
 782         u32 src, dst;
 783
 784         FETCH_BYTE(src);
 785         FETCH_SWORD(adr);
 786         PRE_IO
 787         READ_BYTE_F(adr, res)
 788         res &= src;
 789         flag_C = 0;
 790         flag_V = 0;
 791         flag_NotZ = res;
 792         flag_N = res;
 793         WRITE_BYTE_F(adr, res)
 794         POST_IO
 795 RET(20)
 796 }
 797
 798 // ANDI
 799 OPCODE(0x0239)
 800 {
 801         u32 adr, res;
 802         u32 src, dst;
 803
 804         FETCH_BYTE(src);
 805         FETCH_LONG(adr);
 806         PRE_IO
 807         READ_BYTE_F(adr, res)
 808         res &= src;
 809         flag_C = 0;
 810         flag_V = 0;
 811         flag_NotZ = res;
 812         flag_N = res;
 813         WRITE_BYTE_F(adr, res)
 814         POST_IO
 815 RET(24)
 816 }
 817
 818 // ANDI
 819 OPCODE(0x021F)
 820 {
 821         u32 adr, res;
 822         u32 src, dst;
 823
 824         FETCH_BYTE(src);
 825         adr = AREG(7);
 826         AREG(7) += 2;
 827         PRE_IO
 828         READ_BYTE_F(adr, res)
 829         res &= src;
 830         flag_C = 0;
 831         flag_V = 0;
 832         flag_NotZ = res;
 833         flag_N = res;
 834         WRITE_BYTE_F(adr, res)
 835         POST_IO
 836 RET(16)
 837 }
 838
 839 // ANDI
 840 OPCODE(0x0227)
 841 {
 842         u32 adr, res;
 843         u32 src, dst;
 844
 845         FETCH_BYTE(src);
 846         adr = AREG(7) - 2;
 847         AREG(7) = adr;
 848         PRE_IO
 849         READ_BYTE_F(adr, res)
 850         res &= src;
 851         flag_C = 0;
 852         flag_V = 0;
 853         flag_NotZ = res;
 854         flag_N = res;
 855         WRITE_BYTE_F(adr, res)
 856         POST_IO
 857 RET(18)
 858 }
 859
 860 // ANDI
 861 OPCODE(0x0240)
 862 {
 863         u32 adr, res;
 864         u32 src, dst;
 865
 866         FETCH_WORD(src);
 867         res = DREGu16((Opcode >> 0) & 7);
 868         res &= src;
 869         flag_C = 0;
 870         flag_V = 0;
 871         flag_NotZ = res;
 872         flag_N = res >> 8;
 873         DREGu16((Opcode >> 0) & 7) = res;
 874 RET(8)
 875 }
 876
 877 // ANDI
 878 OPCODE(0x0250)
 879 {
 880         u32 adr, res;
 881         u32 src, dst;
 882
 883         FETCH_WORD(src);
 884         adr = AREG((Opcode >> 0) & 7);
 885         PRE_IO
 886         READ_WORD_F(adr, res)
 887         res &= src;
 888         flag_C = 0;
 889         flag_V = 0;
 890         flag_NotZ = res;
 891         flag_N = res >> 8;
 892         WRITE_WORD_F(adr, res)
 893         POST_IO
 894 RET(16)
 895 }
 896
 897 // ANDI
 898 OPCODE(0x0258)
 899 {
 900         u32 adr, res;
 901         u32 src, dst;
 902
 903         FETCH_WORD(src);
 904         adr = AREG((Opcode >> 0) & 7);
 905         AREG((Opcode >> 0) & 7) += 2;
 906         PRE_IO
 907         READ_WORD_F(adr, res)
 908         res &= src;
 909         flag_C = 0;
 910         flag_V = 0;
 911         flag_NotZ = res;
 912         flag_N = res >> 8;
 913         WRITE_WORD_F(adr, res)
 914         POST_IO
 915 RET(16)
 916 }
 917
 918 // ANDI
 919 OPCODE(0x0260)
 920 {
 921         u32 adr, res;
 922         u32 src, dst;
 923
 924         FETCH_WORD(src);
 925         adr = AREG((Opcode >> 0) & 7) - 2;
 926         AREG((Opcode >> 0) & 7) = adr;
 927         PRE_IO
 928         READ_WORD_F(adr, res)
 929         res &= src;
 930         flag_C = 0;
 931         flag_V = 0;
 932         flag_NotZ = res;
 933         flag_N = res >> 8;
 934         WRITE_WORD_F(adr, res)
 935         POST_IO
 936 RET(18)
 937 }
 938
 939 // ANDI
 940 OPCODE(0x0268)
 941 {
 942         u32 adr, res;
 943         u32 src, dst;
 944
 945         FETCH_WORD(src);
 946         FETCH_SWORD(adr);
 947         adr += AREG((Opcode >> 0) & 7);
 948         PRE_IO
 949         READ_WORD_F(adr, res)
 950         res &= src;
 951         flag_C = 0;
 952         flag_V = 0;
 953         flag_NotZ = res;
 954         flag_N = res >> 8;
 955         WRITE_WORD_F(adr, res)
 956         POST_IO
 957 RET(20)
 958 }
 959
 960 // ANDI
 961 OPCODE(0x0270)
 962 {
 963         u32 adr, res;
 964         u32 src, dst;
 965
 966         FETCH_WORD(src);
 967         adr = AREG((Opcode >> 0) & 7);
 968         DECODE_EXT_WORD
 969         PRE_IO
 970         READ_WORD_F(adr, res)
 971         res &= src;
 972         flag_C = 0;
 973         flag_V = 0;
 974         flag_NotZ = res;
 975         flag_N = res >> 8;
 976         WRITE_WORD_F(adr, res)
 977         POST_IO
 978 RET(22)
 979 }
 980
 981 // ANDI
 982 OPCODE(0x0278)
 983 {
 984         u32 adr, res;
 985         u32 src, dst;
 986
 987         FETCH_WORD(src);
 988         FETCH_SWORD(adr);
 989         PRE_IO
 990         READ_WORD_F(adr, res)
 991         res &= src;
 992         flag_C = 0;
 993         flag_V = 0;
 994         flag_NotZ = res;
 995         flag_N = res >> 8;
 996         WRITE_WORD_F(adr, res)
 997         POST_IO
 998 RET(20)
 999 }
1000
1001 // ANDI
1002 OPCODE(0x0279)
1003 {
1004         u32 adr, res;
1005         u32 src, dst;
1006
1007         FETCH_WORD(src);
1008         FETCH_LONG(adr);
1009         PRE_IO
1010         READ_WORD_F(adr, res)
1011         res &= src;
1012         flag_C = 0;
1013         flag_V = 0;
1014         flag_NotZ = res;
1015         flag_N = res >> 8;
1016         WRITE_WORD_F(adr, res)
1017         POST_IO
1018 RET(24)
1019 }
1020
1021 // ANDI
1022 OPCODE(0x025F)
1023 {
1024         u32 adr, res;
1025         u32 src, dst;
1026
1027         FETCH_WORD(src);
1028         adr = AREG(7);
1029         AREG(7) += 2;
1030         PRE_IO
1031         READ_WORD_F(adr, res)
1032         res &= src;
1033         flag_C = 0;
1034         flag_V = 0;
1035         flag_NotZ = res;
1036         flag_N = res >> 8;
1037         WRITE_WORD_F(adr, res)
1038         POST_IO
1039 RET(16)
1040 }
1041
1042 // ANDI
1043 OPCODE(0x0267)
1044 {
1045         u32 adr, res;
1046         u32 src, dst;
1047
1048         FETCH_WORD(src);
1049         adr = AREG(7) - 2;
1050         AREG(7) = adr;
1051         PRE_IO
1052         READ_WORD_F(adr, res)
1053         res &= src;
1054         flag_C = 0;
1055         flag_V = 0;
1056         flag_NotZ = res;
1057         flag_N = res >> 8;
1058         WRITE_WORD_F(adr, res)
1059         POST_IO
1060 RET(18)
1061 }
1062
1063 // ANDI
1064 OPCODE(0x0280)
1065 {
1066         u32 adr, res;
1067         u32 src, dst;
1068
1069         FETCH_LONG(src);
1070         res = DREGu32((Opcode >> 0) & 7);
1071         res &= src;
1072         flag_C = 0;
1073         flag_V = 0;
1074         flag_NotZ = res;
1075         flag_N = res >> 24;
1076         DREGu32((Opcode >> 0) & 7) = res;
1077 #ifdef USE_CYCLONE_TIMING
1078 RET(14)
1079 #else
1080 RET(16)
1081 #endif
1082 }
1083
1084 // ANDI
1085 OPCODE(0x0290)
1086 {
1087         u32 adr, res;
1088         u32 src, dst;
1089
1090         FETCH_LONG(src);
1091         adr = AREG((Opcode >> 0) & 7);
1092         PRE_IO
1093         READ_LONG_F(adr, res)
1094         res &= src;
1095         flag_C = 0;
1096         flag_V = 0;
1097         flag_NotZ = res;
1098         flag_N = res >> 24;
1099         WRITE_LONG_F(adr, res)
1100         POST_IO
1101 RET(28)
1102 }
1103
1104 // ANDI
1105 OPCODE(0x0298)
1106 {
1107         u32 adr, res;
1108         u32 src, dst;
1109
1110         FETCH_LONG(src);
1111         adr = AREG((Opcode >> 0) & 7);
1112         AREG((Opcode >> 0) & 7) += 4;
1113         PRE_IO
1114         READ_LONG_F(adr, res)
1115         res &= src;
1116         flag_C = 0;
1117         flag_V = 0;
1118         flag_NotZ = res;
1119         flag_N = res >> 24;
1120         WRITE_LONG_F(adr, res)
1121         POST_IO
1122 RET(28)
1123 }
1124
1125 // ANDI
1126 OPCODE(0x02A0)
1127 {
1128         u32 adr, res;
1129         u32 src, dst;
1130
1131         FETCH_LONG(src);
1132         adr = AREG((Opcode >> 0) & 7) - 4;
1133         AREG((Opcode >> 0) & 7) = adr;
1134         PRE_IO
1135         READ_LONG_F(adr, res)
1136         res &= src;
1137         flag_C = 0;
1138         flag_V = 0;
1139         flag_NotZ = res;
1140         flag_N = res >> 24;
1141         WRITE_LONG_F(adr, res)
1142         POST_IO
1143 RET(30)
1144 }
1145
1146 // ANDI
1147 OPCODE(0x02A8)
1148 {
1149         u32 adr, res;
1150         u32 src, dst;
1151
1152         FETCH_LONG(src);
1153         FETCH_SWORD(adr);
1154         adr += AREG((Opcode >> 0) & 7);
1155         PRE_IO
1156         READ_LONG_F(adr, res)
1157         res &= src;
1158         flag_C = 0;
1159         flag_V = 0;
1160         flag_NotZ = res;
1161         flag_N = res >> 24;
1162         WRITE_LONG_F(adr, res)
1163         POST_IO
1164 RET(32)
1165 }
1166
1167 // ANDI
1168 OPCODE(0x02B0)
1169 {
1170         u32 adr, res;
1171         u32 src, dst;
1172
1173         FETCH_LONG(src);
1174         adr = AREG((Opcode >> 0) & 7);
1175         DECODE_EXT_WORD
1176         PRE_IO
1177         READ_LONG_F(adr, res)
1178         res &= src;
1179         flag_C = 0;
1180         flag_V = 0;
1181         flag_NotZ = res;
1182         flag_N = res >> 24;
1183         WRITE_LONG_F(adr, res)
1184         POST_IO
1185 RET(34)
1186 }
1187
1188 // ANDI
1189 OPCODE(0x02B8)
1190 {
1191         u32 adr, res;
1192         u32 src, dst;
1193
1194         FETCH_LONG(src);
1195         FETCH_SWORD(adr);
1196         PRE_IO
1197         READ_LONG_F(adr, res)
1198         res &= src;
1199         flag_C = 0;
1200         flag_V = 0;
1201         flag_NotZ = res;
1202         flag_N = res >> 24;
1203         WRITE_LONG_F(adr, res)
1204         POST_IO
1205 RET(32)
1206 }
1207
1208 // ANDI
1209 OPCODE(0x02B9)
1210 {
1211         u32 adr, res;
1212         u32 src, dst;
1213
1214         FETCH_LONG(src);
1215         FETCH_LONG(adr);
1216         PRE_IO
1217         READ_LONG_F(adr, res)
1218         res &= src;
1219         flag_C = 0;
1220         flag_V = 0;
1221         flag_NotZ = res;
1222         flag_N = res >> 24;
1223         WRITE_LONG_F(adr, res)
1224         POST_IO
1225 RET(36)
1226 }
1227
1228 // ANDI
1229 OPCODE(0x029F)
1230 {
1231         u32 adr, res;
1232         u32 src, dst;
1233
1234         FETCH_LONG(src);
1235         adr = AREG(7);
1236         AREG(7) += 4;
1237         PRE_IO
1238         READ_LONG_F(adr, res)
1239         res &= src;
1240         flag_C = 0;
1241         flag_V = 0;
1242         flag_NotZ = res;
1243         flag_N = res >> 24;
1244         WRITE_LONG_F(adr, res)
1245         POST_IO
1246 RET(28)
1247 }
1248
1249 // ANDI
1250 OPCODE(0x02A7)
1251 {
1252         u32 adr, res;
1253         u32 src, dst;
1254
1255         FETCH_LONG(src);
1256         adr = AREG(7) - 4;
1257         AREG(7) = adr;
1258         PRE_IO
1259         READ_LONG_F(adr, res)
1260         res &= src;
1261         flag_C = 0;
1262         flag_V = 0;
1263         flag_NotZ = res;
1264         flag_N = res >> 24;
1265         WRITE_LONG_F(adr, res)
1266         POST_IO
1267 RET(30)
1268 }
1269
1270 // ANDICCR
1271 OPCODE(0x023C)
1272 {
1273         u32 adr, res;
1274         u32 src, dst;
1275
1276         FETCH_BYTE(res);
1277         res &= M68K_CCR_MASK;
1278         res &= GET_CCR;
1279         SET_CCR(res)
1280 RET(20)
1281 }
1282
1283 // ANDISR
1284 OPCODE(0x027C)
1285 {
1286         u32 adr, res;
1287         u32 src, dst;
1288
1289         if (flag_S)
1290         {
1291                 FETCH_WORD(res);
1292                 res &= M68K_SR_MASK;
1293                 res &= GET_SR;
1294                 SET_SR(res)
1295                 if (!flag_S)
1296                 {
1297                         res = AREG(7);
1298                         AREG(7) = ASP;
1299                         ASP = res;
1300                 }
1301                 CHECK_INT_TO_JUMP(20)
1302         }
1303         else
1304         {
1305                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
1306                 RET(4)
1307         }
1308 RET(20)
1309 }
1310
1311 // EORI
1312 OPCODE(0x0A00)
1313 {
1314         u32 adr, res;
1315         u32 src, dst;
1316
1317         FETCH_BYTE(src);
1318         res = DREGu8((Opcode >> 0) & 7);
1319         res ^= src;
1320         flag_C = 0;
1321         flag_V = 0;
1322         flag_NotZ = res;
1323         flag_N = res;
1324         DREGu8((Opcode >> 0) & 7) = res;
1325 RET(8)
1326 }
1327
1328 // EORI
1329 OPCODE(0x0A10)
1330 {
1331         u32 adr, res;
1332         u32 src, dst;
1333
1334         FETCH_BYTE(src);
1335         adr = AREG((Opcode >> 0) & 7);
1336         PRE_IO
1337         READ_BYTE_F(adr, res)
1338         res ^= src;
1339         flag_C = 0;
1340         flag_V = 0;
1341         flag_NotZ = res;
1342         flag_N = res;
1343         WRITE_BYTE_F(adr, res)
1344         POST_IO
1345 RET(16)
1346 }
1347
1348 // EORI
1349 OPCODE(0x0A18)
1350 {
1351         u32 adr, res;
1352         u32 src, dst;
1353
1354         FETCH_BYTE(src);
1355         adr = AREG((Opcode >> 0) & 7);
1356         AREG((Opcode >> 0) & 7) += 1;
1357         PRE_IO
1358         READ_BYTE_F(adr, res)
1359         res ^= src;
1360         flag_C = 0;
1361         flag_V = 0;
1362         flag_NotZ = res;
1363         flag_N = res;
1364         WRITE_BYTE_F(adr, res)
1365         POST_IO
1366 RET(16)
1367 }
1368
1369 // EORI
1370 OPCODE(0x0A20)
1371 {
1372         u32 adr, res;
1373         u32 src, dst;
1374
1375         FETCH_BYTE(src);
1376         adr = AREG((Opcode >> 0) & 7) - 1;
1377         AREG((Opcode >> 0) & 7) = adr;
1378         PRE_IO
1379         READ_BYTE_F(adr, res)
1380         res ^= src;
1381         flag_C = 0;
1382         flag_V = 0;
1383         flag_NotZ = res;
1384         flag_N = res;
1385         WRITE_BYTE_F(adr, res)
1386         POST_IO
1387 RET(18)
1388 }
1389
1390 // EORI
1391 OPCODE(0x0A28)
1392 {
1393         u32 adr, res;
1394         u32 src, dst;
1395
1396         FETCH_BYTE(src);
1397         FETCH_SWORD(adr);
1398         adr += AREG((Opcode >> 0) & 7);
1399         PRE_IO
1400         READ_BYTE_F(adr, res)
1401         res ^= src;
1402         flag_C = 0;
1403         flag_V = 0;
1404         flag_NotZ = res;
1405         flag_N = res;
1406         WRITE_BYTE_F(adr, res)
1407         POST_IO
1408 RET(20)
1409 }
1410
1411 // EORI
1412 OPCODE(0x0A30)
1413 {
1414         u32 adr, res;
1415         u32 src, dst;
1416
1417         FETCH_BYTE(src);
1418         adr = AREG((Opcode >> 0) & 7);
1419         DECODE_EXT_WORD
1420         PRE_IO
1421         READ_BYTE_F(adr, res)
1422         res ^= src;
1423         flag_C = 0;
1424         flag_V = 0;
1425         flag_NotZ = res;
1426         flag_N = res;
1427         WRITE_BYTE_F(adr, res)
1428         POST_IO
1429 RET(22)
1430 }
1431
1432 // EORI
1433 OPCODE(0x0A38)
1434 {
1435         u32 adr, res;
1436         u32 src, dst;
1437
1438         FETCH_BYTE(src);
1439         FETCH_SWORD(adr);
1440         PRE_IO
1441         READ_BYTE_F(adr, res)
1442         res ^= src;
1443         flag_C = 0;
1444         flag_V = 0;
1445         flag_NotZ = res;
1446         flag_N = res;
1447         WRITE_BYTE_F(adr, res)
1448         POST_IO
1449 RET(20)
1450 }
1451
1452 // EORI
1453 OPCODE(0x0A39)
1454 {
1455         u32 adr, res;
1456         u32 src, dst;
1457
1458         FETCH_BYTE(src);
1459         FETCH_LONG(adr);
1460         PRE_IO
1461         READ_BYTE_F(adr, res)
1462         res ^= src;
1463         flag_C = 0;
1464         flag_V = 0;
1465         flag_NotZ = res;
1466         flag_N = res;
1467         WRITE_BYTE_F(adr, res)
1468         POST_IO
1469 RET(24)
1470 }
1471
1472 // EORI
1473 OPCODE(0x0A1F)
1474 {
1475         u32 adr, res;
1476         u32 src, dst;
1477
1478         FETCH_BYTE(src);
1479         adr = AREG(7);
1480         AREG(7) += 2;
1481         PRE_IO
1482         READ_BYTE_F(adr, res)
1483         res ^= src;
1484         flag_C = 0;
1485         flag_V = 0;
1486         flag_NotZ = res;
1487         flag_N = res;
1488         WRITE_BYTE_F(adr, res)
1489         POST_IO
1490 RET(16)
1491 }
1492
1493 // EORI
1494 OPCODE(0x0A27)
1495 {
1496         u32 adr, res;
1497         u32 src, dst;
1498
1499         FETCH_BYTE(src);
1500         adr = AREG(7) - 2;
1501         AREG(7) = adr;
1502         PRE_IO
1503         READ_BYTE_F(adr, res)
1504         res ^= src;
1505         flag_C = 0;
1506         flag_V = 0;
1507         flag_NotZ = res;
1508         flag_N = res;
1509         WRITE_BYTE_F(adr, res)
1510         POST_IO
1511 RET(18)
1512 }
1513
1514 // EORI
1515 OPCODE(0x0A40)
1516 {
1517         u32 adr, res;
1518         u32 src, dst;
1519
1520         FETCH_WORD(src);
1521         res = DREGu16((Opcode >> 0) & 7);
1522         res ^= src;
1523         flag_C = 0;
1524         flag_V = 0;
1525         flag_NotZ = res;
1526         flag_N = res >> 8;
1527         DREGu16((Opcode >> 0) & 7) = res;
1528 RET(8)
1529 }
1530
1531 // EORI
1532 OPCODE(0x0A50)
1533 {
1534         u32 adr, res;
1535         u32 src, dst;
1536
1537         FETCH_WORD(src);
1538         adr = AREG((Opcode >> 0) & 7);
1539         PRE_IO
1540         READ_WORD_F(adr, res)
1541         res ^= src;
1542         flag_C = 0;
1543         flag_V = 0;
1544         flag_NotZ = res;
1545         flag_N = res >> 8;
1546         WRITE_WORD_F(adr, res)
1547         POST_IO
1548 RET(16)
1549 }
1550
1551 // EORI
1552 OPCODE(0x0A58)
1553 {
1554         u32 adr, res;
1555         u32 src, dst;
1556
1557         FETCH_WORD(src);
1558         adr = AREG((Opcode >> 0) & 7);
1559         AREG((Opcode >> 0) & 7) += 2;
1560         PRE_IO
1561         READ_WORD_F(adr, res)
1562         res ^= src;
1563         flag_C = 0;
1564         flag_V = 0;
1565         flag_NotZ = res;
1566         flag_N = res >> 8;
1567         WRITE_WORD_F(adr, res)
1568         POST_IO
1569 RET(16)
1570 }
1571
1572 // EORI
1573 OPCODE(0x0A60)
1574 {
1575         u32 adr, res;
1576         u32 src, dst;
1577
1578         FETCH_WORD(src);
1579         adr = AREG((Opcode >> 0) & 7) - 2;
1580         AREG((Opcode >> 0) & 7) = adr;
1581         PRE_IO
1582         READ_WORD_F(adr, res)
1583         res ^= src;
1584         flag_C = 0;
1585         flag_V = 0;
1586         flag_NotZ = res;
1587         flag_N = res >> 8;
1588         WRITE_WORD_F(adr, res)
1589         POST_IO
1590 RET(18)
1591 }
1592
1593 // EORI
1594 OPCODE(0x0A68)
1595 {
1596         u32 adr, res;
1597         u32 src, dst;
1598
1599         FETCH_WORD(src);
1600         FETCH_SWORD(adr);
1601         adr += AREG((Opcode >> 0) & 7);
1602         PRE_IO
1603         READ_WORD_F(adr, res)
1604         res ^= src;
1605         flag_C = 0;
1606         flag_V = 0;
1607         flag_NotZ = res;
1608         flag_N = res >> 8;
1609         WRITE_WORD_F(adr, res)
1610         POST_IO
1611 RET(20)
1612 }
1613
1614 // EORI
1615 OPCODE(0x0A70)
1616 {
1617         u32 adr, res;
1618         u32 src, dst;
1619
1620         FETCH_WORD(src);
1621         adr = AREG((Opcode >> 0) & 7);
1622         DECODE_EXT_WORD
1623         PRE_IO
1624         READ_WORD_F(adr, res)
1625         res ^= src;
1626         flag_C = 0;
1627         flag_V = 0;
1628         flag_NotZ = res;
1629         flag_N = res >> 8;
1630         WRITE_WORD_F(adr, res)
1631         POST_IO
1632 RET(22)
1633 }
1634
1635 // EORI
1636 OPCODE(0x0A78)
1637 {
1638         u32 adr, res;
1639         u32 src, dst;
1640
1641         FETCH_WORD(src);
1642         FETCH_SWORD(adr);
1643         PRE_IO
1644         READ_WORD_F(adr, res)
1645         res ^= src;
1646         flag_C = 0;
1647         flag_V = 0;
1648         flag_NotZ = res;
1649         flag_N = res >> 8;
1650         WRITE_WORD_F(adr, res)
1651         POST_IO
1652 RET(20)
1653 }
1654
1655 // EORI
1656 OPCODE(0x0A79)
1657 {
1658         u32 adr, res;
1659         u32 src, dst;
1660
1661         FETCH_WORD(src);
1662         FETCH_LONG(adr);
1663         PRE_IO
1664         READ_WORD_F(adr, res)
1665         res ^= src;
1666         flag_C = 0;
1667         flag_V = 0;
1668         flag_NotZ = res;
1669         flag_N = res >> 8;
1670         WRITE_WORD_F(adr, res)
1671         POST_IO
1672 RET(24)
1673 }
1674
1675 // EORI
1676 OPCODE(0x0A5F)
1677 {
1678         u32 adr, res;
1679         u32 src, dst;
1680
1681         FETCH_WORD(src);
1682         adr = AREG(7);
1683         AREG(7) += 2;
1684         PRE_IO
1685         READ_WORD_F(adr, res)
1686         res ^= src;
1687         flag_C = 0;
1688         flag_V = 0;
1689         flag_NotZ = res;
1690         flag_N = res >> 8;
1691         WRITE_WORD_F(adr, res)
1692         POST_IO
1693 RET(16)
1694 }
1695
1696 // EORI
1697 OPCODE(0x0A67)
1698 {
1699         u32 adr, res;
1700         u32 src, dst;
1701
1702         FETCH_WORD(src);
1703         adr = AREG(7) - 2;
1704         AREG(7) = adr;
1705         PRE_IO
1706         READ_WORD_F(adr, res)
1707         res ^= src;
1708         flag_C = 0;
1709         flag_V = 0;
1710         flag_NotZ = res;
1711         flag_N = res >> 8;
1712         WRITE_WORD_F(adr, res)
1713         POST_IO
1714 RET(18)
1715 }
1716
1717 // EORI
1718 OPCODE(0x0A80)
1719 {
1720         u32 adr, res;
1721         u32 src, dst;
1722
1723         FETCH_LONG(src);
1724         res = DREGu32((Opcode >> 0) & 7);
1725         res ^= src;
1726         flag_C = 0;
1727         flag_V = 0;
1728         flag_NotZ = res;
1729         flag_N = res >> 24;
1730         DREGu32((Opcode >> 0) & 7) = res;
1731 RET(16)
1732 }
1733
1734 // EORI
1735 OPCODE(0x0A90)
1736 {
1737         u32 adr, res;
1738         u32 src, dst;
1739
1740         FETCH_LONG(src);
1741         adr = AREG((Opcode >> 0) & 7);
1742         PRE_IO
1743         READ_LONG_F(adr, res)
1744         res ^= src;
1745         flag_C = 0;
1746         flag_V = 0;
1747         flag_NotZ = res;
1748         flag_N = res >> 24;
1749         WRITE_LONG_F(adr, res)
1750         POST_IO
1751 RET(28)
1752 }
1753
1754 // EORI
1755 OPCODE(0x0A98)
1756 {
1757         u32 adr, res;
1758         u32 src, dst;
1759
1760         FETCH_LONG(src);
1761         adr = AREG((Opcode >> 0) & 7);
1762         AREG((Opcode >> 0) & 7) += 4;
1763         PRE_IO
1764         READ_LONG_F(adr, res)
1765         res ^= src;
1766         flag_C = 0;
1767         flag_V = 0;
1768         flag_NotZ = res;
1769         flag_N = res >> 24;
1770         WRITE_LONG_F(adr, res)
1771         POST_IO
1772 RET(28)
1773 }
1774
1775 // EORI
1776 OPCODE(0x0AA0)
1777 {
1778         u32 adr, res;
1779         u32 src, dst;
1780
1781         FETCH_LONG(src);
1782         adr = AREG((Opcode >> 0) & 7) - 4;
1783         AREG((Opcode >> 0) & 7) = adr;
1784         PRE_IO
1785         READ_LONG_F(adr, res)
1786         res ^= src;
1787         flag_C = 0;
1788         flag_V = 0;
1789         flag_NotZ = res;
1790         flag_N = res >> 24;
1791         WRITE_LONG_F(adr, res)
1792         POST_IO
1793 RET(30)
1794 }
1795
1796 // EORI
1797 OPCODE(0x0AA8)
1798 {
1799         u32 adr, res;
1800         u32 src, dst;
1801
1802         FETCH_LONG(src);
1803         FETCH_SWORD(adr);
1804         adr += AREG((Opcode >> 0) & 7);
1805         PRE_IO
1806         READ_LONG_F(adr, res)
1807         res ^= src;
1808         flag_C = 0;
1809         flag_V = 0;
1810         flag_NotZ = res;
1811         flag_N = res >> 24;
1812         WRITE_LONG_F(adr, res)
1813         POST_IO
1814 RET(32)
1815 }
1816
1817 // EORI
1818 OPCODE(0x0AB0)
1819 {
1820         u32 adr, res;
1821         u32 src, dst;
1822
1823         FETCH_LONG(src);
1824         adr = AREG((Opcode >> 0) & 7);
1825         DECODE_EXT_WORD
1826         PRE_IO
1827         READ_LONG_F(adr, res)
1828         res ^= src;
1829         flag_C = 0;
1830         flag_V = 0;
1831         flag_NotZ = res;
1832         flag_N = res >> 24;
1833         WRITE_LONG_F(adr, res)
1834         POST_IO
1835 RET(34)
1836 }
1837
1838 // EORI
1839 OPCODE(0x0AB8)
1840 {
1841         u32 adr, res;
1842         u32 src, dst;
1843
1844         FETCH_LONG(src);
1845         FETCH_SWORD(adr);
1846         PRE_IO
1847         READ_LONG_F(adr, res)
1848         res ^= src;
1849         flag_C = 0;
1850         flag_V = 0;
1851         flag_NotZ = res;
1852         flag_N = res >> 24;
1853         WRITE_LONG_F(adr, res)
1854         POST_IO
1855 RET(32)
1856 }
1857
1858 // EORI
1859 OPCODE(0x0AB9)
1860 {
1861         u32 adr, res;
1862         u32 src, dst;
1863
1864         FETCH_LONG(src);
1865         FETCH_LONG(adr);
1866         PRE_IO
1867         READ_LONG_F(adr, res)
1868         res ^= src;
1869         flag_C = 0;
1870         flag_V = 0;
1871         flag_NotZ = res;
1872         flag_N = res >> 24;
1873         WRITE_LONG_F(adr, res)
1874         POST_IO
1875 RET(36)
1876 }
1877
1878 // EORI
1879 OPCODE(0x0A9F)
1880 {
1881         u32 adr, res;
1882         u32 src, dst;
1883
1884         FETCH_LONG(src);
1885         adr = AREG(7);
1886         AREG(7) += 4;
1887         PRE_IO
1888         READ_LONG_F(adr, res)
1889         res ^= src;
1890         flag_C = 0;
1891         flag_V = 0;
1892         flag_NotZ = res;
1893         flag_N = res >> 24;
1894         WRITE_LONG_F(adr, res)
1895         POST_IO
1896 RET(28)
1897 }
1898
1899 // EORI
1900 OPCODE(0x0AA7)
1901 {
1902         u32 adr, res;
1903         u32 src, dst;
1904
1905         FETCH_LONG(src);
1906         adr = AREG(7) - 4;
1907         AREG(7) = adr;
1908         PRE_IO
1909         READ_LONG_F(adr, res)
1910         res ^= src;
1911         flag_C = 0;
1912         flag_V = 0;
1913         flag_NotZ = res;
1914         flag_N = res >> 24;
1915         WRITE_LONG_F(adr, res)
1916         POST_IO
1917 RET(30)
1918 }
1919
1920 // EORICCR
1921 OPCODE(0x0A3C)
1922 {
1923         u32 adr, res;
1924         u32 src, dst;
1925
1926         FETCH_BYTE(res);
1927         res &= M68K_CCR_MASK;
1928         res ^= GET_CCR;
1929         SET_CCR(res)
1930 RET(20)
1931 }
1932
1933 // EORISR
1934 OPCODE(0x0A7C)
1935 {
1936         u32 adr, res;
1937         u32 src, dst;
1938
1939         if (flag_S)
1940         {
1941                 FETCH_WORD(res);
1942                 res &= M68K_SR_MASK;
1943                 res ^= GET_SR;
1944                 SET_SR(res)
1945                 if (!flag_S)
1946                 {
1947                         res = AREG(7);
1948                         AREG(7) = ASP;
1949                         ASP = res;
1950                 }
1951                 CHECK_INT_TO_JUMP(20)
1952         }
1953         else
1954         {
1955                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
1956                 RET(0)
1957         }
1958 RET(20)
1959 }
1960
1961 // SUBI
1962 OPCODE(0x0400)
1963 {
1964         u32 adr, res;
1965         u32 src, dst;
1966
1967         FETCH_BYTE(src);
1968         dst = DREGu8((Opcode >> 0) & 7);
1969         res = dst - src;
1970         flag_N = flag_X = flag_C = res;
1971         flag_V = (src ^ dst) & (res ^ dst);
1972         flag_NotZ = res & 0xFF;
1973         DREGu8((Opcode >> 0) & 7) = res;
1974 RET(8)
1975 }
1976
1977 // SUBI
1978 OPCODE(0x0410)
1979 {
1980         u32 adr, res;
1981         u32 src, dst;
1982
1983         FETCH_BYTE(src);
1984         adr = AREG((Opcode >> 0) & 7);
1985         PRE_IO
1986         READ_BYTE_F(adr, dst)
1987         res = dst - src;
1988         flag_N = flag_X = flag_C = res;
1989         flag_V = (src ^ dst) & (res ^ dst);
1990         flag_NotZ = res & 0xFF;
1991         WRITE_BYTE_F(adr, res)
1992         POST_IO
1993 RET(16)
1994 }
1995
1996 // SUBI
1997 OPCODE(0x0418)
1998 {
1999         u32 adr, res;
2000         u32 src, dst;
2001
2002         FETCH_BYTE(src);
2003         adr = AREG((Opcode >> 0) & 7);
2004         AREG((Opcode >> 0) & 7) += 1;
2005         PRE_IO
2006         READ_BYTE_F(adr, dst)
2007         res = dst - src;
2008         flag_N = flag_X = flag_C = res;
2009         flag_V = (src ^ dst) & (res ^ dst);
2010         flag_NotZ = res & 0xFF;
2011         WRITE_BYTE_F(adr, res)
2012         POST_IO
2013 RET(16)
2014 }
2015
2016 // SUBI
2017 OPCODE(0x0420)
2018 {
2019         u32 adr, res;
2020         u32 src, dst;
2021
2022         FETCH_BYTE(src);
2023         adr = AREG((Opcode >> 0) & 7) - 1;
2024         AREG((Opcode >> 0) & 7) = adr;
2025         PRE_IO
2026         READ_BYTE_F(adr, dst)
2027         res = dst - src;
2028         flag_N = flag_X = flag_C = res;
2029         flag_V = (src ^ dst) & (res ^ dst);
2030         flag_NotZ = res & 0xFF;
2031         WRITE_BYTE_F(adr, res)
2032         POST_IO
2033 RET(18)
2034 }
2035
2036 // SUBI
2037 OPCODE(0x0428)
2038 {
2039         u32 adr, res;
2040         u32 src, dst;
2041
2042         FETCH_BYTE(src);
2043         FETCH_SWORD(adr);
2044         adr += AREG((Opcode >> 0) & 7);
2045         PRE_IO
2046         READ_BYTE_F(adr, dst)
2047         res = dst - src;
2048         flag_N = flag_X = flag_C = res;
2049         flag_V = (src ^ dst) & (res ^ dst);
2050         flag_NotZ = res & 0xFF;
2051         WRITE_BYTE_F(adr, res)
2052         POST_IO
2053 RET(20)
2054 }
2055
2056 // SUBI
2057 OPCODE(0x0430)
2058 {
2059         u32 adr, res;
2060         u32 src, dst;
2061
2062         FETCH_BYTE(src);
2063         adr = AREG((Opcode >> 0) & 7);
2064         DECODE_EXT_WORD
2065         PRE_IO
2066         READ_BYTE_F(adr, dst)
2067         res = dst - src;
2068         flag_N = flag_X = flag_C = res;
2069         flag_V = (src ^ dst) & (res ^ dst);
2070         flag_NotZ = res & 0xFF;
2071         WRITE_BYTE_F(adr, res)
2072         POST_IO
2073 RET(22)
2074 }
2075
2076 // SUBI
2077 OPCODE(0x0438)
2078 {
2079         u32 adr, res;
2080         u32 src, dst;
2081
2082         FETCH_BYTE(src);
2083         FETCH_SWORD(adr);
2084         PRE_IO
2085         READ_BYTE_F(adr, dst)
2086         res = dst - src;
2087         flag_N = flag_X = flag_C = res;
2088         flag_V = (src ^ dst) & (res ^ dst);
2089         flag_NotZ = res & 0xFF;
2090         WRITE_BYTE_F(adr, res)
2091         POST_IO
2092 RET(20)
2093 }
2094
2095 // SUBI
2096 OPCODE(0x0439)
2097 {
2098         u32 adr, res;
2099         u32 src, dst;
2100
2101         FETCH_BYTE(src);
2102         FETCH_LONG(adr);
2103         PRE_IO
2104         READ_BYTE_F(adr, dst)
2105         res = dst - src;
2106         flag_N = flag_X = flag_C = res;
2107         flag_V = (src ^ dst) & (res ^ dst);
2108         flag_NotZ = res & 0xFF;
2109         WRITE_BYTE_F(adr, res)
2110         POST_IO
2111 RET(24)
2112 }
2113
2114 // SUBI
2115 OPCODE(0x041F)
2116 {
2117         u32 adr, res;
2118         u32 src, dst;
2119
2120         FETCH_BYTE(src);
2121         adr = AREG(7);
2122         AREG(7) += 2;
2123         PRE_IO
2124         READ_BYTE_F(adr, dst)
2125         res = dst - src;
2126         flag_N = flag_X = flag_C = res;
2127         flag_V = (src ^ dst) & (res ^ dst);
2128         flag_NotZ = res & 0xFF;
2129         WRITE_BYTE_F(adr, res)
2130         POST_IO
2131 RET(16)
2132 }
2133
2134 // SUBI
2135 OPCODE(0x0427)
2136 {
2137         u32 adr, res;
2138         u32 src, dst;
2139
2140         FETCH_BYTE(src);
2141         adr = AREG(7) - 2;
2142         AREG(7) = adr;
2143         PRE_IO
2144         READ_BYTE_F(adr, dst)
2145         res = dst - src;
2146         flag_N = flag_X = flag_C = res;
2147         flag_V = (src ^ dst) & (res ^ dst);
2148         flag_NotZ = res & 0xFF;
2149         WRITE_BYTE_F(adr, res)
2150         POST_IO
2151 RET(18)
2152 }
2153
2154 // SUBI
2155 OPCODE(0x0440)
2156 {
2157         u32 adr, res;
2158         u32 src, dst;
2159
2160         FETCH_WORD(src);
2161         dst = DREGu16((Opcode >> 0) & 7);
2162         res = dst - src;
2163         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2164         flag_N = flag_X = flag_C = res >> 8;
2165         flag_NotZ = res & 0xFFFF;
2166         DREGu16((Opcode >> 0) & 7) = res;
2167 RET(8)
2168 }
2169
2170 // SUBI
2171 OPCODE(0x0450)
2172 {
2173         u32 adr, res;
2174         u32 src, dst;
2175
2176         FETCH_WORD(src);
2177         adr = AREG((Opcode >> 0) & 7);
2178         PRE_IO
2179         READ_WORD_F(adr, dst)
2180         res = dst - src;
2181         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2182         flag_N = flag_X = flag_C = res >> 8;
2183         flag_NotZ = res & 0xFFFF;
2184         WRITE_WORD_F(adr, res)
2185         POST_IO
2186 RET(16)
2187 }
2188
2189 // SUBI
2190 OPCODE(0x0458)
2191 {
2192         u32 adr, res;
2193         u32 src, dst;
2194
2195         FETCH_WORD(src);
2196         adr = AREG((Opcode >> 0) & 7);
2197         AREG((Opcode >> 0) & 7) += 2;
2198         PRE_IO
2199         READ_WORD_F(adr, dst)
2200         res = dst - src;
2201         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2202         flag_N = flag_X = flag_C = res >> 8;
2203         flag_NotZ = res & 0xFFFF;
2204         WRITE_WORD_F(adr, res)
2205         POST_IO
2206 RET(16)
2207 }
2208
2209 // SUBI
2210 OPCODE(0x0460)
2211 {
2212         u32 adr, res;
2213         u32 src, dst;
2214
2215         FETCH_WORD(src);
2216         adr = AREG((Opcode >> 0) & 7) - 2;
2217         AREG((Opcode >> 0) & 7) = adr;
2218         PRE_IO
2219         READ_WORD_F(adr, dst)
2220         res = dst - src;
2221         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2222         flag_N = flag_X = flag_C = res >> 8;
2223         flag_NotZ = res & 0xFFFF;
2224         WRITE_WORD_F(adr, res)
2225         POST_IO
2226 RET(18)
2227 }
2228
2229 // SUBI
2230 OPCODE(0x0468)
2231 {
2232         u32 adr, res;
2233         u32 src, dst;
2234
2235         FETCH_WORD(src);
2236         FETCH_SWORD(adr);
2237         adr += AREG((Opcode >> 0) & 7);
2238         PRE_IO
2239         READ_WORD_F(adr, dst)
2240         res = dst - src;
2241         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2242         flag_N = flag_X = flag_C = res >> 8;
2243         flag_NotZ = res & 0xFFFF;
2244         WRITE_WORD_F(adr, res)
2245         POST_IO
2246 RET(20)
2247 }
2248
2249 // SUBI
2250 OPCODE(0x0470)
2251 {
2252         u32 adr, res;
2253         u32 src, dst;
2254
2255         FETCH_WORD(src);
2256         adr = AREG((Opcode >> 0) & 7);
2257         DECODE_EXT_WORD
2258         PRE_IO
2259         READ_WORD_F(adr, dst)
2260         res = dst - src;
2261         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2262         flag_N = flag_X = flag_C = res >> 8;
2263         flag_NotZ = res & 0xFFFF;
2264         WRITE_WORD_F(adr, res)
2265         POST_IO
2266 RET(22)
2267 }
2268
2269 // SUBI
2270 OPCODE(0x0478)
2271 {
2272         u32 adr, res;
2273         u32 src, dst;
2274
2275         FETCH_WORD(src);
2276         FETCH_SWORD(adr);
2277         PRE_IO
2278         READ_WORD_F(adr, dst)
2279         res = dst - src;
2280         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2281         flag_N = flag_X = flag_C = res >> 8;
2282         flag_NotZ = res & 0xFFFF;
2283         WRITE_WORD_F(adr, res)
2284         POST_IO
2285 RET(20)
2286 }
2287
2288 // SUBI
2289 OPCODE(0x0479)
2290 {
2291         u32 adr, res;
2292         u32 src, dst;
2293
2294         FETCH_WORD(src);
2295         FETCH_LONG(adr);
2296         PRE_IO
2297         READ_WORD_F(adr, dst)
2298         res = dst - src;
2299         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2300         flag_N = flag_X = flag_C = res >> 8;
2301         flag_NotZ = res & 0xFFFF;
2302         WRITE_WORD_F(adr, res)
2303         POST_IO
2304 RET(24)
2305 }
2306
2307 // SUBI
2308 OPCODE(0x045F)
2309 {
2310         u32 adr, res;
2311         u32 src, dst;
2312
2313         FETCH_WORD(src);
2314         adr = AREG(7);
2315         AREG(7) += 2;
2316         PRE_IO
2317         READ_WORD_F(adr, dst)
2318         res = dst - src;
2319         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2320         flag_N = flag_X = flag_C = res >> 8;
2321         flag_NotZ = res & 0xFFFF;
2322         WRITE_WORD_F(adr, res)
2323         POST_IO
2324 RET(16)
2325 }
2326
2327 // SUBI
2328 OPCODE(0x0467)
2329 {
2330         u32 adr, res;
2331         u32 src, dst;
2332
2333         FETCH_WORD(src);
2334         adr = AREG(7) - 2;
2335         AREG(7) = adr;
2336         PRE_IO
2337         READ_WORD_F(adr, dst)
2338         res = dst - src;
2339         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2340         flag_N = flag_X = flag_C = res >> 8;
2341         flag_NotZ = res & 0xFFFF;
2342         WRITE_WORD_F(adr, res)
2343         POST_IO
2344 RET(18)
2345 }
2346
2347 // SUBI
2348 OPCODE(0x0480)
2349 {
2350         u32 adr, res;
2351         u32 src, dst;
2352
2353         FETCH_LONG(src);
2354         dst = DREGu32((Opcode >> 0) & 7);
2355         res = dst - src;
2356         flag_NotZ = res;
2357         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2358         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2359         flag_N = res >> 24;
2360         DREGu32((Opcode >> 0) & 7) = res;
2361 RET(16)
2362 }
2363
2364 // SUBI
2365 OPCODE(0x0490)
2366 {
2367         u32 adr, res;
2368         u32 src, dst;
2369
2370         FETCH_LONG(src);
2371         adr = AREG((Opcode >> 0) & 7);
2372         PRE_IO
2373         READ_LONG_F(adr, dst)
2374         res = dst - src;
2375         flag_NotZ = res;
2376         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2377         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2378         flag_N = res >> 24;
2379         WRITE_LONG_F(adr, res)
2380         POST_IO
2381 RET(28)
2382 }
2383
2384 // SUBI
2385 OPCODE(0x0498)
2386 {
2387         u32 adr, res;
2388         u32 src, dst;
2389
2390         FETCH_LONG(src);
2391         adr = AREG((Opcode >> 0) & 7);
2392         AREG((Opcode >> 0) & 7) += 4;
2393         PRE_IO
2394         READ_LONG_F(adr, dst)
2395         res = dst - src;
2396         flag_NotZ = res;
2397         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2398         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2399         flag_N = res >> 24;
2400         WRITE_LONG_F(adr, res)
2401         POST_IO
2402 RET(28)
2403 }
2404
2405 // SUBI
2406 OPCODE(0x04A0)
2407 {
2408         u32 adr, res;
2409         u32 src, dst;
2410
2411         FETCH_LONG(src);
2412         adr = AREG((Opcode >> 0) & 7) - 4;
2413         AREG((Opcode >> 0) & 7) = adr;
2414         PRE_IO
2415         READ_LONG_F(adr, dst)
2416         res = dst - src;
2417         flag_NotZ = res;
2418         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2419         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2420         flag_N = res >> 24;
2421         WRITE_LONG_F(adr, res)
2422         POST_IO
2423 RET(30)
2424 }
2425
2426 // SUBI
2427 OPCODE(0x04A8)
2428 {
2429         u32 adr, res;
2430         u32 src, dst;
2431
2432         FETCH_LONG(src);
2433         FETCH_SWORD(adr);
2434         adr += AREG((Opcode >> 0) & 7);
2435         PRE_IO
2436         READ_LONG_F(adr, dst)
2437         res = dst - src;
2438         flag_NotZ = res;
2439         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2440         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2441         flag_N = res >> 24;
2442         WRITE_LONG_F(adr, res)
2443         POST_IO
2444 RET(32)
2445 }
2446
2447 // SUBI
2448 OPCODE(0x04B0)
2449 {
2450         u32 adr, res;
2451         u32 src, dst;
2452
2453         FETCH_LONG(src);
2454         adr = AREG((Opcode >> 0) & 7);
2455         DECODE_EXT_WORD
2456         PRE_IO
2457         READ_LONG_F(adr, dst)
2458         res = dst - src;
2459         flag_NotZ = res;
2460         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2461         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2462         flag_N = res >> 24;
2463         WRITE_LONG_F(adr, res)
2464         POST_IO
2465 RET(34)
2466 }
2467
2468 // SUBI
2469 OPCODE(0x04B8)
2470 {
2471         u32 adr, res;
2472         u32 src, dst;
2473
2474         FETCH_LONG(src);
2475         FETCH_SWORD(adr);
2476         PRE_IO
2477         READ_LONG_F(adr, dst)
2478         res = dst - src;
2479         flag_NotZ = res;
2480         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2481         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2482         flag_N = res >> 24;
2483         WRITE_LONG_F(adr, res)
2484         POST_IO
2485 RET(32)
2486 }
2487
2488 // SUBI
2489 OPCODE(0x04B9)
2490 {
2491         u32 adr, res;
2492         u32 src, dst;
2493
2494         FETCH_LONG(src);
2495         FETCH_LONG(adr);
2496         PRE_IO
2497         READ_LONG_F(adr, dst)
2498         res = dst - src;
2499         flag_NotZ = res;
2500         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2501         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2502         flag_N = res >> 24;
2503         WRITE_LONG_F(adr, res)
2504         POST_IO
2505 RET(36)
2506 }
2507
2508 // SUBI
2509 OPCODE(0x049F)
2510 {
2511         u32 adr, res;
2512         u32 src, dst;
2513
2514         FETCH_LONG(src);
2515         adr = AREG(7);
2516         AREG(7) += 4;
2517         PRE_IO
2518         READ_LONG_F(adr, dst)
2519         res = dst - src;
2520         flag_NotZ = res;
2521         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2522         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2523         flag_N = res >> 24;
2524         WRITE_LONG_F(adr, res)
2525         POST_IO
2526 RET(28)
2527 }
2528
2529 // SUBI
2530 OPCODE(0x04A7)
2531 {
2532         u32 adr, res;
2533         u32 src, dst;
2534
2535         FETCH_LONG(src);
2536         adr = AREG(7) - 4;
2537         AREG(7) = adr;
2538         PRE_IO
2539         READ_LONG_F(adr, dst)
2540         res = dst - src;
2541         flag_NotZ = res;
2542         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2543         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2544         flag_N = res >> 24;
2545         WRITE_LONG_F(adr, res)
2546         POST_IO
2547 RET(30)
2548 }
2549
2550 // ADDI
2551 OPCODE(0x0600)
2552 {
2553         u32 adr, res;
2554         u32 src, dst;
2555
2556         FETCH_BYTE(src);
2557         dst = DREGu8((Opcode >> 0) & 7);
2558         res = dst + src;
2559         flag_N = flag_X = flag_C = res;
2560         flag_V = (src ^ res) & (dst ^ res);
2561         flag_NotZ = res & 0xFF;
2562         DREGu8((Opcode >> 0) & 7) = res;
2563 RET(8)
2564 }
2565
2566 // ADDI
2567 OPCODE(0x0610)
2568 {
2569         u32 adr, res;
2570         u32 src, dst;
2571
2572         FETCH_BYTE(src);
2573         adr = AREG((Opcode >> 0) & 7);
2574         PRE_IO
2575         READ_BYTE_F(adr, dst)
2576         res = dst + src;
2577         flag_N = flag_X = flag_C = res;
2578         flag_V = (src ^ res) & (dst ^ res);
2579         flag_NotZ = res & 0xFF;
2580         WRITE_BYTE_F(adr, res)
2581         POST_IO
2582 RET(16)
2583 }
2584
2585 // ADDI
2586 OPCODE(0x0618)
2587 {
2588         u32 adr, res;
2589         u32 src, dst;
2590
2591         FETCH_BYTE(src);
2592         adr = AREG((Opcode >> 0) & 7);
2593         AREG((Opcode >> 0) & 7) += 1;
2594         PRE_IO
2595         READ_BYTE_F(adr, dst)
2596         res = dst + src;
2597         flag_N = flag_X = flag_C = res;
2598         flag_V = (src ^ res) & (dst ^ res);
2599         flag_NotZ = res & 0xFF;
2600         WRITE_BYTE_F(adr, res)
2601         POST_IO
2602 RET(16)
2603 }
2604
2605 // ADDI
2606 OPCODE(0x0620)
2607 {
2608         u32 adr, res;
2609         u32 src, dst;
2610
2611         FETCH_BYTE(src);
2612         adr = AREG((Opcode >> 0) & 7) - 1;
2613         AREG((Opcode >> 0) & 7) = adr;
2614         PRE_IO
2615         READ_BYTE_F(adr, dst)
2616         res = dst + src;
2617         flag_N = flag_X = flag_C = res;
2618         flag_V = (src ^ res) & (dst ^ res);
2619         flag_NotZ = res & 0xFF;
2620         WRITE_BYTE_F(adr, res)
2621         POST_IO
2622 RET(18)
2623 }
2624
2625 // ADDI
2626 OPCODE(0x0628)
2627 {
2628         u32 adr, res;
2629         u32 src, dst;
2630
2631         FETCH_BYTE(src);
2632         FETCH_SWORD(adr);
2633         adr += AREG((Opcode >> 0) & 7);
2634         PRE_IO
2635         READ_BYTE_F(adr, dst)
2636         res = dst + src;
2637         flag_N = flag_X = flag_C = res;
2638         flag_V = (src ^ res) & (dst ^ res);
2639         flag_NotZ = res & 0xFF;
2640         WRITE_BYTE_F(adr, res)
2641         POST_IO
2642 RET(20)
2643 }
2644
2645 // ADDI
2646 OPCODE(0x0630)
2647 {
2648         u32 adr, res;
2649         u32 src, dst;
2650
2651         FETCH_BYTE(src);
2652         adr = AREG((Opcode >> 0) & 7);
2653         DECODE_EXT_WORD
2654         PRE_IO
2655         READ_BYTE_F(adr, dst)
2656         res = dst + src;
2657         flag_N = flag_X = flag_C = res;
2658         flag_V = (src ^ res) & (dst ^ res);
2659         flag_NotZ = res & 0xFF;
2660         WRITE_BYTE_F(adr, res)
2661         POST_IO
2662 RET(22)
2663 }
2664
2665 // ADDI
2666 OPCODE(0x0638)
2667 {
2668         u32 adr, res;
2669         u32 src, dst;
2670
2671         FETCH_BYTE(src);
2672         FETCH_SWORD(adr);
2673         PRE_IO
2674         READ_BYTE_F(adr, dst)
2675         res = dst + src;
2676         flag_N = flag_X = flag_C = res;
2677         flag_V = (src ^ res) & (dst ^ res);
2678         flag_NotZ = res & 0xFF;
2679         WRITE_BYTE_F(adr, res)
2680         POST_IO
2681 RET(20)
2682 }
2683
2684 // ADDI
2685 OPCODE(0x0639)
2686 {
2687         u32 adr, res;
2688         u32 src, dst;
2689
2690         FETCH_BYTE(src);
2691         FETCH_LONG(adr);
2692         PRE_IO
2693         READ_BYTE_F(adr, dst)
2694         res = dst + src;
2695         flag_N = flag_X = flag_C = res;
2696         flag_V = (src ^ res) & (dst ^ res);
2697         flag_NotZ = res & 0xFF;
2698         WRITE_BYTE_F(adr, res)
2699         POST_IO
2700 RET(24)
2701 }
2702
2703 // ADDI
2704 OPCODE(0x061F)
2705 {
2706         u32 adr, res;
2707         u32 src, dst;
2708
2709         FETCH_BYTE(src);
2710         adr = AREG(7);
2711         AREG(7) += 2;
2712         PRE_IO
2713         READ_BYTE_F(adr, dst)
2714         res = dst + src;
2715         flag_N = flag_X = flag_C = res;
2716         flag_V = (src ^ res) & (dst ^ res);
2717         flag_NotZ = res & 0xFF;
2718         WRITE_BYTE_F(adr, res)
2719         POST_IO
2720 RET(16)
2721 }
2722
2723 // ADDI
2724 OPCODE(0x0627)
2725 {
2726         u32 adr, res;
2727         u32 src, dst;
2728
2729         FETCH_BYTE(src);
2730         adr = AREG(7) - 2;
2731         AREG(7) = adr;
2732         PRE_IO
2733         READ_BYTE_F(adr, dst)
2734         res = dst + src;
2735         flag_N = flag_X = flag_C = res;
2736         flag_V = (src ^ res) & (dst ^ res);
2737         flag_NotZ = res & 0xFF;
2738         WRITE_BYTE_F(adr, res)
2739         POST_IO
2740 RET(18)
2741 }
2742
2743 // ADDI
2744 OPCODE(0x0640)
2745 {
2746         u32 adr, res;
2747         u32 src, dst;
2748
2749         FETCH_WORD(src);
2750         dst = DREGu16((Opcode >> 0) & 7);
2751         res = dst + src;
2752         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2753         flag_N = flag_X = flag_C = res >> 8;
2754         flag_NotZ = res & 0xFFFF;
2755         DREGu16((Opcode >> 0) & 7) = res;
2756 RET(8)
2757 }
2758
2759 // ADDI
2760 OPCODE(0x0650)
2761 {
2762         u32 adr, res;
2763         u32 src, dst;
2764
2765         FETCH_WORD(src);
2766         adr = AREG((Opcode >> 0) & 7);
2767         PRE_IO
2768         READ_WORD_F(adr, dst)
2769         res = dst + src;
2770         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2771         flag_N = flag_X = flag_C = res >> 8;
2772         flag_NotZ = res & 0xFFFF;
2773         WRITE_WORD_F(adr, res)
2774         POST_IO
2775 RET(16)
2776 }
2777
2778 // ADDI
2779 OPCODE(0x0658)
2780 {
2781         u32 adr, res;
2782         u32 src, dst;
2783
2784         FETCH_WORD(src);
2785         adr = AREG((Opcode >> 0) & 7);
2786         AREG((Opcode >> 0) & 7) += 2;
2787         PRE_IO
2788         READ_WORD_F(adr, dst)
2789         res = dst + src;
2790         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2791         flag_N = flag_X = flag_C = res >> 8;
2792         flag_NotZ = res & 0xFFFF;
2793         WRITE_WORD_F(adr, res)
2794         POST_IO
2795 RET(16)
2796 }
2797
2798 // ADDI
2799 OPCODE(0x0660)
2800 {
2801         u32 adr, res;
2802         u32 src, dst;
2803
2804         FETCH_WORD(src);
2805         adr = AREG((Opcode >> 0) & 7) - 2;
2806         AREG((Opcode >> 0) & 7) = adr;
2807         PRE_IO
2808         READ_WORD_F(adr, dst)
2809         res = dst + src;
2810         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2811         flag_N = flag_X = flag_C = res >> 8;
2812         flag_NotZ = res & 0xFFFF;
2813         WRITE_WORD_F(adr, res)
2814         POST_IO
2815 RET(18)
2816 }
2817
2818 // ADDI
2819 OPCODE(0x0668)
2820 {
2821         u32 adr, res;
2822         u32 src, dst;
2823
2824         FETCH_WORD(src);
2825         FETCH_SWORD(adr);
2826         adr += AREG((Opcode >> 0) & 7);
2827         PRE_IO
2828         READ_WORD_F(adr, dst)
2829         res = dst + src;
2830         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2831         flag_N = flag_X = flag_C = res >> 8;
2832         flag_NotZ = res & 0xFFFF;
2833         WRITE_WORD_F(adr, res)
2834         POST_IO
2835 RET(20)
2836 }
2837
2838 // ADDI
2839 OPCODE(0x0670)
2840 {
2841         u32 adr, res;
2842         u32 src, dst;
2843
2844         FETCH_WORD(src);
2845         adr = AREG((Opcode >> 0) & 7);
2846         DECODE_EXT_WORD
2847         PRE_IO
2848         READ_WORD_F(adr, dst)
2849         res = dst + src;
2850         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2851         flag_N = flag_X = flag_C = res >> 8;
2852         flag_NotZ = res & 0xFFFF;
2853         WRITE_WORD_F(adr, res)
2854         POST_IO
2855 RET(22)
2856 }
2857
2858 // ADDI
2859 OPCODE(0x0678)
2860 {
2861         u32 adr, res;
2862         u32 src, dst;
2863
2864         FETCH_WORD(src);
2865         FETCH_SWORD(adr);
2866         PRE_IO
2867         READ_WORD_F(adr, dst)
2868         res = dst + src;
2869         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2870         flag_N = flag_X = flag_C = res >> 8;
2871         flag_NotZ = res & 0xFFFF;
2872         WRITE_WORD_F(adr, res)
2873         POST_IO
2874 RET(20)
2875 }
2876
2877 // ADDI
2878 OPCODE(0x0679)
2879 {
2880         u32 adr, res;
2881         u32 src, dst;
2882
2883         FETCH_WORD(src);
2884         FETCH_LONG(adr);
2885         PRE_IO
2886         READ_WORD_F(adr, dst)
2887         res = dst + src;
2888         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2889         flag_N = flag_X = flag_C = res >> 8;
2890         flag_NotZ = res & 0xFFFF;
2891         WRITE_WORD_F(adr, res)
2892         POST_IO
2893 RET(24)
2894 }
2895
2896 // ADDI
2897 OPCODE(0x065F)
2898 {
2899         u32 adr, res;
2900         u32 src, dst;
2901
2902         FETCH_WORD(src);
2903         adr = AREG(7);
2904         AREG(7) += 2;
2905         PRE_IO
2906         READ_WORD_F(adr, dst)
2907         res = dst + src;
2908         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2909         flag_N = flag_X = flag_C = res >> 8;
2910         flag_NotZ = res & 0xFFFF;
2911         WRITE_WORD_F(adr, res)
2912         POST_IO
2913 RET(16)
2914 }
2915
2916 // ADDI
2917 OPCODE(0x0667)
2918 {
2919         u32 adr, res;
2920         u32 src, dst;
2921
2922         FETCH_WORD(src);
2923         adr = AREG(7) - 2;
2924         AREG(7) = adr;
2925         PRE_IO
2926         READ_WORD_F(adr, dst)
2927         res = dst + src;
2928         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2929         flag_N = flag_X = flag_C = res >> 8;
2930         flag_NotZ = res & 0xFFFF;
2931         WRITE_WORD_F(adr, res)
2932         POST_IO
2933 RET(18)
2934 }
2935
2936 // ADDI
2937 OPCODE(0x0680)
2938 {
2939         u32 adr, res;
2940         u32 src, dst;
2941
2942         FETCH_LONG(src);
2943         dst = DREGu32((Opcode >> 0) & 7);
2944         res = dst + src;
2945         flag_NotZ = res;
2946         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
2947         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
2948         flag_N = res >> 24;
2949         DREGu32((Opcode >> 0) & 7) = res;
2950 RET(16)
2951 }
2952
2953 // ADDI
2954 OPCODE(0x0690)
2955 {
2956         u32 adr, res;
2957         u32 src, dst;
2958
2959         FETCH_LONG(src);
2960         adr = AREG((Opcode >> 0) & 7);
2961         PRE_IO
2962         READ_LONG_F(adr, dst)
2963         res = dst + src;
2964         flag_NotZ = res;
2965         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
2966         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
2967         flag_N = res >> 24;
2968         WRITE_LONG_F(adr, res)
2969         POST_IO
2970 RET(28)
2971 }
2972
2973 // ADDI
2974 OPCODE(0x0698)
2975 {
2976         u32 adr, res;
2977         u32 src, dst;
2978
2979         FETCH_LONG(src);
2980         adr = AREG((Opcode >> 0) & 7);
2981         AREG((Opcode >> 0) & 7) += 4;
2982         PRE_IO
2983         READ_LONG_F(adr, dst)
2984         res = dst + src;
2985         flag_NotZ = res;
2986         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
2987         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
2988         flag_N = res >> 24;
2989         WRITE_LONG_F(adr, res)
2990         POST_IO
2991 RET(28)
2992 }
2993
2994 // ADDI
2995 OPCODE(0x06A0)
2996 {
2997         u32 adr, res;
2998         u32 src, dst;
2999
3000         FETCH_LONG(src);
3001         adr = AREG((Opcode >> 0) & 7) - 4;
3002         AREG((Opcode >> 0) & 7) = adr;
3003         PRE_IO
3004         READ_LONG_F(adr, dst)
3005         res = dst + src;
3006         flag_NotZ = res;
3007         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3008         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3009         flag_N = res >> 24;
3010         WRITE_LONG_F(adr, res)
3011         POST_IO
3012 RET(30)
3013 }
3014
3015 // ADDI
3016 OPCODE(0x06A8)
3017 {
3018         u32 adr, res;
3019         u32 src, dst;
3020
3021         FETCH_LONG(src);
3022         FETCH_SWORD(adr);
3023         adr += AREG((Opcode >> 0) & 7);
3024         PRE_IO
3025         READ_LONG_F(adr, dst)
3026         res = dst + src;
3027         flag_NotZ = res;
3028         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3029         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3030         flag_N = res >> 24;
3031         WRITE_LONG_F(adr, res)
3032         POST_IO
3033 RET(32)
3034 }
3035
3036 // ADDI
3037 OPCODE(0x06B0)
3038 {
3039         u32 adr, res;
3040         u32 src, dst;
3041
3042         FETCH_LONG(src);
3043         adr = AREG((Opcode >> 0) & 7);
3044         DECODE_EXT_WORD
3045         PRE_IO
3046         READ_LONG_F(adr, dst)
3047         res = dst + src;
3048         flag_NotZ = res;
3049         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3050         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3051         flag_N = res >> 24;
3052         WRITE_LONG_F(adr, res)
3053         POST_IO
3054 RET(34)
3055 }
3056
3057 // ADDI
3058 OPCODE(0x06B8)
3059 {
3060         u32 adr, res;
3061         u32 src, dst;
3062
3063         FETCH_LONG(src);
3064         FETCH_SWORD(adr);
3065         PRE_IO
3066         READ_LONG_F(adr, dst)
3067         res = dst + src;
3068         flag_NotZ = res;
3069         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3070         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3071         flag_N = res >> 24;
3072         WRITE_LONG_F(adr, res)
3073         POST_IO
3074 RET(32)
3075 }
3076
3077 // ADDI
3078 OPCODE(0x06B9)
3079 {
3080         u32 adr, res;
3081         u32 src, dst;
3082
3083         FETCH_LONG(src);
3084         FETCH_LONG(adr);
3085         PRE_IO
3086         READ_LONG_F(adr, dst)
3087         res = dst + src;
3088         flag_NotZ = res;
3089         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3090         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3091         flag_N = res >> 24;
3092         WRITE_LONG_F(adr, res)
3093         POST_IO
3094 RET(36)
3095 }
3096
3097 // ADDI
3098 OPCODE(0x069F)
3099 {
3100         u32 adr, res;
3101         u32 src, dst;
3102
3103         FETCH_LONG(src);
3104         adr = AREG(7);
3105         AREG(7) += 4;
3106         PRE_IO
3107         READ_LONG_F(adr, dst)
3108         res = dst + src;
3109         flag_NotZ = res;
3110         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3111         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3112         flag_N = res >> 24;
3113         WRITE_LONG_F(adr, res)
3114         POST_IO
3115 RET(28)
3116 }
3117
3118 // ADDI
3119 OPCODE(0x06A7)
3120 {
3121         u32 adr, res;
3122         u32 src, dst;
3123
3124         FETCH_LONG(src);
3125         adr = AREG(7) - 4;
3126         AREG(7) = adr;
3127         PRE_IO
3128         READ_LONG_F(adr, dst)
3129         res = dst + src;
3130         flag_NotZ = res;
3131         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3132         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3133         flag_N = res >> 24;
3134         WRITE_LONG_F(adr, res)
3135         POST_IO
3136 RET(30)
3137 }
3138
3139 // CMPI
3140 OPCODE(0x0C00)
3141 {
3142         u32 adr, res;
3143         u32 src, dst;
3144
3145         FETCH_BYTE(src);
3146         dst = DREGu8((Opcode >> 0) & 7);
3147         res = dst - src;
3148         flag_N = flag_C = res;
3149         flag_V = (src ^ dst) & (res ^ dst);
3150         flag_NotZ = res & 0xFF;
3151 RET(8)
3152 }
3153
3154 // CMPI
3155 OPCODE(0x0C10)
3156 {
3157         u32 adr, res;
3158         u32 src, dst;
3159
3160         FETCH_BYTE(src);
3161         adr = AREG((Opcode >> 0) & 7);
3162         PRE_IO
3163         READ_BYTE_F(adr, dst)
3164         res = dst - src;
3165         flag_N = flag_C = res;
3166         flag_V = (src ^ dst) & (res ^ dst);
3167         flag_NotZ = res & 0xFF;
3168         POST_IO
3169 RET(12)
3170 }
3171
3172 // CMPI
3173 OPCODE(0x0C18)
3174 {
3175         u32 adr, res;
3176         u32 src, dst;
3177
3178         FETCH_BYTE(src);
3179         adr = AREG((Opcode >> 0) & 7);
3180         AREG((Opcode >> 0) & 7) += 1;
3181         PRE_IO
3182         READ_BYTE_F(adr, dst)
3183         res = dst - src;
3184         flag_N = flag_C = res;
3185         flag_V = (src ^ dst) & (res ^ dst);
3186         flag_NotZ = res & 0xFF;
3187         POST_IO
3188 RET(12)
3189 }
3190
3191 // CMPI
3192 OPCODE(0x0C20)
3193 {
3194         u32 adr, res;
3195         u32 src, dst;
3196
3197         FETCH_BYTE(src);
3198         adr = AREG((Opcode >> 0) & 7) - 1;
3199         AREG((Opcode >> 0) & 7) = adr;
3200         PRE_IO
3201         READ_BYTE_F(adr, dst)
3202         res = dst - src;
3203         flag_N = flag_C = res;
3204         flag_V = (src ^ dst) & (res ^ dst);
3205         flag_NotZ = res & 0xFF;
3206         POST_IO
3207 RET(14)
3208 }
3209
3210 // CMPI
3211 OPCODE(0x0C28)
3212 {
3213         u32 adr, res;
3214         u32 src, dst;
3215
3216         FETCH_BYTE(src);
3217         FETCH_SWORD(adr);
3218         adr += AREG((Opcode >> 0) & 7);
3219         PRE_IO
3220         READ_BYTE_F(adr, dst)
3221         res = dst - src;
3222         flag_N = flag_C = res;
3223         flag_V = (src ^ dst) & (res ^ dst);
3224         flag_NotZ = res & 0xFF;
3225         POST_IO
3226 RET(16)
3227 }
3228
3229 // CMPI
3230 OPCODE(0x0C30)
3231 {
3232         u32 adr, res;
3233         u32 src, dst;
3234
3235         FETCH_BYTE(src);
3236         adr = AREG((Opcode >> 0) & 7);
3237         DECODE_EXT_WORD
3238         PRE_IO
3239         READ_BYTE_F(adr, dst)
3240         res = dst - src;
3241         flag_N = flag_C = res;
3242         flag_V = (src ^ dst) & (res ^ dst);
3243         flag_NotZ = res & 0xFF;
3244         POST_IO
3245 RET(18)
3246 }
3247
3248 // CMPI
3249 OPCODE(0x0C38)
3250 {
3251         u32 adr, res;
3252         u32 src, dst;
3253
3254         FETCH_BYTE(src);
3255         FETCH_SWORD(adr);
3256         PRE_IO
3257         READ_BYTE_F(adr, dst)
3258         res = dst - src;
3259         flag_N = flag_C = res;
3260         flag_V = (src ^ dst) & (res ^ dst);
3261         flag_NotZ = res & 0xFF;
3262         POST_IO
3263 RET(16)
3264 }
3265
3266 // CMPI
3267 OPCODE(0x0C39)
3268 {
3269         u32 adr, res;
3270         u32 src, dst;
3271
3272         FETCH_BYTE(src);
3273         FETCH_LONG(adr);
3274         PRE_IO
3275         READ_BYTE_F(adr, dst)
3276         res = dst - src;
3277         flag_N = flag_C = res;
3278         flag_V = (src ^ dst) & (res ^ dst);
3279         flag_NotZ = res & 0xFF;
3280         POST_IO
3281 RET(20)
3282 }
3283
3284 // CMPI
3285 OPCODE(0x0C1F)
3286 {
3287         u32 adr, res;
3288         u32 src, dst;
3289
3290         FETCH_BYTE(src);
3291         adr = AREG(7);
3292         AREG(7) += 2;
3293         PRE_IO
3294         READ_BYTE_F(adr, dst)
3295         res = dst - src;
3296         flag_N = flag_C = res;
3297         flag_V = (src ^ dst) & (res ^ dst);
3298         flag_NotZ = res & 0xFF;
3299         POST_IO
3300 RET(12)
3301 }
3302
3303 // CMPI
3304 OPCODE(0x0C27)
3305 {
3306         u32 adr, res;
3307         u32 src, dst;
3308
3309         FETCH_BYTE(src);
3310         adr = AREG(7) - 2;
3311         AREG(7) = adr;
3312         PRE_IO
3313         READ_BYTE_F(adr, dst)
3314         res = dst - src;
3315         flag_N = flag_C = res;
3316         flag_V = (src ^ dst) & (res ^ dst);
3317         flag_NotZ = res & 0xFF;
3318         POST_IO
3319 RET(14)
3320 }
3321
3322 // CMPI
3323 OPCODE(0x0C40)
3324 {
3325         u32 adr, res;
3326         u32 src, dst;
3327
3328         FETCH_WORD(src);
3329         dst = DREGu16((Opcode >> 0) & 7);
3330         res = dst - src;
3331         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3332         flag_N = flag_C = res >> 8;
3333         flag_NotZ = res & 0xFFFF;
3334 RET(8)
3335 }
3336
3337 // CMPI
3338 OPCODE(0x0C50)
3339 {
3340         u32 adr, res;
3341         u32 src, dst;
3342
3343         FETCH_WORD(src);
3344         adr = AREG((Opcode >> 0) & 7);
3345         PRE_IO
3346         READ_WORD_F(adr, dst)
3347         res = dst - src;
3348         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3349         flag_N = flag_C = res >> 8;
3350         flag_NotZ = res & 0xFFFF;
3351         POST_IO
3352 RET(12)
3353 }
3354
3355 // CMPI
3356 OPCODE(0x0C58)
3357 {
3358         u32 adr, res;
3359         u32 src, dst;
3360
3361         FETCH_WORD(src);
3362         adr = AREG((Opcode >> 0) & 7);
3363         AREG((Opcode >> 0) & 7) += 2;
3364         PRE_IO
3365         READ_WORD_F(adr, dst)
3366         res = dst - src;
3367         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3368         flag_N = flag_C = res >> 8;
3369         flag_NotZ = res & 0xFFFF;
3370         POST_IO
3371 RET(12)
3372 }
3373
3374 // CMPI
3375 OPCODE(0x0C60)
3376 {
3377         u32 adr, res;
3378         u32 src, dst;
3379
3380         FETCH_WORD(src);
3381         adr = AREG((Opcode >> 0) & 7) - 2;
3382         AREG((Opcode >> 0) & 7) = adr;
3383         PRE_IO
3384         READ_WORD_F(adr, dst)
3385         res = dst - src;
3386         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3387         flag_N = flag_C = res >> 8;
3388         flag_NotZ = res & 0xFFFF;
3389         POST_IO
3390 RET(14)
3391 }
3392
3393 // CMPI
3394 OPCODE(0x0C68)
3395 {
3396         u32 adr, res;
3397         u32 src, dst;
3398
3399         FETCH_WORD(src);
3400         FETCH_SWORD(adr);
3401         adr += AREG((Opcode >> 0) & 7);
3402         PRE_IO
3403         READ_WORD_F(adr, dst)
3404         res = dst - src;
3405         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3406         flag_N = flag_C = res >> 8;
3407         flag_NotZ = res & 0xFFFF;
3408         POST_IO
3409 RET(16)
3410 }
3411
3412 // CMPI
3413 OPCODE(0x0C70)
3414 {
3415         u32 adr, res;
3416         u32 src, dst;
3417
3418         FETCH_WORD(src);
3419         adr = AREG((Opcode >> 0) & 7);
3420         DECODE_EXT_WORD
3421         PRE_IO
3422         READ_WORD_F(adr, dst)
3423         res = dst - src;
3424         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3425         flag_N = flag_C = res >> 8;
3426         flag_NotZ = res & 0xFFFF;
3427         POST_IO
3428 RET(18)
3429 }
3430
3431 // CMPI
3432 OPCODE(0x0C78)
3433 {
3434         u32 adr, res;
3435         u32 src, dst;
3436
3437         FETCH_WORD(src);
3438         FETCH_SWORD(adr);
3439         PRE_IO
3440         READ_WORD_F(adr, dst)
3441         res = dst - src;
3442         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3443         flag_N = flag_C = res >> 8;
3444         flag_NotZ = res & 0xFFFF;
3445         POST_IO
3446 RET(16)
3447 }
3448
3449 // CMPI
3450 OPCODE(0x0C79)
3451 {
3452         u32 adr, res;
3453         u32 src, dst;
3454
3455         FETCH_WORD(src);
3456         FETCH_LONG(adr);
3457         PRE_IO
3458         READ_WORD_F(adr, dst)
3459         res = dst - src;
3460         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3461         flag_N = flag_C = res >> 8;
3462         flag_NotZ = res & 0xFFFF;
3463         POST_IO
3464 RET(20)
3465 }
3466
3467 // CMPI
3468 OPCODE(0x0C5F)
3469 {
3470         u32 adr, res;
3471         u32 src, dst;
3472
3473         FETCH_WORD(src);
3474         adr = AREG(7);
3475         AREG(7) += 2;
3476         PRE_IO
3477         READ_WORD_F(adr, dst)
3478         res = dst - src;
3479         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3480         flag_N = flag_C = res >> 8;
3481         flag_NotZ = res & 0xFFFF;
3482         POST_IO
3483 RET(12)
3484 }
3485
3486 // CMPI
3487 OPCODE(0x0C67)
3488 {
3489         u32 adr, res;
3490         u32 src, dst;
3491
3492         FETCH_WORD(src);
3493         adr = AREG(7) - 2;
3494         AREG(7) = adr;
3495         PRE_IO
3496         READ_WORD_F(adr, dst)
3497         res = dst - src;
3498         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3499         flag_N = flag_C = res >> 8;
3500         flag_NotZ = res & 0xFFFF;
3501         POST_IO
3502 RET(14)
3503 }
3504
3505 // CMPI
3506 OPCODE(0x0C80)
3507 {
3508         u32 adr, res;
3509         u32 src, dst;
3510
3511         FETCH_LONG(src);
3512         dst = DREGu32((Opcode >> 0) & 7);
3513         res = dst - src;
3514         flag_NotZ = res;
3515         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3516         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3517         flag_N = res >> 24;
3518 RET(14)
3519 }
3520
3521 // CMPI
3522 OPCODE(0x0C90)
3523 {
3524         u32 adr, res;
3525         u32 src, dst;
3526
3527         FETCH_LONG(src);
3528         adr = AREG((Opcode >> 0) & 7);
3529         PRE_IO
3530         READ_LONG_F(adr, dst)
3531         res = dst - src;
3532         flag_NotZ = res;
3533         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3534         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3535         flag_N = res >> 24;
3536         POST_IO
3537 RET(20)
3538 }
3539
3540 // CMPI
3541 OPCODE(0x0C98)
3542 {
3543         u32 adr, res;
3544         u32 src, dst;
3545
3546         FETCH_LONG(src);
3547         adr = AREG((Opcode >> 0) & 7);
3548         AREG((Opcode >> 0) & 7) += 4;
3549         PRE_IO
3550         READ_LONG_F(adr, dst)
3551         res = dst - src;
3552         flag_NotZ = res;
3553         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3554         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3555         flag_N = res >> 24;
3556         POST_IO
3557 RET(20)
3558 }
3559
3560 // CMPI
3561 OPCODE(0x0CA0)
3562 {
3563         u32 adr, res;
3564         u32 src, dst;
3565
3566         FETCH_LONG(src);
3567         adr = AREG((Opcode >> 0) & 7) - 4;
3568         AREG((Opcode >> 0) & 7) = adr;
3569         PRE_IO
3570         READ_LONG_F(adr, dst)
3571         res = dst - src;
3572         flag_NotZ = res;
3573         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3574         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3575         flag_N = res >> 24;
3576         POST_IO
3577 RET(22)
3578 }
3579
3580 // CMPI
3581 OPCODE(0x0CA8)
3582 {
3583         u32 adr, res;
3584         u32 src, dst;
3585
3586         FETCH_LONG(src);
3587         FETCH_SWORD(adr);
3588         adr += AREG((Opcode >> 0) & 7);
3589         PRE_IO
3590         READ_LONG_F(adr, dst)
3591         res = dst - src;
3592         flag_NotZ = res;
3593         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3594         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3595         flag_N = res >> 24;
3596         POST_IO
3597 RET(24)
3598 }
3599
3600 // CMPI
3601 OPCODE(0x0CB0)
3602 {
3603         u32 adr, res;
3604         u32 src, dst;
3605
3606         FETCH_LONG(src);
3607         adr = AREG((Opcode >> 0) & 7);
3608         DECODE_EXT_WORD
3609         PRE_IO
3610         READ_LONG_F(adr, dst)
3611         res = dst - src;
3612         flag_NotZ = res;
3613         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3614         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3615         flag_N = res >> 24;
3616         POST_IO
3617 RET(26)
3618 }
3619
3620 // CMPI
3621 OPCODE(0x0CB8)
3622 {
3623         u32 adr, res;
3624         u32 src, dst;
3625
3626         FETCH_LONG(src);
3627         FETCH_SWORD(adr);
3628         PRE_IO
3629         READ_LONG_F(adr, dst)
3630         res = dst - src;
3631         flag_NotZ = res;
3632         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3633         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3634         flag_N = res >> 24;
3635         POST_IO
3636 RET(24)
3637 }
3638
3639 // CMPI
3640 OPCODE(0x0CB9)
3641 {
3642         u32 adr, res;
3643         u32 src, dst;
3644
3645         FETCH_LONG(src);
3646         FETCH_LONG(adr);
3647         PRE_IO
3648         READ_LONG_F(adr, dst)
3649         res = dst - src;
3650         flag_NotZ = res;
3651         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3652         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3653         flag_N = res >> 24;
3654         POST_IO
3655 RET(28)
3656 }
3657
3658 // CMPI
3659 OPCODE(0x0C9F)
3660 {
3661         u32 adr, res;
3662         u32 src, dst;
3663
3664         FETCH_LONG(src);
3665         adr = AREG(7);
3666         AREG(7) += 4;
3667         PRE_IO
3668         READ_LONG_F(adr, dst)
3669         res = dst - src;
3670         flag_NotZ = res;
3671         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3672         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3673         flag_N = res >> 24;
3674         POST_IO
3675 RET(20)
3676 }
3677
3678 // CMPI
3679 OPCODE(0x0CA7)
3680 {
3681         u32 adr, res;
3682         u32 src, dst;
3683
3684         FETCH_LONG(src);
3685         adr = AREG(7) - 4;
3686         AREG(7) = adr;
3687         PRE_IO
3688         READ_LONG_F(adr, dst)
3689         res = dst - src;
3690         flag_NotZ = res;
3691         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3692         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3693         flag_N = res >> 24;
3694         POST_IO
3695 RET(22)
3696 }
3697
3698 // BTSTn
3699 OPCODE(0x0800)
3700 {
3701         u32 adr, res;
3702         u32 src, dst;
3703
3704         FETCH_BYTE(src);
3705         src = 1 << (src & 31);
3706         res = DREGu32((Opcode >> 0) & 7);
3707         flag_NotZ = res & src;
3708 RET(10)
3709 }
3710
3711 // BTSTn
3712 OPCODE(0x0810)
3713 {
3714         u32 adr, res;
3715         u32 src, dst;
3716
3717         FETCH_BYTE(src);
3718         src = 1 << (src & 7);
3719         adr = AREG((Opcode >> 0) & 7);
3720         PRE_IO
3721         READ_BYTE_F(adr, res)
3722         flag_NotZ = res & src;
3723         POST_IO
3724 RET(12)
3725 }
3726
3727 // BTSTn
3728 OPCODE(0x0818)
3729 {
3730         u32 adr, res;
3731         u32 src, dst;
3732
3733         FETCH_BYTE(src);
3734         src = 1 << (src & 7);
3735         adr = AREG((Opcode >> 0) & 7);
3736         AREG((Opcode >> 0) & 7) += 1;
3737         PRE_IO
3738         READ_BYTE_F(adr, res)
3739         flag_NotZ = res & src;
3740         POST_IO
3741 RET(12)
3742 }
3743
3744 // BTSTn
3745 OPCODE(0x0820)
3746 {
3747         u32 adr, res;
3748         u32 src, dst;
3749
3750         FETCH_BYTE(src);
3751         src = 1 << (src & 7);
3752         adr = AREG((Opcode >> 0) & 7) - 1;
3753         AREG((Opcode >> 0) & 7) = adr;
3754         PRE_IO
3755         READ_BYTE_F(adr, res)
3756         flag_NotZ = res & src;
3757         POST_IO
3758 RET(14)
3759 }
3760
3761 // BTSTn
3762 OPCODE(0x0828)
3763 {
3764         u32 adr, res;
3765         u32 src, dst;
3766
3767         FETCH_BYTE(src);
3768         src = 1 << (src & 7);
3769         FETCH_SWORD(adr);
3770         adr += AREG((Opcode >> 0) & 7);
3771         PRE_IO
3772         READ_BYTE_F(adr, res)
3773         flag_NotZ = res & src;
3774         POST_IO
3775 RET(16)
3776 }
3777
3778 // BTSTn
3779 OPCODE(0x0830)
3780 {
3781         u32 adr, res;
3782         u32 src, dst;
3783
3784         FETCH_BYTE(src);
3785         src = 1 << (src & 7);
3786         adr = AREG((Opcode >> 0) & 7);
3787         DECODE_EXT_WORD
3788         PRE_IO
3789         READ_BYTE_F(adr, res)
3790         flag_NotZ = res & src;
3791         POST_IO
3792 RET(18)
3793 }
3794
3795 // BTSTn
3796 OPCODE(0x0838)
3797 {
3798         u32 adr, res;
3799         u32 src, dst;
3800
3801         FETCH_BYTE(src);
3802         src = 1 << (src & 7);
3803         FETCH_SWORD(adr);
3804         PRE_IO
3805         READ_BYTE_F(adr, res)
3806         flag_NotZ = res & src;
3807         POST_IO
3808 RET(16)
3809 }
3810
3811 // BTSTn
3812 OPCODE(0x0839)
3813 {
3814         u32 adr, res;
3815         u32 src, dst;
3816
3817         FETCH_BYTE(src);
3818         src = 1 << (src & 7);
3819         FETCH_LONG(adr);
3820         PRE_IO
3821         READ_BYTE_F(adr, res)
3822         flag_NotZ = res & src;
3823         POST_IO
3824 RET(20)
3825 }
3826
3827 // BTSTn
3828 OPCODE(0x083A)
3829 {
3830         u32 adr, res;
3831         u32 src, dst;
3832
3833         FETCH_BYTE(src);
3834         src = 1 << (src & 7);
3835         adr = GET_SWORD + GET_PC;
3836         PC++;
3837         PRE_IO
3838         READ_BYTE_F(adr, res)
3839         flag_NotZ = res & src;
3840         POST_IO
3841 RET(16)
3842 }
3843
3844 // BTSTn
3845 OPCODE(0x083B)
3846 {
3847         u32 adr, res;
3848         u32 src, dst;
3849
3850         FETCH_BYTE(src);
3851         src = 1 << (src & 7);
3852         adr = (uptr)(PC) - BasePC;
3853         DECODE_EXT_WORD
3854         PRE_IO
3855         READ_BYTE_F(adr, res)
3856         flag_NotZ = res & src;
3857         POST_IO
3858 RET(18)
3859 }
3860
3861 // BTSTn
3862 OPCODE(0x081F)
3863 {
3864         u32 adr, res;
3865         u32 src, dst;
3866
3867         FETCH_BYTE(src);
3868         src = 1 << (src & 7);
3869         adr = AREG(7);
3870         AREG(7) += 2;
3871         PRE_IO
3872         READ_BYTE_F(adr, res)
3873         flag_NotZ = res & src;
3874         POST_IO
3875 RET(12)
3876 }
3877
3878 // BTSTn
3879 OPCODE(0x0827)
3880 {
3881         u32 adr, res;
3882         u32 src, dst;
3883
3884         FETCH_BYTE(src);
3885         src = 1 << (src & 7);
3886         adr = AREG(7) - 2;
3887         AREG(7) = adr;
3888         PRE_IO
3889         READ_BYTE_F(adr, res)
3890         flag_NotZ = res & src;
3891         POST_IO
3892 RET(14)
3893 }
3894
3895 // BCHGn
3896 OPCODE(0x0840)
3897 {
3898         u32 adr, res;
3899         u32 src, dst;
3900
3901         FETCH_BYTE(src);
3902         src = 1 << (src & 31);
3903         res = DREGu32((Opcode >> 0) & 7);
3904         flag_NotZ = res & src;
3905         res ^= src;
3906         DREGu32((Opcode >> 0) & 7) = res;
3907 RET(12)
3908 }
3909
3910 // BCHGn
3911 OPCODE(0x0850)
3912 {
3913         u32 adr, res;
3914         u32 src, dst;
3915
3916         FETCH_BYTE(src);
3917         src = 1 << (src & 7);
3918         adr = AREG((Opcode >> 0) & 7);
3919         PRE_IO
3920         READ_BYTE_F(adr, res)
3921         flag_NotZ = res & src;
3922         res ^= src;
3923         WRITE_BYTE_F(adr, res)
3924         POST_IO
3925 RET(16)
3926 }
3927
3928 // BCHGn
3929 OPCODE(0x0858)
3930 {
3931         u32 adr, res;
3932         u32 src, dst;
3933
3934         FETCH_BYTE(src);
3935         src = 1 << (src & 7);
3936         adr = AREG((Opcode >> 0) & 7);
3937         AREG((Opcode >> 0) & 7) += 1;
3938         PRE_IO
3939         READ_BYTE_F(adr, res)
3940         flag_NotZ = res & src;
3941         res ^= src;
3942         WRITE_BYTE_F(adr, res)
3943         POST_IO
3944 RET(16)
3945 }
3946
3947 // BCHGn
3948 OPCODE(0x0860)
3949 {
3950         u32 adr, res;
3951         u32 src, dst;
3952
3953         FETCH_BYTE(src);
3954         src = 1 << (src & 7);
3955         adr = AREG((Opcode >> 0) & 7) - 1;
3956         AREG((Opcode >> 0) & 7) = adr;
3957         PRE_IO
3958         READ_BYTE_F(adr, res)
3959         flag_NotZ = res & src;
3960         res ^= src;
3961         WRITE_BYTE_F(adr, res)
3962         POST_IO
3963 RET(18)
3964 }
3965
3966 // BCHGn
3967 OPCODE(0x0868)
3968 {
3969         u32 adr, res;
3970         u32 src, dst;
3971
3972         FETCH_BYTE(src);
3973         src = 1 << (src & 7);
3974         FETCH_SWORD(adr);
3975         adr += AREG((Opcode >> 0) & 7);
3976         PRE_IO
3977         READ_BYTE_F(adr, res)
3978         flag_NotZ = res & src;
3979         res ^= src;
3980         WRITE_BYTE_F(adr, res)
3981         POST_IO
3982 RET(20)
3983 }
3984
3985 // BCHGn
3986 OPCODE(0x0870)
3987 {
3988         u32 adr, res;
3989         u32 src, dst;
3990
3991         FETCH_BYTE(src);
3992         src = 1 << (src & 7);
3993         adr = AREG((Opcode >> 0) & 7);
3994         DECODE_EXT_WORD
3995         PRE_IO
3996         READ_BYTE_F(adr, res)
3997         flag_NotZ = res & src;
3998         res ^= src;
3999         WRITE_BYTE_F(adr, res)
4000         POST_IO
4001 RET(22)
4002 }
4003
4004 // BCHGn
4005 OPCODE(0x0878)
4006 {
4007         u32 adr, res;
4008         u32 src, dst;
4009
4010         FETCH_BYTE(src);
4011         src = 1 << (src & 7);
4012         FETCH_SWORD(adr);
4013         PRE_IO
4014         READ_BYTE_F(adr, res)
4015         flag_NotZ = res & src;
4016         res ^= src;
4017         WRITE_BYTE_F(adr, res)
4018         POST_IO
4019 RET(20)
4020 }
4021
4022 // BCHGn
4023 OPCODE(0x0879)
4024 {
4025         u32 adr, res;
4026         u32 src, dst;
4027
4028         FETCH_BYTE(src);
4029         src = 1 << (src & 7);
4030         FETCH_LONG(adr);
4031         PRE_IO
4032         READ_BYTE_F(adr, res)
4033         flag_NotZ = res & src;
4034         res ^= src;
4035         WRITE_BYTE_F(adr, res)
4036         POST_IO
4037 RET(24)
4038 }
4039
4040 // BCHGn
4041 OPCODE(0x085F)
4042 {
4043         u32 adr, res;
4044         u32 src, dst;
4045
4046         FETCH_BYTE(src);
4047         src = 1 << (src & 7);
4048         adr = AREG(7);
4049         AREG(7) += 2;
4050         PRE_IO
4051         READ_BYTE_F(adr, res)
4052         flag_NotZ = res & src;
4053         res ^= src;
4054         WRITE_BYTE_F(adr, res)
4055         POST_IO
4056 RET(16)
4057 }
4058
4059 // BCHGn
4060 OPCODE(0x0867)
4061 {
4062         u32 adr, res;
4063         u32 src, dst;
4064
4065         FETCH_BYTE(src);
4066         src = 1 << (src & 7);
4067         adr = AREG(7) - 2;
4068         AREG(7) = adr;
4069         PRE_IO
4070         READ_BYTE_F(adr, res)
4071         flag_NotZ = res & src;
4072         res ^= src;
4073         WRITE_BYTE_F(adr, res)
4074         POST_IO
4075 RET(18)
4076 }
4077
4078 // BCLRn
4079 OPCODE(0x0880)
4080 {
4081         u32 adr, res;
4082         u32 src, dst;
4083
4084         FETCH_BYTE(src);
4085         src = 1 << (src & 31);
4086         res = DREGu32((Opcode >> 0) & 7);
4087         flag_NotZ = res & src;
4088         res &= ~src;
4089         DREGu32((Opcode >> 0) & 7) = res;
4090 RET(14)
4091 }
4092
4093 // BCLRn
4094 OPCODE(0x0890)
4095 {
4096         u32 adr, res;
4097         u32 src, dst;
4098
4099         FETCH_BYTE(src);
4100         src = 1 << (src & 7);
4101         adr = AREG((Opcode >> 0) & 7);
4102         PRE_IO
4103         READ_BYTE_F(adr, res)
4104         flag_NotZ = res & src;
4105         res &= ~src;
4106         WRITE_BYTE_F(adr, res)
4107         POST_IO
4108 RET(16)
4109 }
4110
4111 // BCLRn
4112 OPCODE(0x0898)
4113 {
4114         u32 adr, res;
4115         u32 src, dst;
4116
4117         FETCH_BYTE(src);
4118         src = 1 << (src & 7);
4119         adr = AREG((Opcode >> 0) & 7);
4120         AREG((Opcode >> 0) & 7) += 1;
4121         PRE_IO
4122         READ_BYTE_F(adr, res)
4123         flag_NotZ = res & src;
4124         res &= ~src;
4125         WRITE_BYTE_F(adr, res)
4126         POST_IO
4127 RET(16)
4128 }
4129
4130 // BCLRn
4131 OPCODE(0x08A0)
4132 {
4133         u32 adr, res;
4134         u32 src, dst;
4135
4136         FETCH_BYTE(src);
4137         src = 1 << (src & 7);
4138         adr = AREG((Opcode >> 0) & 7) - 1;
4139         AREG((Opcode >> 0) & 7) = adr;
4140         PRE_IO
4141         READ_BYTE_F(adr, res)
4142         flag_NotZ = res & src;
4143         res &= ~src;
4144         WRITE_BYTE_F(adr, res)
4145         POST_IO
4146 RET(18)
4147 }
4148
4149 // BCLRn
4150 OPCODE(0x08A8)
4151 {
4152         u32 adr, res;
4153         u32 src, dst;
4154
4155         FETCH_BYTE(src);
4156         src = 1 << (src & 7);
4157         FETCH_SWORD(adr);
4158         adr += AREG((Opcode >> 0) & 7);
4159         PRE_IO
4160         READ_BYTE_F(adr, res)
4161         flag_NotZ = res & src;
4162         res &= ~src;
4163         WRITE_BYTE_F(adr, res)
4164         POST_IO
4165 RET(20)
4166 }
4167
4168 // BCLRn
4169 OPCODE(0x08B0)
4170 {
4171         u32 adr, res;
4172         u32 src, dst;
4173
4174         FETCH_BYTE(src);
4175         src = 1 << (src & 7);
4176         adr = AREG((Opcode >> 0) & 7);
4177         DECODE_EXT_WORD
4178         PRE_IO
4179         READ_BYTE_F(adr, res)
4180         flag_NotZ = res & src;
4181         res &= ~src;
4182         WRITE_BYTE_F(adr, res)
4183         POST_IO
4184 RET(22)
4185 }
4186
4187 // BCLRn
4188 OPCODE(0x08B8)
4189 {
4190         u32 adr, res;
4191         u32 src, dst;
4192
4193         FETCH_BYTE(src);
4194         src = 1 << (src & 7);
4195         FETCH_SWORD(adr);
4196         PRE_IO
4197         READ_BYTE_F(adr, res)
4198         flag_NotZ = res & src;
4199         res &= ~src;
4200         WRITE_BYTE_F(adr, res)
4201         POST_IO
4202 RET(20)
4203 }
4204
4205 // BCLRn
4206 OPCODE(0x08B9)
4207 {
4208         u32 adr, res;
4209         u32 src, dst;
4210
4211         FETCH_BYTE(src);
4212         src = 1 << (src & 7);
4213         FETCH_LONG(adr);
4214         PRE_IO
4215         READ_BYTE_F(adr, res)
4216         flag_NotZ = res & src;
4217         res &= ~src;
4218         WRITE_BYTE_F(adr, res)
4219         POST_IO
4220 RET(24)
4221 }
4222
4223 // BCLRn
4224 OPCODE(0x089F)
4225 {
4226         u32 adr, res;
4227         u32 src, dst;
4228
4229         FETCH_BYTE(src);
4230         src = 1 << (src & 7);
4231         adr = AREG(7);
4232         AREG(7) += 2;
4233         PRE_IO
4234         READ_BYTE_F(adr, res)
4235         flag_NotZ = res & src;
4236         res &= ~src;
4237         WRITE_BYTE_F(adr, res)
4238         POST_IO
4239 RET(16)
4240 }
4241
4242 // BCLRn
4243 OPCODE(0x08A7)
4244 {
4245         u32 adr, res;
4246         u32 src, dst;
4247
4248         FETCH_BYTE(src);
4249         src = 1 << (src & 7);
4250         adr = AREG(7) - 2;
4251         AREG(7) = adr;
4252         PRE_IO
4253         READ_BYTE_F(adr, res)
4254         flag_NotZ = res & src;
4255         res &= ~src;
4256         WRITE_BYTE_F(adr, res)
4257         POST_IO
4258 RET(18)
4259 }
4260
4261 // BSETn
4262 OPCODE(0x08C0)
4263 {
4264         u32 adr, res;
4265         u32 src, dst;
4266
4267         FETCH_BYTE(src);
4268         src = 1 << (src & 31);
4269         res = DREGu32((Opcode >> 0) & 7);
4270         flag_NotZ = res & src;
4271         res |= src;
4272         DREGu32((Opcode >> 0) & 7) = res;
4273 RET(12)
4274 }
4275
4276 // BSETn
4277 OPCODE(0x08D0)
4278 {
4279         u32 adr, res;
4280         u32 src, dst;
4281
4282         FETCH_BYTE(src);
4283         src = 1 << (src & 7);
4284         adr = AREG((Opcode >> 0) & 7);
4285         PRE_IO
4286         READ_BYTE_F(adr, res)
4287         flag_NotZ = res & src;
4288         res |= src;
4289         WRITE_BYTE_F(adr, res)
4290         POST_IO
4291 RET(16)
4292 }
4293
4294 // BSETn
4295 OPCODE(0x08D8)
4296 {
4297         u32 adr, res;
4298         u32 src, dst;
4299
4300         FETCH_BYTE(src);
4301         src = 1 << (src & 7);
4302         adr = AREG((Opcode >> 0) & 7);
4303         AREG((Opcode >> 0) & 7) += 1;
4304         PRE_IO
4305         READ_BYTE_F(adr, res)
4306         flag_NotZ = res & src;
4307         res |= src;
4308         WRITE_BYTE_F(adr, res)
4309         POST_IO
4310 RET(16)
4311 }
4312
4313 // BSETn
4314 OPCODE(0x08E0)
4315 {
4316         u32 adr, res;
4317         u32 src, dst;
4318
4319         FETCH_BYTE(src);
4320         src = 1 << (src & 7);
4321         adr = AREG((Opcode >> 0) & 7) - 1;
4322         AREG((Opcode >> 0) & 7) = adr;
4323         PRE_IO
4324         READ_BYTE_F(adr, res)
4325         flag_NotZ = res & src;
4326         res |= src;
4327         WRITE_BYTE_F(adr, res)
4328         POST_IO
4329 RET(18)
4330 }
4331
4332 // BSETn
4333 OPCODE(0x08E8)
4334 {
4335         u32 adr, res;
4336         u32 src, dst;
4337
4338         FETCH_BYTE(src);
4339         src = 1 << (src & 7);
4340         FETCH_SWORD(adr);
4341         adr += AREG((Opcode >> 0) & 7);
4342         PRE_IO
4343         READ_BYTE_F(adr, res)
4344         flag_NotZ = res & src;
4345         res |= src;
4346         WRITE_BYTE_F(adr, res)
4347         POST_IO
4348 RET(20)
4349 }
4350
4351 // BSETn
4352 OPCODE(0x08F0)
4353 {
4354         u32 adr, res;
4355         u32 src, dst;
4356
4357         FETCH_BYTE(src);
4358         src = 1 << (src & 7);
4359         adr = AREG((Opcode >> 0) & 7);
4360         DECODE_EXT_WORD
4361         PRE_IO
4362         READ_BYTE_F(adr, res)
4363         flag_NotZ = res & src;
4364         res |= src;
4365         WRITE_BYTE_F(adr, res)
4366         POST_IO
4367 RET(22)
4368 }
4369
4370 // BSETn
4371 OPCODE(0x08F8)
4372 {
4373         u32 adr, res;
4374         u32 src, dst;
4375
4376         FETCH_BYTE(src);
4377         src = 1 << (src & 7);
4378         FETCH_SWORD(adr);
4379         PRE_IO
4380         READ_BYTE_F(adr, res)
4381         flag_NotZ = res & src;
4382         res |= src;
4383         WRITE_BYTE_F(adr, res)
4384         POST_IO
4385 RET(20)
4386 }
4387
4388 // BSETn
4389 OPCODE(0x08F9)
4390 {
4391         u32 adr, res;
4392         u32 src, dst;
4393
4394         FETCH_BYTE(src);
4395         src = 1 << (src & 7);
4396         FETCH_LONG(adr);
4397         PRE_IO
4398         READ_BYTE_F(adr, res)
4399         flag_NotZ = res & src;
4400         res |= src;
4401         WRITE_BYTE_F(adr, res)
4402         POST_IO
4403 RET(24)
4404 }
4405
4406 // BSETn
4407 OPCODE(0x08DF)
4408 {
4409         u32 adr, res;
4410         u32 src, dst;
4411
4412         FETCH_BYTE(src);
4413         src = 1 << (src & 7);
4414         adr = AREG(7);
4415         AREG(7) += 2;
4416         PRE_IO
4417         READ_BYTE_F(adr, res)
4418         flag_NotZ = res & src;
4419         res |= src;
4420         WRITE_BYTE_F(adr, res)
4421         POST_IO
4422 RET(16)
4423 }
4424
4425 // BSETn
4426 OPCODE(0x08E7)
4427 {
4428         u32 adr, res;
4429         u32 src, dst;
4430
4431         FETCH_BYTE(src);
4432         src = 1 << (src & 7);
4433         adr = AREG(7) - 2;
4434         AREG(7) = adr;
4435         PRE_IO
4436         READ_BYTE_F(adr, res)
4437         flag_NotZ = res & src;
4438         res |= src;
4439         WRITE_BYTE_F(adr, res)
4440         POST_IO
4441 RET(18)
4442 }
4443
4444 // BTST
4445 OPCODE(0x0100)
4446 {
4447         u32 adr, res;
4448         u32 src, dst;
4449
4450         src = DREGu32((Opcode >> 9) & 7);
4451         src = 1 << (src & 31);
4452         res = DREGu32((Opcode >> 0) & 7);
4453         flag_NotZ = res & src;
4454 RET(6)
4455 }
4456
4457 // BTST
4458 OPCODE(0x0110)
4459 {
4460         u32 adr, res;
4461         u32 src, dst;
4462
4463         src = DREGu8((Opcode >> 9) & 7);
4464         src = 1 << (src & 7);
4465         adr = AREG((Opcode >> 0) & 7);
4466         PRE_IO
4467         READ_BYTE_F(adr, res)
4468         flag_NotZ = res & src;
4469         POST_IO
4470 RET(8)
4471 }
4472
4473 // BTST
4474 OPCODE(0x0118)
4475 {
4476         u32 adr, res;
4477         u32 src, dst;
4478
4479         src = DREGu8((Opcode >> 9) & 7);
4480         src = 1 << (src & 7);
4481         adr = AREG((Opcode >> 0) & 7);
4482         AREG((Opcode >> 0) & 7) += 1;
4483         PRE_IO
4484         READ_BYTE_F(adr, res)
4485         flag_NotZ = res & src;
4486         POST_IO
4487 RET(8)
4488 }
4489
4490 // BTST
4491 OPCODE(0x0120)
4492 {
4493         u32 adr, res;
4494         u32 src, dst;
4495
4496         src = DREGu8((Opcode >> 9) & 7);
4497         src = 1 << (src & 7);
4498         adr = AREG((Opcode >> 0) & 7) - 1;
4499         AREG((Opcode >> 0) & 7) = adr;
4500         PRE_IO
4501         READ_BYTE_F(adr, res)
4502         flag_NotZ = res & src;
4503         POST_IO
4504 RET(10)
4505 }
4506
4507 // BTST
4508 OPCODE(0x0128)
4509 {
4510         u32 adr, res;
4511         u32 src, dst;
4512
4513         src = DREGu8((Opcode >> 9) & 7);
4514         src = 1 << (src & 7);
4515         FETCH_SWORD(adr);
4516         adr += AREG((Opcode >> 0) & 7);
4517         PRE_IO
4518         READ_BYTE_F(adr, res)
4519         flag_NotZ = res & src;
4520         POST_IO
4521 RET(12)
4522 }
4523
4524 // BTST
4525 OPCODE(0x0130)
4526 {
4527         u32 adr, res;
4528         u32 src, dst;
4529
4530         src = DREGu8((Opcode >> 9) & 7);
4531         src = 1 << (src & 7);
4532         adr = AREG((Opcode >> 0) & 7);
4533         DECODE_EXT_WORD
4534         PRE_IO
4535         READ_BYTE_F(adr, res)
4536         flag_NotZ = res & src;
4537         POST_IO
4538 RET(14)
4539 }
4540
4541 // BTST
4542 OPCODE(0x0138)
4543 {
4544         u32 adr, res;
4545         u32 src, dst;
4546
4547         src = DREGu8((Opcode >> 9) & 7);
4548         src = 1 << (src & 7);
4549         FETCH_SWORD(adr);
4550         PRE_IO
4551         READ_BYTE_F(adr, res)
4552         flag_NotZ = res & src;
4553         POST_IO
4554 RET(12)
4555 }
4556
4557 // BTST
4558 OPCODE(0x0139)
4559 {
4560         u32 adr, res;
4561         u32 src, dst;
4562
4563         src = DREGu8((Opcode >> 9) & 7);
4564         src = 1 << (src & 7);
4565         FETCH_LONG(adr);
4566         PRE_IO
4567         READ_BYTE_F(adr, res)
4568         flag_NotZ = res & src;
4569         POST_IO
4570 RET(16)
4571 }
4572
4573 // BTST
4574 OPCODE(0x013A)
4575 {
4576         u32 adr, res;
4577         u32 src, dst;
4578
4579         src = DREGu8((Opcode >> 9) & 7);
4580         src = 1 << (src & 7);
4581         adr = GET_SWORD + GET_PC;
4582         PC++;
4583         PRE_IO
4584         READ_BYTE_F(adr, res)
4585         flag_NotZ = res & src;
4586         POST_IO
4587 RET(12)
4588 }
4589
4590 // BTST
4591 OPCODE(0x013B)
4592 {
4593         u32 adr, res;
4594         u32 src, dst;
4595
4596         src = DREGu8((Opcode >> 9) & 7);
4597         src = 1 << (src & 7);
4598         adr = (uptr)(PC) - BasePC;
4599         DECODE_EXT_WORD
4600         PRE_IO
4601         READ_BYTE_F(adr, res)
4602         flag_NotZ = res & src;
4603         POST_IO
4604 RET(14)
4605 }
4606
4607 // BTST
4608 OPCODE(0x013C)
4609 {
4610         u32 adr, res;
4611         u32 src, dst;
4612
4613         src = DREGu8((Opcode >> 9) & 7);
4614         src = 1 << (src & 7);
4615         FETCH_BYTE(res);
4616         flag_NotZ = res & src;
4617 RET(8)
4618 }
4619
4620 // BTST
4621 OPCODE(0x011F)
4622 {
4623         u32 adr, res;
4624         u32 src, dst;
4625
4626         src = DREGu8((Opcode >> 9) & 7);
4627         src = 1 << (src & 7);
4628         adr = AREG(7);
4629         AREG(7) += 2;
4630         PRE_IO
4631         READ_BYTE_F(adr, res)
4632         flag_NotZ = res & src;
4633         POST_IO
4634 RET(8)
4635 }
4636
4637 // BTST
4638 OPCODE(0x0127)
4639 {
4640         u32 adr, res;
4641         u32 src, dst;
4642
4643         src = DREGu8((Opcode >> 9) & 7);
4644         src = 1 << (src & 7);
4645         adr = AREG(7) - 2;
4646         AREG(7) = adr;
4647         PRE_IO
4648         READ_BYTE_F(adr, res)
4649         flag_NotZ = res & src;
4650         POST_IO
4651 RET(10)
4652 }
4653
4654 // BCHG
4655 OPCODE(0x0140)
4656 {
4657         u32 adr, res;
4658         u32 src, dst;
4659
4660         src = DREGu32((Opcode >> 9) & 7);
4661         src = 1 << (src & 31);
4662         res = DREGu32((Opcode >> 0) & 7);
4663         flag_NotZ = res & src;
4664         res ^= src;
4665         DREGu32((Opcode >> 0) & 7) = res;
4666 RET(8)
4667 }
4668
4669 // BCHG
4670 OPCODE(0x0150)
4671 {
4672         u32 adr, res;
4673         u32 src, dst;
4674
4675         src = DREGu8((Opcode >> 9) & 7);
4676         src = 1 << (src & 7);
4677         adr = AREG((Opcode >> 0) & 7);
4678         PRE_IO
4679         READ_BYTE_F(adr, res)
4680         flag_NotZ = res & src;
4681         res ^= src;
4682         WRITE_BYTE_F(adr, res)
4683         POST_IO
4684 RET(12)
4685 }
4686
4687 // BCHG
4688 OPCODE(0x0158)
4689 {
4690         u32 adr, res;
4691         u32 src, dst;
4692
4693         src = DREGu8((Opcode >> 9) & 7);
4694         src = 1 << (src & 7);
4695         adr = AREG((Opcode >> 0) & 7);
4696         AREG((Opcode >> 0) & 7) += 1;
4697         PRE_IO
4698         READ_BYTE_F(adr, res)
4699         flag_NotZ = res & src;
4700         res ^= src;
4701         WRITE_BYTE_F(adr, res)
4702         POST_IO
4703 RET(12)
4704 }
4705
4706 // BCHG
4707 OPCODE(0x0160)
4708 {
4709         u32 adr, res;
4710         u32 src, dst;
4711
4712         src = DREGu8((Opcode >> 9) & 7);
4713         src = 1 << (src & 7);
4714         adr = AREG((Opcode >> 0) & 7) - 1;
4715         AREG((Opcode >> 0) & 7) = adr;
4716         PRE_IO
4717         READ_BYTE_F(adr, res)
4718         flag_NotZ = res & src;
4719         res ^= src;
4720         WRITE_BYTE_F(adr, res)
4721         POST_IO
4722 RET(14)
4723 }
4724
4725 // BCHG
4726 OPCODE(0x0168)
4727 {
4728         u32 adr, res;
4729         u32 src, dst;
4730
4731         src = DREGu8((Opcode >> 9) & 7);
4732         src = 1 << (src & 7);
4733         FETCH_SWORD(adr);
4734         adr += AREG((Opcode >> 0) & 7);
4735         PRE_IO
4736         READ_BYTE_F(adr, res)
4737         flag_NotZ = res & src;
4738         res ^= src;
4739         WRITE_BYTE_F(adr, res)
4740         POST_IO
4741 RET(16)
4742 }
4743
4744 // BCHG
4745 OPCODE(0x0170)
4746 {
4747         u32 adr, res;
4748         u32 src, dst;
4749
4750         src = DREGu8((Opcode >> 9) & 7);
4751         src = 1 << (src & 7);
4752         adr = AREG((Opcode >> 0) & 7);
4753         DECODE_EXT_WORD
4754         PRE_IO
4755         READ_BYTE_F(adr, res)
4756         flag_NotZ = res & src;
4757         res ^= src;
4758         WRITE_BYTE_F(adr, res)
4759         POST_IO
4760 RET(18)
4761 }
4762
4763 // BCHG
4764 OPCODE(0x0178)
4765 {
4766         u32 adr, res;
4767         u32 src, dst;
4768
4769         src = DREGu8((Opcode >> 9) & 7);
4770         src = 1 << (src & 7);
4771         FETCH_SWORD(adr);
4772         PRE_IO
4773         READ_BYTE_F(adr, res)
4774         flag_NotZ = res & src;
4775         res ^= src;
4776         WRITE_BYTE_F(adr, res)
4777         POST_IO
4778 RET(16)
4779 }
4780
4781 // BCHG
4782 OPCODE(0x0179)
4783 {
4784         u32 adr, res;
4785         u32 src, dst;
4786
4787         src = DREGu8((Opcode >> 9) & 7);
4788         src = 1 << (src & 7);
4789         FETCH_LONG(adr);
4790         PRE_IO
4791         READ_BYTE_F(adr, res)
4792         flag_NotZ = res & src;
4793         res ^= src;
4794         WRITE_BYTE_F(adr, res)
4795         POST_IO
4796 RET(20)
4797 }
4798
4799 // BCHG
4800 OPCODE(0x015F)
4801 {
4802         u32 adr, res;
4803         u32 src, dst;
4804
4805         src = DREGu8((Opcode >> 9) & 7);
4806         src = 1 << (src & 7);
4807         adr = AREG(7);
4808         AREG(7) += 2;
4809         PRE_IO
4810         READ_BYTE_F(adr, res)
4811         flag_NotZ = res & src;
4812         res ^= src;
4813         WRITE_BYTE_F(adr, res)
4814         POST_IO
4815 RET(12)
4816 }
4817
4818 // BCHG
4819 OPCODE(0x0167)
4820 {
4821         u32 adr, res;
4822         u32 src, dst;
4823
4824         src = DREGu8((Opcode >> 9) & 7);
4825         src = 1 << (src & 7);
4826         adr = AREG(7) - 2;
4827         AREG(7) = adr;
4828         PRE_IO
4829         READ_BYTE_F(adr, res)
4830         flag_NotZ = res & src;
4831         res ^= src;
4832         WRITE_BYTE_F(adr, res)
4833         POST_IO
4834 RET(14)
4835 }
4836
4837 // BCLR
4838 OPCODE(0x0180)
4839 {
4840         u32 adr, res;
4841         u32 src, dst;
4842
4843         src = DREGu32((Opcode >> 9) & 7);
4844         src = 1 << (src & 31);
4845         res = DREGu32((Opcode >> 0) & 7);
4846         flag_NotZ = res & src;
4847         res &= ~src;
4848         DREGu32((Opcode >> 0) & 7) = res;
4849 RET(10)
4850 }
4851
4852 // BCLR
4853 OPCODE(0x0190)
4854 {
4855         u32 adr, res;
4856         u32 src, dst;
4857
4858         src = DREGu8((Opcode >> 9) & 7);
4859         src = 1 << (src & 7);
4860         adr = AREG((Opcode >> 0) & 7);
4861         PRE_IO
4862         READ_BYTE_F(adr, res)
4863         flag_NotZ = res & src;
4864         res &= ~src;
4865         WRITE_BYTE_F(adr, res)
4866         POST_IO
4867 RET(12)
4868 }
4869
4870 // BCLR
4871 OPCODE(0x0198)
4872 {
4873         u32 adr, res;
4874         u32 src, dst;
4875
4876         src = DREGu8((Opcode >> 9) & 7);
4877         src = 1 << (src & 7);
4878         adr = AREG((Opcode >> 0) & 7);
4879         AREG((Opcode >> 0) & 7) += 1;
4880         PRE_IO
4881         READ_BYTE_F(adr, res)
4882         flag_NotZ = res & src;
4883         res &= ~src;
4884         WRITE_BYTE_F(adr, res)
4885         POST_IO
4886 RET(12)
4887 }
4888
4889 // BCLR
4890 OPCODE(0x01A0)
4891 {
4892         u32 adr, res;
4893         u32 src, dst;
4894
4895         src = DREGu8((Opcode >> 9) & 7);
4896         src = 1 << (src & 7);
4897         adr = AREG((Opcode >> 0) & 7) - 1;
4898         AREG((Opcode >> 0) & 7) = adr;
4899         PRE_IO
4900         READ_BYTE_F(adr, res)
4901         flag_NotZ = res & src;
4902         res &= ~src;
4903         WRITE_BYTE_F(adr, res)
4904         POST_IO
4905 RET(14)
4906 }
4907
4908 // BCLR
4909 OPCODE(0x01A8)
4910 {
4911         u32 adr, res;
4912         u32 src, dst;
4913
4914         src = DREGu8((Opcode >> 9) & 7);
4915         src = 1 << (src & 7);
4916         FETCH_SWORD(adr);
4917         adr += AREG((Opcode >> 0) & 7);
4918         PRE_IO
4919         READ_BYTE_F(adr, res)
4920         flag_NotZ = res & src;
4921         res &= ~src;
4922         WRITE_BYTE_F(adr, res)
4923         POST_IO
4924 RET(16)
4925 }
4926
4927 // BCLR
4928 OPCODE(0x01B0)
4929 {
4930         u32 adr, res;
4931         u32 src, dst;
4932
4933         src = DREGu8((Opcode >> 9) & 7);
4934         src = 1 << (src & 7);
4935         adr = AREG((Opcode >> 0) & 7);
4936         DECODE_EXT_WORD
4937         PRE_IO
4938         READ_BYTE_F(adr, res)
4939         flag_NotZ = res & src;
4940         res &= ~src;
4941         WRITE_BYTE_F(adr, res)
4942         POST_IO
4943 RET(18)
4944 }
4945
4946 // BCLR
4947 OPCODE(0x01B8)
4948 {
4949         u32 adr, res;
4950         u32 src, dst;
4951
4952         src = DREGu8((Opcode >> 9) & 7);
4953         src = 1 << (src & 7);
4954         FETCH_SWORD(adr);
4955         PRE_IO
4956         READ_BYTE_F(adr, res)
4957         flag_NotZ = res & src;
4958         res &= ~src;
4959         WRITE_BYTE_F(adr, res)
4960         POST_IO
4961 RET(16)
4962 }
4963
4964 // BCLR
4965 OPCODE(0x01B9)
4966 {
4967         u32 adr, res;
4968         u32 src, dst;
4969
4970         src = DREGu8((Opcode >> 9) & 7);
4971         src = 1 << (src & 7);
4972         FETCH_LONG(adr);
4973         PRE_IO
4974         READ_BYTE_F(adr, res)
4975         flag_NotZ = res & src;
4976         res &= ~src;
4977         WRITE_BYTE_F(adr, res)
4978         POST_IO
4979 RET(20)
4980 }
4981
4982 // BCLR
4983 OPCODE(0x019F)
4984 {
4985         u32 adr, res;
4986         u32 src, dst;
4987
4988         src = DREGu8((Opcode >> 9) & 7);
4989         src = 1 << (src & 7);
4990         adr = AREG(7);
4991         AREG(7) += 2;
4992         PRE_IO
4993         READ_BYTE_F(adr, res)
4994         flag_NotZ = res & src;
4995         res &= ~src;
4996         WRITE_BYTE_F(adr, res)
4997         POST_IO
4998 RET(12)
4999 }
5000
5001 // BCLR
5002 OPCODE(0x01A7)
5003 {
5004         u32 adr, res;
5005         u32 src, dst;
5006
5007         src = DREGu8((Opcode >> 9) & 7);
5008         src = 1 << (src & 7);
5009         adr = AREG(7) - 2;
5010         AREG(7) = adr;
5011         PRE_IO
5012         READ_BYTE_F(adr, res)
5013         flag_NotZ = res & src;
5014         res &= ~src;
5015         WRITE_BYTE_F(adr, res)
5016         POST_IO
5017 RET(14)
5018 }
5019
5020 // BSET
5021 OPCODE(0x01C0)
5022 {
5023         u32 adr, res;
5024         u32 src, dst;
5025
5026         src = DREGu32((Opcode >> 9) & 7);
5027         src = 1 << (src & 31);
5028         res = DREGu32((Opcode >> 0) & 7);
5029         flag_NotZ = res & src;
5030         res |= src;
5031         DREGu32((Opcode >> 0) & 7) = res;
5032 RET(8)
5033 }
5034
5035 // BSET
5036 OPCODE(0x01D0)
5037 {
5038         u32 adr, res;
5039         u32 src, dst;
5040
5041         src = DREGu8((Opcode >> 9) & 7);
5042         src = 1 << (src & 7);
5043         adr = AREG((Opcode >> 0) & 7);
5044         PRE_IO
5045         READ_BYTE_F(adr, res)
5046         flag_NotZ = res & src;
5047         res |= src;
5048         WRITE_BYTE_F(adr, res)
5049         POST_IO
5050 RET(12)
5051 }
5052
5053 // BSET
5054 OPCODE(0x01D8)
5055 {
5056         u32 adr, res;
5057         u32 src, dst;
5058
5059         src = DREGu8((Opcode >> 9) & 7);
5060         src = 1 << (src & 7);
5061         adr = AREG((Opcode >> 0) & 7);
5062         AREG((Opcode >> 0) & 7) += 1;
5063         PRE_IO
5064         READ_BYTE_F(adr, res)
5065         flag_NotZ = res & src;
5066         res |= src;
5067         WRITE_BYTE_F(adr, res)
5068         POST_IO
5069 RET(12)
5070 }
5071
5072 // BSET
5073 OPCODE(0x01E0)
5074 {
5075         u32 adr, res;
5076         u32 src, dst;
5077
5078         src = DREGu8((Opcode >> 9) & 7);
5079         src = 1 << (src & 7);
5080         adr = AREG((Opcode >> 0) & 7) - 1;
5081         AREG((Opcode >> 0) & 7) = adr;
5082         PRE_IO
5083         READ_BYTE_F(adr, res)
5084         flag_NotZ = res & src;
5085         res |= src;
5086         WRITE_BYTE_F(adr, res)
5087         POST_IO
5088 RET(14)
5089 }
5090
5091 // BSET
5092 OPCODE(0x01E8)
5093 {
5094         u32 adr, res;
5095         u32 src, dst;
5096
5097         src = DREGu8((Opcode >> 9) & 7);
5098         src = 1 << (src & 7);
5099         FETCH_SWORD(adr);
5100         adr += AREG((Opcode >> 0) & 7);
5101         PRE_IO
5102         READ_BYTE_F(adr, res)
5103         flag_NotZ = res & src;
5104         res |= src;
5105         WRITE_BYTE_F(adr, res)
5106         POST_IO
5107 RET(16)
5108 }
5109
5110 // BSET
5111 OPCODE(0x01F0)
5112 {
5113         u32 adr, res;
5114         u32 src, dst;
5115
5116         src = DREGu8((Opcode >> 9) & 7);
5117         src = 1 << (src & 7);
5118         adr = AREG((Opcode >> 0) & 7);
5119         DECODE_EXT_WORD
5120         PRE_IO
5121         READ_BYTE_F(adr, res)
5122         flag_NotZ = res & src;
5123         res |= src;
5124         WRITE_BYTE_F(adr, res)
5125         POST_IO
5126 RET(18)
5127 }
5128
5129 // BSET
5130 OPCODE(0x01F8)
5131 {
5132         u32 adr, res;
5133         u32 src, dst;
5134
5135         src = DREGu8((Opcode >> 9) & 7);
5136         src = 1 << (src & 7);
5137         FETCH_SWORD(adr);
5138         PRE_IO
5139         READ_BYTE_F(adr, res)
5140         flag_NotZ = res & src;
5141         res |= src;
5142         WRITE_BYTE_F(adr, res)
5143         POST_IO
5144 RET(16)
5145 }
5146
5147 // BSET
5148 OPCODE(0x01F9)
5149 {
5150         u32 adr, res;
5151         u32 src, dst;
5152
5153         src = DREGu8((Opcode >> 9) & 7);
5154         src = 1 << (src & 7);
5155         FETCH_LONG(adr);
5156         PRE_IO
5157         READ_BYTE_F(adr, res)
5158         flag_NotZ = res & src;
5159         res |= src;
5160         WRITE_BYTE_F(adr, res)
5161         POST_IO
5162 RET(20)
5163 }
5164
5165 // BSET
5166 OPCODE(0x01DF)
5167 {
5168         u32 adr, res;
5169         u32 src, dst;
5170
5171         src = DREGu8((Opcode >> 9) & 7);
5172         src = 1 << (src & 7);
5173         adr = AREG(7);
5174         AREG(7) += 2;
5175         PRE_IO
5176         READ_BYTE_F(adr, res)
5177         flag_NotZ = res & src;
5178         res |= src;
5179         WRITE_BYTE_F(adr, res)
5180         POST_IO
5181 RET(12)
5182 }
5183
5184 // BSET
5185 OPCODE(0x01E7)
5186 {
5187         u32 adr, res;
5188         u32 src, dst;
5189
5190         src = DREGu8((Opcode >> 9) & 7);
5191         src = 1 << (src & 7);
5192         adr = AREG(7) - 2;
5193         AREG(7) = adr;
5194         PRE_IO
5195         READ_BYTE_F(adr, res)
5196         flag_NotZ = res & src;
5197         res |= src;
5198         WRITE_BYTE_F(adr, res)
5199         POST_IO
5200 RET(14)
5201 }
5202
5203 // MOVEPWaD
5204 OPCODE(0x0108)
5205 {
5206         u32 adr, res;
5207         u32 src, dst;
5208
5209         FETCH_SWORD(adr);
5210         adr += AREG((Opcode >> 0) & 7);
5211         PRE_IO
5212         READ_BYTE_F(adr + 0, res)
5213         READ_BYTE_F(adr + 2, src)
5214         DREGu16((Opcode >> 9) & 7) = (res << 8) | src;
5215         POST_IO
5216 #ifdef USE_CYCLONE_TIMING
5217 RET(16)
5218 #else
5219 RET(24)
5220 #endif
5221 }
5222
5223 // MOVEPLaD
5224 OPCODE(0x0148)
5225 {
5226         u32 adr, res;
5227         u32 src, dst;
5228
5229         FETCH_SWORD(adr);
5230         adr += AREG((Opcode >> 0) & 7);
5231         PRE_IO
5232         READ_BYTE_F(adr, res)
5233         res <<= 24;
5234         adr += 2;
5235         READ_BYTE_F(adr, src)
5236         res |= src << 16;
5237         adr += 2;
5238         READ_BYTE_F(adr, src)
5239         res |= src << 8;
5240         adr += 2;
5241         READ_BYTE_F(adr, src)
5242         DREG((Opcode >> 9) & 7) = res | src;
5243         POST_IO
5244 #ifdef USE_CYCLONE_TIMING
5245 RET(24)
5246 #else
5247 RET(32)
5248 #endif
5249 }
5250
5251 // MOVEPWDa
5252 OPCODE(0x0188)
5253 {
5254         u32 adr, res;
5255         u32 src, dst;
5256
5257         res = DREGu32((Opcode >> 9) & 7);
5258         FETCH_SWORD(adr);
5259         adr += AREG((Opcode >> 0) & 7);
5260         PRE_IO
5261         WRITE_BYTE_F(adr + 0, res >> 8)
5262         WRITE_BYTE_F(adr + 2, res >> 0)
5263         POST_IO
5264 #ifdef USE_CYCLONE_TIMING
5265 RET(16)
5266 #else
5267 RET(24)
5268 #endif
5269 }
5270
5271 // MOVEPLDa
5272 OPCODE(0x01C8)
5273 {
5274         u32 adr, res;
5275         u32 src, dst;
5276
5277         res = DREGu32((Opcode >> 9) & 7);
5278         FETCH_SWORD(adr);
5279         adr += AREG((Opcode >> 0) & 7);
5280         PRE_IO
5281         WRITE_BYTE_F(adr, res >> 24)
5282         adr += 2;
5283         WRITE_BYTE_F(adr, res >> 16)
5284         adr += 2;
5285         WRITE_BYTE_F(adr, res >> 8)
5286         adr += 2;
5287         WRITE_BYTE_F(adr, res >> 0)
5288         POST_IO
5289 #ifdef USE_CYCLONE_TIMING
5290 RET(24)
5291 #else
5292 RET(32)
5293 #endif
5294 }
5295
5296 // MOVEB
5297 OPCODE(0x1000)
5298 {
5299         u32 adr, res;
5300         u32 src, dst;
5301
5302         res = DREGu8((Opcode >> 0) & 7);
5303         flag_C = 0;
5304         flag_V = 0;
5305         flag_NotZ = res;
5306         flag_N = res;
5307         DREGu8((Opcode >> 9) & 7) = res;
5308 RET(4)
5309 }
5310
5311 // MOVEB
5312 OPCODE(0x1080)
5313 {
5314         u32 adr, res;
5315         u32 src, dst;
5316
5317         res = DREGu8((Opcode >> 0) & 7);
5318         flag_C = 0;
5319         flag_V = 0;
5320         flag_NotZ = res;
5321         flag_N = res;
5322         adr = AREG((Opcode >> 9) & 7);
5323         PRE_IO
5324         WRITE_BYTE_F(adr, res)
5325         POST_IO
5326 RET(8)
5327 }
5328
5329 // MOVEB
5330 OPCODE(0x10C0)
5331 {
5332         u32 adr, res;
5333         u32 src, dst;
5334
5335         res = DREGu8((Opcode >> 0) & 7);
5336         flag_C = 0;
5337         flag_V = 0;
5338         flag_NotZ = res;
5339         flag_N = res;
5340         adr = AREG((Opcode >> 9) & 7);
5341         AREG((Opcode >> 9) & 7) += 1;
5342         PRE_IO
5343         WRITE_BYTE_F(adr, res)
5344         POST_IO
5345 RET(8)
5346 }
5347
5348 // MOVEB
5349 OPCODE(0x1100)
5350 {
5351         u32 adr, res;
5352         u32 src, dst;
5353
5354         res = DREGu8((Opcode >> 0) & 7);
5355         flag_C = 0;
5356         flag_V = 0;
5357         flag_NotZ = res;
5358         flag_N = res;
5359         adr = AREG((Opcode >> 9) & 7) - 1;
5360         AREG((Opcode >> 9) & 7) = adr;
5361         PRE_IO
5362         WRITE_BYTE_F(adr, res)
5363         POST_IO
5364 RET(8)
5365 }
5366
5367 // MOVEB
5368 OPCODE(0x1140)
5369 {
5370         u32 adr, res;
5371         u32 src, dst;
5372
5373         res = DREGu8((Opcode >> 0) & 7);
5374         flag_C = 0;
5375         flag_V = 0;
5376         flag_NotZ = res;
5377         flag_N = res;
5378         FETCH_SWORD(adr);
5379         adr += AREG((Opcode >> 9) & 7);
5380         PRE_IO
5381         WRITE_BYTE_F(adr, res)
5382         POST_IO
5383 RET(12)
5384 }
5385
5386 // MOVEB
5387 OPCODE(0x1180)
5388 {
5389         u32 adr, res;
5390         u32 src, dst;
5391
5392         res = DREGu8((Opcode >> 0) & 7);
5393         flag_C = 0;
5394         flag_V = 0;
5395         flag_NotZ = res;
5396         flag_N = res;
5397         adr = AREG((Opcode >> 9) & 7);
5398         DECODE_EXT_WORD
5399         PRE_IO
5400         WRITE_BYTE_F(adr, res)
5401         POST_IO
5402 RET(14)
5403 }
5404
5405 // MOVEB
5406 OPCODE(0x11C0)
5407 {
5408         u32 adr, res;
5409         u32 src, dst;
5410
5411         res = DREGu8((Opcode >> 0) & 7);
5412         flag_C = 0;
5413         flag_V = 0;
5414         flag_NotZ = res;
5415         flag_N = res;
5416         FETCH_SWORD(adr);
5417         PRE_IO
5418         WRITE_BYTE_F(adr, res)
5419         POST_IO
5420 RET(12)
5421 }
5422
5423 // MOVEB
5424 OPCODE(0x13C0)
5425 {
5426         u32 adr, res;
5427         u32 src, dst;
5428
5429         res = DREGu8((Opcode >> 0) & 7);
5430         flag_C = 0;
5431         flag_V = 0;
5432         flag_NotZ = res;
5433         flag_N = res;
5434         FETCH_LONG(adr);
5435         PRE_IO
5436         WRITE_BYTE_F(adr, res)
5437         POST_IO
5438 RET(16)
5439 }
5440
5441 // MOVEB
5442 OPCODE(0x1EC0)
5443 {
5444         u32 adr, res;
5445         u32 src, dst;
5446
5447         res = DREGu8((Opcode >> 0) & 7);
5448         flag_C = 0;
5449         flag_V = 0;
5450         flag_NotZ = res;
5451         flag_N = res;
5452         adr = AREG(7);
5453         AREG(7) += 2;
5454         PRE_IO
5455         WRITE_BYTE_F(adr, res)
5456         POST_IO
5457 RET(8)
5458 }
5459
5460 // MOVEB
5461 OPCODE(0x1F00)
5462 {
5463         u32 adr, res;
5464         u32 src, dst;
5465
5466         res = DREGu8((Opcode >> 0) & 7);
5467         flag_C = 0;
5468         flag_V = 0;
5469         flag_NotZ = res;
5470         flag_N = res;
5471         adr = AREG(7) - 2;
5472         AREG(7) = adr;
5473         PRE_IO
5474         WRITE_BYTE_F(adr, res)
5475         POST_IO
5476 RET(8)
5477 }
5478
5479 #if 0
5480 // MOVEB
5481 OPCODE(0x1008)
5482 {
5483         u32 adr, res;
5484         u32 src, dst;
5485
5486         // can't read byte from Ax registers !
5487         m68kcontext.execinfo |= M68K_FAULTED;
5488         m68kcontext.io_cycle_counter = 0;
5489 /*
5490         goto famec_Exec_End;
5491         flag_C = 0;
5492         flag_V = 0;
5493         flag_NotZ = res;
5494         flag_N = res;
5495         DREGu8((Opcode >> 9) & 7) = res;
5496 */
5497 RET(4)
5498 }
5499
5500 // MOVEB
5501 OPCODE(0x1088)
5502 {
5503         u32 adr, res;
5504         u32 src, dst;
5505
5506         // can't read byte from Ax registers !
5507         m68kcontext.execinfo |= M68K_FAULTED;
5508         m68kcontext.io_cycle_counter = 0;
5509 /*
5510         goto famec_Exec_End;
5511         flag_C = 0;
5512         flag_V = 0;
5513         flag_NotZ = res;
5514         flag_N = res;
5515         adr = AREG((Opcode >> 9) & 7);
5516         PRE_IO
5517         WRITE_BYTE_F(adr, res)
5518         POST_IO
5519 */
5520 RET(8)
5521 }
5522
5523 // MOVEB
5524 OPCODE(0x10C8)
5525 {
5526         u32 adr, res;
5527         u32 src, dst;
5528
5529         // can't read byte from Ax registers !
5530         m68kcontext.execinfo |= M68K_FAULTED;
5531         m68kcontext.io_cycle_counter = 0;
5532 /*
5533         goto famec_Exec_End;
5534         flag_C = 0;
5535         flag_V = 0;
5536         flag_NotZ = res;
5537         flag_N = res;
5538         adr = AREG((Opcode >> 9) & 7);
5539         AREG((Opcode >> 9) & 7) += 1;
5540         PRE_IO
5541         WRITE_BYTE_F(adr, res)
5542         POST_IO
5543 */
5544 RET(8)
5545 }
5546
5547 // MOVEB
5548 OPCODE(0x1108)
5549 {
5550         u32 adr, res;
5551         u32 src, dst;
5552
5553         // can't read byte from Ax registers !
5554         m68kcontext.execinfo |= M68K_FAULTED;
5555         m68kcontext.io_cycle_counter = 0;
5556 /*
5557         goto famec_Exec_End;
5558         flag_C = 0;
5559         flag_V = 0;
5560         flag_NotZ = res;
5561         flag_N = res;
5562         adr = AREG((Opcode >> 9) & 7) - 1;
5563         AREG((Opcode >> 9) & 7) = adr;
5564         PRE_IO
5565         WRITE_BYTE_F(adr, res)
5566         POST_IO
5567 */
5568 RET(8)
5569 }
5570
5571 // MOVEB
5572 OPCODE(0x1148)
5573 {
5574         u32 adr, res;
5575         u32 src, dst;
5576
5577         // can't read byte from Ax registers !
5578         m68kcontext.execinfo |= M68K_FAULTED;
5579         m68kcontext.io_cycle_counter = 0;
5580 /*
5581         goto famec_Exec_End;
5582         flag_C = 0;
5583         flag_V = 0;
5584         flag_NotZ = res;
5585         flag_N = res;
5586         FETCH_SWORD(adr);
5587         adr += AREG((Opcode >> 9) & 7);
5588         PRE_IO
5589         WRITE_BYTE_F(adr, res)
5590         POST_IO
5591 */
5592 RET(12)
5593 }
5594
5595 // MOVEB
5596 OPCODE(0x1188)
5597 {
5598         u32 adr, res;
5599         u32 src, dst;
5600
5601         // can't read byte from Ax registers !
5602         m68kcontext.execinfo |= M68K_FAULTED;
5603         m68kcontext.io_cycle_counter = 0;
5604 /*
5605         goto famec_Exec_End;
5606         flag_C = 0;
5607         flag_V = 0;
5608         flag_NotZ = res;
5609         flag_N = res;
5610         adr = AREG((Opcode >> 9) & 7);
5611         DECODE_EXT_WORD
5612         PRE_IO
5613         WRITE_BYTE_F(adr, res)
5614         POST_IO
5615 */
5616 RET(14)
5617 }
5618
5619 // MOVEB
5620 OPCODE(0x11C8)
5621 {
5622         u32 adr, res;
5623         u32 src, dst;
5624
5625         // can't read byte from Ax registers !
5626         m68kcontext.execinfo |= M68K_FAULTED;
5627         m68kcontext.io_cycle_counter = 0;
5628 /*
5629         goto famec_Exec_End;
5630         flag_C = 0;
5631         flag_V = 0;
5632         flag_NotZ = res;
5633         flag_N = res;
5634         FETCH_SWORD(adr);
5635         PRE_IO
5636         WRITE_BYTE_F(adr, res)
5637         POST_IO
5638 */
5639 RET(12)
5640 }
5641
5642 // MOVEB
5643 OPCODE(0x13C8)
5644 {
5645         u32 adr, res;
5646         u32 src, dst;
5647
5648         // can't read byte from Ax registers !
5649         m68kcontext.execinfo |= M68K_FAULTED;
5650         m68kcontext.io_cycle_counter = 0;
5651 /*
5652         goto famec_Exec_End;
5653         flag_C = 0;
5654         flag_V = 0;
5655         flag_NotZ = res;
5656         flag_N = res;
5657         FETCH_LONG(adr);
5658         PRE_IO
5659         WRITE_BYTE_F(adr, res)
5660         POST_IO
5661 */
5662 RET(16)
5663 }
5664
5665 // MOVEB
5666 OPCODE(0x1EC8)
5667 {
5668         u32 adr, res;
5669         u32 src, dst;
5670
5671         // can't read byte from Ax registers !
5672         m68kcontext.execinfo |= M68K_FAULTED;
5673         m68kcontext.io_cycle_counter = 0;
5674 /*
5675         goto famec_Exec_End;
5676         flag_C = 0;
5677         flag_V = 0;
5678         flag_NotZ = res;
5679         flag_N = res;
5680         adr = AREG(7);
5681         AREG(7) += 2;
5682         PRE_IO
5683         WRITE_BYTE_F(adr, res)
5684         POST_IO
5685 */
5686 RET(8)
5687 }
5688
5689 // MOVEB
5690 OPCODE(0x1F08)
5691 {
5692         u32 adr, res;
5693         u32 src, dst;
5694
5695         // can't read byte from Ax registers !
5696         m68kcontext.execinfo |= M68K_FAULTED;
5697         m68kcontext.io_cycle_counter = 0;
5698 /*
5699         goto famec_Exec_End;
5700         flag_C = 0;
5701         flag_V = 0;
5702         flag_NotZ = res;
5703         flag_N = res;
5704         adr = AREG(7) - 2;
5705         AREG(7) = adr;
5706         PRE_IO
5707         WRITE_BYTE_F(adr, res)
5708         POST_IO
5709 */
5710 RET(8)
5711 }
5712 #endif
5713
5714 // MOVEB
5715 OPCODE(0x1010)
5716 {
5717         u32 adr, res;
5718         u32 src, dst;
5719
5720         adr = AREG((Opcode >> 0) & 7);
5721         PRE_IO
5722         READ_BYTE_F(adr, res)
5723         flag_C = 0;
5724         flag_V = 0;
5725         flag_NotZ = res;
5726         flag_N = res;
5727         DREGu8((Opcode >> 9) & 7) = res;
5728         POST_IO
5729 RET(8)
5730 }
5731
5732 // MOVEB
5733 OPCODE(0x1090)
5734 {
5735         u32 adr, res;
5736         u32 src, dst;
5737
5738         adr = AREG((Opcode >> 0) & 7);
5739         PRE_IO
5740         READ_BYTE_F(adr, res)
5741         flag_C = 0;
5742         flag_V = 0;
5743         flag_NotZ = res;
5744         flag_N = res;
5745         adr = AREG((Opcode >> 9) & 7);
5746         WRITE_BYTE_F(adr, res)
5747         POST_IO
5748 RET(12)
5749 }
5750
5751 // MOVEB
5752 OPCODE(0x10D0)
5753 {
5754         u32 adr, res;
5755         u32 src, dst;
5756
5757         adr = AREG((Opcode >> 0) & 7);
5758         PRE_IO
5759         READ_BYTE_F(adr, res)
5760         flag_C = 0;
5761         flag_V = 0;
5762         flag_NotZ = res;
5763         flag_N = res;
5764         adr = AREG((Opcode >> 9) & 7);
5765         AREG((Opcode >> 9) & 7) += 1;
5766         WRITE_BYTE_F(adr, res)
5767         POST_IO
5768 RET(12)
5769 }
5770
5771 // MOVEB
5772 OPCODE(0x1110)
5773 {
5774         u32 adr, res;
5775         u32 src, dst;
5776
5777         adr = AREG((Opcode >> 0) & 7);
5778         PRE_IO
5779         READ_BYTE_F(adr, res)
5780         flag_C = 0;
5781         flag_V = 0;
5782         flag_NotZ = res;
5783         flag_N = res;
5784         adr = AREG((Opcode >> 9) & 7) - 1;
5785         AREG((Opcode >> 9) & 7) = adr;
5786         WRITE_BYTE_F(adr, res)
5787         POST_IO
5788 RET(12)
5789 }
5790
5791 // MOVEB
5792 OPCODE(0x1150)
5793 {
5794         u32 adr, res;
5795         u32 src, dst;
5796
5797         adr = AREG((Opcode >> 0) & 7);
5798         PRE_IO
5799         READ_BYTE_F(adr, res)
5800         flag_C = 0;
5801         flag_V = 0;
5802         flag_NotZ = res;
5803         flag_N = res;
5804         FETCH_SWORD(adr);
5805         adr += AREG((Opcode >> 9) & 7);
5806         WRITE_BYTE_F(adr, res)
5807         POST_IO
5808 RET(16)
5809 }
5810
5811 // MOVEB
5812 OPCODE(0x1190)
5813 {
5814         u32 adr, res;
5815         u32 src, dst;
5816
5817         adr = AREG((Opcode >> 0) & 7);
5818         PRE_IO
5819         READ_BYTE_F(adr, res)
5820         flag_C = 0;
5821         flag_V = 0;
5822         flag_NotZ = res;
5823         flag_N = res;
5824         adr = AREG((Opcode >> 9) & 7);
5825         DECODE_EXT_WORD
5826         WRITE_BYTE_F(adr, res)
5827         POST_IO
5828 RET(18)
5829 }
5830
5831 // MOVEB
5832 OPCODE(0x11D0)
5833 {
5834         u32 adr, res;
5835         u32 src, dst;
5836
5837         adr = AREG((Opcode >> 0) & 7);
5838         PRE_IO
5839         READ_BYTE_F(adr, res)
5840         flag_C = 0;
5841         flag_V = 0;
5842         flag_NotZ = res;
5843         flag_N = res;
5844         FETCH_SWORD(adr);
5845         WRITE_BYTE_F(adr, res)
5846         POST_IO
5847 RET(16)
5848 }
5849
5850 // MOVEB
5851 OPCODE(0x13D0)
5852 {
5853         u32 adr, res;
5854         u32 src, dst;
5855
5856         adr = AREG((Opcode >> 0) & 7);
5857         PRE_IO
5858         READ_BYTE_F(adr, res)
5859         flag_C = 0;
5860         flag_V = 0;
5861         flag_NotZ = res;
5862         flag_N = res;
5863         FETCH_LONG(adr);
5864         WRITE_BYTE_F(adr, res)
5865         POST_IO
5866 RET(20)
5867 }
5868
5869 // MOVEB
5870 OPCODE(0x1ED0)
5871 {
5872         u32 adr, res;
5873         u32 src, dst;
5874
5875         adr = AREG((Opcode >> 0) & 7);
5876         PRE_IO
5877         READ_BYTE_F(adr, res)
5878         flag_C = 0;
5879         flag_V = 0;
5880         flag_NotZ = res;
5881         flag_N = res;
5882         adr = AREG(7);
5883         AREG(7) += 2;
5884         WRITE_BYTE_F(adr, res)
5885         POST_IO
5886 RET(12)
5887 }
5888
5889 // MOVEB
5890 OPCODE(0x1F10)
5891 {
5892         u32 adr, res;
5893         u32 src, dst;
5894
5895         adr = AREG((Opcode >> 0) & 7);
5896         PRE_IO
5897         READ_BYTE_F(adr, res)
5898         flag_C = 0;
5899         flag_V = 0;
5900         flag_NotZ = res;
5901         flag_N = res;
5902         adr = AREG(7) - 2;
5903         AREG(7) = adr;
5904         WRITE_BYTE_F(adr, res)
5905         POST_IO
5906 RET(12)
5907 }
5908
5909 // MOVEB
5910 OPCODE(0x1018)
5911 {
5912         u32 adr, res;
5913         u32 src, dst;
5914
5915         adr = AREG((Opcode >> 0) & 7);
5916         AREG((Opcode >> 0) & 7) += 1;
5917         PRE_IO
5918         READ_BYTE_F(adr, res)
5919         flag_C = 0;
5920         flag_V = 0;
5921         flag_NotZ = res;
5922         flag_N = res;
5923         DREGu8((Opcode >> 9) & 7) = res;
5924         POST_IO
5925 RET(8)
5926 }
5927
5928 // MOVEB
5929 OPCODE(0x1098)
5930 {
5931         u32 adr, res;
5932         u32 src, dst;
5933
5934         adr = AREG((Opcode >> 0) & 7);
5935         AREG((Opcode >> 0) & 7) += 1;
5936         PRE_IO
5937         READ_BYTE_F(adr, res)
5938         flag_C = 0;
5939         flag_V = 0;
5940         flag_NotZ = res;
5941         flag_N = res;
5942         adr = AREG((Opcode >> 9) & 7);
5943         WRITE_BYTE_F(adr, res)
5944         POST_IO
5945 RET(12)
5946 }
5947
5948 // MOVEB
5949 OPCODE(0x10D8)
5950 {
5951         u32 adr, res;
5952         u32 src, dst;
5953
5954         adr = AREG((Opcode >> 0) & 7);
5955         AREG((Opcode >> 0) & 7) += 1;
5956         PRE_IO
5957         READ_BYTE_F(adr, res)
5958         flag_C = 0;
5959         flag_V = 0;
5960         flag_NotZ = res;
5961         flag_N = res;
5962         adr = AREG((Opcode >> 9) & 7);
5963         AREG((Opcode >> 9) & 7) += 1;
5964         WRITE_BYTE_F(adr, res)
5965         POST_IO
5966 RET(12)
5967 }
5968
5969 // MOVEB
5970 OPCODE(0x1118)
5971 {
5972         u32 adr, res;
5973         u32 src, dst;
5974
5975         adr = AREG((Opcode >> 0) & 7);
5976         AREG((Opcode >> 0) & 7) += 1;
5977         PRE_IO
5978         READ_BYTE_F(adr, res)
5979         flag_C = 0;
5980         flag_V = 0;
5981         flag_NotZ = res;
5982         flag_N = res;
5983         adr = AREG((Opcode >> 9) & 7) - 1;
5984         AREG((Opcode >> 9) & 7) = adr;
5985         WRITE_BYTE_F(adr, res)
5986         POST_IO
5987 RET(12)
5988 }
5989
5990 // MOVEB
5991 OPCODE(0x1158)
5992 {
5993         u32 adr, res;
5994         u32 src, dst;
5995
5996         adr = AREG((Opcode >> 0) & 7);
5997         AREG((Opcode >> 0) & 7) += 1;
5998         PRE_IO
5999         READ_BYTE_F(adr, res)
6000         flag_C = 0;
6001         flag_V = 0;
6002         flag_NotZ = res;
6003         flag_N = res;
6004         FETCH_SWORD(adr);
6005         adr += AREG((Opcode >> 9) & 7);
6006         WRITE_BYTE_F(adr, res)
6007         POST_IO
6008 RET(16)
6009 }
6010
6011 // MOVEB
6012 OPCODE(0x1198)
6013 {
6014         u32 adr, res;
6015         u32 src, dst;
6016
6017         adr = AREG((Opcode >> 0) & 7);
6018         AREG((Opcode >> 0) & 7) += 1;
6019         PRE_IO
6020         READ_BYTE_F(adr, res)
6021         flag_C = 0;
6022         flag_V = 0;
6023         flag_NotZ = res;
6024         flag_N = res;
6025         adr = AREG((Opcode >> 9) & 7);
6026         DECODE_EXT_WORD
6027         WRITE_BYTE_F(adr, res)
6028         POST_IO
6029 RET(18)
6030 }
6031
6032 // MOVEB
6033 OPCODE(0x11D8)
6034 {
6035         u32 adr, res;
6036         u32 src, dst;
6037
6038         adr = AREG((Opcode >> 0) & 7);
6039         AREG((Opcode >> 0) & 7) += 1;
6040         PRE_IO
6041         READ_BYTE_F(adr, res)
6042         flag_C = 0;
6043         flag_V = 0;
6044         flag_NotZ = res;
6045         flag_N = res;
6046         FETCH_SWORD(adr);
6047         WRITE_BYTE_F(adr, res)
6048         POST_IO
6049 RET(16)
6050 }
6051
6052 // MOVEB
6053 OPCODE(0x13D8)
6054 {
6055         u32 adr, res;
6056         u32 src, dst;
6057
6058         adr = AREG((Opcode >> 0) & 7);
6059         AREG((Opcode >> 0) & 7) += 1;
6060         PRE_IO
6061         READ_BYTE_F(adr, res)
6062         flag_C = 0;
6063         flag_V = 0;
6064         flag_NotZ = res;
6065         flag_N = res;
6066         FETCH_LONG(adr);
6067         WRITE_BYTE_F(adr, res)
6068         POST_IO
6069 RET(20)
6070 }
6071
6072 // MOVEB
6073 OPCODE(0x1ED8)
6074 {
6075         u32 adr, res;
6076         u32 src, dst;
6077
6078         adr = AREG((Opcode >> 0) & 7);
6079         AREG((Opcode >> 0) & 7) += 1;
6080         PRE_IO
6081         READ_BYTE_F(adr, res)
6082         flag_C = 0;
6083         flag_V = 0;
6084         flag_NotZ = res;
6085         flag_N = res;
6086         adr = AREG(7);
6087         AREG(7) += 2;
6088         WRITE_BYTE_F(adr, res)
6089         POST_IO
6090 RET(12)
6091 }
6092
6093 // MOVEB
6094 OPCODE(0x1F18)
6095 {
6096         u32 adr, res;
6097         u32 src, dst;
6098
6099         adr = AREG((Opcode >> 0) & 7);
6100         AREG((Opcode >> 0) & 7) += 1;
6101         PRE_IO
6102         READ_BYTE_F(adr, res)
6103         flag_C = 0;
6104         flag_V = 0;
6105         flag_NotZ = res;
6106         flag_N = res;
6107         adr = AREG(7) - 2;
6108         AREG(7) = adr;
6109         WRITE_BYTE_F(adr, res)
6110         POST_IO
6111 RET(12)
6112 }
6113
6114 // MOVEB
6115 OPCODE(0x1020)
6116 {
6117         u32 adr, res;
6118         u32 src, dst;
6119
6120         adr = AREG((Opcode >> 0) & 7) - 1;
6121         AREG((Opcode >> 0) & 7) = adr;
6122         PRE_IO
6123         READ_BYTE_F(adr, res)
6124         flag_C = 0;
6125         flag_V = 0;
6126         flag_NotZ = res;
6127         flag_N = res;
6128         DREGu8((Opcode >> 9) & 7) = res;
6129         POST_IO
6130 RET(10)
6131 }
6132
6133 // MOVEB
6134 OPCODE(0x10A0)
6135 {
6136         u32 adr, res;
6137         u32 src, dst;
6138
6139         adr = AREG((Opcode >> 0) & 7) - 1;
6140         AREG((Opcode >> 0) & 7) = adr;
6141         PRE_IO
6142         READ_BYTE_F(adr, res)
6143         flag_C = 0;
6144         flag_V = 0;
6145         flag_NotZ = res;
6146         flag_N = res;
6147         adr = AREG((Opcode >> 9) & 7);
6148         WRITE_BYTE_F(adr, res)
6149         POST_IO
6150 RET(14)
6151 }
6152
6153 // MOVEB
6154 OPCODE(0x10E0)
6155 {
6156         u32 adr, res;
6157         u32 src, dst;
6158
6159         adr = AREG((Opcode >> 0) & 7) - 1;
6160         AREG((Opcode >> 0) & 7) = adr;
6161         PRE_IO
6162         READ_BYTE_F(adr, res)
6163         flag_C = 0;
6164         flag_V = 0;
6165         flag_NotZ = res;
6166         flag_N = res;
6167         adr = AREG((Opcode >> 9) & 7);
6168         AREG((Opcode >> 9) & 7) += 1;
6169         WRITE_BYTE_F(adr, res)
6170         POST_IO
6171 RET(14)
6172 }
6173
6174 // MOVEB
6175 OPCODE(0x1120)
6176 {
6177         u32 adr, res;
6178         u32 src, dst;
6179
6180         adr = AREG((Opcode >> 0) & 7) - 1;
6181         AREG((Opcode >> 0) & 7) = adr;
6182         PRE_IO
6183         READ_BYTE_F(adr, res)
6184         flag_C = 0;
6185         flag_V = 0;
6186         flag_NotZ = res;
6187         flag_N = res;
6188         adr = AREG((Opcode >> 9) & 7) - 1;
6189         AREG((Opcode >> 9) & 7) = adr;
6190         WRITE_BYTE_F(adr, res)
6191         POST_IO
6192 RET(14)
6193 }
6194
6195 // MOVEB
6196 OPCODE(0x1160)
6197 {
6198         u32 adr, res;
6199         u32 src, dst;
6200
6201         adr = AREG((Opcode >> 0) & 7) - 1;
6202         AREG((Opcode >> 0) & 7) = adr;
6203         PRE_IO
6204         READ_BYTE_F(adr, res)
6205         flag_C = 0;
6206         flag_V = 0;
6207         flag_NotZ = res;
6208         flag_N = res;
6209         FETCH_SWORD(adr);
6210         adr += AREG((Opcode >> 9) & 7);
6211         WRITE_BYTE_F(adr, res)
6212         POST_IO
6213 RET(18)
6214 }
6215
6216 // MOVEB
6217 OPCODE(0x11A0)
6218 {
6219         u32 adr, res;
6220         u32 src, dst;
6221
6222         adr = AREG((Opcode >> 0) & 7) - 1;
6223         AREG((Opcode >> 0) & 7) = adr;
6224         PRE_IO
6225         READ_BYTE_F(adr, res)
6226         flag_C = 0;
6227         flag_V = 0;
6228         flag_NotZ = res;
6229         flag_N = res;
6230         adr = AREG((Opcode >> 9) & 7);
6231         DECODE_EXT_WORD
6232         WRITE_BYTE_F(adr, res)
6233         POST_IO
6234 RET(20)
6235 }
6236
6237 // MOVEB
6238 OPCODE(0x11E0)
6239 {
6240         u32 adr, res;
6241         u32 src, dst;
6242
6243         adr = AREG((Opcode >> 0) & 7) - 1;
6244         AREG((Opcode >> 0) & 7) = adr;
6245         PRE_IO
6246         READ_BYTE_F(adr, res)
6247         flag_C = 0;
6248         flag_V = 0;
6249         flag_NotZ = res;
6250         flag_N = res;
6251         FETCH_SWORD(adr);
6252         WRITE_BYTE_F(adr, res)
6253         POST_IO
6254 RET(18)
6255 }
6256
6257 // MOVEB
6258 OPCODE(0x13E0)
6259 {
6260         u32 adr, res;
6261         u32 src, dst;
6262
6263         adr = AREG((Opcode >> 0) & 7) - 1;
6264         AREG((Opcode >> 0) & 7) = adr;
6265         PRE_IO
6266         READ_BYTE_F(adr, res)
6267         flag_C = 0;
6268         flag_V = 0;
6269         flag_NotZ = res;
6270         flag_N = res;
6271         FETCH_LONG(adr);
6272         WRITE_BYTE_F(adr, res)
6273         POST_IO
6274 RET(22)
6275 }
6276
6277 // MOVEB
6278 OPCODE(0x1EE0)
6279 {
6280         u32 adr, res;
6281         u32 src, dst;
6282
6283         adr = AREG((Opcode >> 0) & 7) - 1;
6284         AREG((Opcode >> 0) & 7) = adr;
6285         PRE_IO
6286         READ_BYTE_F(adr, res)
6287         flag_C = 0;
6288         flag_V = 0;
6289         flag_NotZ = res;
6290         flag_N = res;
6291         adr = AREG(7);
6292         AREG(7) += 2;
6293         WRITE_BYTE_F(adr, res)
6294         POST_IO
6295 RET(14)
6296 }
6297
6298 // MOVEB
6299 OPCODE(0x1F20)
6300 {
6301         u32 adr, res;
6302         u32 src, dst;
6303
6304         adr = AREG((Opcode >> 0) & 7) - 1;
6305         AREG((Opcode >> 0) & 7) = adr;
6306         PRE_IO
6307         READ_BYTE_F(adr, res)
6308         flag_C = 0;
6309         flag_V = 0;
6310         flag_NotZ = res;
6311         flag_N = res;
6312         adr = AREG(7) - 2;
6313         AREG(7) = adr;
6314         WRITE_BYTE_F(adr, res)
6315         POST_IO
6316 RET(14)
6317 }
6318
6319 // MOVEB
6320 OPCODE(0x1028)
6321 {
6322         u32 adr, res;
6323         u32 src, dst;
6324
6325         FETCH_SWORD(adr);
6326         adr += AREG((Opcode >> 0) & 7);
6327         PRE_IO
6328         READ_BYTE_F(adr, res)
6329         flag_C = 0;
6330         flag_V = 0;
6331         flag_NotZ = res;
6332         flag_N = res;
6333         DREGu8((Opcode >> 9) & 7) = res;
6334         POST_IO
6335 RET(12)
6336 }
6337
6338 // MOVEB
6339 OPCODE(0x10A8)
6340 {
6341         u32 adr, res;
6342         u32 src, dst;
6343
6344         FETCH_SWORD(adr);
6345         adr += AREG((Opcode >> 0) & 7);
6346         PRE_IO
6347         READ_BYTE_F(adr, res)
6348         flag_C = 0;
6349         flag_V = 0;
6350         flag_NotZ = res;
6351         flag_N = res;
6352         adr = AREG((Opcode >> 9) & 7);
6353         WRITE_BYTE_F(adr, res)
6354         POST_IO
6355 RET(16)
6356 }
6357
6358 // MOVEB
6359 OPCODE(0x10E8)
6360 {
6361         u32 adr, res;
6362         u32 src, dst;
6363
6364         FETCH_SWORD(adr);
6365         adr += AREG((Opcode >> 0) & 7);
6366         PRE_IO
6367         READ_BYTE_F(adr, res)
6368         flag_C = 0;
6369         flag_V = 0;
6370         flag_NotZ = res;
6371         flag_N = res;
6372         adr = AREG((Opcode >> 9) & 7);
6373         AREG((Opcode >> 9) & 7) += 1;
6374         WRITE_BYTE_F(adr, res)
6375         POST_IO
6376 RET(16)
6377 }
6378
6379 // MOVEB
6380 OPCODE(0x1128)
6381 {
6382         u32 adr, res;
6383         u32 src, dst;
6384
6385         FETCH_SWORD(adr);
6386         adr += AREG((Opcode >> 0) & 7);
6387         PRE_IO
6388         READ_BYTE_F(adr, res)
6389         flag_C = 0;
6390         flag_V = 0;
6391         flag_NotZ = res;
6392         flag_N = res;
6393         adr = AREG((Opcode >> 9) & 7) - 1;
6394         AREG((Opcode >> 9) & 7) = adr;
6395         WRITE_BYTE_F(adr, res)
6396         POST_IO
6397 RET(16)
6398 }
6399
6400 // MOVEB
6401 OPCODE(0x1168)
6402 {
6403         u32 adr, res;
6404         u32 src, dst;
6405
6406         FETCH_SWORD(adr);
6407         adr += AREG((Opcode >> 0) & 7);
6408         PRE_IO
6409         READ_BYTE_F(adr, res)
6410         flag_C = 0;
6411         flag_V = 0;
6412         flag_NotZ = res;
6413         flag_N = res;
6414         FETCH_SWORD(adr);
6415         adr += AREG((Opcode >> 9) & 7);
6416         WRITE_BYTE_F(adr, res)
6417         POST_IO
6418 RET(20)
6419 }
6420
6421 // MOVEB
6422 OPCODE(0x11A8)
6423 {
6424         u32 adr, res;
6425         u32 src, dst;
6426
6427         FETCH_SWORD(adr);
6428         adr += AREG((Opcode >> 0) & 7);
6429         PRE_IO
6430         READ_BYTE_F(adr, res)
6431         flag_C = 0;
6432         flag_V = 0;
6433         flag_NotZ = res;
6434         flag_N = res;
6435         adr = AREG((Opcode >> 9) & 7);
6436         DECODE_EXT_WORD
6437         WRITE_BYTE_F(adr, res)
6438         POST_IO
6439 RET(22)
6440 }
6441
6442 // MOVEB
6443 OPCODE(0x11E8)
6444 {
6445         u32 adr, res;
6446         u32 src, dst;
6447
6448         FETCH_SWORD(adr);
6449         adr += AREG((Opcode >> 0) & 7);
6450         PRE_IO
6451         READ_BYTE_F(adr, res)
6452         flag_C = 0;
6453         flag_V = 0;
6454         flag_NotZ = res;
6455         flag_N = res;
6456         FETCH_SWORD(adr);
6457         WRITE_BYTE_F(adr, res)
6458         POST_IO
6459 RET(20)
6460 }
6461
6462 // MOVEB
6463 OPCODE(0x13E8)
6464 {
6465         u32 adr, res;
6466         u32 src, dst;
6467
6468         FETCH_SWORD(adr);
6469         adr += AREG((Opcode >> 0) & 7);
6470         PRE_IO
6471         READ_BYTE_F(adr, res)
6472         flag_C = 0;
6473         flag_V = 0;
6474         flag_NotZ = res;
6475         flag_N = res;
6476         FETCH_LONG(adr);
6477         WRITE_BYTE_F(adr, res)
6478         POST_IO
6479 RET(24)
6480 }
6481
6482 // MOVEB
6483 OPCODE(0x1EE8)
6484 {
6485         u32 adr, res;
6486         u32 src, dst;
6487
6488         FETCH_SWORD(adr);
6489         adr += AREG((Opcode >> 0) & 7);
6490         PRE_IO
6491         READ_BYTE_F(adr, res)
6492         flag_C = 0;
6493         flag_V = 0;
6494         flag_NotZ = res;
6495         flag_N = res;
6496         adr = AREG(7);
6497         AREG(7) += 2;
6498         WRITE_BYTE_F(adr, res)
6499         POST_IO
6500 RET(16)
6501 }
6502
6503 // MOVEB
6504 OPCODE(0x1F28)
6505 {
6506         u32 adr, res;
6507         u32 src, dst;
6508
6509         FETCH_SWORD(adr);
6510         adr += AREG((Opcode >> 0) & 7);
6511         PRE_IO
6512         READ_BYTE_F(adr, res)
6513         flag_C = 0;
6514         flag_V = 0;
6515         flag_NotZ = res;
6516         flag_N = res;
6517         adr = AREG(7) - 2;
6518         AREG(7) = adr;
6519         WRITE_BYTE_F(adr, res)
6520         POST_IO
6521 RET(16)
6522 }
6523
6524 // MOVEB
6525 OPCODE(0x1030)
6526 {
6527         u32 adr, res;
6528         u32 src, dst;
6529
6530         adr = AREG((Opcode >> 0) & 7);
6531         DECODE_EXT_WORD
6532         PRE_IO
6533         READ_BYTE_F(adr, res)
6534         flag_C = 0;
6535         flag_V = 0;
6536         flag_NotZ = res;
6537         flag_N = res;
6538         DREGu8((Opcode >> 9) & 7) = res;
6539         POST_IO
6540 RET(14)
6541 }
6542
6543 // MOVEB
6544 OPCODE(0x10B0)
6545 {
6546         u32 adr, res;
6547         u32 src, dst;
6548
6549         adr = AREG((Opcode >> 0) & 7);
6550         DECODE_EXT_WORD
6551         PRE_IO
6552         READ_BYTE_F(adr, res)
6553         flag_C = 0;
6554         flag_V = 0;
6555         flag_NotZ = res;
6556         flag_N = res;
6557         adr = AREG((Opcode >> 9) & 7);
6558         WRITE_BYTE_F(adr, res)
6559         POST_IO
6560 RET(18)
6561 }
6562
6563 // MOVEB
6564 OPCODE(0x10F0)
6565 {
6566         u32 adr, res;
6567         u32 src, dst;
6568
6569         adr = AREG((Opcode >> 0) & 7);
6570         DECODE_EXT_WORD
6571         PRE_IO
6572         READ_BYTE_F(adr, res)
6573         flag_C = 0;
6574         flag_V = 0;
6575         flag_NotZ = res;
6576         flag_N = res;
6577         adr = AREG((Opcode >> 9) & 7);
6578         AREG((Opcode >> 9) & 7) += 1;
6579         WRITE_BYTE_F(adr, res)
6580         POST_IO
6581 RET(18)
6582 }
6583
6584 // MOVEB
6585 OPCODE(0x1130)
6586 {
6587         u32 adr, res;
6588         u32 src, dst;
6589
6590         adr = AREG((Opcode >> 0) & 7);
6591         DECODE_EXT_WORD
6592         PRE_IO
6593         READ_BYTE_F(adr, res)
6594         flag_C = 0;
6595         flag_V = 0;
6596         flag_NotZ = res;
6597         flag_N = res;
6598         adr = AREG((Opcode >> 9) & 7) - 1;
6599         AREG((Opcode >> 9) & 7) = adr;
6600         WRITE_BYTE_F(adr, res)
6601         POST_IO
6602 RET(18)
6603 }
6604
6605 // MOVEB
6606 OPCODE(0x1170)
6607 {
6608         u32 adr, res;
6609         u32 src, dst;
6610
6611         adr = AREG((Opcode >> 0) & 7);
6612         DECODE_EXT_WORD
6613         PRE_IO
6614         READ_BYTE_F(adr, res)
6615         flag_C = 0;
6616         flag_V = 0;
6617         flag_NotZ = res;
6618         flag_N = res;
6619         FETCH_SWORD(adr);
6620         adr += AREG((Opcode >> 9) & 7);
6621         WRITE_BYTE_F(adr, res)
6622         POST_IO
6623 RET(22)
6624 }
6625
6626 // MOVEB
6627 OPCODE(0x11B0)
6628 {
6629         u32 adr, res;
6630         u32 src, dst;
6631
6632         adr = AREG((Opcode >> 0) & 7);
6633         DECODE_EXT_WORD
6634         PRE_IO
6635         READ_BYTE_F(adr, res)
6636         flag_C = 0;
6637         flag_V = 0;
6638         flag_NotZ = res;
6639         flag_N = res;
6640         adr = AREG((Opcode >> 9) & 7);
6641         DECODE_EXT_WORD
6642         WRITE_BYTE_F(adr, res)
6643         POST_IO
6644 RET(24)
6645 }
6646
6647 // MOVEB
6648 OPCODE(0x11F0)
6649 {
6650         u32 adr, res;
6651         u32 src, dst;
6652
6653         adr = AREG((Opcode >> 0) & 7);
6654         DECODE_EXT_WORD
6655         PRE_IO
6656         READ_BYTE_F(adr, res)
6657         flag_C = 0;
6658         flag_V = 0;
6659         flag_NotZ = res;
6660         flag_N = res;
6661         FETCH_SWORD(adr);
6662         WRITE_BYTE_F(adr, res)
6663         POST_IO
6664 RET(22)
6665 }
6666
6667 // MOVEB
6668 OPCODE(0x13F0)
6669 {
6670         u32 adr, res;
6671         u32 src, dst;
6672
6673         adr = AREG((Opcode >> 0) & 7);
6674         DECODE_EXT_WORD
6675         PRE_IO
6676         READ_BYTE_F(adr, res)
6677         flag_C = 0;
6678         flag_V = 0;
6679         flag_NotZ = res;
6680         flag_N = res;
6681         FETCH_LONG(adr);
6682         WRITE_BYTE_F(adr, res)
6683         POST_IO
6684 RET(26)
6685 }
6686
6687 // MOVEB
6688 OPCODE(0x1EF0)
6689 {
6690         u32 adr, res;
6691         u32 src, dst;
6692
6693         adr = AREG((Opcode >> 0) & 7);
6694         DECODE_EXT_WORD
6695         PRE_IO
6696         READ_BYTE_F(adr, res)
6697         flag_C = 0;
6698         flag_V = 0;
6699         flag_NotZ = res;
6700         flag_N = res;
6701         adr = AREG(7);
6702         AREG(7) += 2;
6703         WRITE_BYTE_F(adr, res)
6704         POST_IO
6705 RET(18)
6706 }
6707
6708 // MOVEB
6709 OPCODE(0x1F30)
6710 {
6711         u32 adr, res;
6712         u32 src, dst;
6713
6714         adr = AREG((Opcode >> 0) & 7);
6715         DECODE_EXT_WORD
6716         PRE_IO
6717         READ_BYTE_F(adr, res)
6718         flag_C = 0;
6719         flag_V = 0;
6720         flag_NotZ = res;
6721         flag_N = res;
6722         adr = AREG(7) - 2;
6723         AREG(7) = adr;
6724         WRITE_BYTE_F(adr, res)
6725         POST_IO
6726 RET(18)
6727 }
6728
6729 // MOVEB
6730 OPCODE(0x1038)
6731 {
6732         u32 adr, res;
6733         u32 src, dst;
6734
6735         FETCH_SWORD(adr);
6736         PRE_IO
6737         READ_BYTE_F(adr, res)
6738         flag_C = 0;
6739         flag_V = 0;
6740         flag_NotZ = res;
6741         flag_N = res;
6742         DREGu8((Opcode >> 9) & 7) = res;
6743         POST_IO
6744 RET(12)
6745 }
6746
6747 // MOVEB
6748 OPCODE(0x10B8)
6749 {
6750         u32 adr, res;
6751         u32 src, dst;
6752
6753         FETCH_SWORD(adr);
6754         PRE_IO
6755         READ_BYTE_F(adr, res)
6756         flag_C = 0;
6757         flag_V = 0;
6758         flag_NotZ = res;
6759         flag_N = res;
6760         adr = AREG((Opcode >> 9) & 7);
6761         WRITE_BYTE_F(adr, res)
6762         POST_IO
6763 RET(16)
6764 }
6765
6766 // MOVEB
6767 OPCODE(0x10F8)
6768 {
6769         u32 adr, res;
6770         u32 src, dst;
6771
6772         FETCH_SWORD(adr);
6773         PRE_IO
6774         READ_BYTE_F(adr, res)
6775         flag_C = 0;
6776         flag_V = 0;
6777         flag_NotZ = res;
6778         flag_N = res;
6779         adr = AREG((Opcode >> 9) & 7);
6780         AREG((Opcode >> 9) & 7) += 1;
6781         WRITE_BYTE_F(adr, res)
6782         POST_IO
6783 RET(16)
6784 }
6785
6786 // MOVEB
6787 OPCODE(0x1138)
6788 {
6789         u32 adr, res;
6790         u32 src, dst;
6791
6792         FETCH_SWORD(adr);
6793         PRE_IO
6794         READ_BYTE_F(adr, res)
6795         flag_C = 0;
6796         flag_V = 0;
6797         flag_NotZ = res;
6798         flag_N = res;
6799         adr = AREG((Opcode >> 9) & 7) - 1;
6800         AREG((Opcode >> 9) & 7) = adr;
6801         WRITE_BYTE_F(adr, res)
6802         POST_IO
6803 RET(16)
6804 }
6805
6806 // MOVEB
6807 OPCODE(0x1178)
6808 {
6809         u32 adr, res;
6810         u32 src, dst;
6811
6812         FETCH_SWORD(adr);
6813         PRE_IO
6814         READ_BYTE_F(adr, res)
6815         flag_C = 0;
6816         flag_V = 0;
6817         flag_NotZ = res;
6818         flag_N = res;
6819         FETCH_SWORD(adr);
6820         adr += AREG((Opcode >> 9) & 7);
6821         WRITE_BYTE_F(adr, res)
6822         POST_IO
6823 RET(20)
6824 }
6825
6826 // MOVEB
6827 OPCODE(0x11B8)
6828 {
6829         u32 adr, res;
6830         u32 src, dst;
6831
6832         FETCH_SWORD(adr);
6833         PRE_IO
6834         READ_BYTE_F(adr, res)
6835         flag_C = 0;
6836         flag_V = 0;
6837         flag_NotZ = res;
6838         flag_N = res;
6839         adr = AREG((Opcode >> 9) & 7);
6840         DECODE_EXT_WORD
6841         WRITE_BYTE_F(adr, res)
6842         POST_IO
6843 RET(22)
6844 }
6845
6846 // MOVEB
6847 OPCODE(0x11F8)
6848 {
6849         u32 adr, res;
6850         u32 src, dst;
6851
6852         FETCH_SWORD(adr);
6853         PRE_IO
6854         READ_BYTE_F(adr, res)
6855         flag_C = 0;
6856         flag_V = 0;
6857         flag_NotZ = res;
6858         flag_N = res;
6859         FETCH_SWORD(adr);
6860         WRITE_BYTE_F(adr, res)
6861         POST_IO
6862 RET(20)
6863 }
6864
6865 // MOVEB
6866 OPCODE(0x13F8)
6867 {
6868         u32 adr, res;
6869         u32 src, dst;
6870
6871         FETCH_SWORD(adr);
6872         PRE_IO
6873         READ_BYTE_F(adr, res)
6874         flag_C = 0;
6875         flag_V = 0;
6876         flag_NotZ = res;
6877         flag_N = res;
6878         FETCH_LONG(adr);
6879         WRITE_BYTE_F(adr, res)
6880         POST_IO
6881 RET(24)
6882 }
6883
6884 // MOVEB
6885 OPCODE(0x1EF8)
6886 {
6887         u32 adr, res;
6888         u32 src, dst;
6889
6890         FETCH_SWORD(adr);
6891         PRE_IO
6892         READ_BYTE_F(adr, res)
6893         flag_C = 0;
6894         flag_V = 0;
6895         flag_NotZ = res;
6896         flag_N = res;
6897         adr = AREG(7);
6898         AREG(7) += 2;
6899         WRITE_BYTE_F(adr, res)
6900         POST_IO
6901 RET(16)
6902 }
6903
6904 // MOVEB
6905 OPCODE(0x1F38)
6906 {
6907         u32 adr, res;
6908         u32 src, dst;
6909
6910         FETCH_SWORD(adr);
6911         PRE_IO
6912         READ_BYTE_F(adr, res)
6913         flag_C = 0;
6914         flag_V = 0;
6915         flag_NotZ = res;
6916         flag_N = res;
6917         adr = AREG(7) - 2;
6918         AREG(7) = adr;
6919         WRITE_BYTE_F(adr, res)
6920         POST_IO
6921 RET(16)
6922 }
6923
6924 // MOVEB
6925 OPCODE(0x1039)
6926 {
6927         u32 adr, res;
6928         u32 src, dst;
6929
6930         FETCH_LONG(adr);
6931         PRE_IO
6932         READ_BYTE_F(adr, res)
6933         flag_C = 0;
6934         flag_V = 0;
6935         flag_NotZ = res;
6936         flag_N = res;
6937         DREGu8((Opcode >> 9) & 7) = res;
6938         POST_IO
6939 RET(16)
6940 }
6941
6942 // MOVEB
6943 OPCODE(0x10B9)
6944 {
6945         u32 adr, res;
6946         u32 src, dst;
6947
6948         FETCH_LONG(adr);
6949         PRE_IO
6950         READ_BYTE_F(adr, res)
6951         flag_C = 0;
6952         flag_V = 0;
6953         flag_NotZ = res;
6954         flag_N = res;
6955         adr = AREG((Opcode >> 9) & 7);
6956         WRITE_BYTE_F(adr, res)
6957         POST_IO
6958 RET(20)
6959 }
6960
6961 // MOVEB
6962 OPCODE(0x10F9)
6963 {
6964         u32 adr, res;
6965         u32 src, dst;
6966
6967         FETCH_LONG(adr);
6968         PRE_IO
6969         READ_BYTE_F(adr, res)
6970         flag_C = 0;
6971         flag_V = 0;
6972         flag_NotZ = res;
6973         flag_N = res;
6974         adr = AREG((Opcode >> 9) & 7);
6975         AREG((Opcode >> 9) & 7) += 1;
6976         WRITE_BYTE_F(adr, res)
6977         POST_IO
6978 RET(20)
6979 }
6980
6981 // MOVEB
6982 OPCODE(0x1139)
6983 {
6984         u32 adr, res;
6985         u32 src, dst;
6986
6987         FETCH_LONG(adr);
6988         PRE_IO
6989         READ_BYTE_F(adr, res)
6990         flag_C = 0;
6991         flag_V = 0;
6992         flag_NotZ = res;
6993         flag_N = res;
6994         adr = AREG((Opcode >> 9) & 7) - 1;
6995         AREG((Opcode >> 9) & 7) = adr;
6996         WRITE_BYTE_F(adr, res)
6997         POST_IO
6998 RET(20)
6999 }
7000
7001 // MOVEB
7002 OPCODE(0x1179)
7003 {
7004         u32 adr, res;
7005         u32 src, dst;
7006
7007         FETCH_LONG(adr);
7008         PRE_IO
7009         READ_BYTE_F(adr, res)
7010         flag_C = 0;
7011         flag_V = 0;
7012         flag_NotZ = res;
7013         flag_N = res;
7014         FETCH_SWORD(adr);
7015         adr += AREG((Opcode >> 9) & 7);
7016         WRITE_BYTE_F(adr, res)
7017         POST_IO
7018 RET(24)
7019 }
7020
7021 // MOVEB
7022 OPCODE(0x11B9)
7023 {
7024         u32 adr, res;
7025         u32 src, dst;
7026
7027         FETCH_LONG(adr);
7028         PRE_IO
7029         READ_BYTE_F(adr, res)
7030         flag_C = 0;
7031         flag_V = 0;
7032         flag_NotZ = res;
7033         flag_N = res;
7034         adr = AREG((Opcode >> 9) & 7);
7035         DECODE_EXT_WORD
7036         WRITE_BYTE_F(adr, res)
7037         POST_IO
7038 RET(26)
7039 }
7040
7041 // MOVEB
7042 OPCODE(0x11F9)
7043 {
7044         u32 adr, res;
7045         u32 src, dst;
7046
7047         FETCH_LONG(adr);
7048         PRE_IO
7049         READ_BYTE_F(adr, res)
7050         flag_C = 0;
7051         flag_V = 0;
7052         flag_NotZ = res;
7053         flag_N = res;
7054         FETCH_SWORD(adr);
7055         WRITE_BYTE_F(adr, res)
7056         POST_IO
7057 RET(24)
7058 }
7059
7060 // MOVEB
7061 OPCODE(0x13F9)
7062 {
7063         u32 adr, res;
7064         u32 src, dst;
7065
7066         FETCH_LONG(adr);
7067         PRE_IO
7068         READ_BYTE_F(adr, res)
7069         flag_C = 0;
7070         flag_V = 0;
7071         flag_NotZ = res;
7072         flag_N = res;
7073         FETCH_LONG(adr);
7074         WRITE_BYTE_F(adr, res)
7075         POST_IO
7076 RET(28)
7077 }
7078
7079 // MOVEB
7080 OPCODE(0x1EF9)
7081 {
7082         u32 adr, res;
7083         u32 src, dst;
7084
7085         FETCH_LONG(adr);
7086         PRE_IO
7087         READ_BYTE_F(adr, res)
7088         flag_C = 0;
7089         flag_V = 0;
7090         flag_NotZ = res;
7091         flag_N = res;
7092         adr = AREG(7);
7093         AREG(7) += 2;
7094         WRITE_BYTE_F(adr, res)
7095         POST_IO
7096 RET(20)
7097 }
7098
7099 // MOVEB
7100 OPCODE(0x1F39)
7101 {
7102         u32 adr, res;
7103         u32 src, dst;
7104
7105         FETCH_LONG(adr);
7106         PRE_IO
7107         READ_BYTE_F(adr, res)
7108         flag_C = 0;
7109         flag_V = 0;
7110         flag_NotZ = res;
7111         flag_N = res;
7112         adr = AREG(7) - 2;
7113         AREG(7) = adr;
7114         WRITE_BYTE_F(adr, res)
7115         POST_IO
7116 RET(20)
7117 }
7118
7119 // MOVEB
7120 OPCODE(0x103A)
7121 {
7122         u32 adr, res;
7123         u32 src, dst;
7124
7125         adr = GET_SWORD + GET_PC;
7126         PC++;
7127         PRE_IO
7128         READ_BYTE_F(adr, res)
7129         flag_C = 0;
7130         flag_V = 0;
7131         flag_NotZ = res;
7132         flag_N = res;
7133         DREGu8((Opcode >> 9) & 7) = res;
7134         POST_IO
7135 RET(12)
7136 }
7137
7138 // MOVEB
7139 OPCODE(0x10BA)
7140 {
7141         u32 adr, res;
7142         u32 src, dst;
7143
7144         adr = GET_SWORD + GET_PC;
7145         PC++;
7146         PRE_IO
7147         READ_BYTE_F(adr, res)
7148         flag_C = 0;
7149         flag_V = 0;
7150         flag_NotZ = res;
7151         flag_N = res;
7152         adr = AREG((Opcode >> 9) & 7);
7153         WRITE_BYTE_F(adr, res)
7154         POST_IO
7155 RET(16)
7156 }
7157
7158 // MOVEB
7159 OPCODE(0x10FA)
7160 {
7161         u32 adr, res;
7162         u32 src, dst;
7163
7164         adr = GET_SWORD + GET_PC;
7165         PC++;
7166         PRE_IO
7167         READ_BYTE_F(adr, res)
7168         flag_C = 0;
7169         flag_V = 0;
7170         flag_NotZ = res;
7171         flag_N = res;
7172         adr = AREG((Opcode >> 9) & 7);
7173         AREG((Opcode >> 9) & 7) += 1;
7174         WRITE_BYTE_F(adr, res)
7175         POST_IO
7176 RET(16)
7177 }
7178
7179 // MOVEB
7180 OPCODE(0x113A)
7181 {
7182         u32 adr, res;
7183         u32 src, dst;
7184
7185         adr = GET_SWORD + GET_PC;
7186         PC++;
7187         PRE_IO
7188         READ_BYTE_F(adr, res)
7189         flag_C = 0;
7190         flag_V = 0;
7191         flag_NotZ = res;
7192         flag_N = res;
7193         adr = AREG((Opcode >> 9) & 7) - 1;
7194         AREG((Opcode >> 9) & 7) = adr;
7195         WRITE_BYTE_F(adr, res)
7196         POST_IO
7197 RET(16)
7198 }
7199
7200 // MOVEB
7201 OPCODE(0x117A)
7202 {
7203         u32 adr, res;
7204         u32 src, dst;
7205
7206         adr = GET_SWORD + GET_PC;
7207         PC++;
7208         PRE_IO
7209         READ_BYTE_F(adr, res)
7210         flag_C = 0;
7211         flag_V = 0;
7212         flag_NotZ = res;
7213         flag_N = res;
7214         FETCH_SWORD(adr);
7215         adr += AREG((Opcode >> 9) & 7);
7216         WRITE_BYTE_F(adr, res)
7217         POST_IO
7218 RET(20)
7219 }
7220
7221 // MOVEB
7222 OPCODE(0x11BA)
7223 {
7224         u32 adr, res;
7225         u32 src, dst;
7226
7227         adr = GET_SWORD + GET_PC;
7228         PC++;
7229         PRE_IO
7230         READ_BYTE_F(adr, res)
7231         flag_C = 0;
7232         flag_V = 0;
7233         flag_NotZ = res;
7234         flag_N = res;
7235         adr = AREG((Opcode >> 9) & 7);
7236         DECODE_EXT_WORD
7237         WRITE_BYTE_F(adr, res)
7238         POST_IO
7239 RET(22)
7240 }
7241
7242 // MOVEB
7243 OPCODE(0x11FA)
7244 {
7245         u32 adr, res;
7246         u32 src, dst;
7247
7248         adr = GET_SWORD + GET_PC;
7249         PC++;
7250         PRE_IO
7251         READ_BYTE_F(adr, res)
7252         flag_C = 0;
7253         flag_V = 0;
7254         flag_NotZ = res;
7255         flag_N = res;
7256         FETCH_SWORD(adr);
7257         WRITE_BYTE_F(adr, res)
7258         POST_IO
7259 RET(20)
7260 }
7261
7262 // MOVEB
7263 OPCODE(0x13FA)
7264 {
7265         u32 adr, res;
7266         u32 src, dst;
7267
7268         adr = GET_SWORD + GET_PC;
7269         PC++;
7270         PRE_IO
7271         READ_BYTE_F(adr, res)
7272         flag_C = 0;
7273         flag_V = 0;
7274         flag_NotZ = res;
7275         flag_N = res;
7276         FETCH_LONG(adr);
7277         WRITE_BYTE_F(adr, res)
7278         POST_IO
7279 RET(24)
7280 }
7281
7282 // MOVEB
7283 OPCODE(0x1EFA)
7284 {
7285         u32 adr, res;
7286         u32 src, dst;
7287
7288         adr = GET_SWORD + GET_PC;
7289         PC++;
7290         PRE_IO
7291         READ_BYTE_F(adr, res)
7292         flag_C = 0;
7293         flag_V = 0;
7294         flag_NotZ = res;
7295         flag_N = res;
7296         adr = AREG(7);
7297         AREG(7) += 2;
7298         WRITE_BYTE_F(adr, res)
7299         POST_IO
7300 RET(16)
7301 }
7302
7303 // MOVEB
7304 OPCODE(0x1F3A)
7305 {
7306         u32 adr, res;
7307         u32 src, dst;
7308
7309         adr = GET_SWORD + GET_PC;
7310         PC++;
7311         PRE_IO
7312         READ_BYTE_F(adr, res)
7313         flag_C = 0;
7314         flag_V = 0;
7315         flag_NotZ = res;
7316         flag_N = res;
7317         adr = AREG(7) - 2;
7318         AREG(7) = adr;
7319         WRITE_BYTE_F(adr, res)
7320         POST_IO
7321 RET(16)
7322 }
7323
7324 // MOVEB
7325 OPCODE(0x103B)
7326 {
7327         u32 adr, res;
7328         u32 src, dst;
7329
7330         adr = (uptr)(PC) - BasePC;
7331         DECODE_EXT_WORD
7332         PRE_IO
7333         READ_BYTE_F(adr, res)
7334         flag_C = 0;
7335         flag_V = 0;
7336         flag_NotZ = res;
7337         flag_N = res;
7338         DREGu8((Opcode >> 9) & 7) = res;
7339         POST_IO
7340 RET(14)
7341 }
7342
7343 // MOVEB
7344 OPCODE(0x10BB)
7345 {
7346         u32 adr, res;
7347         u32 src, dst;
7348
7349         adr = (uptr)(PC) - BasePC;
7350         DECODE_EXT_WORD
7351         PRE_IO
7352         READ_BYTE_F(adr, res)
7353         flag_C = 0;
7354         flag_V = 0;
7355         flag_NotZ = res;
7356         flag_N = res;
7357         adr = AREG((Opcode >> 9) & 7);
7358         WRITE_BYTE_F(adr, res)
7359         POST_IO
7360 RET(18)
7361 }
7362
7363 // MOVEB
7364 OPCODE(0x10FB)
7365 {
7366         u32 adr, res;
7367         u32 src, dst;
7368
7369         adr = (uptr)(PC) - BasePC;
7370         DECODE_EXT_WORD
7371         PRE_IO
7372         READ_BYTE_F(adr, res)
7373         flag_C = 0;
7374         flag_V = 0;
7375         flag_NotZ = res;
7376         flag_N = res;
7377         adr = AREG((Opcode >> 9) & 7);
7378         AREG((Opcode >> 9) & 7) += 1;
7379         WRITE_BYTE_F(adr, res)
7380         POST_IO
7381 RET(18)
7382 }
7383
7384 // MOVEB
7385 OPCODE(0x113B)
7386 {
7387         u32 adr, res;
7388         u32 src, dst;
7389
7390         adr = (uptr)(PC) - BasePC;
7391         DECODE_EXT_WORD
7392         PRE_IO
7393         READ_BYTE_F(adr, res)
7394         flag_C = 0;
7395         flag_V = 0;
7396         flag_NotZ = res;
7397         flag_N = res;
7398         adr = AREG((Opcode >> 9) & 7) - 1;
7399         AREG((Opcode >> 9) & 7) = adr;
7400         WRITE_BYTE_F(adr, res)
7401         POST_IO
7402 RET(18)
7403 }
7404
7405 // MOVEB
7406 OPCODE(0x117B)
7407 {
7408         u32 adr, res;
7409         u32 src, dst;
7410
7411         adr = (uptr)(PC) - BasePC;
7412         DECODE_EXT_WORD
7413         PRE_IO
7414         READ_BYTE_F(adr, res)
7415         flag_C = 0;
7416         flag_V = 0;
7417         flag_NotZ = res;
7418         flag_N = res;
7419         FETCH_SWORD(adr);
7420         adr += AREG((Opcode >> 9) & 7);
7421         WRITE_BYTE_F(adr, res)
7422         POST_IO
7423 RET(22)
7424 }
7425
7426 // MOVEB
7427 OPCODE(0x11BB)
7428 {
7429         u32 adr, res;
7430         u32 src, dst;
7431
7432         adr = (uptr)(PC) - BasePC;
7433         DECODE_EXT_WORD
7434         PRE_IO
7435         READ_BYTE_F(adr, res)
7436         flag_C = 0;
7437         flag_V = 0;
7438         flag_NotZ = res;
7439         flag_N = res;
7440         adr = AREG((Opcode >> 9) & 7);
7441         DECODE_EXT_WORD
7442         WRITE_BYTE_F(adr, res)
7443         POST_IO
7444 RET(24)
7445 }
7446
7447 // MOVEB
7448 OPCODE(0x11FB)
7449 {
7450         u32 adr, res;
7451         u32 src, dst;
7452
7453         adr = (uptr)(PC) - BasePC;
7454         DECODE_EXT_WORD
7455         PRE_IO
7456         READ_BYTE_F(adr, res)
7457         flag_C = 0;
7458         flag_V = 0;
7459         flag_NotZ = res;
7460         flag_N = res;
7461         FETCH_SWORD(adr);
7462         WRITE_BYTE_F(adr, res)
7463         POST_IO
7464 RET(22)
7465 }
7466
7467 // MOVEB
7468 OPCODE(0x13FB)
7469 {
7470         u32 adr, res;
7471         u32 src, dst;
7472
7473         adr = (uptr)(PC) - BasePC;
7474         DECODE_EXT_WORD
7475         PRE_IO
7476         READ_BYTE_F(adr, res)
7477         flag_C = 0;
7478         flag_V = 0;
7479         flag_NotZ = res;
7480         flag_N = res;
7481         FETCH_LONG(adr);
7482         WRITE_BYTE_F(adr, res)
7483         POST_IO
7484 RET(26)
7485 }
7486
7487 // MOVEB
7488 OPCODE(0x1EFB)
7489 {
7490         u32 adr, res;
7491         u32 src, dst;
7492
7493         adr = (uptr)(PC) - BasePC;
7494         DECODE_EXT_WORD
7495         PRE_IO
7496         READ_BYTE_F(adr, res)
7497         flag_C = 0;
7498         flag_V = 0;
7499         flag_NotZ = res;
7500         flag_N = res;
7501         adr = AREG(7);
7502         AREG(7) += 2;
7503         WRITE_BYTE_F(adr, res)
7504         POST_IO
7505 RET(18)
7506 }
7507
7508 // MOVEB
7509 OPCODE(0x1F3B)
7510 {
7511         u32 adr, res;
7512         u32 src, dst;
7513
7514         adr = (uptr)(PC) - BasePC;
7515         DECODE_EXT_WORD
7516         PRE_IO
7517         READ_BYTE_F(adr, res)
7518         flag_C = 0;
7519         flag_V = 0;
7520         flag_NotZ = res;
7521         flag_N = res;
7522         adr = AREG(7) - 2;
7523         AREG(7) = adr;
7524         WRITE_BYTE_F(adr, res)
7525         POST_IO
7526 RET(18)
7527 }
7528
7529 // MOVEB
7530 OPCODE(0x103C)
7531 {
7532         u32 adr, res;
7533         u32 src, dst;
7534
7535         FETCH_BYTE(res);
7536         flag_C = 0;
7537         flag_V = 0;
7538         flag_NotZ = res;
7539         flag_N = res;
7540         DREGu8((Opcode >> 9) & 7) = res;
7541 RET(8)
7542 }
7543
7544 // MOVEB
7545 OPCODE(0x10BC)
7546 {
7547         u32 adr, res;
7548         u32 src, dst;
7549
7550         FETCH_BYTE(res);
7551         flag_C = 0;
7552         flag_V = 0;
7553         flag_NotZ = res;
7554         flag_N = res;
7555         adr = AREG((Opcode >> 9) & 7);
7556         PRE_IO
7557         WRITE_BYTE_F(adr, res)
7558         POST_IO
7559 RET(12)
7560 }
7561
7562 // MOVEB
7563 OPCODE(0x10FC)
7564 {
7565         u32 adr, res;
7566         u32 src, dst;
7567
7568         FETCH_BYTE(res);
7569         flag_C = 0;
7570         flag_V = 0;
7571         flag_NotZ = res;
7572         flag_N = res;
7573         adr = AREG((Opcode >> 9) & 7);
7574         AREG((Opcode >> 9) & 7) += 1;
7575         PRE_IO
7576         WRITE_BYTE_F(adr, res)
7577         POST_IO
7578 RET(12)
7579 }
7580
7581 // MOVEB
7582 OPCODE(0x113C)
7583 {
7584         u32 adr, res;
7585         u32 src, dst;
7586
7587         FETCH_BYTE(res);
7588         flag_C = 0;
7589         flag_V = 0;
7590         flag_NotZ = res;
7591         flag_N = res;
7592         adr = AREG((Opcode >> 9) & 7) - 1;
7593         AREG((Opcode >> 9) & 7) = adr;
7594         PRE_IO
7595         WRITE_BYTE_F(adr, res)
7596         POST_IO
7597 RET(12)
7598 }
7599
7600 // MOVEB
7601 OPCODE(0x117C)
7602 {
7603         u32 adr, res;
7604         u32 src, dst;
7605
7606         FETCH_BYTE(res);
7607         flag_C = 0;
7608         flag_V = 0;
7609         flag_NotZ = res;
7610         flag_N = res;
7611         FETCH_SWORD(adr);
7612         adr += AREG((Opcode >> 9) & 7);
7613         PRE_IO
7614         WRITE_BYTE_F(adr, res)
7615         POST_IO
7616 RET(16)
7617 }
7618
7619 // MOVEB
7620 OPCODE(0x11BC)
7621 {
7622         u32 adr, res;
7623         u32 src, dst;
7624
7625         FETCH_BYTE(res);
7626         flag_C = 0;
7627         flag_V = 0;
7628         flag_NotZ = res;
7629         flag_N = res;
7630         adr = AREG((Opcode >> 9) & 7);
7631         DECODE_EXT_WORD
7632         PRE_IO
7633         WRITE_BYTE_F(adr, res)
7634         POST_IO
7635 RET(18)
7636 }
7637
7638 // MOVEB
7639 OPCODE(0x11FC)
7640 {
7641         u32 adr, res;
7642         u32 src, dst;
7643
7644         FETCH_BYTE(res);
7645         flag_C = 0;
7646         flag_V = 0;
7647         flag_NotZ = res;
7648         flag_N = res;
7649         FETCH_SWORD(adr);
7650         PRE_IO
7651         WRITE_BYTE_F(adr, res)
7652         POST_IO
7653 RET(16)
7654 }
7655
7656 // MOVEB
7657 OPCODE(0x13FC)
7658 {
7659         u32 adr, res;
7660         u32 src, dst;
7661
7662         FETCH_BYTE(res);
7663         flag_C = 0;
7664         flag_V = 0;
7665         flag_NotZ = res;
7666         flag_N = res;
7667         FETCH_LONG(adr);
7668         PRE_IO
7669         WRITE_BYTE_F(adr, res)
7670         POST_IO
7671 RET(20)
7672 }
7673
7674 // MOVEB
7675 OPCODE(0x1EFC)
7676 {
7677         u32 adr, res;
7678         u32 src, dst;
7679
7680         FETCH_BYTE(res);
7681         flag_C = 0;
7682         flag_V = 0;
7683         flag_NotZ = res;
7684         flag_N = res;
7685         adr = AREG(7);
7686         AREG(7) += 2;
7687         PRE_IO
7688         WRITE_BYTE_F(adr, res)
7689         POST_IO
7690 RET(12)
7691 }
7692
7693 // MOVEB
7694 OPCODE(0x1F3C)
7695 {
7696         u32 adr, res;
7697         u32 src, dst;
7698
7699         FETCH_BYTE(res);
7700         flag_C = 0;
7701         flag_V = 0;
7702         flag_NotZ = res;
7703         flag_N = res;
7704         adr = AREG(7) - 2;
7705         AREG(7) = adr;
7706         PRE_IO
7707         WRITE_BYTE_F(adr, res)
7708         POST_IO
7709 RET(12)
7710 }
7711
7712 // MOVEB
7713 OPCODE(0x101F)
7714 {
7715         u32 adr, res;
7716         u32 src, dst;
7717
7718         adr = AREG(7);
7719         AREG(7) += 2;
7720         PRE_IO
7721         READ_BYTE_F(adr, res)
7722         flag_C = 0;
7723         flag_V = 0;
7724         flag_NotZ = res;
7725         flag_N = res;
7726         DREGu8((Opcode >> 9) & 7) = res;
7727         POST_IO
7728 RET(8)
7729 }
7730
7731 // MOVEB
7732 OPCODE(0x109F)
7733 {
7734         u32 adr, res;
7735         u32 src, dst;
7736
7737         adr = AREG(7);
7738         AREG(7) += 2;
7739         PRE_IO
7740         READ_BYTE_F(adr, res)
7741         flag_C = 0;
7742         flag_V = 0;
7743         flag_NotZ = res;
7744         flag_N = res;
7745         adr = AREG((Opcode >> 9) & 7);
7746         WRITE_BYTE_F(adr, res)
7747         POST_IO
7748 RET(12)
7749 }
7750
7751 // MOVEB
7752 OPCODE(0x10DF)
7753 {
7754         u32 adr, res;
7755         u32 src, dst;
7756
7757         adr = AREG(7);
7758         AREG(7) += 2;
7759         PRE_IO
7760         READ_BYTE_F(adr, res)
7761         flag_C = 0;
7762         flag_V = 0;
7763         flag_NotZ = res;
7764         flag_N = res;
7765         adr = AREG((Opcode >> 9) & 7);
7766         AREG((Opcode >> 9) & 7) += 1;
7767         WRITE_BYTE_F(adr, res)
7768         POST_IO
7769 RET(12)
7770 }
7771
7772 // MOVEB
7773 OPCODE(0x111F)
7774 {
7775         u32 adr, res;
7776         u32 src, dst;
7777
7778         adr = AREG(7);
7779         AREG(7) += 2;
7780         PRE_IO
7781         READ_BYTE_F(adr, res)
7782         flag_C = 0;
7783         flag_V = 0;
7784         flag_NotZ = res;
7785         flag_N = res;
7786         adr = AREG((Opcode >> 9) & 7) - 1;
7787         AREG((Opcode >> 9) & 7) = adr;
7788         WRITE_BYTE_F(adr, res)
7789         POST_IO
7790 RET(12)
7791 }
7792
7793 // MOVEB
7794 OPCODE(0x115F)
7795 {
7796         u32 adr, res;
7797         u32 src, dst;
7798
7799         adr = AREG(7);
7800         AREG(7) += 2;
7801         PRE_IO
7802         READ_BYTE_F(adr, res)
7803         flag_C = 0;
7804         flag_V = 0;
7805         flag_NotZ = res;
7806         flag_N = res;
7807         FETCH_SWORD(adr);
7808         adr += AREG((Opcode >> 9) & 7);
7809         WRITE_BYTE_F(adr, res)
7810         POST_IO
7811 RET(16)
7812 }
7813
7814 // MOVEB
7815 OPCODE(0x119F)
7816 {
7817         u32 adr, res;
7818         u32 src, dst;
7819
7820         adr = AREG(7);
7821         AREG(7) += 2;
7822         PRE_IO
7823         READ_BYTE_F(adr, res)
7824         flag_C = 0;
7825         flag_V = 0;
7826         flag_NotZ = res;
7827         flag_N = res;
7828         adr = AREG((Opcode >> 9) & 7);
7829         DECODE_EXT_WORD
7830         WRITE_BYTE_F(adr, res)
7831         POST_IO
7832 RET(18)
7833 }
7834
7835 // MOVEB
7836 OPCODE(0x11DF)
7837 {
7838         u32 adr, res;
7839         u32 src, dst;
7840
7841         adr = AREG(7);
7842         AREG(7) += 2;
7843         PRE_IO
7844         READ_BYTE_F(adr, res)
7845         flag_C = 0;
7846         flag_V = 0;
7847         flag_NotZ = res;
7848         flag_N = res;
7849         FETCH_SWORD(adr);
7850         WRITE_BYTE_F(adr, res)
7851         POST_IO
7852 RET(16)
7853 }
7854
7855 // MOVEB
7856 OPCODE(0x13DF)
7857 {
7858         u32 adr, res;
7859         u32 src, dst;
7860
7861         adr = AREG(7);
7862         AREG(7) += 2;
7863         PRE_IO
7864         READ_BYTE_F(adr, res)
7865         flag_C = 0;
7866         flag_V = 0;
7867         flag_NotZ = res;
7868         flag_N = res;
7869         FETCH_LONG(adr);
7870         WRITE_BYTE_F(adr, res)
7871         POST_IO
7872 RET(20)
7873 }
7874
7875 // MOVEB
7876 OPCODE(0x1EDF)
7877 {
7878         u32 adr, res;
7879         u32 src, dst;
7880
7881         adr = AREG(7);
7882         AREG(7) += 2;
7883         PRE_IO
7884         READ_BYTE_F(adr, res)
7885         flag_C = 0;
7886         flag_V = 0;
7887         flag_NotZ = res;
7888         flag_N = res;
7889         adr = AREG(7);
7890         AREG(7) += 2;
7891         WRITE_BYTE_F(adr, res)
7892         POST_IO
7893 RET(12)
7894 }
7895
7896 // MOVEB
7897 OPCODE(0x1F1F)
7898 {
7899         u32 adr, res;
7900         u32 src, dst;
7901
7902         adr = AREG(7);
7903         AREG(7) += 2;
7904         PRE_IO
7905         READ_BYTE_F(adr, res)
7906         flag_C = 0;
7907         flag_V = 0;
7908         flag_NotZ = res;
7909         flag_N = res;
7910         adr = AREG(7) - 2;
7911         AREG(7) = adr;
7912         WRITE_BYTE_F(adr, res)
7913         POST_IO
7914 RET(12)
7915 }
7916
7917 // MOVEB
7918 OPCODE(0x1027)
7919 {
7920         u32 adr, res;
7921         u32 src, dst;
7922
7923         adr = AREG(7) - 2;
7924         AREG(7) = adr;
7925         PRE_IO
7926         READ_BYTE_F(adr, res)
7927         flag_C = 0;
7928         flag_V = 0;
7929         flag_NotZ = res;
7930         flag_N = res;
7931         DREGu8((Opcode >> 9) & 7) = res;
7932         POST_IO
7933 RET(10)
7934 }
7935
7936 // MOVEB
7937 OPCODE(0x10A7)
7938 {
7939         u32 adr, res;
7940         u32 src, dst;
7941
7942         adr = AREG(7) - 2;
7943         AREG(7) = adr;
7944         PRE_IO
7945         READ_BYTE_F(adr, res)
7946         flag_C = 0;
7947         flag_V = 0;
7948         flag_NotZ = res;
7949         flag_N = res;
7950         adr = AREG((Opcode >> 9) & 7);
7951         WRITE_BYTE_F(adr, res)
7952         POST_IO
7953 RET(14)
7954 }
7955
7956 // MOVEB
7957 OPCODE(0x10E7)
7958 {
7959         u32 adr, res;
7960         u32 src, dst;
7961
7962         adr = AREG(7) - 2;
7963         AREG(7) = adr;
7964         PRE_IO
7965         READ_BYTE_F(adr, res)
7966         flag_C = 0;
7967         flag_V = 0;
7968         flag_NotZ = res;
7969         flag_N = res;
7970         adr = AREG((Opcode >> 9) & 7);
7971         AREG((Opcode >> 9) & 7) += 1;
7972         WRITE_BYTE_F(adr, res)
7973         POST_IO
7974 RET(14)
7975 }
7976
7977 // MOVEB
7978 OPCODE(0x1127)
7979 {
7980         u32 adr, res;
7981         u32 src, dst;
7982
7983         adr = AREG(7) - 2;
7984         AREG(7) = adr;
7985         PRE_IO
7986         READ_BYTE_F(adr, res)
7987         flag_C = 0;
7988         flag_V = 0;
7989         flag_NotZ = res;
7990         flag_N = res;
7991         adr = AREG((Opcode >> 9) & 7) - 1;
7992         AREG((Opcode >> 9) & 7) = adr;
7993         WRITE_BYTE_F(adr, res)
7994         POST_IO
7995 RET(14)
7996 }
7997
7998 // MOVEB
7999 OPCODE(0x1167)
8000 {
8001         u32 adr, res;
8002         u32 src, dst;
8003
8004         adr = AREG(7) - 2;
8005         AREG(7) = adr;
8006         PRE_IO
8007         READ_BYTE_F(adr, res)
8008         flag_C = 0;
8009         flag_V = 0;
8010         flag_NotZ = res;
8011         flag_N = res;
8012         FETCH_SWORD(adr);
8013         adr += AREG((Opcode >> 9) & 7);
8014         WRITE_BYTE_F(adr, res)
8015         POST_IO
8016 RET(18)
8017 }
8018
8019 // MOVEB
8020 OPCODE(0x11A7)
8021 {
8022         u32 adr, res;
8023         u32 src, dst;
8024
8025         adr = AREG(7) - 2;
8026         AREG(7) = adr;
8027         PRE_IO
8028         READ_BYTE_F(adr, res)
8029         flag_C = 0;
8030         flag_V = 0;
8031         flag_NotZ = res;
8032         flag_N = res;
8033         adr = AREG((Opcode >> 9) & 7);
8034         DECODE_EXT_WORD
8035         WRITE_BYTE_F(adr, res)
8036         POST_IO
8037 RET(20)
8038 }
8039
8040 // MOVEB
8041 OPCODE(0x11E7)
8042 {
8043         u32 adr, res;
8044         u32 src, dst;
8045
8046         adr = AREG(7) - 2;
8047         AREG(7) = adr;
8048         PRE_IO
8049         READ_BYTE_F(adr, res)
8050         flag_C = 0;
8051         flag_V = 0;
8052         flag_NotZ = res;
8053         flag_N = res;
8054         FETCH_SWORD(adr);
8055         WRITE_BYTE_F(adr, res)
8056         POST_IO
8057 RET(18)
8058 }
8059
8060 // MOVEB
8061 OPCODE(0x13E7)
8062 {
8063         u32 adr, res;
8064         u32 src, dst;
8065
8066         adr = AREG(7) - 2;
8067         AREG(7) = adr;
8068         PRE_IO
8069         READ_BYTE_F(adr, res)
8070         flag_C = 0;
8071         flag_V = 0;
8072         flag_NotZ = res;
8073         flag_N = res;
8074         FETCH_LONG(adr);
8075         WRITE_BYTE_F(adr, res)
8076         POST_IO
8077 RET(22)
8078 }
8079
8080 // MOVEB
8081 OPCODE(0x1EE7)
8082 {
8083         u32 adr, res;
8084         u32 src, dst;
8085
8086         adr = AREG(7) - 2;
8087         AREG(7) = adr;
8088         PRE_IO
8089         READ_BYTE_F(adr, res)
8090         flag_C = 0;
8091         flag_V = 0;
8092         flag_NotZ = res;
8093         flag_N = res;
8094         adr = AREG(7);
8095         AREG(7) += 2;
8096         WRITE_BYTE_F(adr, res)
8097         POST_IO
8098 RET(14)
8099 }
8100
8101 // MOVEB
8102 OPCODE(0x1F27)
8103 {
8104         u32 adr, res;
8105         u32 src, dst;
8106
8107         adr = AREG(7) - 2;
8108         AREG(7) = adr;
8109         PRE_IO
8110         READ_BYTE_F(adr, res)
8111         flag_C = 0;
8112         flag_V = 0;
8113         flag_NotZ = res;
8114         flag_N = res;
8115         adr = AREG(7) - 2;
8116         AREG(7) = adr;
8117         WRITE_BYTE_F(adr, res)
8118         POST_IO
8119 RET(14)
8120 }
8121
8122 // MOVEL
8123 OPCODE(0x2000)
8124 {
8125         u32 adr, res;
8126         u32 src, dst;
8127
8128         res = DREGu32((Opcode >> 0) & 7);
8129         flag_C = 0;
8130         flag_V = 0;
8131         flag_NotZ = res;
8132         flag_N = res >> 24;
8133         DREGu32((Opcode >> 9) & 7) = res;
8134 RET(4)
8135 }
8136
8137 // MOVEL
8138 OPCODE(0x2080)
8139 {
8140         u32 adr, res;
8141         u32 src, dst;
8142
8143         res = DREGu32((Opcode >> 0) & 7);
8144         flag_C = 0;
8145         flag_V = 0;
8146         flag_NotZ = res;
8147         flag_N = res >> 24;
8148         adr = AREG((Opcode >> 9) & 7);
8149         PRE_IO
8150         WRITE_LONG_F(adr, res)
8151         POST_IO
8152 RET(12)
8153 }
8154
8155 // MOVEL
8156 OPCODE(0x20C0)
8157 {
8158         u32 adr, res;
8159         u32 src, dst;
8160
8161         res = DREGu32((Opcode >> 0) & 7);
8162         flag_C = 0;
8163         flag_V = 0;
8164         flag_NotZ = res;
8165         flag_N = res >> 24;
8166         adr = AREG((Opcode >> 9) & 7);
8167         AREG((Opcode >> 9) & 7) += 4;
8168         PRE_IO
8169         WRITE_LONG_F(adr, res)
8170         POST_IO
8171 RET(12)
8172 }
8173
8174 // MOVEL
8175 OPCODE(0x2100)
8176 {
8177         u32 adr, res;
8178         u32 src, dst;
8179
8180         res = DREGu32((Opcode >> 0) & 7);
8181         flag_C = 0;
8182         flag_V = 0;
8183         flag_NotZ = res;
8184         flag_N = res >> 24;
8185         adr = AREG((Opcode >> 9) & 7) - 4;
8186         AREG((Opcode >> 9) & 7) = adr;
8187         PRE_IO
8188         WRITE_LONG_DEC_F(adr, res)
8189         POST_IO
8190 RET(12)
8191 }
8192
8193 // MOVEL
8194 OPCODE(0x2140)
8195 {
8196         u32 adr, res;
8197         u32 src, dst;
8198
8199         res = DREGu32((Opcode >> 0) & 7);
8200         flag_C = 0;
8201         flag_V = 0;
8202         flag_NotZ = res;
8203         flag_N = res >> 24;
8204         FETCH_SWORD(adr);
8205         adr += AREG((Opcode >> 9) & 7);
8206         PRE_IO
8207         WRITE_LONG_F(adr, res)
8208         POST_IO
8209 RET(16)
8210 }
8211
8212 // MOVEL
8213 OPCODE(0x2180)
8214 {
8215         u32 adr, res;
8216         u32 src, dst;
8217
8218         res = DREGu32((Opcode >> 0) & 7);
8219         flag_C = 0;
8220         flag_V = 0;
8221         flag_NotZ = res;
8222         flag_N = res >> 24;
8223         adr = AREG((Opcode >> 9) & 7);
8224         DECODE_EXT_WORD
8225         PRE_IO
8226         WRITE_LONG_F(adr, res)
8227         POST_IO
8228 RET(18)
8229 }
8230
8231 // MOVEL
8232 OPCODE(0x21C0)
8233 {
8234         u32 adr, res;
8235         u32 src, dst;
8236
8237         res = DREGu32((Opcode >> 0) & 7);
8238         flag_C = 0;
8239         flag_V = 0;
8240         flag_NotZ = res;
8241         flag_N = res >> 24;
8242         FETCH_SWORD(adr);
8243         PRE_IO
8244         WRITE_LONG_F(adr, res)
8245         POST_IO
8246 RET(16)
8247 }
8248
8249 // MOVEL
8250 OPCODE(0x23C0)
8251 {
8252         u32 adr, res;
8253         u32 src, dst;
8254
8255         res = DREGu32((Opcode >> 0) & 7);
8256         flag_C = 0;
8257         flag_V = 0;
8258         flag_NotZ = res;
8259         flag_N = res >> 24;
8260         FETCH_LONG(adr);
8261         PRE_IO
8262         WRITE_LONG_F(adr, res)
8263         POST_IO
8264 RET(20)
8265 }
8266
8267 // MOVEL
8268 OPCODE(0x2EC0)
8269 {
8270         u32 adr, res;
8271         u32 src, dst;
8272
8273         res = DREGu32((Opcode >> 0) & 7);
8274         flag_C = 0;
8275         flag_V = 0;
8276         flag_NotZ = res;
8277         flag_N = res >> 24;
8278         adr = AREG(7);
8279         AREG(7) += 4;
8280         PRE_IO
8281         WRITE_LONG_F(adr, res)
8282         POST_IO
8283 RET(12)
8284 }
8285
8286 // MOVEL
8287 OPCODE(0x2F00)
8288 {
8289         u32 adr, res;
8290         u32 src, dst;
8291
8292         res = DREGu32((Opcode >> 0) & 7);
8293         flag_C = 0;
8294         flag_V = 0;
8295         flag_NotZ = res;
8296         flag_N = res >> 24;
8297         adr = AREG(7) - 4;
8298         AREG(7) = adr;
8299         PRE_IO
8300         WRITE_LONG_DEC_F(adr, res)
8301         POST_IO
8302 RET(12)
8303 }
8304
8305 // MOVEL
8306 OPCODE(0x2008)
8307 {
8308         u32 adr, res;
8309         u32 src, dst;
8310
8311         res = AREGu32((Opcode >> 0) & 7);
8312         flag_C = 0;
8313         flag_V = 0;
8314         flag_NotZ = res;
8315         flag_N = res >> 24;
8316         DREGu32((Opcode >> 9) & 7) = res;
8317 RET(4)
8318 }
8319
8320 // MOVEL
8321 OPCODE(0x2088)
8322 {
8323         u32 adr, res;
8324         u32 src, dst;
8325
8326         res = AREGu32((Opcode >> 0) & 7);
8327         flag_C = 0;
8328         flag_V = 0;
8329         flag_NotZ = res;
8330         flag_N = res >> 24;
8331         adr = AREG((Opcode >> 9) & 7);
8332         PRE_IO
8333         WRITE_LONG_F(adr, res)
8334         POST_IO
8335 RET(12)
8336 }
8337
8338 // MOVEL
8339 OPCODE(0x20C8)
8340 {
8341         u32 adr, res;
8342         u32 src, dst;
8343
8344         res = AREGu32((Opcode >> 0) & 7);
8345         flag_C = 0;
8346         flag_V = 0;
8347         flag_NotZ = res;
8348         flag_N = res >> 24;
8349         adr = AREG((Opcode >> 9) & 7);
8350         AREG((Opcode >> 9) & 7) += 4;
8351         PRE_IO
8352         WRITE_LONG_F(adr, res)
8353         POST_IO
8354 RET(12)
8355 }
8356
8357 // MOVEL
8358 OPCODE(0x2108)
8359 {
8360         u32 adr, res;
8361         u32 src, dst;
8362
8363         res = AREGu32((Opcode >> 0) & 7);
8364         flag_C = 0;
8365         flag_V = 0;
8366         flag_NotZ = res;
8367         flag_N = res >> 24;
8368         adr = AREG((Opcode >> 9) & 7) - 4;
8369         AREG((Opcode >> 9) & 7) = adr;
8370         PRE_IO
8371         WRITE_LONG_DEC_F(adr, res)
8372         POST_IO
8373 RET(12)
8374 }
8375
8376 // MOVEL
8377 OPCODE(0x2148)
8378 {
8379         u32 adr, res;
8380         u32 src, dst;
8381
8382         res = AREGu32((Opcode >> 0) & 7);
8383         flag_C = 0;
8384         flag_V = 0;
8385         flag_NotZ = res;
8386         flag_N = res >> 24;
8387         FETCH_SWORD(adr);
8388         adr += AREG((Opcode >> 9) & 7);
8389         PRE_IO
8390         WRITE_LONG_F(adr, res)
8391         POST_IO
8392 RET(16)
8393 }
8394
8395 // MOVEL
8396 OPCODE(0x2188)
8397 {
8398         u32 adr, res;
8399         u32 src, dst;
8400
8401         res = AREGu32((Opcode >> 0) & 7);
8402         flag_C = 0;
8403         flag_V = 0;
8404         flag_NotZ = res;
8405         flag_N = res >> 24;
8406         adr = AREG((Opcode >> 9) & 7);
8407         DECODE_EXT_WORD
8408         PRE_IO
8409         WRITE_LONG_F(adr, res)
8410         POST_IO
8411 RET(18)
8412 }
8413
8414 // MOVEL
8415 OPCODE(0x21C8)
8416 {
8417         u32 adr, res;
8418         u32 src, dst;
8419
8420         res = AREGu32((Opcode >> 0) & 7);
8421         flag_C = 0;
8422         flag_V = 0;
8423         flag_NotZ = res;
8424         flag_N = res >> 24;
8425         FETCH_SWORD(adr);
8426         PRE_IO
8427         WRITE_LONG_F(adr, res)
8428         POST_IO
8429 RET(16)
8430 }
8431
8432 // MOVEL
8433 OPCODE(0x23C8)
8434 {
8435         u32 adr, res;
8436         u32 src, dst;
8437
8438         res = AREGu32((Opcode >> 0) & 7);
8439         flag_C = 0;
8440         flag_V = 0;
8441         flag_NotZ = res;
8442         flag_N = res >> 24;
8443         FETCH_LONG(adr);
8444         PRE_IO
8445         WRITE_LONG_F(adr, res)
8446         POST_IO
8447 RET(20)
8448 }
8449
8450 // MOVEL
8451 OPCODE(0x2EC8)
8452 {
8453         u32 adr, res;
8454         u32 src, dst;
8455
8456         res = AREGu32((Opcode >> 0) & 7);
8457         flag_C = 0;
8458         flag_V = 0;
8459         flag_NotZ = res;
8460         flag_N = res >> 24;
8461         adr = AREG(7);
8462         AREG(7) += 4;
8463         PRE_IO
8464         WRITE_LONG_F(adr, res)
8465         POST_IO
8466 RET(12)
8467 }
8468
8469 // MOVEL
8470 OPCODE(0x2F08)
8471 {
8472         u32 adr, res;
8473         u32 src, dst;
8474
8475         res = AREGu32((Opcode >> 0) & 7);
8476         flag_C = 0;
8477         flag_V = 0;
8478         flag_NotZ = res;
8479         flag_N = res >> 24;
8480         adr = AREG(7) - 4;
8481         AREG(7) = adr;
8482         PRE_IO
8483         WRITE_LONG_DEC_F(adr, res)
8484         POST_IO
8485 RET(12)
8486 }
8487
8488 // MOVEL
8489 OPCODE(0x2010)
8490 {
8491         u32 adr, res;
8492         u32 src, dst;
8493
8494         adr = AREG((Opcode >> 0) & 7);
8495         PRE_IO
8496         READ_LONG_F(adr, res)
8497         flag_C = 0;
8498         flag_V = 0;
8499         flag_NotZ = res;
8500         flag_N = res >> 24;
8501         DREGu32((Opcode >> 9) & 7) = res;
8502         POST_IO
8503 RET(12)
8504 }
8505
8506 // MOVEL
8507 OPCODE(0x2090)
8508 {
8509         u32 adr, res;
8510         u32 src, dst;
8511
8512         adr = AREG((Opcode >> 0) & 7);
8513         PRE_IO
8514         READ_LONG_F(adr, res)
8515         flag_C = 0;
8516         flag_V = 0;
8517         flag_NotZ = res;
8518         flag_N = res >> 24;
8519         adr = AREG((Opcode >> 9) & 7);
8520         WRITE_LONG_F(adr, res)
8521         POST_IO
8522 RET(20)
8523 }
8524
8525 // MOVEL
8526 OPCODE(0x20D0)
8527 {
8528         u32 adr, res;
8529         u32 src, dst;
8530
8531         adr = AREG((Opcode >> 0) & 7);
8532         PRE_IO
8533         READ_LONG_F(adr, res)
8534         flag_C = 0;
8535         flag_V = 0;
8536         flag_NotZ = res;
8537         flag_N = res >> 24;
8538         adr = AREG((Opcode >> 9) & 7);
8539         AREG((Opcode >> 9) & 7) += 4;
8540         WRITE_LONG_F(adr, res)
8541         POST_IO
8542 RET(20)
8543 }
8544
8545 // MOVEL
8546 OPCODE(0x2110)
8547 {
8548         u32 adr, res;
8549         u32 src, dst;
8550
8551         adr = AREG((Opcode >> 0) & 7);
8552         PRE_IO
8553         READ_LONG_F(adr, res)
8554         flag_C = 0;
8555         flag_V = 0;
8556         flag_NotZ = res;
8557         flag_N = res >> 24;
8558         adr = AREG((Opcode >> 9) & 7) - 4;
8559         AREG((Opcode >> 9) & 7) = adr;
8560         WRITE_LONG_DEC_F(adr, res)
8561         POST_IO
8562 RET(20)
8563 }
8564
8565 // MOVEL
8566 OPCODE(0x2150)
8567 {
8568         u32 adr, res;
8569         u32 src, dst;
8570
8571         adr = AREG((Opcode >> 0) & 7);
8572         PRE_IO
8573         READ_LONG_F(adr, res)
8574         flag_C = 0;
8575         flag_V = 0;
8576         flag_NotZ = res;
8577         flag_N = res >> 24;
8578         FETCH_SWORD(adr);
8579         adr += AREG((Opcode >> 9) & 7);
8580         WRITE_LONG_F(adr, res)
8581         POST_IO
8582 RET(24)
8583 }
8584
8585 // MOVEL
8586 OPCODE(0x2190)
8587 {
8588         u32 adr, res;
8589         u32 src, dst;
8590
8591         adr = AREG((Opcode >> 0) & 7);
8592         PRE_IO
8593         READ_LONG_F(adr, res)
8594         flag_C = 0;
8595         flag_V = 0;
8596         flag_NotZ = res;
8597         flag_N = res >> 24;
8598         adr = AREG((Opcode >> 9) & 7);
8599         DECODE_EXT_WORD
8600         WRITE_LONG_F(adr, res)
8601         POST_IO
8602 RET(26)
8603 }
8604
8605 // MOVEL
8606 OPCODE(0x21D0)
8607 {
8608         u32 adr, res;
8609         u32 src, dst;
8610
8611         adr = AREG((Opcode >> 0) & 7);
8612         PRE_IO
8613         READ_LONG_F(adr, res)
8614         flag_C = 0;
8615         flag_V = 0;
8616         flag_NotZ = res;
8617         flag_N = res >> 24;
8618         FETCH_SWORD(adr);
8619         WRITE_LONG_F(adr, res)
8620         POST_IO
8621 RET(24)
8622 }
8623
8624 // MOVEL
8625 OPCODE(0x23D0)
8626 {
8627         u32 adr, res;
8628         u32 src, dst;
8629
8630         adr = AREG((Opcode >> 0) & 7);
8631         PRE_IO
8632         READ_LONG_F(adr, res)
8633         flag_C = 0;
8634         flag_V = 0;
8635         flag_NotZ = res;
8636         flag_N = res >> 24;
8637         FETCH_LONG(adr);
8638         WRITE_LONG_F(adr, res)
8639         POST_IO
8640 RET(28)
8641 }
8642
8643 // MOVEL
8644 OPCODE(0x2ED0)
8645 {
8646         u32 adr, res;
8647         u32 src, dst;
8648
8649         adr = AREG((Opcode >> 0) & 7);
8650         PRE_IO
8651         READ_LONG_F(adr, res)
8652         flag_C = 0;
8653         flag_V = 0;
8654         flag_NotZ = res;
8655         flag_N = res >> 24;
8656         adr = AREG(7);
8657         AREG(7) += 4;
8658         WRITE_LONG_F(adr, res)
8659         POST_IO
8660 RET(20)
8661 }
8662
8663 // MOVEL
8664 OPCODE(0x2F10)
8665 {
8666         u32 adr, res;
8667         u32 src, dst;
8668
8669         adr = AREG((Opcode >> 0) & 7);
8670         PRE_IO
8671         READ_LONG_F(adr, res)
8672         flag_C = 0;
8673         flag_V = 0;
8674         flag_NotZ = res;
8675         flag_N = res >> 24;
8676         adr = AREG(7) - 4;
8677         AREG(7) = adr;
8678         WRITE_LONG_DEC_F(adr, res)
8679         POST_IO
8680 RET(20)
8681 }
8682
8683 // MOVEL
8684 OPCODE(0x2018)
8685 {
8686         u32 adr, res;
8687         u32 src, dst;
8688
8689         adr = AREG((Opcode >> 0) & 7);
8690         AREG((Opcode >> 0) & 7) += 4;
8691         PRE_IO
8692         READ_LONG_F(adr, res)
8693         flag_C = 0;
8694         flag_V = 0;
8695         flag_NotZ = res;
8696         flag_N = res >> 24;
8697         DREGu32((Opcode >> 9) & 7) = res;
8698         POST_IO
8699 RET(12)
8700 }
8701
8702 // MOVEL
8703 OPCODE(0x2098)
8704 {
8705         u32 adr, res;
8706         u32 src, dst;
8707
8708         adr = AREG((Opcode >> 0) & 7);
8709         AREG((Opcode >> 0) & 7) += 4;
8710         PRE_IO
8711         READ_LONG_F(adr, res)
8712         flag_C = 0;
8713         flag_V = 0;
8714         flag_NotZ = res;
8715         flag_N = res >> 24;
8716         adr = AREG((Opcode >> 9) & 7);
8717         WRITE_LONG_F(adr, res)
8718         POST_IO
8719 RET(20)
8720 }
8721
8722 // MOVEL
8723 OPCODE(0x20D8)
8724 {
8725         u32 adr, res;
8726         u32 src, dst;
8727
8728         adr = AREG((Opcode >> 0) & 7);
8729         AREG((Opcode >> 0) & 7) += 4;
8730         PRE_IO
8731         READ_LONG_F(adr, res)
8732         flag_C = 0;
8733         flag_V = 0;
8734         flag_NotZ = res;
8735         flag_N = res >> 24;
8736         adr = AREG((Opcode >> 9) & 7);
8737         AREG((Opcode >> 9) & 7) += 4;
8738         WRITE_LONG_F(adr, res)
8739         POST_IO
8740 RET(20)
8741 }
8742
8743 // MOVEL
8744 OPCODE(0x2118)
8745 {
8746         u32 adr, res;
8747         u32 src, dst;
8748
8749         adr = AREG((Opcode >> 0) & 7);
8750         AREG((Opcode >> 0) & 7) += 4;
8751         PRE_IO
8752         READ_LONG_F(adr, res)
8753         flag_C = 0;
8754         flag_V = 0;
8755         flag_NotZ = res;
8756         flag_N = res >> 24;
8757         adr = AREG((Opcode >> 9) & 7) - 4;
8758         AREG((Opcode >> 9) & 7) = adr;
8759         WRITE_LONG_DEC_F(adr, res)
8760         POST_IO
8761 RET(20)
8762 }
8763
8764 // MOVEL
8765 OPCODE(0x2158)
8766 {
8767         u32 adr, res;
8768         u32 src, dst;
8769
8770         adr = AREG((Opcode >> 0) & 7);
8771         AREG((Opcode >> 0) & 7) += 4;
8772         PRE_IO
8773         READ_LONG_F(adr, res)
8774         flag_C = 0;
8775         flag_V = 0;
8776         flag_NotZ = res;
8777         flag_N = res >> 24;
8778         FETCH_SWORD(adr);
8779         adr += AREG((Opcode >> 9) & 7);
8780         WRITE_LONG_F(adr, res)
8781         POST_IO
8782 RET(24)
8783 }
8784
8785 // MOVEL
8786 OPCODE(0x2198)
8787 {
8788         u32 adr, res;
8789         u32 src, dst;
8790
8791         adr = AREG((Opcode >> 0) & 7);
8792         AREG((Opcode >> 0) & 7) += 4;
8793         PRE_IO
8794         READ_LONG_F(adr, res)
8795         flag_C = 0;
8796         flag_V = 0;
8797         flag_NotZ = res;
8798         flag_N = res >> 24;
8799         adr = AREG((Opcode >> 9) & 7);
8800         DECODE_EXT_WORD
8801         WRITE_LONG_F(adr, res)
8802         POST_IO
8803 RET(26)
8804 }
8805
8806 // MOVEL
8807 OPCODE(0x21D8)
8808 {
8809         u32 adr, res;
8810         u32 src, dst;
8811
8812         adr = AREG((Opcode >> 0) & 7);
8813         AREG((Opcode >> 0) & 7) += 4;
8814         PRE_IO
8815         READ_LONG_F(adr, res)
8816         flag_C = 0;
8817         flag_V = 0;
8818         flag_NotZ = res;
8819         flag_N = res >> 24;
8820         FETCH_SWORD(adr);
8821         WRITE_LONG_F(adr, res)
8822         POST_IO
8823 RET(24)
8824 }
8825
8826 // MOVEL
8827 OPCODE(0x23D8)
8828 {
8829         u32 adr, res;
8830         u32 src, dst;
8831
8832         adr = AREG((Opcode >> 0) & 7);
8833         AREG((Opcode >> 0) & 7) += 4;
8834         PRE_IO
8835         READ_LONG_F(adr, res)
8836         flag_C = 0;
8837         flag_V = 0;
8838         flag_NotZ = res;
8839         flag_N = res >> 24;
8840         FETCH_LONG(adr);
8841         WRITE_LONG_F(adr, res)
8842         POST_IO
8843 RET(28)
8844 }
8845
8846 // MOVEL
8847 OPCODE(0x2ED8)
8848 {
8849         u32 adr, res;
8850         u32 src, dst;
8851
8852         adr = AREG((Opcode >> 0) & 7);
8853         AREG((Opcode >> 0) & 7) += 4;
8854         PRE_IO
8855         READ_LONG_F(adr, res)
8856         flag_C = 0;
8857         flag_V = 0;
8858         flag_NotZ = res;
8859         flag_N = res >> 24;
8860         adr = AREG(7);
8861         AREG(7) += 4;
8862         WRITE_LONG_F(adr, res)
8863         POST_IO
8864 RET(20)
8865 }
8866
8867 // MOVEL
8868 OPCODE(0x2F18)
8869 {
8870         u32 adr, res;
8871         u32 src, dst;
8872
8873         adr = AREG((Opcode >> 0) & 7);
8874         AREG((Opcode >> 0) & 7) += 4;
8875         PRE_IO
8876         READ_LONG_F(adr, res)
8877         flag_C = 0;
8878         flag_V = 0;
8879         flag_NotZ = res;
8880         flag_N = res >> 24;
8881         adr = AREG(7) - 4;
8882         AREG(7) = adr;
8883         WRITE_LONG_DEC_F(adr, res)
8884         POST_IO
8885 RET(20)
8886 }
8887
8888 // MOVEL
8889 OPCODE(0x2020)
8890 {
8891         u32 adr, res;
8892         u32 src, dst;
8893
8894         adr = AREG((Opcode >> 0) & 7) - 4;
8895         AREG((Opcode >> 0) & 7) = adr;
8896         PRE_IO
8897         READ_LONG_F(adr, res)
8898         flag_C = 0;
8899         flag_V = 0;
8900         flag_NotZ = res;
8901         flag_N = res >> 24;
8902         DREGu32((Opcode >> 9) & 7) = res;
8903         POST_IO
8904 RET(14)
8905 }
8906
8907 // MOVEL
8908 OPCODE(0x20A0)
8909 {
8910         u32 adr, res;
8911         u32 src, dst;
8912
8913         adr = AREG((Opcode >> 0) & 7) - 4;
8914         AREG((Opcode >> 0) & 7) = adr;
8915         PRE_IO
8916         READ_LONG_F(adr, res)
8917         flag_C = 0;
8918         flag_V = 0;
8919         flag_NotZ = res;
8920         flag_N = res >> 24;
8921         adr = AREG((Opcode >> 9) & 7);
8922         WRITE_LONG_F(adr, res)
8923         POST_IO
8924 RET(22)
8925 }
8926
8927 // MOVEL
8928 OPCODE(0x20E0)
8929 {
8930         u32 adr, res;
8931         u32 src, dst;
8932
8933         adr = AREG((Opcode >> 0) & 7) - 4;
8934         AREG((Opcode >> 0) & 7) = adr;
8935         PRE_IO
8936         READ_LONG_F(adr, res)
8937         flag_C = 0;
8938         flag_V = 0;
8939         flag_NotZ = res;
8940         flag_N = res >> 24;
8941         adr = AREG((Opcode >> 9) & 7);
8942         AREG((Opcode >> 9) & 7) += 4;
8943         WRITE_LONG_F(adr, res)
8944         POST_IO
8945 RET(22)
8946 }
8947
8948 // MOVEL
8949 OPCODE(0x2120)
8950 {
8951         u32 adr, res;
8952         u32 src, dst;
8953
8954         adr = AREG((Opcode >> 0) & 7) - 4;
8955         AREG((Opcode >> 0) & 7) = adr;
8956         PRE_IO
8957         READ_LONG_F(adr, res)
8958         flag_C = 0;
8959         flag_V = 0;
8960         flag_NotZ = res;
8961         flag_N = res >> 24;
8962         adr = AREG((Opcode >> 9) & 7) - 4;
8963         AREG((Opcode >> 9) & 7) = adr;
8964         WRITE_LONG_DEC_F(adr, res)
8965         POST_IO
8966 RET(22)
8967 }
8968
8969 // MOVEL
8970 OPCODE(0x2160)
8971 {
8972         u32 adr, res;
8973         u32 src, dst;
8974
8975         adr = AREG((Opcode >> 0) & 7) - 4;
8976         AREG((Opcode >> 0) & 7) = adr;
8977         PRE_IO
8978         READ_LONG_F(adr, res)
8979         flag_C = 0;
8980         flag_V = 0;
8981         flag_NotZ = res;
8982         flag_N = res >> 24;
8983         FETCH_SWORD(adr);
8984         adr += AREG((Opcode >> 9) & 7);
8985         WRITE_LONG_F(adr, res)
8986         POST_IO
8987 RET(26)
8988 }
8989
8990 // MOVEL
8991 OPCODE(0x21A0)
8992 {
8993         u32 adr, res;
8994         u32 src, dst;
8995
8996         adr = AREG((Opcode >> 0) & 7) - 4;
8997         AREG((Opcode >> 0) & 7) = adr;
8998         PRE_IO
8999         READ_LONG_F(adr, res)
9000         flag_C = 0;
9001         flag_V = 0;
9002         flag_NotZ = res;
9003         flag_N = res >> 24;
9004         adr = AREG((Opcode >> 9) & 7);
9005         DECODE_EXT_WORD
9006         WRITE_LONG_F(adr, res)
9007         POST_IO
9008 RET(28)
9009 }
9010
9011 // MOVEL
9012 OPCODE(0x21E0)
9013 {
9014         u32 adr, res;
9015         u32 src, dst;
9016
9017         adr = AREG((Opcode >> 0) & 7) - 4;
9018         AREG((Opcode >> 0) & 7) = adr;
9019         PRE_IO
9020         READ_LONG_F(adr, res)
9021         flag_C = 0;
9022         flag_V = 0;
9023         flag_NotZ = res;
9024         flag_N = res >> 24;
9025         FETCH_SWORD(adr);
9026         WRITE_LONG_F(adr, res)
9027         POST_IO
9028 RET(26)
9029 }
9030
9031 // MOVEL
9032 OPCODE(0x23E0)
9033 {
9034         u32 adr, res;
9035         u32 src, dst;
9036
9037         adr = AREG((Opcode >> 0) & 7) - 4;
9038         AREG((Opcode >> 0) & 7) = adr;
9039         PRE_IO
9040         READ_LONG_F(adr, res)
9041         flag_C = 0;
9042         flag_V = 0;
9043         flag_NotZ = res;
9044         flag_N = res >> 24;
9045         FETCH_LONG(adr);
9046         WRITE_LONG_F(adr, res)
9047         POST_IO
9048 RET(30)
9049 }
9050
9051 // MOVEL
9052 OPCODE(0x2EE0)
9053 {
9054         u32 adr, res;
9055         u32 src, dst;
9056
9057         adr = AREG((Opcode >> 0) & 7) - 4;
9058         AREG((Opcode >> 0) & 7) = adr;
9059         PRE_IO
9060         READ_LONG_F(adr, res)
9061         flag_C = 0;
9062         flag_V = 0;
9063         flag_NotZ = res;
9064         flag_N = res >> 24;
9065         adr = AREG(7);
9066         AREG(7) += 4;
9067         WRITE_LONG_F(adr, res)
9068         POST_IO
9069 RET(22)
9070 }
9071
9072 // MOVEL
9073 OPCODE(0x2F20)
9074 {
9075         u32 adr, res;
9076         u32 src, dst;
9077
9078         adr = AREG((Opcode >> 0) & 7) - 4;
9079         AREG((Opcode >> 0) & 7) = adr;
9080         PRE_IO
9081         READ_LONG_F(adr, res)
9082         flag_C = 0;
9083         flag_V = 0;
9084         flag_NotZ = res;
9085         flag_N = res >> 24;
9086         adr = AREG(7) - 4;
9087         AREG(7) = adr;
9088         WRITE_LONG_DEC_F(adr, res)
9089         POST_IO
9090 RET(22)
9091 }
9092
9093 // MOVEL
9094 OPCODE(0x2028)
9095 {
9096         u32 adr, res;
9097         u32 src, dst;
9098
9099         FETCH_SWORD(adr);
9100         adr += AREG((Opcode >> 0) & 7);
9101         PRE_IO
9102         READ_LONG_F(adr, res)
9103         flag_C = 0;
9104         flag_V = 0;
9105         flag_NotZ = res;
9106         flag_N = res >> 24;
9107         DREGu32((Opcode >> 9) & 7) = res;
9108         POST_IO
9109 RET(16)
9110 }
9111
9112 // MOVEL
9113 OPCODE(0x20A8)
9114 {
9115         u32 adr, res;
9116         u32 src, dst;
9117
9118         FETCH_SWORD(adr);
9119         adr += AREG((Opcode >> 0) & 7);
9120         PRE_IO
9121         READ_LONG_F(adr, res)
9122         flag_C = 0;
9123         flag_V = 0;
9124         flag_NotZ = res;
9125         flag_N = res >> 24;
9126         adr = AREG((Opcode >> 9) & 7);
9127         WRITE_LONG_F(adr, res)
9128         POST_IO
9129 RET(24)
9130 }
9131
9132 // MOVEL
9133 OPCODE(0x20E8)
9134 {
9135         u32 adr, res;
9136         u32 src, dst;
9137
9138         FETCH_SWORD(adr);
9139         adr += AREG((Opcode >> 0) & 7);
9140         PRE_IO
9141         READ_LONG_F(adr, res)
9142         flag_C = 0;
9143         flag_V = 0;
9144         flag_NotZ = res;
9145         flag_N = res >> 24;
9146         adr = AREG((Opcode >> 9) & 7);
9147         AREG((Opcode >> 9) & 7) += 4;
9148         WRITE_LONG_F(adr, res)
9149         POST_IO
9150 RET(24)
9151 }
9152
9153 // MOVEL
9154 OPCODE(0x2128)
9155 {
9156         u32 adr, res;
9157         u32 src, dst;
9158
9159         FETCH_SWORD(adr);
9160         adr += AREG((Opcode >> 0) & 7);
9161         PRE_IO
9162         READ_LONG_F(adr, res)
9163         flag_C = 0;
9164         flag_V = 0;
9165         flag_NotZ = res;
9166         flag_N = res >> 24;
9167         adr = AREG((Opcode >> 9) & 7) - 4;
9168         AREG((Opcode >> 9) & 7) = adr;
9169         WRITE_LONG_DEC_F(adr, res)
9170         POST_IO
9171 RET(24)
9172 }
9173
9174 // MOVEL
9175 OPCODE(0x2168)
9176 {
9177         u32 adr, res;
9178         u32 src, dst;
9179
9180         FETCH_SWORD(adr);
9181         adr += AREG((Opcode >> 0) & 7);
9182         PRE_IO
9183         READ_LONG_F(adr, res)
9184         flag_C = 0;
9185         flag_V = 0;
9186         flag_NotZ = res;
9187         flag_N = res >> 24;
9188         FETCH_SWORD(adr);
9189         adr += AREG((Opcode >> 9) & 7);
9190         WRITE_LONG_F(adr, res)
9191         POST_IO
9192 RET(28)
9193 }
9194
9195 // MOVEL
9196 OPCODE(0x21A8)
9197 {
9198         u32 adr, res;
9199         u32 src, dst;
9200
9201         FETCH_SWORD(adr);
9202         adr += AREG((Opcode >> 0) & 7);
9203         PRE_IO
9204         READ_LONG_F(adr, res)
9205         flag_C = 0;
9206         flag_V = 0;
9207         flag_NotZ = res;
9208         flag_N = res >> 24;
9209         adr = AREG((Opcode >> 9) & 7);
9210         DECODE_EXT_WORD
9211         WRITE_LONG_F(adr, res)
9212         POST_IO
9213 RET(30)
9214 }
9215
9216 // MOVEL
9217 OPCODE(0x21E8)
9218 {
9219         u32 adr, res;
9220         u32 src, dst;
9221
9222         FETCH_SWORD(adr);
9223         adr += AREG((Opcode >> 0) & 7);
9224         PRE_IO
9225         READ_LONG_F(adr, res)
9226         flag_C = 0;
9227         flag_V = 0;
9228         flag_NotZ = res;
9229         flag_N = res >> 24;
9230         FETCH_SWORD(adr);
9231         WRITE_LONG_F(adr, res)
9232         POST_IO
9233 RET(28)
9234 }
9235
9236 // MOVEL
9237 OPCODE(0x23E8)
9238 {
9239         u32 adr, res;
9240         u32 src, dst;
9241
9242         FETCH_SWORD(adr);
9243         adr += AREG((Opcode >> 0) & 7);
9244         PRE_IO
9245         READ_LONG_F(adr, res)
9246         flag_C = 0;
9247         flag_V = 0;
9248         flag_NotZ = res;
9249         flag_N = res >> 24;
9250         FETCH_LONG(adr);
9251         WRITE_LONG_F(adr, res)
9252         POST_IO
9253 RET(32)
9254 }
9255
9256 // MOVEL
9257 OPCODE(0x2EE8)
9258 {
9259         u32 adr, res;
9260         u32 src, dst;
9261
9262         FETCH_SWORD(adr);
9263         adr += AREG((Opcode >> 0) & 7);
9264         PRE_IO
9265         READ_LONG_F(adr, res)
9266         flag_C = 0;
9267         flag_V = 0;
9268         flag_NotZ = res;
9269         flag_N = res >> 24;
9270         adr = AREG(7);
9271         AREG(7) += 4;
9272         WRITE_LONG_F(adr, res)
9273         POST_IO
9274 RET(24)
9275 }
9276
9277 // MOVEL
9278 OPCODE(0x2F28)
9279 {
9280         u32 adr, res;
9281         u32 src, dst;
9282
9283         FETCH_SWORD(adr);
9284         adr += AREG((Opcode >> 0) & 7);
9285         PRE_IO
9286         READ_LONG_F(adr, res)
9287         flag_C = 0;
9288         flag_V = 0;
9289         flag_NotZ = res;
9290         flag_N = res >> 24;
9291         adr = AREG(7) - 4;
9292         AREG(7) = adr;
9293         WRITE_LONG_DEC_F(adr, res)
9294         POST_IO
9295 RET(24)
9296 }
9297
9298 // MOVEL
9299 OPCODE(0x2030)
9300 {
9301         u32 adr, res;
9302         u32 src, dst;
9303
9304         adr = AREG((Opcode >> 0) & 7);
9305         DECODE_EXT_WORD
9306         PRE_IO
9307         READ_LONG_F(adr, res)
9308         flag_C = 0;
9309         flag_V = 0;
9310         flag_NotZ = res;
9311         flag_N = res >> 24;
9312         DREGu32((Opcode >> 9) & 7) = res;
9313         POST_IO
9314 RET(18)
9315 }
9316
9317 // MOVEL
9318 OPCODE(0x20B0)
9319 {
9320         u32 adr, res;
9321         u32 src, dst;
9322
9323         adr = AREG((Opcode >> 0) & 7);
9324         DECODE_EXT_WORD
9325         PRE_IO
9326         READ_LONG_F(adr, res)
9327         flag_C = 0;
9328         flag_V = 0;
9329         flag_NotZ = res;
9330         flag_N = res >> 24;
9331         adr = AREG((Opcode >> 9) & 7);
9332         WRITE_LONG_F(adr, res)
9333         POST_IO
9334 RET(26)
9335 }
9336
9337 // MOVEL
9338 OPCODE(0x20F0)
9339 {
9340         u32 adr, res;
9341         u32 src, dst;
9342
9343         adr = AREG((Opcode >> 0) & 7);
9344         DECODE_EXT_WORD
9345         PRE_IO
9346         READ_LONG_F(adr, res)
9347         flag_C = 0;
9348         flag_V = 0;
9349         flag_NotZ = res;
9350         flag_N = res >> 24;
9351         adr = AREG((Opcode >> 9) & 7);
9352         AREG((Opcode >> 9) & 7) += 4;
9353         WRITE_LONG_F(adr, res)
9354         POST_IO
9355 RET(26)
9356 }
9357
9358 // MOVEL
9359 OPCODE(0x2130)
9360 {
9361         u32 adr, res;
9362         u32 src, dst;
9363
9364         adr = AREG((Opcode >> 0) & 7);
9365         DECODE_EXT_WORD
9366         PRE_IO
9367         READ_LONG_F(adr, res)
9368         flag_C = 0;
9369         flag_V = 0;
9370         flag_NotZ = res;
9371         flag_N = res >> 24;
9372         adr = AREG((Opcode >> 9) & 7) - 4;
9373         AREG((Opcode >> 9) & 7) = adr;
9374         WRITE_LONG_DEC_F(adr, res)
9375         POST_IO
9376 RET(26)
9377 }
9378
9379 // MOVEL
9380 OPCODE(0x2170)
9381 {
9382         u32 adr, res;
9383         u32 src, dst;
9384
9385         adr = AREG((Opcode >> 0) & 7);
9386         DECODE_EXT_WORD
9387         PRE_IO
9388         READ_LONG_F(adr, res)
9389         flag_C = 0;
9390         flag_V = 0;
9391         flag_NotZ = res;
9392         flag_N = res >> 24;
9393         FETCH_SWORD(adr);
9394         adr += AREG((Opcode >> 9) & 7);
9395         WRITE_LONG_F(adr, res)
9396         POST_IO
9397 RET(30)
9398 }
9399
9400 // MOVEL
9401 OPCODE(0x21B0)
9402 {
9403         u32 adr, res;
9404         u32 src, dst;
9405
9406         adr = AREG((Opcode >> 0) & 7);
9407         DECODE_EXT_WORD
9408         PRE_IO
9409         READ_LONG_F(adr, res)
9410         flag_C = 0;
9411         flag_V = 0;
9412         flag_NotZ = res;
9413         flag_N = res >> 24;
9414         adr = AREG((Opcode >> 9) & 7);
9415         DECODE_EXT_WORD
9416         WRITE_LONG_F(adr, res)
9417         POST_IO
9418 RET(32)
9419 }
9420
9421 // MOVEL
9422 OPCODE(0x21F0)
9423 {
9424         u32 adr, res;
9425         u32 src, dst;
9426
9427         adr = AREG((Opcode >> 0) & 7);
9428         DECODE_EXT_WORD
9429         PRE_IO
9430         READ_LONG_F(adr, res)
9431         flag_C = 0;
9432         flag_V = 0;
9433         flag_NotZ = res;
9434         flag_N = res >> 24;
9435         FETCH_SWORD(adr);
9436         WRITE_LONG_F(adr, res)
9437         POST_IO
9438 RET(30)
9439 }
9440
9441 // MOVEL
9442 OPCODE(0x23F0)
9443 {
9444         u32 adr, res;
9445         u32 src, dst;
9446
9447         adr = AREG((Opcode >> 0) & 7);
9448         DECODE_EXT_WORD
9449         PRE_IO
9450         READ_LONG_F(adr, res)
9451         flag_C = 0;
9452         flag_V = 0;
9453         flag_NotZ = res;
9454         flag_N = res >> 24;
9455         FETCH_LONG(adr);
9456         WRITE_LONG_F(adr, res)
9457         POST_IO
9458 RET(34)
9459 }
9460
9461 // MOVEL
9462 OPCODE(0x2EF0)
9463 {
9464         u32 adr, res;
9465         u32 src, dst;
9466
9467         adr = AREG((Opcode >> 0) & 7);
9468         DECODE_EXT_WORD
9469         PRE_IO
9470         READ_LONG_F(adr, res)
9471         flag_C = 0;
9472         flag_V = 0;
9473         flag_NotZ = res;
9474         flag_N = res >> 24;
9475         adr = AREG(7);
9476         AREG(7) += 4;
9477         WRITE_LONG_F(adr, res)
9478         POST_IO
9479 RET(26)
9480 }
9481
9482 // MOVEL
9483 OPCODE(0x2F30)
9484 {
9485         u32 adr, res;
9486         u32 src, dst;
9487
9488         adr = AREG((Opcode >> 0) & 7);
9489         DECODE_EXT_WORD
9490         PRE_IO
9491         READ_LONG_F(adr, res)
9492         flag_C = 0;
9493         flag_V = 0;
9494         flag_NotZ = res;
9495         flag_N = res >> 24;
9496         adr = AREG(7) - 4;
9497         AREG(7) = adr;
9498         WRITE_LONG_DEC_F(adr, res)
9499         POST_IO
9500 RET(26)
9501 }
9502
9503 // MOVEL
9504 OPCODE(0x2038)
9505 {
9506         u32 adr, res;
9507         u32 src, dst;
9508
9509         FETCH_SWORD(adr);
9510         PRE_IO
9511         READ_LONG_F(adr, res)
9512         flag_C = 0;
9513         flag_V = 0;
9514         flag_NotZ = res;
9515         flag_N = res >> 24;
9516         DREGu32((Opcode >> 9) & 7) = res;
9517         POST_IO
9518 RET(16)
9519 }
9520
9521 // MOVEL
9522 OPCODE(0x20B8)
9523 {
9524         u32 adr, res;
9525         u32 src, dst;
9526
9527         FETCH_SWORD(adr);
9528         PRE_IO
9529         READ_LONG_F(adr, res)
9530         flag_C = 0;
9531         flag_V = 0;
9532         flag_NotZ = res;
9533         flag_N = res >> 24;
9534         adr = AREG((Opcode >> 9) & 7);
9535         WRITE_LONG_F(adr, res)
9536         POST_IO
9537 RET(24)
9538 }
9539
9540 // MOVEL
9541 OPCODE(0x20F8)
9542 {
9543         u32 adr, res;
9544         u32 src, dst;
9545
9546         FETCH_SWORD(adr);
9547         PRE_IO
9548         READ_LONG_F(adr, res)
9549         flag_C = 0;
9550         flag_V = 0;
9551         flag_NotZ = res;
9552         flag_N = res >> 24;
9553         adr = AREG((Opcode >> 9) & 7);
9554         AREG((Opcode >> 9) & 7) += 4;
9555         WRITE_LONG_F(adr, res)
9556         POST_IO
9557 RET(24)
9558 }
9559
9560 // MOVEL
9561 OPCODE(0x2138)
9562 {
9563         u32 adr, res;
9564         u32 src, dst;
9565
9566         FETCH_SWORD(adr);
9567         PRE_IO
9568         READ_LONG_F(adr, res)
9569         flag_C = 0;
9570         flag_V = 0;
9571         flag_NotZ = res;
9572         flag_N = res >> 24;
9573         adr = AREG((Opcode >> 9) & 7) - 4;
9574         AREG((Opcode >> 9) & 7) = adr;
9575         WRITE_LONG_DEC_F(adr, res)
9576         POST_IO
9577 RET(24)
9578 }
9579
9580 // MOVEL
9581 OPCODE(0x2178)
9582 {
9583         u32 adr, res;
9584         u32 src, dst;
9585
9586         FETCH_SWORD(adr);
9587         PRE_IO
9588         READ_LONG_F(adr, res)
9589         flag_C = 0;
9590         flag_V = 0;
9591         flag_NotZ = res;
9592         flag_N = res >> 24;
9593         FETCH_SWORD(adr);
9594         adr += AREG((Opcode >> 9) & 7);
9595         WRITE_LONG_F(adr, res)
9596         POST_IO
9597 RET(28)
9598 }
9599
9600 // MOVEL
9601 OPCODE(0x21B8)
9602 {
9603         u32 adr, res;
9604         u32 src, dst;
9605
9606         FETCH_SWORD(adr);
9607         PRE_IO
9608         READ_LONG_F(adr, res)
9609         flag_C = 0;
9610         flag_V = 0;
9611         flag_NotZ = res;
9612         flag_N = res >> 24;
9613         adr = AREG((Opcode >> 9) & 7);
9614         DECODE_EXT_WORD
9615         WRITE_LONG_F(adr, res)
9616         POST_IO
9617 RET(30)
9618 }
9619
9620 // MOVEL
9621 OPCODE(0x21F8)
9622 {
9623         u32 adr, res;
9624         u32 src, dst;
9625
9626         FETCH_SWORD(adr);
9627         PRE_IO
9628         READ_LONG_F(adr, res)
9629         flag_C = 0;
9630         flag_V = 0;
9631         flag_NotZ = res;
9632         flag_N = res >> 24;
9633         FETCH_SWORD(adr);
9634         WRITE_LONG_F(adr, res)
9635         POST_IO
9636 RET(28)
9637 }
9638
9639 // MOVEL
9640 OPCODE(0x23F8)
9641 {
9642         u32 adr, res;
9643         u32 src, dst;
9644
9645         FETCH_SWORD(adr);
9646         PRE_IO
9647         READ_LONG_F(adr, res)
9648         flag_C = 0;
9649         flag_V = 0;
9650         flag_NotZ = res;
9651         flag_N = res >> 24;
9652         FETCH_LONG(adr);
9653         WRITE_LONG_F(adr, res)
9654         POST_IO
9655 RET(32)
9656 }
9657
9658 // MOVEL
9659 OPCODE(0x2EF8)
9660 {
9661         u32 adr, res;
9662         u32 src, dst;
9663
9664         FETCH_SWORD(adr);
9665         PRE_IO
9666         READ_LONG_F(adr, res)
9667         flag_C = 0;
9668         flag_V = 0;
9669         flag_NotZ = res;
9670         flag_N = res >> 24;
9671         adr = AREG(7);
9672         AREG(7) += 4;
9673         WRITE_LONG_F(adr, res)
9674         POST_IO
9675 RET(24)
9676 }
9677
9678 // MOVEL
9679 OPCODE(0x2F38)
9680 {
9681         u32 adr, res;
9682         u32 src, dst;
9683
9684         FETCH_SWORD(adr);
9685         PRE_IO
9686         READ_LONG_F(adr, res)
9687         flag_C = 0;
9688         flag_V = 0;
9689         flag_NotZ = res;
9690         flag_N = res >> 24;
9691         adr = AREG(7) - 4;
9692         AREG(7) = adr;
9693         WRITE_LONG_DEC_F(adr, res)
9694         POST_IO
9695 RET(24)
9696 }
9697
9698 // MOVEL
9699 OPCODE(0x2039)
9700 {
9701         u32 adr, res;
9702         u32 src, dst;
9703
9704         FETCH_LONG(adr);
9705         PRE_IO
9706         READ_LONG_F(adr, res)
9707         flag_C = 0;
9708         flag_V = 0;
9709         flag_NotZ = res;
9710         flag_N = res >> 24;
9711         DREGu32((Opcode >> 9) & 7) = res;
9712         POST_IO
9713 RET(20)
9714 }
9715
9716 // MOVEL
9717 OPCODE(0x20B9)
9718 {
9719         u32 adr, res;
9720         u32 src, dst;
9721
9722         FETCH_LONG(adr);
9723         PRE_IO
9724         READ_LONG_F(adr, res)
9725         flag_C = 0;
9726         flag_V = 0;
9727         flag_NotZ = res;
9728         flag_N = res >> 24;
9729         adr = AREG((Opcode >> 9) & 7);
9730         WRITE_LONG_F(adr, res)
9731         POST_IO
9732 RET(28)
9733 }
9734
9735 // MOVEL
9736 OPCODE(0x20F9)
9737 {
9738         u32 adr, res;
9739         u32 src, dst;
9740
9741         FETCH_LONG(adr);
9742         PRE_IO
9743         READ_LONG_F(adr, res)
9744         flag_C = 0;
9745         flag_V = 0;
9746         flag_NotZ = res;
9747         flag_N = res >> 24;
9748         adr = AREG((Opcode >> 9) & 7);
9749         AREG((Opcode >> 9) & 7) += 4;
9750         WRITE_LONG_F(adr, res)
9751         POST_IO
9752 RET(28)
9753 }
9754
9755 // MOVEL
9756 OPCODE(0x2139)
9757 {
9758         u32 adr, res;
9759         u32 src, dst;
9760
9761         FETCH_LONG(adr);
9762         PRE_IO
9763         READ_LONG_F(adr, res)
9764         flag_C = 0;
9765         flag_V = 0;
9766         flag_NotZ = res;
9767         flag_N = res >> 24;
9768         adr = AREG((Opcode >> 9) & 7) - 4;
9769         AREG((Opcode >> 9) & 7) = adr;
9770         WRITE_LONG_DEC_F(adr, res)
9771         POST_IO
9772 RET(28)
9773 }
9774
9775 // MOVEL
9776 OPCODE(0x2179)
9777 {
9778         u32 adr, res;
9779         u32 src, dst;
9780
9781         FETCH_LONG(adr);
9782         PRE_IO
9783         READ_LONG_F(adr, res)
9784         flag_C = 0;
9785         flag_V = 0;
9786         flag_NotZ = res;
9787         flag_N = res >> 24;
9788         FETCH_SWORD(adr);
9789         adr += AREG((Opcode >> 9) & 7);
9790         WRITE_LONG_F(adr, res)
9791         POST_IO
9792 RET(32)
9793 }
9794
9795 // MOVEL
9796 OPCODE(0x21B9)
9797 {
9798         u32 adr, res;
9799         u32 src, dst;
9800
9801         FETCH_LONG(adr);
9802         PRE_IO
9803         READ_LONG_F(adr, res)
9804         flag_C = 0;
9805         flag_V = 0;
9806         flag_NotZ = res;
9807         flag_N = res >> 24;
9808         adr = AREG((Opcode >> 9) & 7);
9809         DECODE_EXT_WORD
9810         WRITE_LONG_F(adr, res)
9811         POST_IO
9812 RET(34)
9813 }
9814
9815 // MOVEL
9816 OPCODE(0x21F9)
9817 {
9818         u32 adr, res;
9819         u32 src, dst;
9820
9821         FETCH_LONG(adr);
9822         PRE_IO
9823         READ_LONG_F(adr, res)
9824         flag_C = 0;
9825         flag_V = 0;
9826         flag_NotZ = res;
9827         flag_N = res >> 24;
9828         FETCH_SWORD(adr);
9829         WRITE_LONG_F(adr, res)
9830         POST_IO
9831 RET(32)
9832 }
9833
9834 // MOVEL
9835 OPCODE(0x23F9)
9836 {
9837         u32 adr, res;
9838         u32 src, dst;
9839
9840         FETCH_LONG(adr);
9841         PRE_IO
9842         READ_LONG_F(adr, res)
9843         flag_C = 0;
9844         flag_V = 0;
9845         flag_NotZ = res;
9846         flag_N = res >> 24;
9847         FETCH_LONG(adr);
9848         WRITE_LONG_F(adr, res)
9849         POST_IO
9850 RET(36)
9851 }
9852
9853 // MOVEL
9854 OPCODE(0x2EF9)
9855 {
9856         u32 adr, res;
9857         u32 src, dst;
9858
9859         FETCH_LONG(adr);
9860         PRE_IO
9861         READ_LONG_F(adr, res)
9862         flag_C = 0;
9863         flag_V = 0;
9864         flag_NotZ = res;
9865         flag_N = res >> 24;
9866         adr = AREG(7);
9867         AREG(7) += 4;
9868         WRITE_LONG_F(adr, res)
9869         POST_IO
9870 RET(28)
9871 }
9872
9873 // MOVEL
9874 OPCODE(0x2F39)
9875 {
9876         u32 adr, res;
9877         u32 src, dst;
9878
9879         FETCH_LONG(adr);
9880         PRE_IO
9881         READ_LONG_F(adr, res)
9882         flag_C = 0;
9883         flag_V = 0;
9884         flag_NotZ = res;
9885         flag_N = res >> 24;
9886         adr = AREG(7) - 4;
9887         AREG(7) = adr;
9888         WRITE_LONG_DEC_F(adr, res)
9889         POST_IO
9890 RET(28)
9891 }
9892
9893 // MOVEL
9894 OPCODE(0x203A)
9895 {
9896         u32 adr, res;
9897         u32 src, dst;
9898
9899         adr = GET_SWORD + GET_PC;
9900         PC++;
9901         PRE_IO
9902         READ_LONG_F(adr, res)
9903         flag_C = 0;
9904         flag_V = 0;
9905         flag_NotZ = res;
9906         flag_N = res >> 24;
9907         DREGu32((Opcode >> 9) & 7) = res;
9908         POST_IO
9909 RET(16)
9910 }
9911
9912 // MOVEL
9913 OPCODE(0x20BA)
9914 {
9915         u32 adr, res;
9916         u32 src, dst;
9917
9918         adr = GET_SWORD + GET_PC;
9919         PC++;
9920         PRE_IO
9921         READ_LONG_F(adr, res)
9922         flag_C = 0;
9923         flag_V = 0;
9924         flag_NotZ = res;
9925         flag_N = res >> 24;
9926         adr = AREG((Opcode >> 9) & 7);
9927         WRITE_LONG_F(adr, res)
9928         POST_IO
9929 RET(24)
9930 }
9931
9932 // MOVEL
9933 OPCODE(0x20FA)
9934 {
9935         u32 adr, res;
9936         u32 src, dst;
9937
9938         adr = GET_SWORD + GET_PC;
9939         PC++;
9940         PRE_IO
9941         READ_LONG_F(adr, res)
9942         flag_C = 0;
9943         flag_V = 0;
9944         flag_NotZ = res;
9945         flag_N = res >> 24;
9946         adr = AREG((Opcode >> 9) & 7);
9947         AREG((Opcode >> 9) & 7) += 4;
9948         WRITE_LONG_F(adr, res)
9949         POST_IO
9950 RET(24)
9951 }
9952
9953 // MOVEL
9954 OPCODE(0x213A)
9955 {
9956         u32 adr, res;
9957         u32 src, dst;
9958
9959         adr = GET_SWORD + GET_PC;
9960         PC++;
9961         PRE_IO
9962         READ_LONG_F(adr, res)
9963         flag_C = 0;
9964         flag_V = 0;
9965         flag_NotZ = res;
9966         flag_N = res >> 24;
9967         adr = AREG((Opcode >> 9) & 7) - 4;
9968         AREG((Opcode >> 9) & 7) = adr;
9969         WRITE_LONG_DEC_F(adr, res)
9970         POST_IO
9971 RET(24)
9972 }
9973
9974 // MOVEL
9975 OPCODE(0x217A)
9976 {
9977         u32 adr, res;
9978         u32 src, dst;
9979
9980         adr = GET_SWORD + GET_PC;
9981         PC++;
9982         PRE_IO
9983         READ_LONG_F(adr, res)
9984         flag_C = 0;
9985         flag_V = 0;
9986         flag_NotZ = res;
9987         flag_N = res >> 24;
9988         FETCH_SWORD(adr);
9989         adr += AREG((Opcode >> 9) & 7);
9990         WRITE_LONG_F(adr, res)
9991         POST_IO
9992 RET(28)
9993 }
9994
9995 // MOVEL
9996 OPCODE(0x21BA)
9997 {
9998         u32 adr, res;
9999         u32 src, dst;
10000
10001         adr = GET_SWORD + GET_PC;
10002         PC++;
10003         PRE_IO
10004         READ_LONG_F(adr, res)
10005         flag_C = 0;
10006         flag_V = 0;
10007         flag_NotZ = res;
10008         flag_N = res >> 24;
10009         adr = AREG((Opcode >> 9) & 7);
10010         DECODE_EXT_WORD
10011         WRITE_LONG_F(adr, res)
10012         POST_IO
10013 RET(30)
10014 }
10015
10016 // MOVEL
10017 OPCODE(0x21FA)
10018 {
10019         u32 adr, res;
10020         u32 src, dst;
10021
10022         adr = GET_SWORD + GET_PC;
10023         PC++;
10024         PRE_IO
10025         READ_LONG_F(adr, res)
10026         flag_C = 0;
10027         flag_V = 0;
10028         flag_NotZ = res;
10029         flag_N = res >> 24;
10030         FETCH_SWORD(adr);
10031         WRITE_LONG_F(adr, res)
10032         POST_IO
10033 RET(28)
10034 }
10035
10036 // MOVEL
10037 OPCODE(0x23FA)
10038 {
10039         u32 adr, res;
10040         u32 src, dst;
10041
10042         adr = GET_SWORD + GET_PC;
10043         PC++;
10044         PRE_IO
10045         READ_LONG_F(adr, res)
10046         flag_C = 0;
10047         flag_V = 0;
10048         flag_NotZ = res;
10049         flag_N = res >> 24;
10050         FETCH_LONG(adr);
10051         WRITE_LONG_F(adr, res)
10052         POST_IO
10053 RET(32)
10054 }
10055
10056 // MOVEL
10057 OPCODE(0x2EFA)
10058 {
10059         u32 adr, res;
10060         u32 src, dst;
10061
10062         adr = GET_SWORD + GET_PC;
10063         PC++;
10064         PRE_IO
10065         READ_LONG_F(adr, res)
10066         flag_C = 0;
10067         flag_V = 0;
10068         flag_NotZ = res;
10069         flag_N = res >> 24;
10070         adr = AREG(7);
10071         AREG(7) += 4;
10072         WRITE_LONG_F(adr, res)
10073         POST_IO
10074 RET(24)
10075 }
10076
10077 // MOVEL
10078 OPCODE(0x2F3A)
10079 {
10080         u32 adr, res;
10081         u32 src, dst;
10082
10083         adr = GET_SWORD + GET_PC;
10084         PC++;
10085         PRE_IO
10086         READ_LONG_F(adr, res)
10087         flag_C = 0;
10088         flag_V = 0;
10089         flag_NotZ = res;
10090         flag_N = res >> 24;
10091         adr = AREG(7) - 4;
10092         AREG(7) = adr;
10093         WRITE_LONG_DEC_F(adr, res)
10094         POST_IO
10095 RET(24)
10096 }
10097
10098 // MOVEL
10099 OPCODE(0x203B)
10100 {
10101         u32 adr, res;
10102         u32 src, dst;
10103
10104         adr = GET_PC;
10105         DECODE_EXT_WORD
10106         PRE_IO
10107         READ_LONG_F(adr, res)
10108         flag_C = 0;
10109         flag_V = 0;
10110         flag_NotZ = res;
10111         flag_N = res >> 24;
10112         DREGu32((Opcode >> 9) & 7) = res;
10113         POST_IO
10114 RET(18)
10115 }
10116
10117 // MOVEL
10118 OPCODE(0x20BB)
10119 {
10120         u32 adr, res;
10121         u32 src, dst;
10122
10123         adr = GET_PC;
10124         DECODE_EXT_WORD
10125         PRE_IO
10126         READ_LONG_F(adr, res)
10127         flag_C = 0;
10128         flag_V = 0;
10129         flag_NotZ = res;
10130         flag_N = res >> 24;
10131         adr = AREG((Opcode >> 9) & 7);
10132         WRITE_LONG_F(adr, res)
10133         POST_IO
10134 RET(26)
10135 }
10136
10137 // MOVEL
10138 OPCODE(0x20FB)
10139 {
10140         u32 adr, res;
10141         u32 src, dst;
10142
10143         adr = GET_PC;
10144         DECODE_EXT_WORD
10145         PRE_IO
10146         READ_LONG_F(adr, res)
10147         flag_C = 0;
10148         flag_V = 0;
10149         flag_NotZ = res;
10150         flag_N = res >> 24;
10151         adr = AREG((Opcode >> 9) & 7);
10152         AREG((Opcode >> 9) & 7) += 4;
10153         WRITE_LONG_F(adr, res)
10154         POST_IO
10155 RET(26)
10156 }
10157
10158 // MOVEL
10159 OPCODE(0x213B)
10160 {
10161         u32 adr, res;
10162         u32 src, dst;
10163
10164         adr = GET_PC;
10165         DECODE_EXT_WORD
10166         PRE_IO
10167         READ_LONG_F(adr, res)
10168         flag_C = 0;
10169         flag_V = 0;
10170         flag_NotZ = res;
10171         flag_N = res >> 24;
10172         adr = AREG((Opcode >> 9) & 7) - 4;
10173         AREG((Opcode >> 9) & 7) = adr;
10174         WRITE_LONG_DEC_F(adr, res)
10175         POST_IO
10176 RET(26)
10177 }
10178
10179 // MOVEL
10180 OPCODE(0x217B)
10181 {
10182         u32 adr, res;
10183         u32 src, dst;
10184
10185         adr = GET_PC;
10186         DECODE_EXT_WORD
10187         PRE_IO
10188         READ_LONG_F(adr, res)
10189         flag_C = 0;
10190         flag_V = 0;
10191         flag_NotZ = res;
10192         flag_N = res >> 24;
10193         FETCH_SWORD(adr);
10194         adr += AREG((Opcode >> 9) & 7);
10195         WRITE_LONG_F(adr, res)
10196         POST_IO
10197 RET(30)
10198 }
10199
10200 // MOVEL
10201 OPCODE(0x21BB)
10202 {
10203         u32 adr, res;
10204         u32 src, dst;
10205
10206         adr = GET_PC;
10207         DECODE_EXT_WORD
10208         PRE_IO
10209         READ_LONG_F(adr, res)
10210         flag_C = 0;
10211         flag_V = 0;
10212         flag_NotZ = res;
10213         flag_N = res >> 24;
10214         adr = AREG((Opcode >> 9) & 7);
10215         DECODE_EXT_WORD
10216         WRITE_LONG_F(adr, res)
10217         POST_IO
10218 RET(32)
10219 }
10220
10221 // MOVEL
10222 OPCODE(0x21FB)
10223 {
10224         u32 adr, res;
10225         u32 src, dst;
10226
10227         adr = GET_PC;
10228         DECODE_EXT_WORD
10229         PRE_IO
10230         READ_LONG_F(adr, res)
10231         flag_C = 0;
10232         flag_V = 0;
10233         flag_NotZ = res;
10234         flag_N = res >> 24;
10235         FETCH_SWORD(adr);
10236         WRITE_LONG_F(adr, res)
10237         POST_IO
10238 RET(30)
10239 }
10240
10241 // MOVEL
10242 OPCODE(0x23FB)
10243 {
10244         u32 adr, res;
10245         u32 src, dst;
10246
10247         adr = GET_PC;
10248         DECODE_EXT_WORD
10249         PRE_IO
10250         READ_LONG_F(adr, res)
10251         flag_C = 0;
10252         flag_V = 0;
10253         flag_NotZ = res;
10254         flag_N = res >> 24;
10255         FETCH_LONG(adr);
10256         WRITE_LONG_F(adr, res)
10257         POST_IO
10258 RET(34)
10259 }
10260
10261 // MOVEL
10262 OPCODE(0x2EFB)
10263 {
10264         u32 adr, res;
10265         u32 src, dst;
10266
10267         adr = GET_PC;
10268         DECODE_EXT_WORD
10269         PRE_IO
10270         READ_LONG_F(adr, res)
10271         flag_C = 0;
10272         flag_V = 0;
10273         flag_NotZ = res;
10274         flag_N = res >> 24;
10275         adr = AREG(7);
10276         AREG(7) += 4;
10277         WRITE_LONG_F(adr, res)
10278         POST_IO
10279 RET(26)
10280 }
10281
10282 // MOVEL
10283 OPCODE(0x2F3B)
10284 {
10285         u32 adr, res;
10286         u32 src, dst;
10287
10288         adr = GET_PC;
10289         DECODE_EXT_WORD
10290         PRE_IO
10291         READ_LONG_F(adr, res)
10292         flag_C = 0;
10293         flag_V = 0;
10294         flag_NotZ = res;
10295         flag_N = res >> 24;
10296         adr = AREG(7) - 4;
10297         AREG(7) = adr;
10298         WRITE_LONG_DEC_F(adr, res)
10299         POST_IO
10300 RET(26)
10301 }
10302
10303 // MOVEL
10304 OPCODE(0x203C)
10305 {
10306         u32 adr, res;
10307         u32 src, dst;
10308
10309         FETCH_LONG(res);
10310         flag_C = 0;
10311         flag_V = 0;
10312         flag_NotZ = res;
10313         flag_N = res >> 24;
10314         DREGu32((Opcode >> 9) & 7) = res;
10315 RET(12)
10316 }
10317
10318 // MOVEL
10319 OPCODE(0x20BC)
10320 {
10321         u32 adr, res;
10322         u32 src, dst;
10323
10324         FETCH_LONG(res);
10325         flag_C = 0;
10326         flag_V = 0;
10327         flag_NotZ = res;
10328         flag_N = res >> 24;
10329         adr = AREG((Opcode >> 9) & 7);
10330         PRE_IO
10331         WRITE_LONG_F(adr, res)
10332         POST_IO
10333 RET(20)
10334 }
10335
10336 // MOVEL
10337 OPCODE(0x20FC)
10338 {
10339         u32 adr, res;
10340         u32 src, dst;
10341
10342         FETCH_LONG(res);
10343         flag_C = 0;
10344         flag_V = 0;
10345         flag_NotZ = res;
10346         flag_N = res >> 24;
10347         adr = AREG((Opcode >> 9) & 7);
10348         AREG((Opcode >> 9) & 7) += 4;
10349         PRE_IO
10350         WRITE_LONG_F(adr, res)
10351         POST_IO
10352 RET(20)
10353 }
10354
10355 // MOVEL
10356 OPCODE(0x213C)
10357 {
10358         u32 adr, res;
10359         u32 src, dst;
10360
10361         FETCH_LONG(res);
10362         flag_C = 0;
10363         flag_V = 0;
10364         flag_NotZ = res;
10365         flag_N = res >> 24;
10366         adr = AREG((Opcode >> 9) & 7) - 4;
10367         AREG((Opcode >> 9) & 7) = adr;
10368         PRE_IO
10369         WRITE_LONG_DEC_F(adr, res)
10370         POST_IO
10371 RET(20)
10372 }
10373
10374 // MOVEL
10375 OPCODE(0x217C)
10376 {
10377         u32 adr, res;
10378         u32 src, dst;
10379
10380         FETCH_LONG(res);
10381         flag_C = 0;
10382         flag_V = 0;
10383         flag_NotZ = res;
10384         flag_N = res >> 24;
10385         FETCH_SWORD(adr);
10386         adr += AREG((Opcode >> 9) & 7);
10387         PRE_IO
10388         WRITE_LONG_F(adr, res)
10389         POST_IO
10390 RET(24)
10391 }
10392
10393 // MOVEL
10394 OPCODE(0x21BC)
10395 {
10396         u32 adr, res;
10397         u32 src, dst;
10398
10399         FETCH_LONG(res);
10400         flag_C = 0;
10401         flag_V = 0;
10402         flag_NotZ = res;
10403         flag_N = res >> 24;
10404         adr = AREG((Opcode >> 9) & 7);
10405         DECODE_EXT_WORD
10406         PRE_IO
10407         WRITE_LONG_F(adr, res)
10408         POST_IO
10409 RET(26)
10410 }
10411
10412 // MOVEL
10413 OPCODE(0x21FC)
10414 {
10415         u32 adr, res;
10416         u32 src, dst;
10417
10418         FETCH_LONG(res);
10419         flag_C = 0;
10420         flag_V = 0;
10421         flag_NotZ = res;
10422         flag_N = res >> 24;
10423         FETCH_SWORD(adr);
10424         PRE_IO
10425         WRITE_LONG_F(adr, res)
10426         POST_IO
10427 RET(24)
10428 }
10429
10430 // MOVEL
10431 OPCODE(0x23FC)
10432 {
10433         u32 adr, res;
10434         u32 src, dst;
10435
10436         FETCH_LONG(res);
10437         flag_C = 0;
10438         flag_V = 0;
10439         flag_NotZ = res;
10440         flag_N = res >> 24;
10441         FETCH_LONG(adr);
10442         PRE_IO
10443         WRITE_LONG_F(adr, res)
10444         POST_IO
10445 RET(28)
10446 }
10447
10448 // MOVEL
10449 OPCODE(0x2EFC)
10450 {
10451         u32 adr, res;
10452         u32 src, dst;
10453
10454         FETCH_LONG(res);
10455         flag_C = 0;
10456         flag_V = 0;
10457         flag_NotZ = res;
10458         flag_N = res >> 24;
10459         adr = AREG(7);
10460         AREG(7) += 4;
10461         PRE_IO
10462         WRITE_LONG_F(adr, res)
10463         POST_IO
10464 RET(20)
10465 }
10466
10467 // MOVEL
10468 OPCODE(0x2F3C)
10469 {
10470         u32 adr, res;
10471         u32 src, dst;
10472
10473         FETCH_LONG(res);
10474         flag_C = 0;
10475         flag_V = 0;
10476         flag_NotZ = res;
10477         flag_N = res >> 24;
10478         adr = AREG(7) - 4;
10479         AREG(7) = adr;
10480         PRE_IO
10481         WRITE_LONG_DEC_F(adr, res)
10482         POST_IO
10483 RET(20)
10484 }
10485
10486 // MOVEL
10487 OPCODE(0x201F)
10488 {
10489         u32 adr, res;
10490         u32 src, dst;
10491
10492         adr = AREG(7);
10493         AREG(7) += 4;
10494         PRE_IO
10495         READ_LONG_F(adr, res)
10496         flag_C = 0;
10497         flag_V = 0;
10498         flag_NotZ = res;
10499         flag_N = res >> 24;
10500         DREGu32((Opcode >> 9) & 7) = res;
10501         POST_IO
10502 RET(12)
10503 }
10504
10505 // MOVEL
10506 OPCODE(0x209F)
10507 {
10508         u32 adr, res;
10509         u32 src, dst;
10510
10511         adr = AREG(7);
10512         AREG(7) += 4;
10513         PRE_IO
10514         READ_LONG_F(adr, res)
10515         flag_C = 0;
10516         flag_V = 0;
10517         flag_NotZ = res;
10518         flag_N = res >> 24;
10519         adr = AREG((Opcode >> 9) & 7);
10520         WRITE_LONG_F(adr, res)
10521         POST_IO
10522 RET(20)
10523 }
10524
10525 // MOVEL
10526 OPCODE(0x20DF)
10527 {
10528         u32 adr, res;
10529         u32 src, dst;
10530
10531         adr = AREG(7);
10532         AREG(7) += 4;
10533         PRE_IO
10534         READ_LONG_F(adr, res)
10535         flag_C = 0;
10536         flag_V = 0;
10537         flag_NotZ = res;
10538         flag_N = res >> 24;
10539         adr = AREG((Opcode >> 9) & 7);
10540         AREG((Opcode >> 9) & 7) += 4;
10541         WRITE_LONG_F(adr, res)
10542         POST_IO
10543 RET(20)
10544 }
10545
10546 // MOVEL
10547 OPCODE(0x211F)
10548 {
10549         u32 adr, res;
10550         u32 src, dst;
10551
10552         adr = AREG(7);
10553         AREG(7) += 4;
10554         PRE_IO
10555         READ_LONG_F(adr, res)
10556         flag_C = 0;
10557         flag_V = 0;
10558         flag_NotZ = res;
10559         flag_N = res >> 24;
10560         adr = AREG((Opcode >> 9) & 7) - 4;
10561         AREG((Opcode >> 9) & 7) = adr;
10562         WRITE_LONG_DEC_F(adr, res)
10563         POST_IO
10564 RET(20)
10565 }
10566
10567 // MOVEL
10568 OPCODE(0x215F)
10569 {
10570         u32 adr, res;
10571         u32 src, dst;
10572
10573         adr = AREG(7);
10574         AREG(7) += 4;
10575         PRE_IO
10576         READ_LONG_F(adr, res)
10577         flag_C = 0;
10578         flag_V = 0;
10579         flag_NotZ = res;
10580         flag_N = res >> 24;
10581         FETCH_SWORD(adr);
10582         adr += AREG((Opcode >> 9) & 7);
10583         WRITE_LONG_F(adr, res)
10584         POST_IO
10585 RET(24)
10586 }
10587
10588 // MOVEL
10589 OPCODE(0x219F)
10590 {
10591         u32 adr, res;
10592         u32 src, dst;
10593
10594         adr = AREG(7);
10595         AREG(7) += 4;
10596         PRE_IO
10597         READ_LONG_F(adr, res)
10598         flag_C = 0;
10599         flag_V = 0;
10600         flag_NotZ = res;
10601         flag_N = res >> 24;
10602         adr = AREG((Opcode >> 9) & 7);
10603         DECODE_EXT_WORD
10604         WRITE_LONG_F(adr, res)
10605         POST_IO
10606 RET(26)
10607 }
10608
10609 // MOVEL
10610 OPCODE(0x21DF)
10611 {
10612         u32 adr, res;
10613         u32 src, dst;
10614
10615         adr = AREG(7);
10616         AREG(7) += 4;
10617         PRE_IO
10618         READ_LONG_F(adr, res)
10619         flag_C = 0;
10620         flag_V = 0;
10621         flag_NotZ = res;
10622         flag_N = res >> 24;
10623         FETCH_SWORD(adr);
10624         WRITE_LONG_F(adr, res)
10625         POST_IO
10626 RET(24)
10627 }
10628
10629 // MOVEL
10630 OPCODE(0x23DF)
10631 {
10632         u32 adr, res;
10633         u32 src, dst;
10634
10635         adr = AREG(7);
10636         AREG(7) += 4;
10637         PRE_IO
10638         READ_LONG_F(adr, res)
10639         flag_C = 0;
10640         flag_V = 0;
10641         flag_NotZ = res;
10642         flag_N = res >> 24;
10643         FETCH_LONG(adr);
10644         WRITE_LONG_F(adr, res)
10645         POST_IO
10646 RET(28)
10647 }
10648
10649 // MOVEL
10650 OPCODE(0x2EDF)
10651 {
10652         u32 adr, res;
10653         u32 src, dst;
10654
10655         adr = AREG(7);
10656         AREG(7) += 4;
10657         PRE_IO
10658         READ_LONG_F(adr, res)
10659         flag_C = 0;
10660         flag_V = 0;
10661         flag_NotZ = res;
10662         flag_N = res >> 24;
10663         adr = AREG(7);
10664         AREG(7) += 4;
10665         WRITE_LONG_F(adr, res)
10666         POST_IO
10667 RET(20)
10668 }
10669
10670 // MOVEL
10671 OPCODE(0x2F1F)
10672 {
10673         u32 adr, res;
10674         u32 src, dst;
10675
10676         adr = AREG(7);
10677         AREG(7) += 4;
10678         PRE_IO
10679         READ_LONG_F(adr, res)
10680         flag_C = 0;
10681         flag_V = 0;
10682         flag_NotZ = res;
10683         flag_N = res >> 24;
10684         adr = AREG(7) - 4;
10685         AREG(7) = adr;
10686         WRITE_LONG_DEC_F(adr, res)
10687         POST_IO
10688 RET(20)
10689 }
10690
10691 // MOVEL
10692 OPCODE(0x2027)
10693 {
10694         u32 adr, res;
10695         u32 src, dst;
10696
10697         adr = AREG(7) - 4;
10698         AREG(7) = adr;
10699         PRE_IO
10700         READ_LONG_F(adr, res)
10701         flag_C = 0;
10702         flag_V = 0;
10703         flag_NotZ = res;
10704         flag_N = res >> 24;
10705         DREGu32((Opcode >> 9) & 7) = res;
10706         POST_IO
10707 RET(14)
10708 }
10709
10710 // MOVEL
10711 OPCODE(0x20A7)
10712 {
10713         u32 adr, res;
10714         u32 src, dst;
10715
10716         adr = AREG(7) - 4;
10717         AREG(7) = adr;
10718         PRE_IO
10719         READ_LONG_F(adr, res)
10720         flag_C = 0;
10721         flag_V = 0;
10722         flag_NotZ = res;
10723         flag_N = res >> 24;
10724         adr = AREG((Opcode >> 9) & 7);
10725         WRITE_LONG_F(adr, res)
10726         POST_IO
10727 RET(22)
10728 }
10729
10730 // MOVEL
10731 OPCODE(0x20E7)
10732 {
10733         u32 adr, res;
10734         u32 src, dst;
10735
10736         adr = AREG(7) - 4;
10737         AREG(7) = adr;
10738         PRE_IO
10739         READ_LONG_F(adr, res)
10740         flag_C = 0;
10741         flag_V = 0;
10742         flag_NotZ = res;
10743         flag_N = res >> 24;
10744         adr = AREG((Opcode >> 9) & 7);
10745         AREG((Opcode >> 9) & 7) += 4;
10746         WRITE_LONG_F(adr, res)
10747         POST_IO
10748 RET(22)
10749 }
10750
10751 // MOVEL
10752 OPCODE(0x2127)
10753 {
10754         u32 adr, res;
10755         u32 src, dst;
10756
10757         adr = AREG(7) - 4;
10758         AREG(7) = adr;
10759         PRE_IO
10760         READ_LONG_F(adr, res)
10761         flag_C = 0;
10762         flag_V = 0;
10763         flag_NotZ = res;
10764         flag_N = res >> 24;
10765         adr = AREG((Opcode >> 9) & 7) - 4;
10766         AREG((Opcode >> 9) & 7) = adr;
10767         WRITE_LONG_DEC_F(adr, res)
10768         POST_IO
10769 RET(22)
10770 }
10771
10772 // MOVEL
10773 OPCODE(0x2167)
10774 {
10775         u32 adr, res;
10776         u32 src, dst;
10777
10778         adr = AREG(7) - 4;
10779         AREG(7) = adr;
10780         PRE_IO
10781         READ_LONG_F(adr, res)
10782         flag_C = 0;
10783         flag_V = 0;
10784         flag_NotZ = res;
10785         flag_N = res >> 24;
10786         FETCH_SWORD(adr);
10787         adr += AREG((Opcode >> 9) & 7);
10788         WRITE_LONG_F(adr, res)
10789         POST_IO
10790 RET(26)
10791 }
10792
10793 // MOVEL
10794 OPCODE(0x21A7)
10795 {
10796         u32 adr, res;
10797         u32 src, dst;
10798
10799         adr = AREG(7) - 4;
10800         AREG(7) = adr;
10801         PRE_IO
10802         READ_LONG_F(adr, res)
10803         flag_C = 0;
10804         flag_V = 0;
10805         flag_NotZ = res;
10806         flag_N = res >> 24;
10807         adr = AREG((Opcode >> 9) & 7);
10808         DECODE_EXT_WORD
10809         WRITE_LONG_F(adr, res)
10810         POST_IO
10811 RET(28)
10812 }
10813
10814 // MOVEL
10815 OPCODE(0x21E7)
10816 {
10817         u32 adr, res;
10818         u32 src, dst;
10819
10820         adr = AREG(7) - 4;
10821         AREG(7) = adr;
10822         PRE_IO
10823         READ_LONG_F(adr, res)
10824         flag_C = 0;
10825         flag_V = 0;
10826         flag_NotZ = res;
10827         flag_N = res >> 24;
10828         FETCH_SWORD(adr);
10829         WRITE_LONG_F(adr, res)
10830         POST_IO
10831 RET(26)
10832 }
10833
10834 // MOVEL
10835 OPCODE(0x23E7)
10836 {
10837         u32 adr, res;
10838         u32 src, dst;
10839
10840         adr = AREG(7) - 4;
10841         AREG(7) = adr;
10842         PRE_IO
10843         READ_LONG_F(adr, res)
10844         flag_C = 0;
10845         flag_V = 0;
10846         flag_NotZ = res;
10847         flag_N = res >> 24;
10848         FETCH_LONG(adr);
10849         WRITE_LONG_F(adr, res)
10850         POST_IO
10851 RET(30)
10852 }
10853
10854 // MOVEL
10855 OPCODE(0x2EE7)
10856 {
10857         u32 adr, res;
10858         u32 src, dst;
10859
10860         adr = AREG(7) - 4;
10861         AREG(7) = adr;
10862         PRE_IO
10863         READ_LONG_F(adr, res)
10864         flag_C = 0;
10865         flag_V = 0;
10866         flag_NotZ = res;
10867         flag_N = res >> 24;
10868         adr = AREG(7);
10869         AREG(7) += 4;
10870         WRITE_LONG_F(adr, res)
10871         POST_IO
10872 RET(22)
10873 }
10874
10875 // MOVEL
10876 OPCODE(0x2F27)
10877 {
10878         u32 adr, res;
10879         u32 src, dst;
10880
10881         adr = AREG(7) - 4;
10882         AREG(7) = adr;
10883         PRE_IO
10884         READ_LONG_F(adr, res)
10885         flag_C = 0;
10886         flag_V = 0;
10887         flag_NotZ = res;
10888         flag_N = res >> 24;
10889         adr = AREG(7) - 4;
10890         AREG(7) = adr;
10891         WRITE_LONG_DEC_F(adr, res)
10892         POST_IO
10893 RET(22)
10894 }
10895
10896 // MOVEAL
10897 OPCODE(0x2040)
10898 {
10899         u32 adr, res;
10900         u32 src, dst;
10901
10902         res = (s32)DREGs32((Opcode >> 0) & 7);
10903         AREG((Opcode >> 9) & 7) = res;
10904 RET(4)
10905 }
10906
10907 // MOVEAL
10908 OPCODE(0x2048)
10909 {
10910         u32 adr, res;
10911         u32 src, dst;
10912
10913         res = (s32)AREGs32((Opcode >> 0) & 7);
10914         AREG((Opcode >> 9) & 7) = res;
10915 RET(4)
10916 }
10917
10918 // MOVEAL
10919 OPCODE(0x2050)
10920 {
10921         u32 adr, res;
10922         u32 src, dst;
10923
10924         adr = AREG((Opcode >> 0) & 7);
10925         PRE_IO
10926         READSX_LONG_F(adr, res)
10927         AREG((Opcode >> 9) & 7) = res;
10928         POST_IO
10929 RET(12)
10930 }
10931
10932 // MOVEAL
10933 OPCODE(0x2058)
10934 {
10935         u32 adr, res;
10936         u32 src, dst;
10937
10938         adr = AREG((Opcode >> 0) & 7);
10939         AREG((Opcode >> 0) & 7) += 4;
10940         PRE_IO
10941         READSX_LONG_F(adr, res)
10942         AREG((Opcode >> 9) & 7) = res;
10943         POST_IO
10944 RET(12)
10945 }
10946
10947 // MOVEAL
10948 OPCODE(0x2060)
10949 {
10950         u32 adr, res;
10951         u32 src, dst;
10952
10953         adr = AREG((Opcode >> 0) & 7) - 4;
10954         AREG((Opcode >> 0) & 7) = adr;
10955         PRE_IO
10956         READSX_LONG_F(adr, res)
10957         AREG((Opcode >> 9) & 7) = res;
10958         POST_IO
10959 RET(14)
10960 }
10961
10962 // MOVEAL
10963 OPCODE(0x2068)
10964 {
10965         u32 adr, res;
10966         u32 src, dst;
10967
10968         FETCH_SWORD(adr);
10969         adr += AREG((Opcode >> 0) & 7);
10970         PRE_IO
10971         READSX_LONG_F(adr, res)
10972         AREG((Opcode >> 9) & 7) = res;
10973         POST_IO
10974 RET(16)
10975 }
10976
10977 // MOVEAL
10978 OPCODE(0x2070)
10979 {
10980         u32 adr, res;
10981         u32 src, dst;
10982
10983         adr = AREG((Opcode >> 0) & 7);
10984         DECODE_EXT_WORD
10985         PRE_IO
10986         READSX_LONG_F(adr, res)
10987         AREG((Opcode >> 9) & 7) = res;
10988         POST_IO
10989 RET(18)
10990 }
10991
10992 // MOVEAL
10993 OPCODE(0x2078)
10994 {
10995         u32 adr, res;
10996         u32 src, dst;
10997
10998         FETCH_SWORD(adr);
10999         PRE_IO
11000         READSX_LONG_F(adr, res)
11001         AREG((Opcode >> 9) & 7) = res;
11002         POST_IO
11003 RET(16)
11004 }
11005
11006 // MOVEAL
11007 OPCODE(0x2079)
11008 {
11009         u32 adr, res;
11010         u32 src, dst;
11011
11012         FETCH_LONG(adr);
11013         PRE_IO
11014         READSX_LONG_F(adr, res)
11015         AREG((Opcode >> 9) & 7) = res;
11016         POST_IO
11017 RET(20)
11018 }
11019
11020 // MOVEAL
11021 OPCODE(0x207A)
11022 {
11023         u32 adr, res;
11024         u32 src, dst;
11025
11026         adr = GET_SWORD + GET_PC;
11027         PC++;
11028         PRE_IO
11029         READSX_LONG_F(adr, res)
11030         AREG((Opcode >> 9) & 7) = res;
11031         POST_IO
11032 RET(16)
11033 }
11034
11035 // MOVEAL
11036 OPCODE(0x207B)
11037 {
11038         u32 adr, res;
11039         u32 src, dst;
11040
11041         adr = GET_PC;
11042         DECODE_EXT_WORD
11043         PRE_IO
11044         READSX_LONG_F(adr, res)
11045         AREG((Opcode >> 9) & 7) = res;
11046         POST_IO
11047 RET(18)
11048 }
11049
11050 // MOVEAL
11051 OPCODE(0x207C)
11052 {
11053         u32 adr, res;
11054         u32 src, dst;
11055
11056         FETCH_LONG(res);
11057         AREG((Opcode >> 9) & 7) = res;
11058 RET(12)
11059 }
11060
11061 // MOVEAL
11062 OPCODE(0x205F)
11063 {
11064         u32 adr, res;
11065         u32 src, dst;
11066
11067         adr = AREG(7);
11068         AREG(7) += 4;
11069         PRE_IO
11070         READSX_LONG_F(adr, res)
11071         AREG((Opcode >> 9) & 7) = res;
11072         POST_IO
11073 RET(12)
11074 }
11075
11076 // MOVEAL
11077 OPCODE(0x2067)
11078 {
11079         u32 adr, res;
11080         u32 src, dst;
11081
11082         adr = AREG(7) - 4;
11083         AREG(7) = adr;
11084         PRE_IO
11085         READSX_LONG_F(adr, res)
11086         AREG((Opcode >> 9) & 7) = res;
11087         POST_IO
11088 RET(14)
11089 }
11090
11091 // MOVEW
11092 OPCODE(0x3000)
11093 {
11094         u32 adr, res;
11095         u32 src, dst;
11096
11097         res = DREGu16((Opcode >> 0) & 7);
11098         flag_C = 0;
11099         flag_V = 0;
11100         flag_NotZ = res;
11101         flag_N = res >> 8;
11102         DREGu16((Opcode >> 9) & 7) = res;
11103 RET(4)
11104 }
11105
11106 // MOVEW
11107 OPCODE(0x3080)
11108 {
11109         u32 adr, res;
11110         u32 src, dst;
11111
11112         res = DREGu16((Opcode >> 0) & 7);
11113         flag_C = 0;
11114         flag_V = 0;
11115         flag_NotZ = res;
11116         flag_N = res >> 8;
11117         adr = AREG((Opcode >> 9) & 7);
11118         PRE_IO
11119         WRITE_WORD_F(adr, res)
11120         POST_IO
11121 RET(8)
11122 }
11123
11124 // MOVEW
11125 OPCODE(0x30C0)
11126 {
11127         u32 adr, res;
11128         u32 src, dst;
11129
11130         res = DREGu16((Opcode >> 0) & 7);
11131         flag_C = 0;
11132         flag_V = 0;
11133         flag_NotZ = res;
11134         flag_N = res >> 8;
11135         adr = AREG((Opcode >> 9) & 7);
11136         AREG((Opcode >> 9) & 7) += 2;
11137         PRE_IO
11138         WRITE_WORD_F(adr, res)
11139         POST_IO
11140 RET(8)
11141 }
11142
11143 // MOVEW
11144 OPCODE(0x3100)
11145 {
11146         u32 adr, res;
11147         u32 src, dst;
11148
11149         res = DREGu16((Opcode >> 0) & 7);
11150         flag_C = 0;
11151         flag_V = 0;
11152         flag_NotZ = res;
11153         flag_N = res >> 8;
11154         adr = AREG((Opcode >> 9) & 7) - 2;
11155         AREG((Opcode >> 9) & 7) = adr;
11156         PRE_IO
11157         WRITE_WORD_F(adr, res)
11158         POST_IO
11159 RET(8)
11160 }
11161
11162 // MOVEW
11163 OPCODE(0x3140)
11164 {
11165         u32 adr, res;
11166         u32 src, dst;
11167
11168         res = DREGu16((Opcode >> 0) & 7);
11169         flag_C = 0;
11170         flag_V = 0;
11171         flag_NotZ = res;
11172         flag_N = res >> 8;
11173         FETCH_SWORD(adr);
11174         adr += AREG((Opcode >> 9) & 7);
11175         PRE_IO
11176         WRITE_WORD_F(adr, res)
11177         POST_IO
11178 RET(12)
11179 }
11180
11181 // MOVEW
11182 OPCODE(0x3180)
11183 {
11184         u32 adr, res;
11185         u32 src, dst;
11186
11187         res = DREGu16((Opcode >> 0) & 7);
11188         flag_C = 0;
11189         flag_V = 0;
11190         flag_NotZ = res;
11191         flag_N = res >> 8;
11192         adr = AREG((Opcode >> 9) & 7);
11193         DECODE_EXT_WORD
11194         PRE_IO
11195         WRITE_WORD_F(adr, res)
11196         POST_IO
11197 RET(14)
11198 }
11199
11200 // MOVEW
11201 OPCODE(0x31C0)
11202 {
11203         u32 adr, res;
11204         u32 src, dst;
11205
11206         res = DREGu16((Opcode >> 0) & 7);
11207         flag_C = 0;
11208         flag_V = 0;
11209         flag_NotZ = res;
11210         flag_N = res >> 8;
11211         FETCH_SWORD(adr);
11212         PRE_IO
11213         WRITE_WORD_F(adr, res)
11214         POST_IO
11215 RET(12)
11216 }
11217
11218 // MOVEW
11219 OPCODE(0x33C0)
11220 {
11221         u32 adr, res;
11222         u32 src, dst;
11223
11224         res = DREGu16((Opcode >> 0) & 7);
11225         flag_C = 0;
11226         flag_V = 0;
11227         flag_NotZ = res;
11228         flag_N = res >> 8;
11229         FETCH_LONG(adr);
11230         PRE_IO
11231         WRITE_WORD_F(adr, res)
11232         POST_IO
11233 RET(16)
11234 }
11235
11236 // MOVEW
11237 OPCODE(0x3EC0)
11238 {
11239         u32 adr, res;
11240         u32 src, dst;
11241
11242         res = DREGu16((Opcode >> 0) & 7);
11243         flag_C = 0;
11244         flag_V = 0;
11245         flag_NotZ = res;
11246         flag_N = res >> 8;
11247         adr = AREG(7);
11248         AREG(7) += 2;
11249         PRE_IO
11250         WRITE_WORD_F(adr, res)
11251         POST_IO
11252 RET(8)
11253 }
11254
11255 // MOVEW
11256 OPCODE(0x3F00)
11257 {
11258         u32 adr, res;
11259         u32 src, dst;
11260
11261         res = DREGu16((Opcode >> 0) & 7);
11262         flag_C = 0;
11263         flag_V = 0;
11264         flag_NotZ = res;
11265         flag_N = res >> 8;
11266         adr = AREG(7) - 2;
11267         AREG(7) = adr;
11268         PRE_IO
11269         WRITE_WORD_F(adr, res)
11270         POST_IO
11271 RET(8)
11272 }
11273
11274 // MOVEW
11275 OPCODE(0x3008)
11276 {
11277         u32 adr, res;
11278         u32 src, dst;
11279
11280         res = AREGu16((Opcode >> 0) & 7);
11281         flag_C = 0;
11282         flag_V = 0;
11283         flag_NotZ = res;
11284         flag_N = res >> 8;
11285         DREGu16((Opcode >> 9) & 7) = res;
11286 RET(4)
11287 }
11288
11289 // MOVEW
11290 OPCODE(0x3088)
11291 {
11292         u32 adr, res;
11293         u32 src, dst;
11294
11295         res = AREGu16((Opcode >> 0) & 7);
11296         flag_C = 0;
11297         flag_V = 0;
11298         flag_NotZ = res;
11299         flag_N = res >> 8;
11300         adr = AREG((Opcode >> 9) & 7);
11301         PRE_IO
11302         WRITE_WORD_F(adr, res)
11303         POST_IO
11304 RET(8)
11305 }
11306
11307 // MOVEW
11308 OPCODE(0x30C8)
11309 {
11310         u32 adr, res;
11311         u32 src, dst;
11312
11313         res = AREGu16((Opcode >> 0) & 7);
11314         flag_C = 0;
11315         flag_V = 0;
11316         flag_NotZ = res;
11317         flag_N = res >> 8;
11318         adr = AREG((Opcode >> 9) & 7);
11319         AREG((Opcode >> 9) & 7) += 2;
11320         PRE_IO
11321         WRITE_WORD_F(adr, res)
11322         POST_IO
11323 RET(8)
11324 }
11325
11326 // MOVEW
11327 OPCODE(0x3108)
11328 {
11329         u32 adr, res;
11330         u32 src, dst;
11331
11332         res = AREGu16((Opcode >> 0) & 7);
11333         flag_C = 0;
11334         flag_V = 0;
11335         flag_NotZ = res;
11336         flag_N = res >> 8;
11337         adr = AREG((Opcode >> 9) & 7) - 2;
11338         AREG((Opcode >> 9) & 7) = adr;
11339         PRE_IO
11340         WRITE_WORD_F(adr, res)
11341         POST_IO
11342 RET(8)
11343 }
11344
11345 // MOVEW
11346 OPCODE(0x3148)
11347 {
11348         u32 adr, res;
11349         u32 src, dst;
11350
11351         res = AREGu16((Opcode >> 0) & 7);
11352         flag_C = 0;
11353         flag_V = 0;
11354         flag_NotZ = res;
11355         flag_N = res >> 8;
11356         FETCH_SWORD(adr);
11357         adr += AREG((Opcode >> 9) & 7);
11358         PRE_IO
11359         WRITE_WORD_F(adr, res)
11360         POST_IO
11361 RET(12)
11362 }
11363
11364 // MOVEW
11365 OPCODE(0x3188)
11366 {
11367         u32 adr, res;
11368         u32 src, dst;
11369
11370         res = AREGu16((Opcode >> 0) & 7);
11371         flag_C = 0;
11372         flag_V = 0;
11373         flag_NotZ = res;
11374         flag_N = res >> 8;
11375         adr = AREG((Opcode >> 9) & 7);
11376         DECODE_EXT_WORD
11377         PRE_IO
11378         WRITE_WORD_F(adr, res)
11379         POST_IO
11380 RET(14)
11381 }
11382
11383 // MOVEW
11384 OPCODE(0x31C8)
11385 {
11386         u32 adr, res;
11387         u32 src, dst;
11388
11389         res = AREGu16((Opcode >> 0) & 7);
11390         flag_C = 0;
11391         flag_V = 0;
11392         flag_NotZ = res;
11393         flag_N = res >> 8;
11394         FETCH_SWORD(adr);
11395         PRE_IO
11396         WRITE_WORD_F(adr, res)
11397         POST_IO
11398 RET(12)
11399 }
11400
11401 // MOVEW
11402 OPCODE(0x33C8)
11403 {
11404         u32 adr, res;
11405         u32 src, dst;
11406
11407         res = AREGu16((Opcode >> 0) & 7);
11408         flag_C = 0;
11409         flag_V = 0;
11410         flag_NotZ = res;
11411         flag_N = res >> 8;
11412         FETCH_LONG(adr);
11413         PRE_IO
11414         WRITE_WORD_F(adr, res)
11415         POST_IO
11416 RET(16)
11417 }
11418
11419 // MOVEW
11420 OPCODE(0x3EC8)
11421 {
11422         u32 adr, res;
11423         u32 src, dst;
11424
11425         res = AREGu16((Opcode >> 0) & 7);
11426         flag_C = 0;
11427         flag_V = 0;
11428         flag_NotZ = res;
11429         flag_N = res >> 8;
11430         adr = AREG(7);
11431         AREG(7) += 2;
11432         PRE_IO
11433         WRITE_WORD_F(adr, res)
11434         POST_IO
11435 RET(8)
11436 }
11437
11438 // MOVEW
11439 OPCODE(0x3F08)
11440 {
11441         u32 adr, res;
11442         u32 src, dst;
11443
11444         res = AREGu16((Opcode >> 0) & 7);
11445         flag_C = 0;
11446         flag_V = 0;
11447         flag_NotZ = res;
11448         flag_N = res >> 8;
11449         adr = AREG(7) - 2;
11450         AREG(7) = adr;
11451         PRE_IO
11452         WRITE_WORD_F(adr, res)
11453         POST_IO
11454 RET(8)
11455 }
11456
11457 // MOVEW
11458 OPCODE(0x3010)
11459 {
11460         u32 adr, res;
11461         u32 src, dst;
11462
11463         adr = AREG((Opcode >> 0) & 7);
11464         PRE_IO
11465         READ_WORD_F(adr, res)
11466         flag_C = 0;
11467         flag_V = 0;
11468         flag_NotZ = res;
11469         flag_N = res >> 8;
11470         DREGu16((Opcode >> 9) & 7) = res;
11471         POST_IO
11472 RET(8)
11473 }
11474
11475 // MOVEW
11476 OPCODE(0x3090)
11477 {
11478         u32 adr, res;
11479         u32 src, dst;
11480
11481         adr = AREG((Opcode >> 0) & 7);
11482         PRE_IO
11483         READ_WORD_F(adr, res)
11484         flag_C = 0;
11485         flag_V = 0;
11486         flag_NotZ = res;
11487         flag_N = res >> 8;
11488         adr = AREG((Opcode >> 9) & 7);
11489         WRITE_WORD_F(adr, res)
11490         POST_IO
11491 RET(12)
11492 }
11493
11494 // MOVEW
11495 OPCODE(0x30D0)
11496 {
11497         u32 adr, res;
11498         u32 src, dst;
11499
11500         adr = AREG((Opcode >> 0) & 7);
11501         PRE_IO
11502         READ_WORD_F(adr, res)
11503         flag_C = 0;
11504         flag_V = 0;
11505         flag_NotZ = res;
11506         flag_N = res >> 8;
11507         adr = AREG((Opcode >> 9) & 7);
11508         AREG((Opcode >> 9) & 7) += 2;
11509         WRITE_WORD_F(adr, res)
11510         POST_IO
11511 RET(12)
11512 }
11513
11514 // MOVEW
11515 OPCODE(0x3110)
11516 {
11517         u32 adr, res;
11518         u32 src, dst;
11519
11520         adr = AREG((Opcode >> 0) & 7);
11521         PRE_IO
11522         READ_WORD_F(adr, res)
11523         flag_C = 0;
11524         flag_V = 0;
11525         flag_NotZ = res;
11526         flag_N = res >> 8;
11527         adr = AREG((Opcode >> 9) & 7) - 2;
11528         AREG((Opcode >> 9) & 7) = adr;
11529         WRITE_WORD_F(adr, res)
11530         POST_IO
11531 RET(12)
11532 }
11533
11534 // MOVEW
11535 OPCODE(0x3150)
11536 {
11537         u32 adr, res;
11538         u32 src, dst;
11539
11540         adr = AREG((Opcode >> 0) & 7);
11541         PRE_IO
11542         READ_WORD_F(adr, res)
11543         flag_C = 0;
11544         flag_V = 0;
11545         flag_NotZ = res;
11546         flag_N = res >> 8;
11547         FETCH_SWORD(adr);
11548         adr += AREG((Opcode >> 9) & 7);
11549         WRITE_WORD_F(adr, res)
11550         POST_IO
11551 RET(16)
11552 }
11553
11554 // MOVEW
11555 OPCODE(0x3190)
11556 {
11557         u32 adr, res;
11558         u32 src, dst;
11559
11560         adr = AREG((Opcode >> 0) & 7);
11561         PRE_IO
11562         READ_WORD_F(adr, res)
11563         flag_C = 0;
11564         flag_V = 0;
11565         flag_NotZ = res;
11566         flag_N = res >> 8;
11567         adr = AREG((Opcode >> 9) & 7);
11568         DECODE_EXT_WORD
11569         WRITE_WORD_F(adr, res)
11570         POST_IO
11571 RET(18)
11572 }
11573
11574 // MOVEW
11575 OPCODE(0x31D0)
11576 {
11577         u32 adr, res;
11578         u32 src, dst;
11579
11580         adr = AREG((Opcode >> 0) & 7);
11581         PRE_IO
11582         READ_WORD_F(adr, res)
11583         flag_C = 0;
11584         flag_V = 0;
11585         flag_NotZ = res;
11586         flag_N = res >> 8;
11587         FETCH_SWORD(adr);
11588         WRITE_WORD_F(adr, res)
11589         POST_IO
11590 RET(16)
11591 }
11592
11593 // MOVEW
11594 OPCODE(0x33D0)
11595 {
11596         u32 adr, res;
11597         u32 src, dst;
11598
11599         adr = AREG((Opcode >> 0) & 7);
11600         PRE_IO
11601         READ_WORD_F(adr, res)
11602         flag_C = 0;
11603         flag_V = 0;
11604         flag_NotZ = res;
11605         flag_N = res >> 8;
11606         FETCH_LONG(adr);
11607         WRITE_WORD_F(adr, res)
11608         POST_IO
11609 RET(20)
11610 }
11611
11612 // MOVEW
11613 OPCODE(0x3ED0)
11614 {
11615         u32 adr, res;
11616         u32 src, dst;
11617
11618         adr = AREG((Opcode >> 0) & 7);
11619         PRE_IO
11620         READ_WORD_F(adr, res)
11621         flag_C = 0;
11622         flag_V = 0;
11623         flag_NotZ = res;
11624         flag_N = res >> 8;
11625         adr = AREG(7);
11626         AREG(7) += 2;
11627         WRITE_WORD_F(adr, res)
11628         POST_IO
11629 RET(12)
11630 }
11631
11632 // MOVEW
11633 OPCODE(0x3F10)
11634 {
11635         u32 adr, res;
11636         u32 src, dst;
11637
11638         adr = AREG((Opcode >> 0) & 7);
11639         PRE_IO
11640         READ_WORD_F(adr, res)
11641         flag_C = 0;
11642         flag_V = 0;
11643         flag_NotZ = res;
11644         flag_N = res >> 8;
11645         adr = AREG(7) - 2;
11646         AREG(7) = adr;
11647         WRITE_WORD_F(adr, res)
11648         POST_IO
11649 RET(12)
11650 }
11651
11652 // MOVEW
11653 OPCODE(0x3018)
11654 {
11655         u32 adr, res;
11656         u32 src, dst;
11657
11658         adr = AREG((Opcode >> 0) & 7);
11659         AREG((Opcode >> 0) & 7) += 2;
11660         PRE_IO
11661         READ_WORD_F(adr, res)
11662         flag_C = 0;
11663         flag_V = 0;
11664         flag_NotZ = res;
11665         flag_N = res >> 8;
11666         DREGu16((Opcode >> 9) & 7) = res;
11667         POST_IO
11668 RET(8)
11669 }
11670
11671 // MOVEW
11672 OPCODE(0x3098)
11673 {
11674         u32 adr, res;
11675         u32 src, dst;
11676
11677         adr = AREG((Opcode >> 0) & 7);
11678         AREG((Opcode >> 0) & 7) += 2;
11679         PRE_IO
11680         READ_WORD_F(adr, res)
11681         flag_C = 0;
11682         flag_V = 0;
11683         flag_NotZ = res;
11684         flag_N = res >> 8;
11685         adr = AREG((Opcode >> 9) & 7);
11686         WRITE_WORD_F(adr, res)
11687         POST_IO
11688 RET(12)
11689 }
11690
11691 // MOVEW
11692 OPCODE(0x30D8)
11693 {
11694         u32 adr, res;
11695         u32 src, dst;
11696
11697         adr = AREG((Opcode >> 0) & 7);
11698         AREG((Opcode >> 0) & 7) += 2;
11699         PRE_IO
11700         READ_WORD_F(adr, res)
11701         flag_C = 0;
11702         flag_V = 0;
11703         flag_NotZ = res;
11704         flag_N = res >> 8;
11705         adr = AREG((Opcode >> 9) & 7);
11706         AREG((Opcode >> 9) & 7) += 2;
11707         WRITE_WORD_F(adr, res)
11708         POST_IO
11709 RET(12)
11710 }
11711
11712 // MOVEW
11713 OPCODE(0x3118)
11714 {
11715         u32 adr, res;
11716         u32 src, dst;
11717
11718         adr = AREG((Opcode >> 0) & 7);
11719         AREG((Opcode >> 0) & 7) += 2;
11720         PRE_IO
11721         READ_WORD_F(adr, res)
11722         flag_C = 0;
11723         flag_V = 0;
11724         flag_NotZ = res;
11725         flag_N = res >> 8;
11726         adr = AREG((Opcode >> 9) & 7) - 2;
11727         AREG((Opcode >> 9) & 7) = adr;
11728         WRITE_WORD_F(adr, res)
11729         POST_IO
11730 RET(12)
11731 }
11732
11733 // MOVEW
11734 OPCODE(0x3158)
11735 {
11736         u32 adr, res;
11737         u32 src, dst;
11738
11739         adr = AREG((Opcode >> 0) & 7);
11740         AREG((Opcode >> 0) & 7) += 2;
11741         PRE_IO
11742         READ_WORD_F(adr, res)
11743         flag_C = 0;
11744         flag_V = 0;
11745         flag_NotZ = res;
11746         flag_N = res >> 8;
11747         FETCH_SWORD(adr);
11748         adr += AREG((Opcode >> 9) & 7);
11749         WRITE_WORD_F(adr, res)
11750         POST_IO
11751 RET(16)
11752 }
11753
11754 // MOVEW
11755 OPCODE(0x3198)
11756 {
11757         u32 adr, res;
11758         u32 src, dst;
11759
11760         adr = AREG((Opcode >> 0) & 7);
11761         AREG((Opcode >> 0) & 7) += 2;
11762         PRE_IO
11763         READ_WORD_F(adr, res)
11764         flag_C = 0;
11765         flag_V = 0;
11766         flag_NotZ = res;
11767         flag_N = res >> 8;
11768         adr = AREG((Opcode >> 9) & 7);
11769         DECODE_EXT_WORD
11770         WRITE_WORD_F(adr, res)
11771         POST_IO
11772 RET(18)
11773 }
11774
11775 // MOVEW
11776 OPCODE(0x31D8)
11777 {
11778         u32 adr, res;
11779         u32 src, dst;
11780
11781         adr = AREG((Opcode >> 0) & 7);
11782         AREG((Opcode >> 0) & 7) += 2;
11783         PRE_IO
11784         READ_WORD_F(adr, res)
11785         flag_C = 0;
11786         flag_V = 0;
11787         flag_NotZ = res;
11788         flag_N = res >> 8;
11789         FETCH_SWORD(adr);
11790         WRITE_WORD_F(adr, res)
11791         POST_IO
11792 RET(16)
11793 }
11794
11795 // MOVEW
11796 OPCODE(0x33D8)
11797 {
11798         u32 adr, res;
11799         u32 src, dst;
11800
11801         adr = AREG((Opcode >> 0) & 7);
11802         AREG((Opcode >> 0) & 7) += 2;
11803         PRE_IO
11804         READ_WORD_F(adr, res)
11805         flag_C = 0;
11806         flag_V = 0;
11807         flag_NotZ = res;
11808         flag_N = res >> 8;
11809         FETCH_LONG(adr);
11810         WRITE_WORD_F(adr, res)
11811         POST_IO
11812 RET(20)
11813 }
11814
11815 // MOVEW
11816 OPCODE(0x3ED8)
11817 {
11818         u32 adr, res;
11819         u32 src, dst;
11820
11821         adr = AREG((Opcode >> 0) & 7);
11822         AREG((Opcode >> 0) & 7) += 2;
11823         PRE_IO
11824         READ_WORD_F(adr, res)
11825         flag_C = 0;
11826         flag_V = 0;
11827         flag_NotZ = res;
11828         flag_N = res >> 8;
11829         adr = AREG(7);
11830         AREG(7) += 2;
11831         WRITE_WORD_F(adr, res)
11832         POST_IO
11833 RET(12)
11834 }
11835
11836 // MOVEW
11837 OPCODE(0x3F18)
11838 {
11839         u32 adr, res;
11840         u32 src, dst;
11841
11842         adr = AREG((Opcode >> 0) & 7);
11843         AREG((Opcode >> 0) & 7) += 2;
11844         PRE_IO
11845         READ_WORD_F(adr, res)
11846         flag_C = 0;
11847         flag_V = 0;
11848         flag_NotZ = res;
11849         flag_N = res >> 8;
11850         adr = AREG(7) - 2;
11851         AREG(7) = adr;
11852         WRITE_WORD_F(adr, res)
11853         POST_IO
11854 RET(12)
11855 }
11856
11857 // MOVEW
11858 OPCODE(0x3020)
11859 {
11860         u32 adr, res;
11861         u32 src, dst;
11862
11863         adr = AREG((Opcode >> 0) & 7) - 2;
11864         AREG((Opcode >> 0) & 7) = adr;
11865         PRE_IO
11866         READ_WORD_F(adr, res)
11867         flag_C = 0;
11868         flag_V = 0;
11869         flag_NotZ = res;
11870         flag_N = res >> 8;
11871         DREGu16((Opcode >> 9) & 7) = res;
11872         POST_IO
11873 RET(10)
11874 }
11875
11876 // MOVEW
11877 OPCODE(0x30A0)
11878 {
11879         u32 adr, res;
11880         u32 src, dst;
11881
11882         adr = AREG((Opcode >> 0) & 7) - 2;
11883         AREG((Opcode >> 0) & 7) = adr;
11884         PRE_IO
11885         READ_WORD_F(adr, res)
11886         flag_C = 0;
11887         flag_V = 0;
11888         flag_NotZ = res;
11889         flag_N = res >> 8;
11890         adr = AREG((Opcode >> 9) & 7);
11891         WRITE_WORD_F(adr, res)
11892         POST_IO
11893 RET(14)
11894 }
11895
11896 // MOVEW
11897 OPCODE(0x30E0)
11898 {
11899         u32 adr, res;
11900         u32 src, dst;
11901
11902         adr = AREG((Opcode >> 0) & 7) - 2;
11903         AREG((Opcode >> 0) & 7) = adr;
11904         PRE_IO
11905         READ_WORD_F(adr, res)
11906         flag_C = 0;
11907         flag_V = 0;
11908         flag_NotZ = res;
11909         flag_N = res >> 8;
11910         adr = AREG((Opcode >> 9) & 7);
11911         AREG((Opcode >> 9) & 7) += 2;
11912         WRITE_WORD_F(adr, res)
11913         POST_IO
11914 RET(14)
11915 }
11916
11917 // MOVEW
11918 OPCODE(0x3120)
11919 {
11920         u32 adr, res;
11921         u32 src, dst;
11922
11923         adr = AREG((Opcode >> 0) & 7) - 2;
11924         AREG((Opcode >> 0) & 7) = adr;
11925         PRE_IO
11926         READ_WORD_F(adr, res)
11927         flag_C = 0;
11928         flag_V = 0;
11929         flag_NotZ = res;
11930         flag_N = res >> 8;
11931         adr = AREG((Opcode >> 9) & 7) - 2;
11932         AREG((Opcode >> 9) & 7) = adr;
11933         WRITE_WORD_F(adr, res)
11934         POST_IO
11935 RET(14)
11936 }
11937
11938 // MOVEW
11939 OPCODE(0x3160)
11940 {
11941         u32 adr, res;
11942         u32 src, dst;
11943
11944         adr = AREG((Opcode >> 0) & 7) - 2;
11945         AREG((Opcode >> 0) & 7) = adr;
11946         PRE_IO
11947         READ_WORD_F(adr, res)
11948         flag_C = 0;
11949         flag_V = 0;
11950         flag_NotZ = res;
11951         flag_N = res >> 8;
11952         FETCH_SWORD(adr);
11953         adr += AREG((Opcode >> 9) & 7);
11954         WRITE_WORD_F(adr, res)
11955         POST_IO
11956 RET(18)
11957 }
11958
11959 // MOVEW
11960 OPCODE(0x31A0)
11961 {
11962         u32 adr, res;
11963         u32 src, dst;
11964
11965         adr = AREG((Opcode >> 0) & 7) - 2;
11966         AREG((Opcode >> 0) & 7) = adr;
11967         PRE_IO
11968         READ_WORD_F(adr, res)
11969         flag_C = 0;
11970         flag_V = 0;
11971         flag_NotZ = res;
11972         flag_N = res >> 8;
11973         adr = AREG((Opcode >> 9) & 7);
11974         DECODE_EXT_WORD
11975         WRITE_WORD_F(adr, res)
11976         POST_IO
11977 RET(20)
11978 }
11979
11980 // MOVEW
11981 OPCODE(0x31E0)
11982 {
11983         u32 adr, res;
11984         u32 src, dst;
11985
11986         adr = AREG((Opcode >> 0) & 7) - 2;
11987         AREG((Opcode >> 0) & 7) = adr;
11988         PRE_IO
11989         READ_WORD_F(adr, res)
11990         flag_C = 0;
11991         flag_V = 0;
11992         flag_NotZ = res;
11993         flag_N = res >> 8;
11994         FETCH_SWORD(adr);
11995         WRITE_WORD_F(adr, res)
11996         POST_IO
11997 RET(18)
11998 }
11999
12000 // MOVEW
12001 OPCODE(0x33E0)
12002 {
12003         u32 adr, res;
12004         u32 src, dst;
12005
12006         adr = AREG((Opcode >> 0) & 7) - 2;
12007         AREG((Opcode >> 0) & 7) = adr;
12008         PRE_IO
12009         READ_WORD_F(adr, res)
12010         flag_C = 0;
12011         flag_V = 0;
12012         flag_NotZ = res;
12013         flag_N = res >> 8;
12014         FETCH_LONG(adr);
12015         WRITE_WORD_F(adr, res)
12016         POST_IO
12017 RET(22)
12018 }
12019
12020 // MOVEW
12021 OPCODE(0x3EE0)
12022 {
12023         u32 adr, res;
12024         u32 src, dst;
12025
12026         adr = AREG((Opcode >> 0) & 7) - 2;
12027         AREG((Opcode >> 0) & 7) = adr;
12028         PRE_IO
12029         READ_WORD_F(adr, res)
12030         flag_C = 0;
12031         flag_V = 0;
12032         flag_NotZ = res;
12033         flag_N = res >> 8;
12034         adr = AREG(7);
12035         AREG(7) += 2;
12036         WRITE_WORD_F(adr, res)
12037         POST_IO
12038 RET(14)
12039 }
12040
12041 // MOVEW
12042 OPCODE(0x3F20)
12043 {
12044         u32 adr, res;
12045         u32 src, dst;
12046
12047         adr = AREG((Opcode >> 0) & 7) - 2;
12048         AREG((Opcode >> 0) & 7) = adr;
12049         PRE_IO
12050         READ_WORD_F(adr, res)
12051         flag_C = 0;
12052         flag_V = 0;
12053         flag_NotZ = res;
12054         flag_N = res >> 8;
12055         adr = AREG(7) - 2;
12056         AREG(7) = adr;
12057         WRITE_WORD_F(adr, res)
12058         POST_IO
12059 RET(14)
12060 }
12061
12062 // MOVEW
12063 OPCODE(0x3028)
12064 {
12065         u32 adr, res;
12066         u32 src, dst;
12067
12068         FETCH_SWORD(adr);
12069         adr += AREG((Opcode >> 0) & 7);
12070         PRE_IO
12071         READ_WORD_F(adr, res)
12072         flag_C = 0;
12073         flag_V = 0;
12074         flag_NotZ = res;
12075         flag_N = res >> 8;
12076         DREGu16((Opcode >> 9) & 7) = res;
12077         POST_IO
12078 RET(12)
12079 }
12080
12081 // MOVEW
12082 OPCODE(0x30A8)
12083 {
12084         u32 adr, res;
12085         u32 src, dst;
12086
12087         FETCH_SWORD(adr);
12088         adr += AREG((Opcode >> 0) & 7);
12089         PRE_IO
12090         READ_WORD_F(adr, res)
12091         flag_C = 0;
12092         flag_V = 0;
12093         flag_NotZ = res;
12094         flag_N = res >> 8;
12095         adr = AREG((Opcode >> 9) & 7);
12096         WRITE_WORD_F(adr, res)
12097         POST_IO
12098 RET(16)
12099 }
12100
12101 // MOVEW
12102 OPCODE(0x30E8)
12103 {
12104         u32 adr, res;
12105         u32 src, dst;
12106
12107         FETCH_SWORD(adr);
12108         adr += AREG((Opcode >> 0) & 7);
12109         PRE_IO
12110         READ_WORD_F(adr, res)
12111         flag_C = 0;
12112         flag_V = 0;
12113         flag_NotZ = res;
12114         flag_N = res >> 8;
12115         adr = AREG((Opcode >> 9) & 7);
12116         AREG((Opcode >> 9) & 7) += 2;
12117         WRITE_WORD_F(adr, res)
12118         POST_IO
12119 RET(16)
12120 }
12121
12122 // MOVEW
12123 OPCODE(0x3128)
12124 {
12125         u32 adr, res;
12126         u32 src, dst;
12127
12128         FETCH_SWORD(adr);
12129         adr += AREG((Opcode >> 0) & 7);
12130         PRE_IO
12131         READ_WORD_F(adr, res)
12132         flag_C = 0;
12133         flag_V = 0;
12134         flag_NotZ = res;
12135         flag_N = res >> 8;
12136         adr = AREG((Opcode >> 9) & 7) - 2;
12137         AREG((Opcode >> 9) & 7) = adr;
12138         WRITE_WORD_F(adr, res)
12139         POST_IO
12140 RET(16)
12141 }
12142
12143 // MOVEW
12144 OPCODE(0x3168)
12145 {
12146         u32 adr, res;
12147         u32 src, dst;
12148
12149         FETCH_SWORD(adr);
12150         adr += AREG((Opcode >> 0) & 7);
12151         PRE_IO
12152         READ_WORD_F(adr, res)
12153         flag_C = 0;
12154         flag_V = 0;
12155         flag_NotZ = res;
12156         flag_N = res >> 8;
12157         FETCH_SWORD(adr);
12158         adr += AREG((Opcode >> 9) & 7);
12159         WRITE_WORD_F(adr, res)
12160         POST_IO
12161 RET(20)
12162 }
12163
12164 // MOVEW
12165 OPCODE(0x31A8)
12166 {
12167         u32 adr, res;
12168         u32 src, dst;
12169
12170         FETCH_SWORD(adr);
12171         adr += AREG((Opcode >> 0) & 7);
12172         PRE_IO
12173         READ_WORD_F(adr, res)
12174         flag_C = 0;
12175         flag_V = 0;
12176         flag_NotZ = res;
12177         flag_N = res >> 8;
12178         adr = AREG((Opcode >> 9) & 7);
12179         DECODE_EXT_WORD
12180         WRITE_WORD_F(adr, res)
12181         POST_IO
12182 RET(22)
12183 }
12184
12185 // MOVEW
12186 OPCODE(0x31E8)
12187 {
12188         u32 adr, res;
12189         u32 src, dst;
12190
12191         FETCH_SWORD(adr);
12192         adr += AREG((Opcode >> 0) & 7);
12193         PRE_IO
12194         READ_WORD_F(adr, res)
12195         flag_C = 0;
12196         flag_V = 0;
12197         flag_NotZ = res;
12198         flag_N = res >> 8;
12199         FETCH_SWORD(adr);
12200         WRITE_WORD_F(adr, res)
12201         POST_IO
12202 RET(20)
12203 }
12204
12205 // MOVEW
12206 OPCODE(0x33E8)
12207 {
12208         u32 adr, res;
12209         u32 src, dst;
12210
12211         FETCH_SWORD(adr);
12212         adr += AREG((Opcode >> 0) & 7);
12213         PRE_IO
12214         READ_WORD_F(adr, res)
12215         flag_C = 0;
12216         flag_V = 0;
12217         flag_NotZ = res;
12218         flag_N = res >> 8;
12219         FETCH_LONG(adr);
12220         WRITE_WORD_F(adr, res)
12221         POST_IO
12222 RET(24)
12223 }
12224
12225 // MOVEW
12226 OPCODE(0x3EE8)
12227 {
12228         u32 adr, res;
12229         u32 src, dst;
12230
12231         FETCH_SWORD(adr);
12232         adr += AREG((Opcode >> 0) & 7);
12233         PRE_IO
12234         READ_WORD_F(adr, res)
12235         flag_C = 0;
12236         flag_V = 0;
12237         flag_NotZ = res;
12238         flag_N = res >> 8;
12239         adr = AREG(7);
12240         AREG(7) += 2;
12241         WRITE_WORD_F(adr, res)
12242         POST_IO
12243 RET(16)
12244 }
12245
12246 // MOVEW
12247 OPCODE(0x3F28)
12248 {
12249         u32 adr, res;
12250         u32 src, dst;
12251
12252         FETCH_SWORD(adr);
12253         adr += AREG((Opcode >> 0) & 7);
12254         PRE_IO
12255         READ_WORD_F(adr, res)
12256         flag_C = 0;
12257         flag_V = 0;
12258         flag_NotZ = res;
12259         flag_N = res >> 8;
12260         adr = AREG(7) - 2;
12261         AREG(7) = adr;
12262         WRITE_WORD_F(adr, res)
12263         POST_IO
12264 RET(16)
12265 }
12266
12267 // MOVEW
12268 OPCODE(0x3030)
12269 {
12270         u32 adr, res;
12271         u32 src, dst;
12272
12273         adr = AREG((Opcode >> 0) & 7);
12274         DECODE_EXT_WORD
12275         PRE_IO
12276         READ_WORD_F(adr, res)
12277         flag_C = 0;
12278         flag_V = 0;
12279         flag_NotZ = res;
12280         flag_N = res >> 8;
12281         DREGu16((Opcode >> 9) & 7) = res;
12282         POST_IO
12283 RET(14)
12284 }
12285
12286 // MOVEW
12287 OPCODE(0x30B0)
12288 {
12289         u32 adr, res;
12290         u32 src, dst;
12291
12292         adr = AREG((Opcode >> 0) & 7);
12293         DECODE_EXT_WORD
12294         PRE_IO
12295         READ_WORD_F(adr, res)
12296         flag_C = 0;
12297         flag_V = 0;
12298         flag_NotZ = res;
12299         flag_N = res >> 8;
12300         adr = AREG((Opcode >> 9) & 7);
12301         WRITE_WORD_F(adr, res)
12302         POST_IO
12303 RET(18)
12304 }
12305
12306 // MOVEW
12307 OPCODE(0x30F0)
12308 {
12309         u32 adr, res;
12310         u32 src, dst;
12311
12312         adr = AREG((Opcode >> 0) & 7);
12313         DECODE_EXT_WORD
12314         PRE_IO
12315         READ_WORD_F(adr, res)
12316         flag_C = 0;
12317         flag_V = 0;
12318         flag_NotZ = res;
12319         flag_N = res >> 8;
12320         adr = AREG((Opcode >> 9) & 7);
12321         AREG((Opcode >> 9) & 7) += 2;
12322         WRITE_WORD_F(adr, res)
12323         POST_IO
12324 RET(18)
12325 }
12326
12327 // MOVEW
12328 OPCODE(0x3130)
12329 {
12330         u32 adr, res;
12331         u32 src, dst;
12332
12333         adr = AREG((Opcode >> 0) & 7);
12334         DECODE_EXT_WORD
12335         PRE_IO
12336         READ_WORD_F(adr, res)
12337         flag_C = 0;
12338         flag_V = 0;
12339         flag_NotZ = res;
12340         flag_N = res >> 8;
12341         adr = AREG((Opcode >> 9) & 7) - 2;
12342         AREG((Opcode >> 9) & 7) = adr;
12343         WRITE_WORD_F(adr, res)
12344         POST_IO
12345 RET(18)
12346 }
12347
12348 // MOVEW
12349 OPCODE(0x3170)
12350 {
12351         u32 adr, res;
12352         u32 src, dst;
12353
12354         adr = AREG((Opcode >> 0) & 7);
12355         DECODE_EXT_WORD
12356         PRE_IO
12357         READ_WORD_F(adr, res)
12358         flag_C = 0;
12359         flag_V = 0;
12360         flag_NotZ = res;
12361         flag_N = res >> 8;
12362         FETCH_SWORD(adr);
12363         adr += AREG((Opcode >> 9) & 7);
12364         WRITE_WORD_F(adr, res)
12365         POST_IO
12366 RET(22)
12367 }
12368
12369 // MOVEW
12370 OPCODE(0x31B0)
12371 {
12372         u32 adr, res;
12373         u32 src, dst;
12374
12375         adr = AREG((Opcode >> 0) & 7);
12376         DECODE_EXT_WORD
12377         PRE_IO
12378         READ_WORD_F(adr, res)
12379         flag_C = 0;
12380         flag_V = 0;
12381         flag_NotZ = res;
12382         flag_N = res >> 8;
12383         adr = AREG((Opcode >> 9) & 7);
12384         DECODE_EXT_WORD
12385         WRITE_WORD_F(adr, res)
12386         POST_IO
12387 RET(24)
12388 }
12389
12390 // MOVEW
12391 OPCODE(0x31F0)
12392 {
12393         u32 adr, res;
12394         u32 src, dst;
12395
12396         adr = AREG((Opcode >> 0) & 7);
12397         DECODE_EXT_WORD
12398         PRE_IO
12399         READ_WORD_F(adr, res)
12400         flag_C = 0;
12401         flag_V = 0;
12402         flag_NotZ = res;
12403         flag_N = res >> 8;
12404         FETCH_SWORD(adr);
12405         WRITE_WORD_F(adr, res)
12406         POST_IO
12407 RET(22)
12408 }
12409
12410 // MOVEW
12411 OPCODE(0x33F0)
12412 {
12413         u32 adr, res;
12414         u32 src, dst;
12415
12416         adr = AREG((Opcode >> 0) & 7);
12417         DECODE_EXT_WORD
12418         PRE_IO
12419         READ_WORD_F(adr, res)
12420         flag_C = 0;
12421         flag_V = 0;
12422         flag_NotZ = res;
12423         flag_N = res >> 8;
12424         FETCH_LONG(adr);
12425         WRITE_WORD_F(adr, res)
12426         POST_IO
12427 RET(26)
12428 }
12429
12430 // MOVEW
12431 OPCODE(0x3EF0)
12432 {
12433         u32 adr, res;
12434         u32 src, dst;
12435
12436         adr = AREG((Opcode >> 0) & 7);
12437         DECODE_EXT_WORD
12438         PRE_IO
12439         READ_WORD_F(adr, res)
12440         flag_C = 0;
12441         flag_V = 0;
12442         flag_NotZ = res;
12443         flag_N = res >> 8;
12444         adr = AREG(7);
12445         AREG(7) += 2;
12446         WRITE_WORD_F(adr, res)
12447         POST_IO
12448 RET(18)
12449 }
12450
12451 // MOVEW
12452 OPCODE(0x3F30)
12453 {
12454         u32 adr, res;
12455         u32 src, dst;
12456
12457         adr = AREG((Opcode >> 0) & 7);
12458         DECODE_EXT_WORD
12459         PRE_IO
12460         READ_WORD_F(adr, res)
12461         flag_C = 0;
12462         flag_V = 0;
12463         flag_NotZ = res;
12464         flag_N = res >> 8;
12465         adr = AREG(7) - 2;
12466         AREG(7) = adr;
12467         WRITE_WORD_F(adr, res)
12468         POST_IO
12469 RET(18)
12470 }
12471
12472 // MOVEW
12473 OPCODE(0x3038)
12474 {
12475         u32 adr, res;
12476         u32 src, dst;
12477
12478         FETCH_SWORD(adr);
12479         PRE_IO
12480         READ_WORD_F(adr, res)
12481         flag_C = 0;
12482         flag_V = 0;
12483         flag_NotZ = res;
12484         flag_N = res >> 8;
12485         DREGu16((Opcode >> 9) & 7) = res;
12486         POST_IO
12487 RET(12)
12488 }
12489
12490 // MOVEW
12491 OPCODE(0x30B8)
12492 {
12493         u32 adr, res;
12494         u32 src, dst;
12495
12496         FETCH_SWORD(adr);
12497         PRE_IO
12498         READ_WORD_F(adr, res)
12499         flag_C = 0;
12500         flag_V = 0;
12501         flag_NotZ = res;
12502         flag_N = res >> 8;
12503         adr = AREG((Opcode >> 9) & 7);
12504         WRITE_WORD_F(adr, res)
12505         POST_IO
12506 RET(16)
12507 }
12508
12509 // MOVEW
12510 OPCODE(0x30F8)
12511 {
12512         u32 adr, res;
12513         u32 src, dst;
12514
12515         FETCH_SWORD(adr);
12516         PRE_IO
12517         READ_WORD_F(adr, res)
12518         flag_C = 0;
12519         flag_V = 0;
12520         flag_NotZ = res;
12521         flag_N = res >> 8;
12522         adr = AREG((Opcode >> 9) & 7);
12523         AREG((Opcode >> 9) & 7) += 2;
12524         WRITE_WORD_F(adr, res)
12525         POST_IO
12526 RET(16)
12527 }
12528
12529 // MOVEW
12530 OPCODE(0x3138)
12531 {
12532         u32 adr, res;
12533         u32 src, dst;
12534
12535         FETCH_SWORD(adr);
12536         PRE_IO
12537         READ_WORD_F(adr, res)
12538         flag_C = 0;
12539         flag_V = 0;
12540         flag_NotZ = res;
12541         flag_N = res >> 8;
12542         adr = AREG((Opcode >> 9) & 7) - 2;
12543         AREG((Opcode >> 9) & 7) = adr;
12544         WRITE_WORD_F(adr, res)
12545         POST_IO
12546 RET(16)
12547 }
12548
12549 // MOVEW
12550 OPCODE(0x3178)
12551 {
12552         u32 adr, res;
12553         u32 src, dst;
12554
12555         FETCH_SWORD(adr);
12556         PRE_IO
12557         READ_WORD_F(adr, res)
12558         flag_C = 0;
12559         flag_V = 0;
12560         flag_NotZ = res;
12561         flag_N = res >> 8;
12562         FETCH_SWORD(adr);
12563         adr += AREG((Opcode >> 9) & 7);
12564         WRITE_WORD_F(adr, res)
12565         POST_IO
12566 RET(20)
12567 }
12568
12569 // MOVEW
12570 OPCODE(0x31B8)
12571 {
12572         u32 adr, res;
12573         u32 src, dst;
12574
12575         FETCH_SWORD(adr);
12576         PRE_IO
12577         READ_WORD_F(adr, res)
12578         flag_C = 0;
12579         flag_V = 0;
12580         flag_NotZ = res;
12581         flag_N = res >> 8;
12582         adr = AREG((Opcode >> 9) & 7);
12583         DECODE_EXT_WORD
12584         WRITE_WORD_F(adr, res)
12585         POST_IO
12586 RET(22)
12587 }
12588
12589 // MOVEW
12590 OPCODE(0x31F8)
12591 {
12592         u32 adr, res;
12593         u32 src, dst;
12594
12595         FETCH_SWORD(adr);
12596         PRE_IO
12597         READ_WORD_F(adr, res)
12598         flag_C = 0;
12599         flag_V = 0;
12600         flag_NotZ = res;
12601         flag_N = res >> 8;
12602         FETCH_SWORD(adr);
12603         WRITE_WORD_F(adr, res)
12604         POST_IO
12605 RET(20)
12606 }
12607
12608 // MOVEW
12609 OPCODE(0x33F8)
12610 {
12611         u32 adr, res;
12612         u32 src, dst;
12613
12614         FETCH_SWORD(adr);
12615         PRE_IO
12616         READ_WORD_F(adr, res)
12617         flag_C = 0;
12618         flag_V = 0;
12619         flag_NotZ = res;
12620         flag_N = res >> 8;
12621         FETCH_LONG(adr);
12622         WRITE_WORD_F(adr, res)
12623         POST_IO
12624 RET(24)
12625 }
12626
12627 // MOVEW
12628 OPCODE(0x3EF8)
12629 {
12630         u32 adr, res;
12631         u32 src, dst;
12632
12633         FETCH_SWORD(adr);
12634         PRE_IO
12635         READ_WORD_F(adr, res)
12636         flag_C = 0;
12637         flag_V = 0;
12638         flag_NotZ = res;
12639         flag_N = res >> 8;
12640         adr = AREG(7);
12641         AREG(7) += 2;
12642         WRITE_WORD_F(adr, res)
12643         POST_IO
12644 RET(16)
12645 }
12646
12647 // MOVEW
12648 OPCODE(0x3F38)
12649 {
12650         u32 adr, res;
12651         u32 src, dst;
12652
12653         FETCH_SWORD(adr);
12654         PRE_IO
12655         READ_WORD_F(adr, res)
12656         flag_C = 0;
12657         flag_V = 0;
12658         flag_NotZ = res;
12659         flag_N = res >> 8;
12660         adr = AREG(7) - 2;
12661         AREG(7) = adr;
12662         WRITE_WORD_F(adr, res)
12663         POST_IO
12664 RET(16)
12665 }
12666
12667 // MOVEW
12668 OPCODE(0x3039)
12669 {
12670         u32 adr, res;
12671         u32 src, dst;
12672
12673         FETCH_LONG(adr);
12674         PRE_IO
12675         READ_WORD_F(adr, res)
12676         flag_C = 0;
12677         flag_V = 0;
12678         flag_NotZ = res;
12679         flag_N = res >> 8;
12680         DREGu16((Opcode >> 9) & 7) = res;
12681         POST_IO
12682 RET(16)
12683 }
12684
12685 // MOVEW
12686 OPCODE(0x30B9)
12687 {
12688         u32 adr, res;
12689         u32 src, dst;
12690
12691         FETCH_LONG(adr);
12692         PRE_IO
12693         READ_WORD_F(adr, res)
12694         flag_C = 0;
12695         flag_V = 0;
12696         flag_NotZ = res;
12697         flag_N = res >> 8;
12698         adr = AREG((Opcode >> 9) & 7);
12699         WRITE_WORD_F(adr, res)
12700         POST_IO
12701 RET(20)
12702 }
12703
12704 // MOVEW
12705 OPCODE(0x30F9)
12706 {
12707         u32 adr, res;
12708         u32 src, dst;
12709
12710         FETCH_LONG(adr);
12711         PRE_IO
12712         READ_WORD_F(adr, res)
12713         flag_C = 0;
12714         flag_V = 0;
12715         flag_NotZ = res;
12716         flag_N = res >> 8;
12717         adr = AREG((Opcode >> 9) & 7);
12718         AREG((Opcode >> 9) & 7) += 2;
12719         WRITE_WORD_F(adr, res)
12720         POST_IO
12721 RET(20)
12722 }
12723
12724 // MOVEW
12725 OPCODE(0x3139)
12726 {
12727         u32 adr, res;
12728         u32 src, dst;
12729
12730         FETCH_LONG(adr);
12731         PRE_IO
12732         READ_WORD_F(adr, res)
12733         flag_C = 0;
12734         flag_V = 0;
12735         flag_NotZ = res;
12736         flag_N = res >> 8;
12737         adr = AREG((Opcode >> 9) & 7) - 2;
12738         AREG((Opcode >> 9) & 7) = adr;
12739         WRITE_WORD_F(adr, res)
12740         POST_IO
12741 RET(20)
12742 }
12743
12744 // MOVEW
12745 OPCODE(0x3179)
12746 {
12747         u32 adr, res;
12748         u32 src, dst;
12749
12750         FETCH_LONG(adr);
12751         PRE_IO
12752         READ_WORD_F(adr, res)
12753         flag_C = 0;
12754         flag_V = 0;
12755         flag_NotZ = res;
12756         flag_N = res >> 8;
12757         FETCH_SWORD(adr);
12758         adr += AREG((Opcode >> 9) & 7);
12759         WRITE_WORD_F(adr, res)
12760         POST_IO
12761 RET(24)
12762 }
12763
12764 // MOVEW
12765 OPCODE(0x31B9)
12766 {
12767         u32 adr, res;
12768         u32 src, dst;
12769
12770         FETCH_LONG(adr);
12771         PRE_IO
12772         READ_WORD_F(adr, res)
12773         flag_C = 0;
12774         flag_V = 0;
12775         flag_NotZ = res;
12776         flag_N = res >> 8;
12777         adr = AREG((Opcode >> 9) & 7);
12778         DECODE_EXT_WORD
12779         WRITE_WORD_F(adr, res)
12780         POST_IO
12781 RET(26)
12782 }
12783
12784 // MOVEW
12785 OPCODE(0x31F9)
12786 {
12787         u32 adr, res;
12788         u32 src, dst;
12789
12790         FETCH_LONG(adr);
12791         PRE_IO
12792         READ_WORD_F(adr, res)
12793         flag_C = 0;
12794         flag_V = 0;
12795         flag_NotZ = res;
12796         flag_N = res >> 8;
12797         FETCH_SWORD(adr);
12798         WRITE_WORD_F(adr, res)
12799         POST_IO
12800 RET(24)
12801 }
12802
12803 // MOVEW
12804 OPCODE(0x33F9)
12805 {
12806         u32 adr, res;
12807         u32 src, dst;
12808
12809         FETCH_LONG(adr);
12810         PRE_IO
12811         READ_WORD_F(adr, res)
12812         flag_C = 0;
12813         flag_V = 0;
12814         flag_NotZ = res;
12815         flag_N = res >> 8;
12816         FETCH_LONG(adr);
12817         WRITE_WORD_F(adr, res)
12818         POST_IO
12819 RET(28)
12820 }
12821
12822 // MOVEW
12823 OPCODE(0x3EF9)
12824 {
12825         u32 adr, res;
12826         u32 src, dst;
12827
12828         FETCH_LONG(adr);
12829         PRE_IO
12830         READ_WORD_F(adr, res)
12831         flag_C = 0;
12832         flag_V = 0;
12833         flag_NotZ = res;
12834         flag_N = res >> 8;
12835         adr = AREG(7);
12836         AREG(7) += 2;
12837         WRITE_WORD_F(adr, res)
12838         POST_IO
12839 RET(20)
12840 }
12841
12842 // MOVEW
12843 OPCODE(0x3F39)
12844 {
12845         u32 adr, res;
12846         u32 src, dst;
12847
12848         FETCH_LONG(adr);
12849         PRE_IO
12850         READ_WORD_F(adr, res)
12851         flag_C = 0;
12852         flag_V = 0;
12853         flag_NotZ = res;
12854         flag_N = res >> 8;
12855         adr = AREG(7) - 2;
12856         AREG(7) = adr;
12857         WRITE_WORD_F(adr, res)
12858         POST_IO
12859 RET(20)
12860 }
12861
12862 // MOVEW
12863 OPCODE(0x303A)
12864 {
12865         u32 adr, res;
12866         u32 src, dst;
12867
12868         adr = GET_SWORD + GET_PC;
12869         PC++;
12870         PRE_IO
12871         READ_WORD_F(adr, res)
12872         flag_C = 0;
12873         flag_V = 0;
12874         flag_NotZ = res;
12875         flag_N = res >> 8;
12876         DREGu16((Opcode >> 9) & 7) = res;
12877         POST_IO
12878 RET(12)
12879 }
12880
12881 // MOVEW
12882 OPCODE(0x30BA)
12883 {
12884         u32 adr, res;
12885         u32 src, dst;
12886
12887         adr = GET_SWORD + GET_PC;
12888         PC++;
12889         PRE_IO
12890         READ_WORD_F(adr, res)
12891         flag_C = 0;
12892         flag_V = 0;
12893         flag_NotZ = res;
12894         flag_N = res >> 8;
12895         adr = AREG((Opcode >> 9) & 7);
12896         WRITE_WORD_F(adr, res)
12897         POST_IO
12898 RET(16)
12899 }
12900
12901 // MOVEW
12902 OPCODE(0x30FA)
12903 {
12904         u32 adr, res;
12905         u32 src, dst;
12906
12907         adr = GET_SWORD + GET_PC;
12908         PC++;
12909         PRE_IO
12910         READ_WORD_F(adr, res)
12911         flag_C = 0;
12912         flag_V = 0;
12913         flag_NotZ = res;
12914         flag_N = res >> 8;
12915         adr = AREG((Opcode >> 9) & 7);
12916         AREG((Opcode >> 9) & 7) += 2;
12917         WRITE_WORD_F(adr, res)
12918         POST_IO
12919 RET(16)
12920 }
12921
12922 // MOVEW
12923 OPCODE(0x313A)
12924 {
12925         u32 adr, res;
12926         u32 src, dst;
12927
12928         adr = GET_SWORD + GET_PC;
12929         PC++;
12930         PRE_IO
12931         READ_WORD_F(adr, res)
12932         flag_C = 0;
12933         flag_V = 0;
12934         flag_NotZ = res;
12935         flag_N = res >> 8;
12936         adr = AREG((Opcode >> 9) & 7) - 2;
12937         AREG((Opcode >> 9) & 7) = adr;
12938         WRITE_WORD_F(adr, res)
12939         POST_IO
12940 RET(16)
12941 }
12942
12943 // MOVEW
12944 OPCODE(0x317A)
12945 {
12946         u32 adr, res;
12947         u32 src, dst;
12948
12949         adr = GET_SWORD + GET_PC;
12950         PC++;
12951         PRE_IO
12952         READ_WORD_F(adr, res)
12953         flag_C = 0;
12954         flag_V = 0;
12955         flag_NotZ = res;
12956         flag_N = res >> 8;
12957         FETCH_SWORD(adr);
12958         adr += AREG((Opcode >> 9) & 7);
12959         WRITE_WORD_F(adr, res)
12960         POST_IO
12961 RET(20)
12962 }
12963
12964 // MOVEW
12965 OPCODE(0x31BA)
12966 {
12967         u32 adr, res;
12968         u32 src, dst;
12969
12970         adr = GET_SWORD + GET_PC;
12971         PC++;
12972         PRE_IO
12973         READ_WORD_F(adr, res)
12974         flag_C = 0;
12975         flag_V = 0;
12976         flag_NotZ = res;
12977         flag_N = res >> 8;
12978         adr = AREG((Opcode >> 9) & 7);
12979         DECODE_EXT_WORD
12980         WRITE_WORD_F(adr, res)
12981         POST_IO
12982 RET(22)
12983 }
12984
12985 // MOVEW
12986 OPCODE(0x31FA)
12987 {
12988         u32 adr, res;
12989         u32 src, dst;
12990
12991         adr = GET_SWORD + GET_PC;
12992         PC++;
12993         PRE_IO
12994         READ_WORD_F(adr, res)
12995         flag_C = 0;
12996         flag_V = 0;
12997         flag_NotZ = res;
12998         flag_N = res >> 8;
12999         FETCH_SWORD(adr);
13000         WRITE_WORD_F(adr, res)
13001         POST_IO
13002 RET(20)
13003 }
13004
13005 // MOVEW
13006 OPCODE(0x33FA)
13007 {
13008         u32 adr, res;
13009         u32 src, dst;
13010
13011         adr = GET_SWORD + GET_PC;
13012         PC++;
13013         PRE_IO
13014         READ_WORD_F(adr, res)
13015         flag_C = 0;
13016         flag_V = 0;
13017         flag_NotZ = res;
13018         flag_N = res >> 8;
13019         FETCH_LONG(adr);
13020         WRITE_WORD_F(adr, res)
13021         POST_IO
13022 RET(24)
13023 }
13024
13025 // MOVEW
13026 OPCODE(0x3EFA)
13027 {
13028         u32 adr, res;
13029         u32 src, dst;
13030
13031         adr = GET_SWORD + GET_PC;
13032         PC++;
13033         PRE_IO
13034         READ_WORD_F(adr, res)
13035         flag_C = 0;
13036         flag_V = 0;
13037         flag_NotZ = res;
13038         flag_N = res >> 8;
13039         adr = AREG(7);
13040         AREG(7) += 2;
13041         WRITE_WORD_F(adr, res)
13042         POST_IO
13043 RET(16)
13044 }
13045
13046 // MOVEW
13047 OPCODE(0x3F3A)
13048 {
13049         u32 adr, res;
13050         u32 src, dst;
13051
13052         adr = GET_SWORD + GET_PC;
13053         PC++;
13054         PRE_IO
13055         READ_WORD_F(adr, res)
13056         flag_C = 0;
13057         flag_V = 0;
13058         flag_NotZ = res;
13059         flag_N = res >> 8;
13060         adr = AREG(7) - 2;
13061         AREG(7) = adr;
13062         WRITE_WORD_F(adr, res)
13063         POST_IO
13064 RET(16)
13065 }
13066
13067 // MOVEW
13068 OPCODE(0x303B)
13069 {
13070         u32 adr, res;
13071         u32 src, dst;
13072
13073         adr = GET_PC;
13074         DECODE_EXT_WORD
13075         PRE_IO
13076         READ_WORD_F(adr, res)
13077         flag_C = 0;
13078         flag_V = 0;
13079         flag_NotZ = res;
13080         flag_N = res >> 8;
13081         DREGu16((Opcode >> 9) & 7) = res;
13082         POST_IO
13083 RET(14)
13084 }
13085
13086 // MOVEW
13087 OPCODE(0x30BB)
13088 {
13089         u32 adr, res;
13090         u32 src, dst;
13091
13092         adr = GET_PC;
13093         DECODE_EXT_WORD
13094         PRE_IO
13095         READ_WORD_F(adr, res)
13096         flag_C = 0;
13097         flag_V = 0;
13098         flag_NotZ = res;
13099         flag_N = res >> 8;
13100         adr = AREG((Opcode >> 9) & 7);
13101         WRITE_WORD_F(adr, res)
13102         POST_IO
13103 RET(18)
13104 }
13105
13106 // MOVEW
13107 OPCODE(0x30FB)
13108 {
13109         u32 adr, res;
13110         u32 src, dst;
13111
13112         adr = GET_PC;
13113         DECODE_EXT_WORD
13114         PRE_IO
13115         READ_WORD_F(adr, res)
13116         flag_C = 0;
13117         flag_V = 0;
13118         flag_NotZ = res;
13119         flag_N = res >> 8;
13120         adr = AREG((Opcode >> 9) & 7);
13121         AREG((Opcode >> 9) & 7) += 2;
13122         WRITE_WORD_F(adr, res)
13123         POST_IO
13124 RET(18)
13125 }
13126
13127 // MOVEW
13128 OPCODE(0x313B)
13129 {
13130         u32 adr, res;
13131         u32 src, dst;
13132
13133         adr = GET_PC;
13134         DECODE_EXT_WORD
13135         PRE_IO
13136         READ_WORD_F(adr, res)
13137         flag_C = 0;
13138         flag_V = 0;
13139         flag_NotZ = res;
13140         flag_N = res >> 8;
13141         adr = AREG((Opcode >> 9) & 7) - 2;
13142         AREG((Opcode >> 9) & 7) = adr;
13143         WRITE_WORD_F(adr, res)
13144         POST_IO
13145 RET(18)
13146 }
13147
13148 // MOVEW
13149 OPCODE(0x317B)
13150 {
13151         u32 adr, res;
13152         u32 src, dst;
13153
13154         adr = GET_PC;
13155         DECODE_EXT_WORD
13156         PRE_IO
13157         READ_WORD_F(adr, res)
13158         flag_C = 0;
13159         flag_V = 0;
13160         flag_NotZ = res;
13161         flag_N = res >> 8;
13162         FETCH_SWORD(adr);
13163         adr += AREG((Opcode >> 9) & 7);
13164         WRITE_WORD_F(adr, res)
13165         POST_IO
13166 RET(22)
13167 }
13168
13169 // MOVEW
13170 OPCODE(0x31BB)
13171 {
13172         u32 adr, res;
13173         u32 src, dst;
13174
13175         adr = GET_PC;
13176         DECODE_EXT_WORD
13177         PRE_IO
13178         READ_WORD_F(adr, res)
13179         flag_C = 0;
13180         flag_V = 0;
13181         flag_NotZ = res;
13182         flag_N = res >> 8;
13183         adr = AREG((Opcode >> 9) & 7);
13184         DECODE_EXT_WORD
13185         WRITE_WORD_F(adr, res)
13186         POST_IO
13187 RET(24)
13188 }
13189
13190 // MOVEW
13191 OPCODE(0x31FB)
13192 {
13193         u32 adr, res;
13194         u32 src, dst;
13195
13196         adr = GET_PC;
13197         DECODE_EXT_WORD
13198         PRE_IO
13199         READ_WORD_F(adr, res)
13200         flag_C = 0;
13201         flag_V = 0;
13202         flag_NotZ = res;
13203         flag_N = res >> 8;
13204         FETCH_SWORD(adr);
13205         WRITE_WORD_F(adr, res)
13206         POST_IO
13207 RET(22)
13208 }
13209
13210 // MOVEW
13211 OPCODE(0x33FB)
13212 {
13213         u32 adr, res;
13214         u32 src, dst;
13215
13216         adr = GET_PC;
13217         DECODE_EXT_WORD
13218         PRE_IO
13219         READ_WORD_F(adr, res)
13220         flag_C = 0;
13221         flag_V = 0;
13222         flag_NotZ = res;
13223         flag_N = res >> 8;
13224         FETCH_LONG(adr);
13225         WRITE_WORD_F(adr, res)
13226         POST_IO
13227 RET(26)
13228 }
13229
13230 // MOVEW
13231 OPCODE(0x3EFB)
13232 {
13233         u32 adr, res;
13234         u32 src, dst;
13235
13236         adr = GET_PC;
13237         DECODE_EXT_WORD
13238         PRE_IO
13239         READ_WORD_F(adr, res)
13240         flag_C = 0;
13241         flag_V = 0;
13242         flag_NotZ = res;
13243         flag_N = res >> 8;
13244         adr = AREG(7);
13245         AREG(7) += 2;
13246         WRITE_WORD_F(adr, res)
13247         POST_IO
13248 RET(18)
13249 }
13250
13251 // MOVEW
13252 OPCODE(0x3F3B)
13253 {
13254         u32 adr, res;
13255         u32 src, dst;
13256
13257         adr = GET_PC;
13258         DECODE_EXT_WORD
13259         PRE_IO
13260         READ_WORD_F(adr, res)
13261         flag_C = 0;
13262         flag_V = 0;
13263         flag_NotZ = res;
13264         flag_N = res >> 8;
13265         adr = AREG(7) - 2;
13266         AREG(7) = adr;
13267         WRITE_WORD_F(adr, res)
13268         POST_IO
13269 RET(18)
13270 }
13271
13272 // MOVEW
13273 OPCODE(0x303C)
13274 {
13275         u32 adr, res;
13276         u32 src, dst;
13277
13278         FETCH_WORD(res);
13279         flag_C = 0;
13280         flag_V = 0;
13281         flag_NotZ = res;
13282         flag_N = res >> 8;
13283         DREGu16((Opcode >> 9) & 7) = res;
13284 RET(8)
13285 }
13286
13287 // MOVEW
13288 OPCODE(0x30BC)
13289 {
13290         u32 adr, res;
13291         u32 src, dst;
13292
13293         FETCH_WORD(res);
13294         flag_C = 0;
13295         flag_V = 0;
13296         flag_NotZ = res;
13297         flag_N = res >> 8;
13298         adr = AREG((Opcode >> 9) & 7);
13299         PRE_IO
13300         WRITE_WORD_F(adr, res)
13301         POST_IO
13302 RET(12)
13303 }
13304
13305 // MOVEW
13306 OPCODE(0x30FC)
13307 {
13308         u32 adr, res;
13309         u32 src, dst;
13310
13311         FETCH_WORD(res);
13312         flag_C = 0;
13313         flag_V = 0;
13314         flag_NotZ = res;
13315         flag_N = res >> 8;
13316         adr = AREG((Opcode >> 9) & 7);
13317         AREG((Opcode >> 9) & 7) += 2;
13318         PRE_IO
13319         WRITE_WORD_F(adr, res)
13320         POST_IO
13321 RET(12)
13322 }
13323
13324 // MOVEW
13325 OPCODE(0x313C)
13326 {
13327         u32 adr, res;
13328         u32 src, dst;
13329
13330         FETCH_WORD(res);
13331         flag_C = 0;
13332         flag_V = 0;
13333         flag_NotZ = res;
13334         flag_N = res >> 8;
13335         adr = AREG((Opcode >> 9) & 7) - 2;
13336         AREG((Opcode >> 9) & 7) = adr;
13337         PRE_IO
13338         WRITE_WORD_F(adr, res)
13339         POST_IO
13340 RET(12)
13341 }
13342
13343 // MOVEW
13344 OPCODE(0x317C)
13345 {
13346         u32 adr, res;
13347         u32 src, dst;
13348
13349         FETCH_WORD(res);
13350         flag_C = 0;
13351         flag_V = 0;
13352         flag_NotZ = res;
13353         flag_N = res >> 8;
13354         FETCH_SWORD(adr);
13355         adr += AREG((Opcode >> 9) & 7);
13356         PRE_IO
13357         WRITE_WORD_F(adr, res)
13358         POST_IO
13359 RET(16)
13360 }
13361
13362 // MOVEW
13363 OPCODE(0x31BC)
13364 {
13365         u32 adr, res;
13366         u32 src, dst;
13367
13368         FETCH_WORD(res);
13369         flag_C = 0;
13370         flag_V = 0;
13371         flag_NotZ = res;
13372         flag_N = res >> 8;
13373         adr = AREG((Opcode >> 9) & 7);
13374         DECODE_EXT_WORD
13375         PRE_IO
13376         WRITE_WORD_F(adr, res)
13377         POST_IO
13378 RET(18)
13379 }
13380
13381 // MOVEW
13382 OPCODE(0x31FC)
13383 {
13384         u32 adr, res;
13385         u32 src, dst;
13386
13387         FETCH_WORD(res);
13388         flag_C = 0;
13389         flag_V = 0;
13390         flag_NotZ = res;
13391         flag_N = res >> 8;
13392         FETCH_SWORD(adr);
13393         PRE_IO
13394         WRITE_WORD_F(adr, res)
13395         POST_IO
13396 RET(16)
13397 }
13398
13399 // MOVEW
13400 OPCODE(0x33FC)
13401 {
13402         u32 adr, res;
13403         u32 src, dst;
13404
13405         FETCH_WORD(res);
13406         flag_C = 0;
13407         flag_V = 0;
13408         flag_NotZ = res;
13409         flag_N = res >> 8;
13410         FETCH_LONG(adr);
13411         PRE_IO
13412         WRITE_WORD_F(adr, res)
13413         POST_IO
13414 RET(20)
13415 }
13416
13417 // MOVEW
13418 OPCODE(0x3EFC)
13419 {
13420         u32 adr, res;
13421         u32 src, dst;
13422
13423         FETCH_WORD(res);
13424         flag_C = 0;
13425         flag_V = 0;
13426         flag_NotZ = res;
13427         flag_N = res >> 8;
13428         adr = AREG(7);
13429         AREG(7) += 2;
13430         PRE_IO
13431         WRITE_WORD_F(adr, res)
13432         POST_IO
13433 RET(12)
13434 }
13435
13436 // MOVEW
13437 OPCODE(0x3F3C)
13438 {
13439         u32 adr, res;
13440         u32 src, dst;
13441
13442         FETCH_WORD(res);
13443         flag_C = 0;
13444         flag_V = 0;
13445         flag_NotZ = res;
13446         flag_N = res >> 8;
13447         adr = AREG(7) - 2;
13448         AREG(7) = adr;
13449         PRE_IO
13450         WRITE_WORD_F(adr, res)
13451         POST_IO
13452 RET(12)
13453 }
13454
13455 // MOVEW
13456 OPCODE(0x301F)
13457 {
13458         u32 adr, res;
13459         u32 src, dst;
13460
13461         adr = AREG(7);
13462         AREG(7) += 2;
13463         PRE_IO
13464         READ_WORD_F(adr, res)
13465         flag_C = 0;
13466         flag_V = 0;
13467         flag_NotZ = res;
13468         flag_N = res >> 8;
13469         DREGu16((Opcode >> 9) & 7) = res;
13470         POST_IO
13471 RET(8)
13472 }
13473
13474 // MOVEW
13475 OPCODE(0x309F)
13476 {
13477         u32 adr, res;
13478         u32 src, dst;
13479
13480         adr = AREG(7);
13481         AREG(7) += 2;
13482         PRE_IO
13483         READ_WORD_F(adr, res)
13484         flag_C = 0;
13485         flag_V = 0;
13486         flag_NotZ = res;
13487         flag_N = res >> 8;
13488         adr = AREG((Opcode >> 9) & 7);
13489         WRITE_WORD_F(adr, res)
13490         POST_IO
13491 RET(12)
13492 }
13493
13494 // MOVEW
13495 OPCODE(0x30DF)
13496 {
13497         u32 adr, res;
13498         u32 src, dst;
13499
13500         adr = AREG(7);
13501         AREG(7) += 2;
13502         PRE_IO
13503         READ_WORD_F(adr, res)
13504         flag_C = 0;
13505         flag_V = 0;
13506         flag_NotZ = res;
13507         flag_N = res >> 8;
13508         adr = AREG((Opcode >> 9) & 7);
13509         AREG((Opcode >> 9) & 7) += 2;
13510         WRITE_WORD_F(adr, res)
13511         POST_IO
13512 RET(12)
13513 }
13514
13515 // MOVEW
13516 OPCODE(0x311F)
13517 {
13518         u32 adr, res;
13519         u32 src, dst;
13520
13521         adr = AREG(7);
13522         AREG(7) += 2;
13523         PRE_IO
13524         READ_WORD_F(adr, res)
13525         flag_C = 0;
13526         flag_V = 0;
13527         flag_NotZ = res;
13528         flag_N = res >> 8;
13529         adr = AREG((Opcode >> 9) & 7) - 2;
13530         AREG((Opcode >> 9) & 7) = adr;
13531         WRITE_WORD_F(adr, res)
13532         POST_IO
13533 RET(12)
13534 }
13535
13536 // MOVEW
13537 OPCODE(0x315F)
13538 {
13539         u32 adr, res;
13540         u32 src, dst;
13541
13542         adr = AREG(7);
13543         AREG(7) += 2;
13544         PRE_IO
13545         READ_WORD_F(adr, res)
13546         flag_C = 0;
13547         flag_V = 0;
13548         flag_NotZ = res;
13549         flag_N = res >> 8;
13550         FETCH_SWORD(adr);
13551         adr += AREG((Opcode >> 9) & 7);
13552         WRITE_WORD_F(adr, res)
13553         POST_IO
13554 RET(16)
13555 }
13556
13557 // MOVEW
13558 OPCODE(0x319F)
13559 {
13560         u32 adr, res;
13561         u32 src, dst;
13562
13563         adr = AREG(7);
13564         AREG(7) += 2;
13565         PRE_IO
13566         READ_WORD_F(adr, res)
13567         flag_C = 0;
13568         flag_V = 0;
13569         flag_NotZ = res;
13570         flag_N = res >> 8;
13571         adr = AREG((Opcode >> 9) & 7);
13572         DECODE_EXT_WORD
13573         WRITE_WORD_F(adr, res)
13574         POST_IO
13575 RET(18)
13576 }
13577
13578 // MOVEW
13579 OPCODE(0x31DF)
13580 {
13581         u32 adr, res;
13582         u32 src, dst;
13583
13584         adr = AREG(7);
13585         AREG(7) += 2;
13586         PRE_IO
13587         READ_WORD_F(adr, res)
13588         flag_C = 0;
13589         flag_V = 0;
13590         flag_NotZ = res;
13591         flag_N = res >> 8;
13592         FETCH_SWORD(adr);
13593         WRITE_WORD_F(adr, res)
13594         POST_IO
13595 RET(16)
13596 }
13597
13598 // MOVEW
13599 OPCODE(0x33DF)
13600 {
13601         u32 adr, res;
13602         u32 src, dst;
13603
13604         adr = AREG(7);
13605         AREG(7) += 2;
13606         PRE_IO
13607         READ_WORD_F(adr, res)
13608         flag_C = 0;
13609         flag_V = 0;
13610         flag_NotZ = res;
13611         flag_N = res >> 8;
13612         FETCH_LONG(adr);
13613         WRITE_WORD_F(adr, res)
13614         POST_IO
13615 RET(20)
13616 }
13617
13618 // MOVEW
13619 OPCODE(0x3EDF)
13620 {
13621         u32 adr, res;
13622         u32 src, dst;
13623
13624         adr = AREG(7);
13625         AREG(7) += 2;
13626         PRE_IO
13627         READ_WORD_F(adr, res)
13628         flag_C = 0;
13629         flag_V = 0;
13630         flag_NotZ = res;
13631         flag_N = res >> 8;
13632         adr = AREG(7);
13633         AREG(7) += 2;
13634         WRITE_WORD_F(adr, res)
13635         POST_IO
13636 RET(12)
13637 }
13638
13639 // MOVEW
13640 OPCODE(0x3F1F)
13641 {
13642         u32 adr, res;
13643         u32 src, dst;
13644
13645         adr = AREG(7);
13646         AREG(7) += 2;
13647         PRE_IO
13648         READ_WORD_F(adr, res)
13649         flag_C = 0;
13650         flag_V = 0;
13651         flag_NotZ = res;
13652         flag_N = res >> 8;
13653         adr = AREG(7) - 2;
13654         AREG(7) = adr;
13655         WRITE_WORD_F(adr, res)
13656         POST_IO
13657 RET(12)
13658 }
13659
13660 // MOVEW
13661 OPCODE(0x3027)
13662 {
13663         u32 adr, res;
13664         u32 src, dst;
13665
13666         adr = AREG(7) - 2;
13667         AREG(7) = adr;
13668         PRE_IO
13669         READ_WORD_F(adr, res)
13670         flag_C = 0;
13671         flag_V = 0;
13672         flag_NotZ = res;
13673         flag_N = res >> 8;
13674         DREGu16((Opcode >> 9) & 7) = res;
13675         POST_IO
13676 RET(10)
13677 }
13678
13679 // MOVEW
13680 OPCODE(0x30A7)
13681 {
13682         u32 adr, res;
13683         u32 src, dst;
13684
13685         adr = AREG(7) - 2;
13686         AREG(7) = adr;
13687         PRE_IO
13688         READ_WORD_F(adr, res)
13689         flag_C = 0;
13690         flag_V = 0;
13691         flag_NotZ = res;
13692         flag_N = res >> 8;
13693         adr = AREG((Opcode >> 9) & 7);
13694         WRITE_WORD_F(adr, res)
13695         POST_IO
13696 RET(14)
13697 }
13698
13699 // MOVEW
13700 OPCODE(0x30E7)
13701 {
13702         u32 adr, res;
13703         u32 src, dst;
13704
13705         adr = AREG(7) - 2;
13706         AREG(7) = adr;
13707         PRE_IO
13708         READ_WORD_F(adr, res)
13709         flag_C = 0;
13710         flag_V = 0;
13711         flag_NotZ = res;
13712         flag_N = res >> 8;
13713         adr = AREG((Opcode >> 9) & 7);
13714         AREG((Opcode >> 9) & 7) += 2;
13715         WRITE_WORD_F(adr, res)
13716         POST_IO
13717 RET(14)
13718 }
13719
13720 // MOVEW
13721 OPCODE(0x3127)
13722 {
13723         u32 adr, res;
13724         u32 src, dst;
13725
13726         adr = AREG(7) - 2;
13727         AREG(7) = adr;
13728         PRE_IO
13729         READ_WORD_F(adr, res)
13730         flag_C = 0;
13731         flag_V = 0;
13732         flag_NotZ = res;
13733         flag_N = res >> 8;
13734         adr = AREG((Opcode >> 9) & 7) - 2;
13735         AREG((Opcode >> 9) & 7) = adr;
13736         WRITE_WORD_F(adr, res)
13737         POST_IO
13738 RET(14)
13739 }
13740
13741 // MOVEW
13742 OPCODE(0x3167)
13743 {
13744         u32 adr, res;
13745         u32 src, dst;
13746
13747         adr = AREG(7) - 2;
13748         AREG(7) = adr;
13749         PRE_IO
13750         READ_WORD_F(adr, res)
13751         flag_C = 0;
13752         flag_V = 0;
13753         flag_NotZ = res;
13754         flag_N = res >> 8;
13755         FETCH_SWORD(adr);
13756         adr += AREG((Opcode >> 9) & 7);
13757         WRITE_WORD_F(adr, res)
13758         POST_IO
13759 RET(18)
13760 }
13761
13762 // MOVEW
13763 OPCODE(0x31A7)
13764 {
13765         u32 adr, res;
13766         u32 src, dst;
13767
13768         adr = AREG(7) - 2;
13769         AREG(7) = adr;
13770         PRE_IO
13771         READ_WORD_F(adr, res)
13772         flag_C = 0;
13773         flag_V = 0;
13774         flag_NotZ = res;
13775         flag_N = res >> 8;
13776         adr = AREG((Opcode >> 9) & 7);
13777         DECODE_EXT_WORD
13778         WRITE_WORD_F(adr, res)
13779         POST_IO
13780 RET(20)
13781 }
13782
13783 // MOVEW
13784 OPCODE(0x31E7)
13785 {
13786         u32 adr, res;
13787         u32 src, dst;
13788
13789         adr = AREG(7) - 2;
13790         AREG(7) = adr;
13791         PRE_IO
13792         READ_WORD_F(adr, res)
13793         flag_C = 0;
13794         flag_V = 0;
13795         flag_NotZ = res;
13796         flag_N = res >> 8;
13797         FETCH_SWORD(adr);
13798         WRITE_WORD_F(adr, res)
13799         POST_IO
13800 RET(18)
13801 }
13802
13803 // MOVEW
13804 OPCODE(0x33E7)
13805 {
13806         u32 adr, res;
13807         u32 src, dst;
13808
13809         adr = AREG(7) - 2;
13810         AREG(7) = adr;
13811         PRE_IO
13812         READ_WORD_F(adr, res)
13813         flag_C = 0;
13814         flag_V = 0;
13815         flag_NotZ = res;
13816         flag_N = res >> 8;
13817         FETCH_LONG(adr);
13818         WRITE_WORD_F(adr, res)
13819         POST_IO
13820 RET(22)
13821 }
13822
13823 // MOVEW
13824 OPCODE(0x3EE7)
13825 {
13826         u32 adr, res;
13827         u32 src, dst;
13828
13829         adr = AREG(7) - 2;
13830         AREG(7) = adr;
13831         PRE_IO
13832         READ_WORD_F(adr, res)
13833         flag_C = 0;
13834         flag_V = 0;
13835         flag_NotZ = res;
13836         flag_N = res >> 8;
13837         adr = AREG(7);
13838         AREG(7) += 2;
13839         WRITE_WORD_F(adr, res)
13840         POST_IO
13841 RET(14)
13842 }
13843
13844 // MOVEW
13845 OPCODE(0x3F27)
13846 {
13847         u32 adr, res;
13848         u32 src, dst;
13849
13850         adr = AREG(7) - 2;
13851         AREG(7) = adr;
13852         PRE_IO
13853         READ_WORD_F(adr, res)
13854         flag_C = 0;
13855         flag_V = 0;
13856         flag_NotZ = res;
13857         flag_N = res >> 8;
13858         adr = AREG(7) - 2;
13859         AREG(7) = adr;
13860         WRITE_WORD_F(adr, res)
13861         POST_IO
13862 RET(14)
13863 }
13864
13865 // MOVEAW
13866 OPCODE(0x3040)
13867 {
13868         u32 adr, res;
13869         u32 src, dst;
13870
13871         res = (s32)DREGs16((Opcode >> 0) & 7);
13872         AREG((Opcode >> 9) & 7) = res;
13873 RET(4)
13874 }
13875
13876 // MOVEAW
13877 OPCODE(0x3048)
13878 {
13879         u32 adr, res;
13880         u32 src, dst;
13881
13882         res = (s32)AREGs16((Opcode >> 0) & 7);
13883         AREG((Opcode >> 9) & 7) = res;
13884 RET(4)
13885 }
13886
13887 // MOVEAW
13888 OPCODE(0x3050)
13889 {
13890         u32 adr, res;
13891         u32 src, dst;
13892
13893         adr = AREG((Opcode >> 0) & 7);
13894         PRE_IO
13895         READSX_WORD_F(adr, res)
13896         AREG((Opcode >> 9) & 7) = res;
13897         POST_IO
13898 RET(8)
13899 }
13900
13901 // MOVEAW
13902 OPCODE(0x3058)
13903 {
13904         u32 adr, res;
13905         u32 src, dst;
13906
13907         adr = AREG((Opcode >> 0) & 7);
13908         AREG((Opcode >> 0) & 7) += 2;
13909         PRE_IO
13910         READSX_WORD_F(adr, res)
13911         AREG((Opcode >> 9) & 7) = res;
13912         POST_IO
13913 RET(8)
13914 }
13915
13916 // MOVEAW
13917 OPCODE(0x3060)
13918 {
13919         u32 adr, res;
13920         u32 src, dst;
13921
13922         adr = AREG((Opcode >> 0) & 7) - 2;
13923         AREG((Opcode >> 0) & 7) = adr;
13924         PRE_IO
13925         READSX_WORD_F(adr, res)
13926         AREG((Opcode >> 9) & 7) = res;
13927         POST_IO
13928 RET(10)
13929 }
13930
13931 // MOVEAW
13932 OPCODE(0x3068)
13933 {
13934         u32 adr, res;
13935         u32 src, dst;
13936
13937         FETCH_SWORD(adr);
13938         adr += AREG((Opcode >> 0) & 7);
13939         PRE_IO
13940         READSX_WORD_F(adr, res)
13941         AREG((Opcode >> 9) & 7) = res;
13942         POST_IO
13943 RET(12)
13944 }
13945
13946 // MOVEAW
13947 OPCODE(0x3070)
13948 {
13949         u32 adr, res;
13950         u32 src, dst;
13951
13952         adr = AREG((Opcode >> 0) & 7);
13953         DECODE_EXT_WORD
13954         PRE_IO
13955         READSX_WORD_F(adr, res)
13956         AREG((Opcode >> 9) & 7) = res;
13957         POST_IO
13958 RET(14)
13959 }
13960
13961 // MOVEAW
13962 OPCODE(0x3078)
13963 {
13964         u32 adr, res;
13965         u32 src, dst;
13966
13967         FETCH_SWORD(adr);
13968         PRE_IO
13969         READSX_WORD_F(adr, res)
13970         AREG((Opcode >> 9) & 7) = res;
13971         POST_IO
13972 RET(12)
13973 }
13974
13975 // MOVEAW
13976 OPCODE(0x3079)
13977 {
13978         u32 adr, res;
13979         u32 src, dst;
13980
13981         FETCH_LONG(adr);
13982         PRE_IO
13983         READSX_WORD_F(adr, res)
13984         AREG((Opcode >> 9) & 7) = res;
13985         POST_IO
13986 RET(16)
13987 }
13988
13989 // MOVEAW
13990 OPCODE(0x307A)
13991 {
13992         u32 adr, res;
13993         u32 src, dst;
13994
13995         adr = GET_SWORD + GET_PC;
13996         PC++;
13997         PRE_IO
13998         READSX_WORD_F(adr, res)
13999         AREG((Opcode >> 9) & 7) = res;
14000         POST_IO
14001 RET(12)
14002 }
14003
14004 // MOVEAW
14005 OPCODE(0x307B)
14006 {
14007         u32 adr, res;
14008         u32 src, dst;
14009
14010         adr = GET_PC;
14011         DECODE_EXT_WORD
14012         PRE_IO
14013         READSX_WORD_F(adr, res)
14014         AREG((Opcode >> 9) & 7) = res;
14015         POST_IO
14016 RET(14)
14017 }
14018
14019 // MOVEAW
14020 OPCODE(0x307C)
14021 {
14022         u32 adr, res;
14023         u32 src, dst;
14024
14025         FETCH_SWORD(res);
14026         AREG((Opcode >> 9) & 7) = res;
14027 RET(8)
14028 }
14029
14030 // MOVEAW
14031 OPCODE(0x305F)
14032 {
14033         u32 adr, res;
14034         u32 src, dst;
14035
14036         adr = AREG(7);
14037         AREG(7) += 2;
14038         PRE_IO
14039         READSX_WORD_F(adr, res)
14040         AREG((Opcode >> 9) & 7) = res;
14041         POST_IO
14042 RET(8)
14043 }
14044
14045 // MOVEAW
14046 OPCODE(0x3067)
14047 {
14048         u32 adr, res;
14049         u32 src, dst;
14050
14051         adr = AREG(7) - 2;
14052         AREG(7) = adr;
14053         PRE_IO
14054         READSX_WORD_F(adr, res)
14055         AREG((Opcode >> 9) & 7) = res;
14056         POST_IO
14057 RET(10)
14058 }
14059
14060 // NEGX
14061 OPCODE(0x4000)
14062 {
14063         u32 adr, res;
14064         u32 src, dst;
14065
14066         src = DREGu8((Opcode >> 0) & 7);
14067         res = -src - ((flag_X >> 8) & 1);
14068         flag_V = res & src;
14069         flag_N = flag_X = flag_C = res;
14070         flag_NotZ |= res & 0xFF;
14071         DREGu8((Opcode >> 0) & 7) = res;
14072 RET(4)
14073 }
14074
14075 // NEGX
14076 OPCODE(0x4010)
14077 {
14078         u32 adr, res;
14079         u32 src, dst;
14080
14081         adr = AREG((Opcode >> 0) & 7);
14082         PRE_IO
14083         READ_BYTE_F(adr, src)
14084         res = -src - ((flag_X >> 8) & 1);
14085         flag_V = res & src;
14086         flag_N = flag_X = flag_C = res;
14087         flag_NotZ |= res & 0xFF;
14088         WRITE_BYTE_F(adr, res)
14089         POST_IO
14090 RET(12)
14091 }
14092
14093 // NEGX
14094 OPCODE(0x4018)
14095 {
14096         u32 adr, res;
14097         u32 src, dst;
14098
14099         adr = AREG((Opcode >> 0) & 7);
14100         AREG((Opcode >> 0) & 7) += 1;
14101         PRE_IO
14102         READ_BYTE_F(adr, src)
14103         res = -src - ((flag_X >> 8) & 1);
14104         flag_V = res & src;
14105         flag_N = flag_X = flag_C = res;
14106         flag_NotZ |= res & 0xFF;
14107         WRITE_BYTE_F(adr, res)
14108         POST_IO
14109 RET(12)
14110 }
14111
14112 // NEGX
14113 OPCODE(0x4020)
14114 {
14115         u32 adr, res;
14116         u32 src, dst;
14117
14118         adr = AREG((Opcode >> 0) & 7) - 1;
14119         AREG((Opcode >> 0) & 7) = adr;
14120         PRE_IO
14121         READ_BYTE_F(adr, src)
14122         res = -src - ((flag_X >> 8) & 1);
14123         flag_V = res & src;
14124         flag_N = flag_X = flag_C = res;
14125         flag_NotZ |= res & 0xFF;
14126         WRITE_BYTE_F(adr, res)
14127         POST_IO
14128 RET(14)
14129 }
14130
14131 // NEGX
14132 OPCODE(0x4028)
14133 {
14134         u32 adr, res;
14135         u32 src, dst;
14136
14137         FETCH_SWORD(adr);
14138         adr += AREG((Opcode >> 0) & 7);
14139         PRE_IO
14140         READ_BYTE_F(adr, src)
14141         res = -src - ((flag_X >> 8) & 1);
14142         flag_V = res & src;
14143         flag_N = flag_X = flag_C = res;
14144         flag_NotZ |= res & 0xFF;
14145         WRITE_BYTE_F(adr, res)
14146         POST_IO
14147 RET(16)
14148 }
14149
14150 // NEGX
14151 OPCODE(0x4030)
14152 {
14153         u32 adr, res;
14154         u32 src, dst;
14155
14156         adr = AREG((Opcode >> 0) & 7);
14157         DECODE_EXT_WORD
14158         PRE_IO
14159         READ_BYTE_F(adr, src)
14160         res = -src - ((flag_X >> 8) & 1);
14161         flag_V = res & src;
14162         flag_N = flag_X = flag_C = res;
14163         flag_NotZ |= res & 0xFF;
14164         WRITE_BYTE_F(adr, res)
14165         POST_IO
14166 RET(18)
14167 }
14168
14169 // NEGX
14170 OPCODE(0x4038)
14171 {
14172         u32 adr, res;
14173         u32 src, dst;
14174
14175         FETCH_SWORD(adr);
14176         PRE_IO
14177         READ_BYTE_F(adr, src)
14178         res = -src - ((flag_X >> 8) & 1);
14179         flag_V = res & src;
14180         flag_N = flag_X = flag_C = res;
14181         flag_NotZ |= res & 0xFF;
14182         WRITE_BYTE_F(adr, res)
14183         POST_IO
14184 RET(16)
14185 }
14186
14187 // NEGX
14188 OPCODE(0x4039)
14189 {
14190         u32 adr, res;
14191         u32 src, dst;
14192
14193         FETCH_LONG(adr);
14194         PRE_IO
14195         READ_BYTE_F(adr, src)
14196         res = -src - ((flag_X >> 8) & 1);
14197         flag_V = res & src;
14198         flag_N = flag_X = flag_C = res;
14199         flag_NotZ |= res & 0xFF;
14200         WRITE_BYTE_F(adr, res)
14201         POST_IO
14202 RET(20)
14203 }
14204
14205 // NEGX
14206 OPCODE(0x401F)
14207 {
14208         u32 adr, res;
14209         u32 src, dst;
14210
14211         adr = AREG(7);
14212         AREG(7) += 2;
14213         PRE_IO
14214         READ_BYTE_F(adr, src)
14215         res = -src - ((flag_X >> 8) & 1);
14216         flag_V = res & src;
14217         flag_N = flag_X = flag_C = res;
14218         flag_NotZ |= res & 0xFF;
14219         WRITE_BYTE_F(adr, res)
14220         POST_IO
14221 RET(12)
14222 }
14223
14224 // NEGX
14225 OPCODE(0x4027)
14226 {
14227         u32 adr, res;
14228         u32 src, dst;
14229
14230         adr = AREG(7) - 2;
14231         AREG(7) = adr;
14232         PRE_IO
14233         READ_BYTE_F(adr, src)
14234         res = -src - ((flag_X >> 8) & 1);
14235         flag_V = res & src;
14236         flag_N = flag_X = flag_C = res;
14237         flag_NotZ |= res & 0xFF;
14238         WRITE_BYTE_F(adr, res)
14239         POST_IO
14240 RET(14)
14241 }
14242
14243 // NEGX
14244 OPCODE(0x4040)
14245 {
14246         u32 adr, res;
14247         u32 src, dst;
14248
14249         src = DREGu16((Opcode >> 0) & 7);
14250         res = -src - ((flag_X >> 8) & 1);
14251         flag_V = (res & src) >> 8;
14252         flag_N = flag_X = flag_C = res >> 8;
14253         flag_NotZ |= res & 0xFFFF;
14254         DREGu16((Opcode >> 0) & 7) = res;
14255 RET(4)
14256 }
14257
14258 // NEGX
14259 OPCODE(0x4050)
14260 {
14261         u32 adr, res;
14262         u32 src, dst;
14263
14264         adr = AREG((Opcode >> 0) & 7);
14265         PRE_IO
14266         READ_WORD_F(adr, src)
14267         res = -src - ((flag_X >> 8) & 1);
14268         flag_V = (res & src) >> 8;
14269         flag_N = flag_X = flag_C = res >> 8;
14270         flag_NotZ |= res & 0xFFFF;
14271         WRITE_WORD_F(adr, res)
14272         POST_IO
14273 RET(12)
14274 }
14275
14276 // NEGX
14277 OPCODE(0x4058)
14278 {
14279         u32 adr, res;
14280         u32 src, dst;
14281
14282         adr = AREG((Opcode >> 0) & 7);
14283         AREG((Opcode >> 0) & 7) += 2;
14284         PRE_IO
14285         READ_WORD_F(adr, src)
14286         res = -src - ((flag_X >> 8) & 1);
14287         flag_V = (res & src) >> 8;
14288         flag_N = flag_X = flag_C = res >> 8;
14289         flag_NotZ |= res & 0xFFFF;
14290         WRITE_WORD_F(adr, res)
14291         POST_IO
14292 RET(12)
14293 }
14294
14295 // NEGX
14296 OPCODE(0x4060)
14297 {
14298         u32 adr, res;
14299         u32 src, dst;
14300
14301         adr = AREG((Opcode >> 0) & 7) - 2;
14302         AREG((Opcode >> 0) & 7) = adr;
14303         PRE_IO
14304         READ_WORD_F(adr, src)
14305         res = -src - ((flag_X >> 8) & 1);
14306         flag_V = (res & src) >> 8;
14307         flag_N = flag_X = flag_C = res >> 8;
14308         flag_NotZ |= res & 0xFFFF;
14309         WRITE_WORD_F(adr, res)
14310         POST_IO
14311 RET(14)
14312 }
14313
14314 // NEGX
14315 OPCODE(0x4068)
14316 {
14317         u32 adr, res;
14318         u32 src, dst;
14319
14320         FETCH_SWORD(adr);
14321         adr += AREG((Opcode >> 0) & 7);
14322         PRE_IO
14323         READ_WORD_F(adr, src)
14324         res = -src - ((flag_X >> 8) & 1);
14325         flag_V = (res & src) >> 8;
14326         flag_N = flag_X = flag_C = res >> 8;
14327         flag_NotZ |= res & 0xFFFF;
14328         WRITE_WORD_F(adr, res)
14329         POST_IO
14330 RET(16)
14331 }
14332
14333 // NEGX
14334 OPCODE(0x4070)
14335 {
14336         u32 adr, res;
14337         u32 src, dst;
14338
14339         adr = AREG((Opcode >> 0) & 7);
14340         DECODE_EXT_WORD
14341         PRE_IO
14342         READ_WORD_F(adr, src)
14343         res = -src - ((flag_X >> 8) & 1);
14344         flag_V = (res & src) >> 8;
14345         flag_N = flag_X = flag_C = res >> 8;
14346         flag_NotZ |= res & 0xFFFF;
14347         WRITE_WORD_F(adr, res)
14348         POST_IO
14349 RET(18)
14350 }
14351
14352 // NEGX
14353 OPCODE(0x4078)
14354 {
14355         u32 adr, res;
14356         u32 src, dst;
14357
14358         FETCH_SWORD(adr);
14359         PRE_IO
14360         READ_WORD_F(adr, src)
14361         res = -src - ((flag_X >> 8) & 1);
14362         flag_V = (res & src) >> 8;
14363         flag_N = flag_X = flag_C = res >> 8;
14364         flag_NotZ |= res & 0xFFFF;
14365         WRITE_WORD_F(adr, res)
14366         POST_IO
14367 RET(16)
14368 }
14369
14370 // NEGX
14371 OPCODE(0x4079)
14372 {
14373         u32 adr, res;
14374         u32 src, dst;
14375
14376         FETCH_LONG(adr);
14377         PRE_IO
14378         READ_WORD_F(adr, src)
14379         res = -src - ((flag_X >> 8) & 1);
14380         flag_V = (res & src) >> 8;
14381         flag_N = flag_X = flag_C = res >> 8;
14382         flag_NotZ |= res & 0xFFFF;
14383         WRITE_WORD_F(adr, res)
14384         POST_IO
14385 RET(20)
14386 }
14387
14388 // NEGX
14389 OPCODE(0x405F)
14390 {
14391         u32 adr, res;
14392         u32 src, dst;
14393
14394         adr = AREG(7);
14395         AREG(7) += 2;
14396         PRE_IO
14397         READ_WORD_F(adr, src)
14398         res = -src - ((flag_X >> 8) & 1);
14399         flag_V = (res & src) >> 8;
14400         flag_N = flag_X = flag_C = res >> 8;
14401         flag_NotZ |= res & 0xFFFF;
14402         WRITE_WORD_F(adr, res)
14403         POST_IO
14404 RET(12)
14405 }
14406
14407 // NEGX
14408 OPCODE(0x4067)
14409 {
14410         u32 adr, res;
14411         u32 src, dst;
14412
14413         adr = AREG(7) - 2;
14414         AREG(7) = adr;
14415         PRE_IO
14416         READ_WORD_F(adr, src)
14417         res = -src - ((flag_X >> 8) & 1);
14418         flag_V = (res & src) >> 8;
14419         flag_N = flag_X = flag_C = res >> 8;
14420         flag_NotZ |= res & 0xFFFF;
14421         WRITE_WORD_F(adr, res)
14422         POST_IO
14423 RET(14)
14424 }
14425
14426 // NEGX
14427 OPCODE(0x4080)
14428 {
14429         u32 adr, res;
14430         u32 src, dst;
14431
14432         src = DREGu32((Opcode >> 0) & 7);
14433         res = -src - ((flag_X >> 8) & 1);
14434         flag_NotZ |= res;
14435         flag_V = (res & src) >> 24;
14436 flag_X = flag_C = (res?1:0)<<8;
14437 //      flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14438         flag_N = res >> 24;
14439         DREGu32((Opcode >> 0) & 7) = res;
14440 RET(6)
14441 }
14442
14443 // NEGX
14444 OPCODE(0x4090)
14445 {
14446         u32 adr, res;
14447         u32 src, dst;
14448
14449         adr = AREG((Opcode >> 0) & 7);
14450         PRE_IO
14451         READ_LONG_F(adr, src)
14452         res = -src - ((flag_X >> 8) & 1);
14453         flag_NotZ |= res;
14454         flag_V = (res & src) >> 24;
14455 flag_X = flag_C = (res?1:0)<<8;
14456 //      flag_X = flag_C = ((src & res & 1) | (src >> 1) | (res >> 1)) >> 23;
14457         flag_N = res >> 24;
14458         WRITE_LONG_F(adr, res)
14459         POST_IO
14460 RET(20)
14461 }
14462
14463 // NEGX
14464 OPCODE(0x4098)
14465 {
14466         u32 adr, res;
14467         u32 src, dst;
14468
14469         adr = AREG((Opcode >> 0) & 7);
14470         AREG((Opcode >> 0) & 7) += 4;
14471         PRE_IO
14472         READ_LONG_F(adr, src)
14473         res = -src - ((flag_X >> 8) & 1);
14474         flag_NotZ |= res;
14475         flag_V = (res & src) >> 24;
14476 flag_X = flag_C = (res?1:0)<<8;
14477 //      flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14478         flag_N = res >> 24;
14479         WRITE_LONG_F(adr, res)
14480         POST_IO
14481 RET(20)
14482 }
14483
14484 // NEGX
14485 OPCODE(0x40A0)
14486 {
14487         u32 adr, res;
14488         u32 src, dst;
14489
14490         adr = AREG((Opcode >> 0) & 7) - 4;
14491         AREG((Opcode >> 0) & 7) = adr;
14492         PRE_IO
14493         READ_LONG_F(adr, src)
14494         res = -src - ((flag_X >> 8) & 1);
14495         flag_NotZ |= res;
14496         flag_V = (res & src) >> 24;
14497 flag_X = flag_C = (res?1:0)<<8;
14498 //      flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14499         flag_N = res >> 24;
14500         WRITE_LONG_F(adr, res)
14501         POST_IO
14502 RET(22)
14503 }
14504
14505 // NEGX
14506 OPCODE(0x40A8)
14507 {
14508         u32 adr, res;
14509         u32 src, dst;
14510
14511         FETCH_SWORD(adr);
14512         adr += AREG((Opcode >> 0) & 7);
14513         PRE_IO
14514         READ_LONG_F(adr, src)
14515         res = -src - ((flag_X >> 8) & 1);
14516         flag_NotZ |= res;
14517         flag_V = (res & src) >> 24;
14518 flag_X = flag_C = (res?1:0)<<8;
14519 //      flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14520         flag_N = res >> 24;
14521         WRITE_LONG_F(adr, res)
14522         POST_IO
14523 RET(24)
14524 }
14525
14526 // NEGX
14527 OPCODE(0x40B0)
14528 {
14529         u32 adr, res;
14530         u32 src, dst;
14531
14532         adr = AREG((Opcode >> 0) & 7);
14533         DECODE_EXT_WORD
14534         PRE_IO
14535         READ_LONG_F(adr, src)
14536         res = -src - ((flag_X >> 8) & 1);
14537         flag_NotZ |= res;
14538         flag_V = (res & src) >> 24;
14539 flag_X = flag_C = (res?1:0)<<8;
14540 //      flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14541         flag_N = res >> 24;
14542         WRITE_LONG_F(adr, res)
14543         POST_IO
14544 RET(26)
14545 }
14546
14547 // NEGX
14548 OPCODE(0x40B8)
14549 {
14550         u32 adr, res;
14551         u32 src, dst;
14552
14553         FETCH_SWORD(adr);
14554         PRE_IO
14555         READ_LONG_F(adr, src)
14556         res = -src - ((flag_X >> 8) & 1);
14557         flag_NotZ |= res;
14558         flag_V = (res & src) >> 24;
14559 flag_X = flag_C = (res?1:0)<<8;
14560 //      flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14561         flag_N = res >> 24;
14562         WRITE_LONG_F(adr, res)
14563         POST_IO
14564 RET(24)
14565 }
14566
14567 // NEGX
14568 OPCODE(0x40B9)
14569 {
14570         u32 adr, res;
14571         u32 src, dst;
14572
14573         FETCH_LONG(adr);
14574         PRE_IO
14575         READ_LONG_F(adr, src)
14576         res = -src - ((flag_X >> 8) & 1);
14577         flag_NotZ |= res;
14578         flag_V = (res & src) >> 24;
14579 flag_X = flag_C = (res?1:0)<<8;
14580 //      flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14581         flag_N = res >> 24;
14582         WRITE_LONG_F(adr, res)
14583         POST_IO
14584 RET(28)
14585 }
14586
14587 // NEGX
14588 OPCODE(0x409F)
14589 {
14590         u32 adr, res;
14591         u32 src, dst;
14592
14593         adr = AREG(7);
14594         AREG(7) += 4;
14595         PRE_IO
14596         READ_LONG_F(adr, src)
14597         res = -src - ((flag_X >> 8) & 1);
14598         flag_NotZ |= res;
14599         flag_V = (res & src) >> 24;
14600 flag_X = flag_C = (res?1:0)<<8;
14601 //      flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14602         flag_N = res >> 24;
14603         WRITE_LONG_F(adr, res)
14604         POST_IO
14605 RET(20)
14606 }
14607
14608 // NEGX
14609 OPCODE(0x40A7)
14610 {
14611         u32 adr, res;
14612         u32 src, dst;
14613
14614         adr = AREG(7) - 4;
14615         AREG(7) = adr;
14616         PRE_IO
14617         READ_LONG_F(adr, src)
14618         res = -src - ((flag_X >> 8) & 1);
14619         flag_NotZ |= res;
14620         flag_V = (res & src) >> 24;
14621 flag_X = flag_C = (res?1:0)<<8;
14622 //      flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14623         flag_N = res >> 24;
14624         WRITE_LONG_F(adr, res)
14625         POST_IO
14626 RET(22)
14627 }
14628
14629 // CLR
14630 OPCODE(0x4200)
14631 {
14632         u32 adr, res;
14633         u32 src, dst;
14634
14635         res = 0;
14636         flag_N = flag_NotZ = flag_V = flag_C = 0;
14637         DREGu8((Opcode >> 0) & 7) = res;
14638 RET(4)
14639 }
14640
14641 // CLR
14642 OPCODE(0x4210)
14643 {
14644         u32 adr, res;
14645         u32 src, dst;
14646
14647         adr = AREG((Opcode >> 0) & 7);
14648         res = 0;
14649         flag_N = flag_NotZ = flag_V = flag_C = 0;
14650         PRE_IO
14651         WRITE_BYTE_F(adr, res)
14652         POST_IO
14653 RET(12)
14654 }
14655
14656 // CLR
14657 OPCODE(0x4218)
14658 {
14659         u32 adr, res;
14660         u32 src, dst;
14661
14662         adr = AREG((Opcode >> 0) & 7);
14663         AREG((Opcode >> 0) & 7) += 1;
14664         res = 0;
14665         flag_N = flag_NotZ = flag_V = flag_C = 0;
14666         PRE_IO
14667         WRITE_BYTE_F(adr, res)
14668         POST_IO
14669 RET(12)
14670 }
14671
14672 // CLR
14673 OPCODE(0x4220)
14674 {
14675         u32 adr, res;
14676         u32 src, dst;
14677
14678         adr = AREG((Opcode >> 0) & 7) - 1;
14679         AREG((Opcode >> 0) & 7) = adr;
14680         res = 0;
14681         flag_N = flag_NotZ = flag_V = flag_C = 0;
14682         PRE_IO
14683         WRITE_BYTE_F(adr, res)
14684         POST_IO
14685 RET(14)
14686 }
14687
14688 // CLR
14689 OPCODE(0x4228)
14690 {
14691         u32 adr, res;
14692         u32 src, dst;
14693
14694         FETCH_SWORD(adr);
14695         adr += AREG((Opcode >> 0) & 7);
14696         res = 0;
14697         flag_N = flag_NotZ = flag_V = flag_C = 0;
14698         PRE_IO
14699         WRITE_BYTE_F(adr, res)
14700         POST_IO
14701 RET(16)
14702 }
14703
14704 // CLR
14705 OPCODE(0x4230)
14706 {
14707         u32 adr, res;
14708         u32 src, dst;
14709
14710         adr = AREG((Opcode >> 0) & 7);
14711         DECODE_EXT_WORD
14712         res = 0;
14713         flag_N = flag_NotZ = flag_V = flag_C = 0;
14714         PRE_IO
14715         WRITE_BYTE_F(adr, res)
14716         POST_IO
14717 RET(18)
14718 }
14719
14720 // CLR
14721 OPCODE(0x4238)
14722 {
14723         u32 adr, res;
14724         u32 src, dst;
14725
14726         FETCH_SWORD(adr);
14727         res = 0;
14728         flag_N = flag_NotZ = flag_V = flag_C = 0;
14729         PRE_IO
14730         WRITE_BYTE_F(adr, res)
14731         POST_IO
14732 RET(16)
14733 }
14734
14735 // CLR
14736 OPCODE(0x4239)
14737 {
14738         u32 adr, res;
14739         u32 src, dst;
14740
14741         FETCH_LONG(adr);
14742         res = 0;
14743         flag_N = flag_NotZ = flag_V = flag_C = 0;
14744         PRE_IO
14745         WRITE_BYTE_F(adr, res)
14746         POST_IO
14747 RET(20)
14748 }
14749
14750 // CLR
14751 OPCODE(0x421F)
14752 {
14753         u32 adr, res;
14754         u32 src, dst;
14755
14756         adr = AREG(7);
14757         AREG(7) += 2;
14758         res = 0;
14759         flag_N = flag_NotZ = flag_V = flag_C = 0;
14760         PRE_IO
14761         WRITE_BYTE_F(adr, res)
14762         POST_IO
14763 RET(12)
14764 }
14765
14766 // CLR
14767 OPCODE(0x4227)
14768 {
14769         u32 adr, res;
14770         u32 src, dst;
14771
14772         adr = AREG(7) - 2;
14773         AREG(7) = adr;
14774         res = 0;
14775         flag_N = flag_NotZ = flag_V = flag_C = 0;
14776         PRE_IO
14777         WRITE_BYTE_F(adr, res)
14778         POST_IO
14779 RET(14)
14780 }
14781
14782 // CLR
14783 OPCODE(0x4240)
14784 {
14785         u32 adr, res;
14786         u32 src, dst;
14787
14788         res = 0;
14789         flag_N = flag_NotZ = flag_V = flag_C = 0;
14790         DREGu16((Opcode >> 0) & 7) = res;
14791 RET(4)
14792 }
14793
14794 // CLR
14795 OPCODE(0x4250)
14796 {
14797         u32 adr, res;
14798         u32 src, dst;
14799
14800         adr = AREG((Opcode >> 0) & 7);
14801         res = 0;
14802         flag_N = flag_NotZ = flag_V = flag_C = 0;
14803         PRE_IO
14804         WRITE_WORD_F(adr, res)
14805         POST_IO
14806 RET(12)
14807 }
14808
14809 // CLR
14810 OPCODE(0x4258)
14811 {
14812         u32 adr, res;
14813         u32 src, dst;
14814
14815         adr = AREG((Opcode >> 0) & 7);
14816         AREG((Opcode >> 0) & 7) += 2;
14817         res = 0;
14818         flag_N = flag_NotZ = flag_V = flag_C = 0;
14819         PRE_IO
14820         WRITE_WORD_F(adr, res)
14821         POST_IO
14822 RET(12)
14823 }
14824
14825 // CLR
14826 OPCODE(0x4260)
14827 {
14828         u32 adr, res;
14829         u32 src, dst;
14830
14831         adr = AREG((Opcode >> 0) & 7) - 2;
14832         AREG((Opcode >> 0) & 7) = adr;
14833         res = 0;
14834         flag_N = flag_NotZ = flag_V = flag_C = 0;
14835         PRE_IO
14836         WRITE_WORD_F(adr, res)
14837         POST_IO
14838 RET(14)
14839 }
14840
14841 // CLR
14842 OPCODE(0x4268)
14843 {
14844         u32 adr, res;
14845         u32 src, dst;
14846
14847         FETCH_SWORD(adr);
14848         adr += AREG((Opcode >> 0) & 7);
14849         res = 0;
14850         flag_N = flag_NotZ = flag_V = flag_C = 0;
14851         PRE_IO
14852         WRITE_WORD_F(adr, res)
14853         POST_IO
14854 RET(16)
14855 }
14856
14857 // CLR
14858 OPCODE(0x4270)
14859 {
14860         u32 adr, res;
14861         u32 src, dst;
14862
14863         adr = AREG((Opcode >> 0) & 7);
14864         DECODE_EXT_WORD
14865         res = 0;
14866         flag_N = flag_NotZ = flag_V = flag_C = 0;
14867         PRE_IO
14868         WRITE_WORD_F(adr, res)
14869         POST_IO
14870 RET(18)
14871 }
14872
14873 // CLR
14874 OPCODE(0x4278)
14875 {
14876         u32 adr, res;
14877         u32 src, dst;
14878
14879         FETCH_SWORD(adr);
14880         res = 0;
14881         flag_N = flag_NotZ = flag_V = flag_C = 0;
14882         PRE_IO
14883         WRITE_WORD_F(adr, res)
14884         POST_IO
14885 RET(16)
14886 }
14887
14888 // CLR
14889 OPCODE(0x4279)
14890 {
14891         u32 adr, res;
14892         u32 src, dst;
14893
14894         FETCH_LONG(adr);
14895         res = 0;
14896         flag_N = flag_NotZ = flag_V = flag_C = 0;
14897         PRE_IO
14898         WRITE_WORD_F(adr, res)
14899         POST_IO
14900 RET(20)
14901 }
14902
14903 // CLR
14904 OPCODE(0x425F)
14905 {
14906         u32 adr, res;
14907         u32 src, dst;
14908
14909         adr = AREG(7);
14910         AREG(7) += 2;
14911         res = 0;
14912         flag_N = flag_NotZ = flag_V = flag_C = 0;
14913         PRE_IO
14914         WRITE_WORD_F(adr, res)
14915         POST_IO
14916 RET(12)
14917 }
14918
14919 // CLR
14920 OPCODE(0x4267)
14921 {
14922         u32 adr, res;
14923         u32 src, dst;
14924
14925         adr = AREG(7) - 2;
14926         AREG(7) = adr;
14927         res = 0;
14928         flag_N = flag_NotZ = flag_V = flag_C = 0;
14929         PRE_IO
14930         WRITE_WORD_F(adr, res)
14931         POST_IO
14932 RET(14)
14933 }
14934
14935 // CLR
14936 OPCODE(0x4280)
14937 {
14938         u32 adr, res;
14939         u32 src, dst;
14940
14941         res = 0;
14942         flag_N = flag_NotZ = flag_V = flag_C = 0;
14943         DREGu32((Opcode >> 0) & 7) = res;
14944 RET(6)
14945 }
14946
14947 // CLR
14948 OPCODE(0x4290)
14949 {
14950         u32 adr, res;
14951         u32 src, dst;
14952
14953         adr = AREG((Opcode >> 0) & 7);
14954         res = 0;
14955         flag_N = flag_NotZ = flag_V = flag_C = 0;
14956         PRE_IO
14957         WRITE_LONG_F(adr, res)
14958         POST_IO
14959 RET(20)
14960 }
14961
14962 // CLR
14963 OPCODE(0x4298)
14964 {
14965         u32 adr, res;
14966         u32 src, dst;
14967
14968         adr = AREG((Opcode >> 0) & 7);
14969         AREG((Opcode >> 0) & 7) += 4;
14970         res = 0;
14971         flag_N = flag_NotZ = flag_V = flag_C = 0;
14972         PRE_IO
14973         WRITE_LONG_F(adr, res)
14974         POST_IO
14975 RET(20)
14976 }
14977
14978 // CLR
14979 OPCODE(0x42A0)
14980 {
14981         u32 adr, res;
14982         u32 src, dst;
14983
14984         adr = AREG((Opcode >> 0) & 7) - 4;
14985         AREG((Opcode >> 0) & 7) = adr;
14986         res = 0;
14987         flag_N = flag_NotZ = flag_V = flag_C = 0;
14988         PRE_IO
14989         WRITE_LONG_F(adr, res)
14990         POST_IO
14991 RET(22)
14992 }
14993
14994 // CLR
14995 OPCODE(0x42A8)
14996 {
14997         u32 adr, res;
14998         u32 src, dst;
14999
15000         FETCH_SWORD(adr);
15001         adr += AREG((Opcode >> 0) & 7);
15002         res = 0;
15003         flag_N = flag_NotZ = flag_V = flag_C = 0;
15004         PRE_IO
15005         WRITE_LONG_F(adr, res)
15006         POST_IO
15007 RET(24)
15008 }
15009
15010 // CLR
15011 OPCODE(0x42B0)
15012 {
15013         u32 adr, res;
15014         u32 src, dst;
15015
15016         adr = AREG((Opcode >> 0) & 7);
15017         DECODE_EXT_WORD
15018         res = 0;
15019         flag_N = flag_NotZ = flag_V = flag_C = 0;
15020         PRE_IO
15021         WRITE_LONG_F(adr, res)
15022         POST_IO
15023 RET(26)
15024 }
15025
15026 // CLR
15027 OPCODE(0x42B8)
15028 {
15029         u32 adr, res;
15030         u32 src, dst;
15031
15032         FETCH_SWORD(adr);
15033         res = 0;
15034         flag_N = flag_NotZ = flag_V = flag_C = 0;
15035         PRE_IO
15036         WRITE_LONG_F(adr, res)
15037         POST_IO
15038 RET(24)
15039 }
15040
15041 // CLR
15042 OPCODE(0x42B9)
15043 {
15044         u32 adr, res;
15045         u32 src, dst;
15046
15047         FETCH_LONG(adr);
15048         res = 0;
15049         flag_N = flag_NotZ = flag_V = flag_C = 0;
15050         PRE_IO
15051         WRITE_LONG_F(adr, res)
15052         POST_IO
15053 RET(28)
15054 }
15055
15056 // CLR
15057 OPCODE(0x429F)
15058 {
15059         u32 adr, res;
15060         u32 src, dst;
15061
15062         adr = AREG(7);
15063         AREG(7) += 4;
15064         res = 0;
15065         flag_N = flag_NotZ = flag_V = flag_C = 0;
15066         PRE_IO
15067         WRITE_LONG_F(adr, res)
15068         POST_IO
15069 RET(20)
15070 }
15071
15072 // CLR
15073 OPCODE(0x42A7)
15074 {
15075         u32 adr, res;
15076         u32 src, dst;
15077
15078         adr = AREG(7) - 4;
15079         AREG(7) = adr;
15080         res = 0;
15081         flag_N = flag_NotZ = flag_V = flag_C = 0;
15082         PRE_IO
15083         WRITE_LONG_F(adr, res)
15084         POST_IO
15085 RET(22)
15086 }
15087
15088 // NEG
15089 OPCODE(0x4400)
15090 {
15091         u32 adr, res;
15092         u32 src, dst;
15093
15094         src = DREGu8((Opcode >> 0) & 7);
15095         res = -src;
15096         flag_V = res & src;
15097         flag_N = flag_X = flag_C = res;
15098         flag_NotZ = res & 0xFF;
15099         DREGu8((Opcode >> 0) & 7) = res;
15100 RET(4)
15101 }
15102
15103 // NEG
15104 OPCODE(0x4410)
15105 {
15106         u32 adr, res;
15107         u32 src, dst;
15108
15109         adr = AREG((Opcode >> 0) & 7);
15110         PRE_IO
15111         READ_BYTE_F(adr, src)
15112         res = -src;
15113         flag_V = res & src;
15114         flag_N = flag_X = flag_C = res;
15115         flag_NotZ = res & 0xFF;
15116         WRITE_BYTE_F(adr, res)
15117         POST_IO
15118 RET(12)
15119 }
15120
15121 // NEG
15122 OPCODE(0x4418)
15123 {
15124         u32 adr, res;
15125         u32 src, dst;
15126
15127         adr = AREG((Opcode >> 0) & 7);
15128         AREG((Opcode >> 0) & 7) += 1;
15129         PRE_IO
15130         READ_BYTE_F(adr, src)
15131         res = -src;
15132         flag_V = res & src;
15133         flag_N = flag_X = flag_C = res;
15134         flag_NotZ = res & 0xFF;
15135         WRITE_BYTE_F(adr, res)
15136         POST_IO
15137 RET(12)
15138 }
15139
15140 // NEG
15141 OPCODE(0x4420)
15142 {
15143         u32 adr, res;
15144         u32 src, dst;
15145
15146         adr = AREG((Opcode >> 0) & 7) - 1;
15147         AREG((Opcode >> 0) & 7) = adr;
15148         PRE_IO
15149         READ_BYTE_F(adr, src)
15150         res = -src;
15151         flag_V = res & src;
15152         flag_N = flag_X = flag_C = res;
15153         flag_NotZ = res & 0xFF;
15154         WRITE_BYTE_F(adr, res)
15155         POST_IO
15156 RET(14)
15157 }
15158
15159 // NEG
15160 OPCODE(0x4428)
15161 {
15162         u32 adr, res;
15163         u32 src, dst;
15164
15165         FETCH_SWORD(adr);
15166         adr += AREG((Opcode >> 0) & 7);
15167         PRE_IO
15168         READ_BYTE_F(adr, src)
15169         res = -src;
15170         flag_V = res & src;
15171         flag_N = flag_X = flag_C = res;
15172         flag_NotZ = res & 0xFF;
15173         WRITE_BYTE_F(adr, res)
15174         POST_IO
15175 RET(16)
15176 }
15177
15178 // NEG
15179 OPCODE(0x4430)
15180 {
15181         u32 adr, res;
15182         u32 src, dst;
15183
15184         adr = AREG((Opcode >> 0) & 7);
15185         DECODE_EXT_WORD
15186         PRE_IO
15187         READ_BYTE_F(adr, src)
15188         res = -src;
15189         flag_V = res & src;
15190         flag_N = flag_X = flag_C = res;
15191         flag_NotZ = res & 0xFF;
15192         WRITE_BYTE_F(adr, res)
15193         POST_IO
15194 RET(18)
15195 }
15196
15197 // NEG
15198 OPCODE(0x4438)
15199 {
15200         u32 adr, res;
15201         u32 src, dst;
15202
15203         FETCH_SWORD(adr);
15204         PRE_IO
15205         READ_BYTE_F(adr, src)
15206         res = -src;
15207         flag_V = res & src;
15208         flag_N = flag_X = flag_C = res;
15209         flag_NotZ = res & 0xFF;
15210         WRITE_BYTE_F(adr, res)
15211         POST_IO
15212 RET(16)
15213 }
15214
15215 // NEG
15216 OPCODE(0x4439)
15217 {
15218         u32 adr, res;
15219         u32 src, dst;
15220
15221         FETCH_LONG(adr);
15222         PRE_IO
15223         READ_BYTE_F(adr, src)
15224         res = -src;
15225         flag_V = res & src;
15226         flag_N = flag_X = flag_C = res;
15227         flag_NotZ = res & 0xFF;
15228         WRITE_BYTE_F(adr, res)
15229         POST_IO
15230 RET(20)
15231 }
15232
15233 // NEG
15234 OPCODE(0x441F)
15235 {
15236         u32 adr, res;
15237         u32 src, dst;
15238
15239         adr = AREG(7);
15240         AREG(7) += 2;
15241         PRE_IO
15242         READ_BYTE_F(adr, src)
15243         res = -src;
15244         flag_V = res & src;
15245         flag_N = flag_X = flag_C = res;
15246         flag_NotZ = res & 0xFF;
15247         WRITE_BYTE_F(adr, res)
15248         POST_IO
15249 RET(12)
15250 }
15251
15252 // NEG
15253 OPCODE(0x4427)
15254 {
15255         u32 adr, res;
15256         u32 src, dst;
15257
15258         adr = AREG(7) - 2;
15259         AREG(7) = adr;
15260         PRE_IO
15261         READ_BYTE_F(adr, src)
15262         res = -src;
15263         flag_V = res & src;
15264         flag_N = flag_X = flag_C = res;
15265         flag_NotZ = res & 0xFF;
15266         WRITE_BYTE_F(adr, res)
15267         POST_IO
15268 RET(14)
15269 }
15270
15271 // NEG
15272 OPCODE(0x4440)
15273 {
15274         u32 adr, res;
15275         u32 src, dst;
15276
15277         src = DREGu16((Opcode >> 0) & 7);
15278         res = -src;
15279         flag_V = (res & src) >> 8;
15280         flag_N = flag_X = flag_C = res >> 8;
15281         flag_NotZ = res & 0xFFFF;
15282         DREGu16((Opcode >> 0) & 7) = res;
15283 RET(4)
15284 }
15285
15286 // NEG
15287 OPCODE(0x4450)
15288 {
15289         u32 adr, res;
15290         u32 src, dst;
15291
15292         adr = AREG((Opcode >> 0) & 7);
15293         PRE_IO
15294         READ_WORD_F(adr, src)
15295         res = -src;
15296         flag_V = (res & src) >> 8;
15297         flag_N = flag_X = flag_C = res >> 8;
15298         flag_NotZ = res & 0xFFFF;
15299         WRITE_WORD_F(adr, res)
15300         POST_IO
15301 RET(12)
15302 }
15303
15304 // NEG
15305 OPCODE(0x4458)
15306 {
15307         u32 adr, res;
15308         u32 src, dst;
15309
15310         adr = AREG((Opcode >> 0) & 7);
15311         AREG((Opcode >> 0) & 7) += 2;
15312         PRE_IO
15313         READ_WORD_F(adr, src)
15314         res = -src;
15315         flag_V = (res & src) >> 8;
15316         flag_N = flag_X = flag_C = res >> 8;
15317         flag_NotZ = res & 0xFFFF;
15318         WRITE_WORD_F(adr, res)
15319         POST_IO
15320 RET(12)
15321 }
15322
15323 // NEG
15324 OPCODE(0x4460)
15325 {
15326         u32 adr, res;
15327         u32 src, dst;
15328
15329         adr = AREG((Opcode >> 0) & 7) - 2;
15330         AREG((Opcode >> 0) & 7) = adr;
15331         PRE_IO
15332         READ_WORD_F(adr, src)
15333         res = -src;
15334         flag_V = (res & src) >> 8;
15335         flag_N = flag_X = flag_C = res >> 8;
15336         flag_NotZ = res & 0xFFFF;
15337         WRITE_WORD_F(adr, res)
15338         POST_IO
15339 RET(14)
15340 }
15341
15342 // NEG
15343 OPCODE(0x4468)
15344 {
15345         u32 adr, res;
15346         u32 src, dst;
15347
15348         FETCH_SWORD(adr);
15349         adr += AREG((Opcode >> 0) & 7);
15350         PRE_IO
15351         READ_WORD_F(adr, src)
15352         res = -src;
15353         flag_V = (res & src) >> 8;
15354         flag_N = flag_X = flag_C = res >> 8;
15355         flag_NotZ = res & 0xFFFF;
15356         WRITE_WORD_F(adr, res)
15357         POST_IO
15358 RET(16)
15359 }
15360
15361 // NEG
15362 OPCODE(0x4470)
15363 {
15364         u32 adr, res;
15365         u32 src, dst;
15366
15367         adr = AREG((Opcode >> 0) & 7);
15368         DECODE_EXT_WORD
15369         PRE_IO
15370         READ_WORD_F(adr, src)
15371         res = -src;
15372         flag_V = (res & src) >> 8;
15373         flag_N = flag_X = flag_C = res >> 8;
15374         flag_NotZ = res & 0xFFFF;
15375         WRITE_WORD_F(adr, res)
15376         POST_IO
15377 RET(18)
15378 }
15379
15380 // NEG
15381 OPCODE(0x4478)
15382 {
15383         u32 adr, res;
15384         u32 src, dst;
15385
15386         FETCH_SWORD(adr);
15387         PRE_IO
15388         READ_WORD_F(adr, src)
15389         res = -src;
15390         flag_V = (res & src) >> 8;
15391         flag_N = flag_X = flag_C = res >> 8;
15392         flag_NotZ = res & 0xFFFF;
15393         WRITE_WORD_F(adr, res)
15394         POST_IO
15395 RET(16)
15396 }
15397
15398 // NEG
15399 OPCODE(0x4479)
15400 {
15401         u32 adr, res;
15402         u32 src, dst;
15403
15404         FETCH_LONG(adr);
15405         PRE_IO
15406         READ_WORD_F(adr, src)
15407         res = -src;
15408         flag_V = (res & src) >> 8;
15409         flag_N = flag_X = flag_C = res >> 8;
15410         flag_NotZ = res & 0xFFFF;
15411         WRITE_WORD_F(adr, res)
15412         POST_IO
15413 RET(20)
15414 }
15415
15416 // NEG
15417 OPCODE(0x445F)
15418 {
15419         u32 adr, res;
15420         u32 src, dst;
15421
15422         adr = AREG(7);
15423         AREG(7) += 2;
15424         PRE_IO
15425         READ_WORD_F(adr, src)
15426         res = -src;
15427         flag_V = (res & src) >> 8;
15428         flag_N = flag_X = flag_C = res >> 8;
15429         flag_NotZ = res & 0xFFFF;
15430         WRITE_WORD_F(adr, res)
15431         POST_IO
15432 RET(12)
15433 }
15434
15435 // NEG
15436 OPCODE(0x4467)
15437 {
15438         u32 adr, res;
15439         u32 src, dst;
15440
15441         adr = AREG(7) - 2;
15442         AREG(7) = adr;
15443         PRE_IO
15444         READ_WORD_F(adr, src)
15445         res = -src;
15446         flag_V = (res & src) >> 8;
15447         flag_N = flag_X = flag_C = res >> 8;
15448         flag_NotZ = res & 0xFFFF;
15449         WRITE_WORD_F(adr, res)
15450         POST_IO
15451 RET(14)
15452 }
15453
15454 // NEG
15455 OPCODE(0x4480)
15456 {
15457         u32 adr, res;
15458         u32 src, dst;
15459
15460         src = DREGu32((Opcode >> 0) & 7);
15461         res = -src;
15462         flag_NotZ = res;
15463         flag_V = (res & src) >> 24;
15464         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15465         flag_N = res >> 24;
15466         DREGu32((Opcode >> 0) & 7) = res;
15467 RET(6)
15468 }
15469
15470 // NEG
15471 OPCODE(0x4490)
15472 {
15473         u32 adr, res;
15474         u32 src, dst;
15475
15476         adr = AREG((Opcode >> 0) & 7);
15477         PRE_IO
15478         READ_LONG_F(adr, src)
15479         res = -src;
15480         flag_NotZ = res;
15481         flag_V = (res & src) >> 24;
15482         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15483         flag_N = res >> 24;
15484         WRITE_LONG_F(adr, res)
15485         POST_IO
15486 RET(20)
15487 }
15488
15489 // NEG
15490 OPCODE(0x4498)
15491 {
15492         u32 adr, res;
15493         u32 src, dst;
15494
15495         adr = AREG((Opcode >> 0) & 7);
15496         AREG((Opcode >> 0) & 7) += 4;
15497         PRE_IO
15498         READ_LONG_F(adr, src)
15499         res = -src;
15500         flag_NotZ = res;
15501         flag_V = (res & src) >> 24;
15502         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15503         flag_N = res >> 24;
15504         WRITE_LONG_F(adr, res)
15505         POST_IO
15506 RET(20)
15507 }
15508
15509 // NEG
15510 OPCODE(0x44A0)
15511 {
15512         u32 adr, res;
15513         u32 src, dst;
15514
15515         adr = AREG((Opcode >> 0) & 7) - 4;
15516         AREG((Opcode >> 0) & 7) = adr;
15517         PRE_IO
15518         READ_LONG_F(adr, src)
15519         res = -src;
15520         flag_NotZ = res;
15521         flag_V = (res & src) >> 24;
15522         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15523         flag_N = res >> 24;
15524         WRITE_LONG_F(adr, res)
15525         POST_IO
15526 RET(22)
15527 }
15528
15529 // NEG
15530 OPCODE(0x44A8)
15531 {
15532         u32 adr, res;
15533         u32 src, dst;
15534
15535         FETCH_SWORD(adr);
15536         adr += AREG((Opcode >> 0) & 7);
15537         PRE_IO
15538         READ_LONG_F(adr, src)
15539         res = -src;
15540         flag_NotZ = res;
15541         flag_V = (res & src) >> 24;
15542         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15543         flag_N = res >> 24;
15544         WRITE_LONG_F(adr, res)
15545         POST_IO
15546 RET(24)
15547 }
15548
15549 // NEG
15550 OPCODE(0x44B0)
15551 {
15552         u32 adr, res;
15553         u32 src, dst;
15554
15555         adr = AREG((Opcode >> 0) & 7);
15556         DECODE_EXT_WORD
15557         PRE_IO
15558         READ_LONG_F(adr, src)
15559         res = -src;
15560         flag_NotZ = res;
15561         flag_V = (res & src) >> 24;
15562         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15563         flag_N = res >> 24;
15564         WRITE_LONG_F(adr, res)
15565         POST_IO
15566 RET(26)
15567 }
15568
15569 // NEG
15570 OPCODE(0x44B8)
15571 {
15572         u32 adr, res;
15573         u32 src, dst;
15574
15575         FETCH_SWORD(adr);
15576         PRE_IO
15577         READ_LONG_F(adr, src)
15578         res = -src;
15579         flag_NotZ = res;
15580         flag_V = (res & src) >> 24;
15581         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15582         flag_N = res >> 24;
15583         WRITE_LONG_F(adr, res)
15584         POST_IO
15585 RET(24)
15586 }
15587
15588 // NEG
15589 OPCODE(0x44B9)
15590 {
15591         u32 adr, res;
15592         u32 src, dst;
15593
15594         FETCH_LONG(adr);
15595         PRE_IO
15596         READ_LONG_F(adr, src)
15597         res = -src;
15598         flag_NotZ = res;
15599         flag_V = (res & src) >> 24;
15600         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15601         flag_N = res >> 24;
15602         WRITE_LONG_F(adr, res)
15603         POST_IO
15604 RET(28)
15605 }
15606
15607 // NEG
15608 OPCODE(0x449F)
15609 {
15610         u32 adr, res;
15611         u32 src, dst;
15612
15613         adr = AREG(7);
15614         AREG(7) += 4;
15615         PRE_IO
15616         READ_LONG_F(adr, src)
15617         res = -src;
15618         flag_NotZ = res;
15619         flag_V = (res & src) >> 24;
15620         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15621         flag_N = res >> 24;
15622         WRITE_LONG_F(adr, res)
15623         POST_IO
15624 RET(20)
15625 }
15626
15627 // NEG
15628 OPCODE(0x44A7)
15629 {
15630         u32 adr, res;
15631         u32 src, dst;
15632
15633         adr = AREG(7) - 4;
15634         AREG(7) = adr;
15635         PRE_IO
15636         READ_LONG_F(adr, src)
15637         res = -src;
15638         flag_NotZ = res;
15639         flag_V = (res & src) >> 24;
15640         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15641         flag_N = res >> 24;
15642         WRITE_LONG_F(adr, res)
15643         POST_IO
15644 RET(22)
15645 }
15646
15647 // NOT
15648 OPCODE(0x4600)
15649 {
15650         u32 adr, res;
15651         u32 src, dst;
15652
15653         src = DREGu8((Opcode >> 0) & 7);
15654         res = ~src;
15655         flag_C = 0;
15656         flag_V = 0;
15657         flag_N = res;
15658         flag_NotZ = res & 0xFF;
15659         DREGu8((Opcode >> 0) & 7) = res;
15660 RET(4)
15661 }
15662
15663 // NOT
15664 OPCODE(0x4610)
15665 {
15666         u32 adr, res;
15667         u32 src, dst;
15668
15669         adr = AREG((Opcode >> 0) & 7);
15670         PRE_IO
15671         READ_BYTE_F(adr, src)
15672         res = ~src;
15673         flag_C = 0;
15674         flag_V = 0;
15675         flag_N = res;
15676         flag_NotZ = res & 0xFF;
15677         WRITE_BYTE_F(adr, res)
15678         POST_IO
15679 RET(12)
15680 }
15681
15682 // NOT
15683 OPCODE(0x4618)
15684 {
15685         u32 adr, res;
15686         u32 src, dst;
15687
15688         adr = AREG((Opcode >> 0) & 7);
15689         AREG((Opcode >> 0) & 7) += 1;
15690         PRE_IO
15691         READ_BYTE_F(adr, src)
15692         res = ~src;
15693         flag_C = 0;
15694         flag_V = 0;
15695         flag_N = res;
15696         flag_NotZ = res & 0xFF;
15697         WRITE_BYTE_F(adr, res)
15698         POST_IO
15699 RET(12)
15700 }
15701
15702 // NOT
15703 OPCODE(0x4620)
15704 {
15705         u32 adr, res;
15706         u32 src, dst;
15707
15708         adr = AREG((Opcode >> 0) & 7) - 1;
15709         AREG((Opcode >> 0) & 7) = adr;
15710         PRE_IO
15711         READ_BYTE_F(adr, src)
15712         res = ~src;
15713         flag_C = 0;
15714         flag_V = 0;
15715         flag_N = res;
15716         flag_NotZ = res & 0xFF;
15717         WRITE_BYTE_F(adr, res)
15718         POST_IO
15719 RET(14)
15720 }
15721
15722 // NOT
15723 OPCODE(0x4628)
15724 {
15725         u32 adr, res;
15726         u32 src, dst;
15727
15728         FETCH_SWORD(adr);
15729         adr += AREG((Opcode >> 0) & 7);
15730         PRE_IO
15731         READ_BYTE_F(adr, src)
15732         res = ~src;
15733         flag_C = 0;
15734         flag_V = 0;
15735         flag_N = res;
15736         flag_NotZ = res & 0xFF;
15737         WRITE_BYTE_F(adr, res)
15738         POST_IO
15739 RET(16)
15740 }
15741
15742 // NOT
15743 OPCODE(0x4630)
15744 {
15745         u32 adr, res;
15746         u32 src, dst;
15747
15748         adr = AREG((Opcode >> 0) & 7);
15749         DECODE_EXT_WORD
15750         PRE_IO
15751         READ_BYTE_F(adr, src)
15752         res = ~src;
15753         flag_C = 0;
15754         flag_V = 0;
15755         flag_N = res;
15756         flag_NotZ = res & 0xFF;
15757         WRITE_BYTE_F(adr, res)
15758         POST_IO
15759 RET(18)
15760 }
15761
15762 // NOT
15763 OPCODE(0x4638)
15764 {
15765         u32 adr, res;
15766         u32 src, dst;
15767
15768         FETCH_SWORD(adr);
15769         PRE_IO
15770         READ_BYTE_F(adr, src)
15771         res = ~src;
15772         flag_C = 0;
15773         flag_V = 0;
15774         flag_N = res;
15775         flag_NotZ = res & 0xFF;
15776         WRITE_BYTE_F(adr, res)
15777         POST_IO
15778 RET(16)
15779 }
15780
15781 // NOT
15782 OPCODE(0x4639)
15783 {
15784         u32 adr, res;
15785         u32 src, dst;
15786
15787         FETCH_LONG(adr);
15788         PRE_IO
15789         READ_BYTE_F(adr, src)
15790         res = ~src;
15791         flag_C = 0;
15792         flag_V = 0;
15793         flag_N = res;
15794         flag_NotZ = res & 0xFF;
15795         WRITE_BYTE_F(adr, res)
15796         POST_IO
15797 RET(20)
15798 }
15799
15800 // NOT
15801 OPCODE(0x461F)
15802 {
15803         u32 adr, res;
15804         u32 src, dst;
15805
15806         adr = AREG(7);
15807         AREG(7) += 2;
15808         PRE_IO
15809         READ_BYTE_F(adr, src)
15810         res = ~src;
15811         flag_C = 0;
15812         flag_V = 0;
15813         flag_N = res;
15814         flag_NotZ = res & 0xFF;
15815         WRITE_BYTE_F(adr, res)
15816         POST_IO
15817 RET(12)
15818 }
15819
15820 // NOT
15821 OPCODE(0x4627)
15822 {
15823         u32 adr, res;
15824         u32 src, dst;
15825
15826         adr = AREG(7) - 2;
15827         AREG(7) = adr;
15828         PRE_IO
15829         READ_BYTE_F(adr, src)
15830         res = ~src;
15831         flag_C = 0;
15832         flag_V = 0;
15833         flag_N = res;
15834         flag_NotZ = res & 0xFF;
15835         WRITE_BYTE_F(adr, res)
15836         POST_IO
15837 RET(14)
15838 }
15839
15840 // NOT
15841 OPCODE(0x4640)
15842 {
15843         u32 adr, res;
15844         u32 src, dst;
15845
15846         src = DREGu16((Opcode >> 0) & 7);
15847         res = ~src;
15848         flag_C = 0;
15849         flag_V = 0;
15850         flag_NotZ = res & 0xFFFF;
15851         flag_N = res >> 8;
15852         DREGu16((Opcode >> 0) & 7) = res;
15853 RET(4)
15854 }
15855
15856 // NOT
15857 OPCODE(0x4650)
15858 {
15859         u32 adr, res;
15860         u32 src, dst;
15861
15862         adr = AREG((Opcode >> 0) & 7);
15863         PRE_IO
15864         READ_WORD_F(adr, src)
15865         res = ~src;
15866         flag_C = 0;
15867         flag_V = 0;
15868         flag_NotZ = res & 0xFFFF;
15869         flag_N = res >> 8;
15870         WRITE_WORD_F(adr, res)
15871         POST_IO
15872 RET(12)
15873 }
15874
15875 // NOT
15876 OPCODE(0x4658)
15877 {
15878         u32 adr, res;
15879         u32 src, dst;
15880
15881         adr = AREG((Opcode >> 0) & 7);
15882         AREG((Opcode >> 0) & 7) += 2;
15883         PRE_IO
15884         READ_WORD_F(adr, src)
15885         res = ~src;
15886         flag_C = 0;
15887         flag_V = 0;
15888         flag_NotZ = res & 0xFFFF;
15889         flag_N = res >> 8;
15890         WRITE_WORD_F(adr, res)
15891         POST_IO
15892 RET(12)
15893 }
15894
15895 // NOT
15896 OPCODE(0x4660)
15897 {
15898         u32 adr, res;
15899         u32 src, dst;
15900
15901         adr = AREG((Opcode >> 0) & 7) - 2;
15902         AREG((Opcode >> 0) & 7) = adr;
15903         PRE_IO
15904         READ_WORD_F(adr, src)
15905         res = ~src;
15906         flag_C = 0;
15907         flag_V = 0;
15908         flag_NotZ = res & 0xFFFF;
15909         flag_N = res >> 8;
15910         WRITE_WORD_F(adr, res)
15911         POST_IO
15912 RET(14)
15913 }
15914
15915 // NOT
15916 OPCODE(0x4668)
15917 {
15918         u32 adr, res;
15919         u32 src, dst;
15920
15921         FETCH_SWORD(adr);
15922         adr += AREG((Opcode >> 0) & 7);
15923         PRE_IO
15924         READ_WORD_F(adr, src)
15925         res = ~src;
15926         flag_C = 0;
15927         flag_V = 0;
15928         flag_NotZ = res & 0xFFFF;
15929         flag_N = res >> 8;
15930         WRITE_WORD_F(adr, res)
15931         POST_IO
15932 RET(16)
15933 }
15934
15935 // NOT
15936 OPCODE(0x4670)
15937 {
15938         u32 adr, res;
15939         u32 src, dst;
15940
15941         adr = AREG((Opcode >> 0) & 7);
15942         DECODE_EXT_WORD
15943         PRE_IO
15944         READ_WORD_F(adr, src)
15945         res = ~src;
15946         flag_C = 0;
15947         flag_V = 0;
15948         flag_NotZ = res & 0xFFFF;
15949         flag_N = res >> 8;
15950         WRITE_WORD_F(adr, res)
15951         POST_IO
15952 RET(18)
15953 }
15954
15955 // NOT
15956 OPCODE(0x4678)
15957 {
15958         u32 adr, res;
15959         u32 src, dst;
15960
15961         FETCH_SWORD(adr);
15962         PRE_IO
15963         READ_WORD_F(adr, src)
15964         res = ~src;
15965         flag_C = 0;
15966         flag_V = 0;
15967         flag_NotZ = res & 0xFFFF;
15968         flag_N = res >> 8;
15969         WRITE_WORD_F(adr, res)
15970         POST_IO
15971 RET(16)
15972 }
15973
15974 // NOT
15975 OPCODE(0x4679)
15976 {
15977         u32 adr, res;
15978         u32 src, dst;
15979
15980         FETCH_LONG(adr);
15981         PRE_IO
15982         READ_WORD_F(adr, src)
15983         res = ~src;
15984         flag_C = 0;
15985         flag_V = 0;
15986         flag_NotZ = res & 0xFFFF;
15987         flag_N = res >> 8;
15988         WRITE_WORD_F(adr, res)
15989         POST_IO
15990 RET(20)
15991 }
15992
15993 // NOT
15994 OPCODE(0x465F)
15995 {
15996         u32 adr, res;
15997         u32 src, dst;
15998
15999         adr = AREG(7);
16000         AREG(7) += 2;
16001         PRE_IO
16002         READ_WORD_F(adr, src)
16003         res = ~src;
16004         flag_C = 0;
16005         flag_V = 0;
16006         flag_NotZ = res & 0xFFFF;
16007         flag_N = res >> 8;
16008         WRITE_WORD_F(adr, res)
16009         POST_IO
16010 RET(12)
16011 }
16012
16013 // NOT
16014 OPCODE(0x4667)
16015 {
16016         u32 adr, res;
16017         u32 src, dst;
16018
16019         adr = AREG(7) - 2;
16020         AREG(7) = adr;
16021         PRE_IO
16022         READ_WORD_F(adr, src)
16023         res = ~src;
16024         flag_C = 0;
16025         flag_V = 0;
16026         flag_NotZ = res & 0xFFFF;
16027         flag_N = res >> 8;
16028         WRITE_WORD_F(adr, res)
16029         POST_IO
16030 RET(14)
16031 }
16032
16033 // NOT
16034 OPCODE(0x4680)
16035 {
16036         u32 adr, res;
16037         u32 src, dst;
16038
16039         src = DREGu32((Opcode >> 0) & 7);
16040         res = ~src;
16041         flag_C = 0;
16042         flag_V = 0;
16043         flag_NotZ = res;
16044         flag_N = res >> 24;
16045         DREGu32((Opcode >> 0) & 7) = res;
16046 RET(6)
16047 }
16048
16049 // NOT
16050 OPCODE(0x4690)
16051 {
16052         u32 adr, res;
16053         u32 src, dst;
16054
16055         adr = AREG((Opcode >> 0) & 7);
16056         PRE_IO
16057         READ_LONG_F(adr, src)
16058         res = ~src;
16059         flag_C = 0;
16060         flag_V = 0;
16061         flag_NotZ = res;
16062         flag_N = res >> 24;
16063         WRITE_LONG_F(adr, res)
16064         POST_IO
16065 RET(20)
16066 }
16067
16068 // NOT
16069 OPCODE(0x4698)
16070 {
16071         u32 adr, res;
16072         u32 src, dst;
16073
16074         adr = AREG((Opcode >> 0) & 7);
16075         AREG((Opcode >> 0) & 7) += 4;
16076         PRE_IO
16077         READ_LONG_F(adr, src)
16078         res = ~src;
16079         flag_C = 0;
16080         flag_V = 0;
16081         flag_NotZ = res;
16082         flag_N = res >> 24;
16083         WRITE_LONG_F(adr, res)
16084         POST_IO
16085 RET(20)
16086 }
16087
16088 // NOT
16089 OPCODE(0x46A0)
16090 {
16091         u32 adr, res;
16092         u32 src, dst;
16093
16094         adr = AREG((Opcode >> 0) & 7) - 4;
16095         AREG((Opcode >> 0) & 7) = adr;
16096         PRE_IO
16097         READ_LONG_F(adr, src)
16098         res = ~src;
16099         flag_C = 0;
16100         flag_V = 0;
16101         flag_NotZ = res;
16102         flag_N = res >> 24;
16103         WRITE_LONG_F(adr, res)
16104         POST_IO
16105 RET(22)
16106 }
16107
16108 // NOT
16109 OPCODE(0x46A8)
16110 {
16111         u32 adr, res;
16112         u32 src, dst;
16113
16114         FETCH_SWORD(adr);
16115         adr += AREG((Opcode >> 0) & 7);
16116         PRE_IO
16117         READ_LONG_F(adr, src)
16118         res = ~src;
16119         flag_C = 0;
16120         flag_V = 0;
16121         flag_NotZ = res;
16122         flag_N = res >> 24;
16123         WRITE_LONG_F(adr, res)
16124         POST_IO
16125 RET(24)
16126 }
16127
16128 // NOT
16129 OPCODE(0x46B0)
16130 {
16131         u32 adr, res;
16132         u32 src, dst;
16133
16134         adr = AREG((Opcode >> 0) & 7);
16135         DECODE_EXT_WORD
16136         PRE_IO
16137         READ_LONG_F(adr, src)
16138         res = ~src;
16139         flag_C = 0;
16140         flag_V = 0;
16141         flag_NotZ = res;
16142         flag_N = res >> 24;
16143         WRITE_LONG_F(adr, res)
16144         POST_IO
16145 RET(26)
16146 }
16147
16148 // NOT
16149 OPCODE(0x46B8)
16150 {
16151         u32 adr, res;
16152         u32 src, dst;
16153
16154         FETCH_SWORD(adr);
16155         PRE_IO
16156         READ_LONG_F(adr, src)
16157         res = ~src;
16158         flag_C = 0;
16159         flag_V = 0;
16160         flag_NotZ = res;
16161         flag_N = res >> 24;
16162         WRITE_LONG_F(adr, res)
16163         POST_IO
16164 RET(24)
16165 }
16166
16167 // NOT
16168 OPCODE(0x46B9)
16169 {
16170         u32 adr, res;
16171         u32 src, dst;
16172
16173         FETCH_LONG(adr);
16174         PRE_IO
16175         READ_LONG_F(adr, src)
16176         res = ~src;
16177         flag_C = 0;
16178         flag_V = 0;
16179         flag_NotZ = res;
16180         flag_N = res >> 24;
16181         WRITE_LONG_F(adr, res)
16182         POST_IO
16183 RET(28)
16184 }
16185
16186 // NOT
16187 OPCODE(0x469F)
16188 {
16189         u32 adr, res;
16190         u32 src, dst;
16191
16192         adr = AREG(7);
16193         AREG(7) += 4;
16194         PRE_IO
16195         READ_LONG_F(adr, src)
16196         res = ~src;
16197         flag_C = 0;
16198         flag_V = 0;
16199         flag_NotZ = res;
16200         flag_N = res >> 24;
16201         WRITE_LONG_F(adr, res)
16202         POST_IO
16203 RET(20)
16204 }
16205
16206 // NOT
16207 OPCODE(0x46A7)
16208 {
16209         u32 adr, res;
16210         u32 src, dst;
16211
16212         adr = AREG(7) - 4;
16213         AREG(7) = adr;
16214         PRE_IO
16215         READ_LONG_F(adr, src)
16216         res = ~src;
16217         flag_C = 0;
16218         flag_V = 0;
16219         flag_NotZ = res;
16220         flag_N = res >> 24;
16221         WRITE_LONG_F(adr, res)
16222         POST_IO
16223 RET(22)
16224 }
16225
16226 // MOVESRa
16227 OPCODE(0x40C0)
16228 {
16229         u32 adr, res;
16230         u32 src, dst;
16231
16232         res = GET_SR;
16233         DREGu16((Opcode >> 0) & 7) = res;
16234 RET(6)
16235 }
16236
16237 // MOVESRa
16238 OPCODE(0x40D0)
16239 {
16240         u32 adr, res;
16241         u32 src, dst;
16242
16243         res = GET_SR;
16244         adr = AREG((Opcode >> 0) & 7);
16245         PRE_IO
16246         WRITE_WORD_F(adr, res)
16247         POST_IO
16248 RET(12)
16249 }
16250
16251 // MOVESRa
16252 OPCODE(0x40D8)
16253 {
16254         u32 adr, res;
16255         u32 src, dst;
16256
16257         res = GET_SR;
16258         adr = AREG((Opcode >> 0) & 7);
16259         AREG((Opcode >> 0) & 7) += 2;
16260         PRE_IO
16261         WRITE_WORD_F(adr, res)
16262         POST_IO
16263 RET(12)
16264 }
16265
16266 // MOVESRa
16267 OPCODE(0x40E0)
16268 {
16269         u32 adr, res;
16270         u32 src, dst;
16271
16272         res = GET_SR;
16273         adr = AREG((Opcode >> 0) & 7) - 2;
16274         AREG((Opcode >> 0) & 7) = adr;
16275         PRE_IO
16276         WRITE_WORD_F(adr, res)
16277         POST_IO
16278 RET(14)
16279 }
16280
16281 // MOVESRa
16282 OPCODE(0x40E8)
16283 {
16284         u32 adr, res;
16285         u32 src, dst;
16286
16287         res = GET_SR;
16288         FETCH_SWORD(adr);
16289         adr += AREG((Opcode >> 0) & 7);
16290         PRE_IO
16291         WRITE_WORD_F(adr, res)
16292         POST_IO
16293 RET(16)
16294 }
16295
16296 // MOVESRa
16297 OPCODE(0x40F0)
16298 {
16299         u32 adr, res;
16300         u32 src, dst;
16301
16302         res = GET_SR;
16303         adr = AREG((Opcode >> 0) & 7);
16304         DECODE_EXT_WORD
16305         PRE_IO
16306         WRITE_WORD_F(adr, res)
16307         POST_IO
16308 RET(18)
16309 }
16310
16311 // MOVESRa
16312 OPCODE(0x40F8)
16313 {
16314         u32 adr, res;
16315         u32 src, dst;
16316
16317         res = GET_SR;
16318         FETCH_SWORD(adr);
16319         PRE_IO
16320         WRITE_WORD_F(adr, res)
16321         POST_IO
16322 RET(16)
16323 }
16324
16325 // MOVESRa
16326 OPCODE(0x40F9)
16327 {
16328         u32 adr, res;
16329         u32 src, dst;
16330
16331         res = GET_SR;
16332         FETCH_LONG(adr);
16333         PRE_IO
16334         WRITE_WORD_F(adr, res)
16335         POST_IO
16336 RET(20)
16337 }
16338
16339 // MOVESRa
16340 OPCODE(0x40DF)
16341 {
16342         u32 adr, res;
16343         u32 src, dst;
16344
16345         res = GET_SR;
16346         adr = AREG(7);
16347         AREG(7) += 2;
16348         PRE_IO
16349         WRITE_WORD_F(adr, res)
16350         POST_IO
16351 RET(12)
16352 }
16353
16354 // MOVESRa
16355 OPCODE(0x40E7)
16356 {
16357         u32 adr, res;
16358         u32 src, dst;
16359
16360         res = GET_SR;
16361         adr = AREG(7) - 2;
16362         AREG(7) = adr;
16363         PRE_IO
16364         WRITE_WORD_F(adr, res)
16365         POST_IO
16366 RET(14)
16367 }
16368
16369 // MOVEaCCR
16370 OPCODE(0x44C0)
16371 {
16372         u32 adr, res;
16373         u32 src, dst;
16374
16375         res = DREGu16((Opcode >> 0) & 7);
16376         SET_CCR(res)
16377 RET(12)
16378 }
16379
16380 // MOVEaCCR
16381 OPCODE(0x44D0)
16382 {
16383         u32 adr, res;
16384         u32 src, dst;
16385
16386         adr = AREG((Opcode >> 0) & 7);
16387         PRE_IO
16388         READ_WORD_F(adr, res)
16389         SET_CCR(res)
16390         POST_IO
16391 RET(16)
16392 }
16393
16394 // MOVEaCCR
16395 OPCODE(0x44D8)
16396 {
16397         u32 adr, res;
16398         u32 src, dst;
16399
16400         adr = AREG((Opcode >> 0) & 7);
16401         AREG((Opcode >> 0) & 7) += 2;
16402         PRE_IO
16403         READ_WORD_F(adr, res)
16404         SET_CCR(res)
16405         POST_IO
16406 RET(16)
16407 }
16408
16409 // MOVEaCCR
16410 OPCODE(0x44E0)
16411 {
16412         u32 adr, res;
16413         u32 src, dst;
16414
16415         adr = AREG((Opcode >> 0) & 7) - 2;
16416         AREG((Opcode >> 0) & 7) = adr;
16417         PRE_IO
16418         READ_WORD_F(adr, res)
16419         SET_CCR(res)
16420         POST_IO
16421 RET(18)
16422 }
16423
16424 // MOVEaCCR
16425 OPCODE(0x44E8)
16426 {
16427         u32 adr, res;
16428         u32 src, dst;
16429
16430         FETCH_SWORD(adr);
16431         adr += AREG((Opcode >> 0) & 7);
16432         PRE_IO
16433         READ_WORD_F(adr, res)
16434         SET_CCR(res)
16435         POST_IO
16436 RET(20)
16437 }
16438
16439 // MOVEaCCR
16440 OPCODE(0x44F0)
16441 {
16442         u32 adr, res;
16443         u32 src, dst;
16444
16445         adr = AREG((Opcode >> 0) & 7);
16446         DECODE_EXT_WORD
16447         PRE_IO
16448         READ_WORD_F(adr, res)
16449         SET_CCR(res)
16450         POST_IO
16451 RET(22)
16452 }
16453
16454 // MOVEaCCR
16455 OPCODE(0x44F8)
16456 {
16457         u32 adr, res;
16458         u32 src, dst;
16459
16460         FETCH_SWORD(adr);
16461         PRE_IO
16462         READ_WORD_F(adr, res)
16463         SET_CCR(res)
16464         POST_IO
16465 RET(20)
16466 }
16467
16468 // MOVEaCCR
16469 OPCODE(0x44F9)
16470 {
16471         u32 adr, res;
16472         u32 src, dst;
16473
16474         FETCH_LONG(adr);
16475         PRE_IO
16476         READ_WORD_F(adr, res)
16477         SET_CCR(res)
16478         POST_IO
16479 RET(24)
16480 }
16481
16482 // MOVEaCCR
16483 OPCODE(0x44FA)
16484 {
16485         u32 adr, res;
16486         u32 src, dst;
16487
16488         adr = GET_SWORD + GET_PC;
16489         PC++;
16490         PRE_IO
16491         READ_WORD_F(adr, res)
16492         SET_CCR(res)
16493         POST_IO
16494 RET(20)
16495 }
16496
16497 // MOVEaCCR
16498 OPCODE(0x44FB)
16499 {
16500         u32 adr, res;
16501         u32 src, dst;
16502
16503         adr = GET_PC;
16504         DECODE_EXT_WORD
16505         PRE_IO
16506         READ_WORD_F(adr, res)
16507         SET_CCR(res)
16508         POST_IO
16509 RET(22)
16510 }
16511
16512 // MOVEaCCR
16513 OPCODE(0x44FC)
16514 {
16515         u32 adr, res;
16516         u32 src, dst;
16517
16518         FETCH_WORD(res);
16519         SET_CCR(res)
16520 RET(16)
16521 }
16522
16523 // MOVEaCCR
16524 OPCODE(0x44DF)
16525 {
16526         u32 adr, res;
16527         u32 src, dst;
16528
16529         adr = AREG(7);
16530         AREG(7) += 2;
16531         PRE_IO
16532         READ_WORD_F(adr, res)
16533         SET_CCR(res)
16534         POST_IO
16535 RET(16)
16536 }
16537
16538 // MOVEaCCR
16539 OPCODE(0x44E7)
16540 {
16541         u32 adr, res;
16542         u32 src, dst;
16543
16544         adr = AREG(7) - 2;
16545         AREG(7) = adr;
16546         PRE_IO
16547         READ_WORD_F(adr, res)
16548         SET_CCR(res)
16549         POST_IO
16550 RET(18)
16551 }
16552
16553 // MOVEaSR
16554 OPCODE(0x46C0)
16555 {
16556         u32 adr, res;
16557         u32 src, dst;
16558
16559         if (flag_S)
16560         {
16561                 res = DREGu16((Opcode >> 0) & 7);
16562                 SET_SR(res)
16563                 if (!flag_S)
16564                 {
16565                         res = AREG(7);
16566                         AREG(7) = ASP;
16567                         ASP = res;
16568                 }
16569                 CHECK_INT_TO_JUMP(12)
16570         }
16571         else
16572         {
16573                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16574                 RET(4)
16575         }
16576 RET(12)
16577 }
16578
16579 // MOVEaSR
16580 OPCODE(0x46D0)
16581 {
16582         u32 adr, res;
16583         u32 src, dst;
16584
16585         if (flag_S)
16586         {
16587                 adr = AREG((Opcode >> 0) & 7);
16588                 PRE_IO
16589                 READ_WORD_F(adr, res)
16590                 SET_SR(res)
16591                 if (!flag_S)
16592                 {
16593                         res = AREG(7);
16594                         AREG(7) = ASP;
16595                         ASP = res;
16596                 }
16597                 POST_IO
16598                 CHECK_INT_TO_JUMP(16)
16599         }
16600         else
16601         {
16602                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16603                 RET(4)
16604         }
16605 RET(16)
16606 }
16607
16608 // MOVEaSR
16609 OPCODE(0x46D8)
16610 {
16611         u32 adr, res;
16612         u32 src, dst;
16613
16614         if (flag_S)
16615         {
16616                 adr = AREG((Opcode >> 0) & 7);
16617                 AREG((Opcode >> 0) & 7) += 2;
16618                 PRE_IO
16619                 READ_WORD_F(adr, res)
16620                 SET_SR(res)
16621                 if (!flag_S)
16622                 {
16623                         res = AREG(7);
16624                         AREG(7) = ASP;
16625                         ASP = res;
16626                 }
16627                 POST_IO
16628                 CHECK_INT_TO_JUMP(16)
16629         }
16630         else
16631         {
16632                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16633                 RET(4)
16634         }
16635 RET(16)
16636 }
16637
16638 // MOVEaSR
16639 OPCODE(0x46E0)
16640 {
16641         u32 adr, res;
16642         u32 src, dst;
16643
16644         if (flag_S)
16645         {
16646                 adr = AREG((Opcode >> 0) & 7) - 2;
16647                 AREG((Opcode >> 0) & 7) = adr;
16648                 PRE_IO
16649                 READ_WORD_F(adr, res)
16650                 SET_SR(res)
16651                 if (!flag_S)
16652                 {
16653                         res = AREG(7);
16654                         AREG(7) = ASP;
16655                         ASP = res;
16656                 }
16657                 POST_IO
16658                 CHECK_INT_TO_JUMP(18)
16659         }
16660         else
16661         {
16662                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16663                 RET(4)
16664         }
16665 RET(18)
16666 }
16667
16668 // MOVEaSR
16669 OPCODE(0x46E8)
16670 {
16671         u32 adr, res;
16672         u32 src, dst;
16673
16674         if (flag_S)
16675         {
16676                 FETCH_SWORD(adr);
16677                 adr += AREG((Opcode >> 0) & 7);
16678                 PRE_IO
16679                 READ_WORD_F(adr, res)
16680                 SET_SR(res)
16681                 if (!flag_S)
16682                 {
16683                         res = AREG(7);
16684                         AREG(7) = ASP;
16685                         ASP = res;
16686                 }
16687                 POST_IO
16688                 CHECK_INT_TO_JUMP(20)
16689         }
16690         else
16691         {
16692                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16693                 RET(4)
16694         }
16695 RET(20)
16696 }
16697
16698 // MOVEaSR
16699 OPCODE(0x46F0)
16700 {
16701         u32 adr, res;
16702         u32 src, dst;
16703
16704         if (flag_S)
16705         {
16706                 adr = AREG((Opcode >> 0) & 7);
16707                 DECODE_EXT_WORD
16708                 PRE_IO
16709                 READ_WORD_F(adr, res)
16710                 SET_SR(res)
16711                 if (!flag_S)
16712                 {
16713                         res = AREG(7);
16714                         AREG(7) = ASP;
16715                         ASP = res;
16716                 }
16717                 POST_IO
16718                 CHECK_INT_TO_JUMP(22)
16719         }
16720         else
16721         {
16722                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16723                 RET(4)
16724         }
16725 RET(22)
16726 }
16727
16728
16729 // MOVEaSR
16730 OPCODE(0x46F8)
16731 {
16732         u32 adr, res;
16733         u32 src, dst;
16734
16735         if (flag_S)
16736         {
16737                 FETCH_SWORD(adr);
16738                 PRE_IO
16739                 READ_WORD_F(adr, res)
16740                 SET_SR(res)
16741                 if (!flag_S)
16742                 {
16743                         res = AREG(7);
16744                         AREG(7) = ASP;
16745                         ASP = res;
16746                 }
16747                 POST_IO
16748                 CHECK_INT_TO_JUMP(20)
16749         }
16750         else
16751         {
16752                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16753                 RET(4)
16754         }
16755 RET(20)
16756 }
16757
16758 // MOVEaSR
16759 OPCODE(0x46F9)
16760 {
16761         u32 adr, res;
16762         u32 src, dst;
16763
16764         if (flag_S)
16765         {
16766                 FETCH_LONG(adr);
16767                 PRE_IO
16768                 READ_WORD_F(adr, res)
16769                 SET_SR(res)
16770                 if (!flag_S)
16771                 {
16772                         res = AREG(7);
16773                         AREG(7) = ASP;
16774                         ASP = res;
16775                 }
16776                 POST_IO
16777                 CHECK_INT_TO_JUMP(24)
16778         }
16779         else
16780         {
16781                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16782                 RET(4)
16783         }
16784 RET(24)
16785 }
16786
16787 // MOVEaSR
16788 OPCODE(0x46FA)
16789 {
16790         u32 adr, res;
16791         u32 src, dst;
16792
16793         if (flag_S)
16794         {
16795                 adr = GET_SWORD + GET_PC;
16796                 PC++;
16797                 PRE_IO
16798                 READ_WORD_F(adr, res)
16799                 SET_SR(res)
16800                 if (!flag_S)
16801                 {
16802                         res = AREG(7);
16803                         AREG(7) = ASP;
16804                         ASP = res;
16805                 }
16806                 POST_IO
16807                 CHECK_INT_TO_JUMP(20)
16808         }
16809         else
16810         {
16811                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16812                 RET(4)
16813         }
16814 RET(20)
16815 }
16816
16817 // MOVEaSR
16818 OPCODE(0x46FB)
16819 {
16820         u32 adr, res;
16821         u32 src, dst;
16822
16823         if (flag_S)
16824         {
16825                 adr = GET_PC;
16826                 DECODE_EXT_WORD
16827                 PRE_IO
16828                 READ_WORD_F(adr, res)
16829                 SET_SR(res)
16830                 if (!flag_S)
16831                 {
16832                         res = AREG(7);
16833                         AREG(7) = ASP;
16834                         ASP = res;
16835                 }
16836                 POST_IO
16837                 CHECK_INT_TO_JUMP(22)
16838         }
16839         else
16840         {
16841                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16842                 RET(4)
16843         }
16844 RET(22)
16845 }
16846
16847 // MOVEaSR
16848 OPCODE(0x46FC)
16849 {
16850         u32 adr, res;
16851         u32 src, dst;
16852
16853         if (flag_S)
16854         {
16855                 FETCH_WORD(res);
16856                 SET_SR(res)
16857                 if (!flag_S)
16858                 {
16859                         res = AREG(7);
16860                         AREG(7) = ASP;
16861                         ASP = res;
16862                 }
16863                 CHECK_INT_TO_JUMP(16)
16864         }
16865         else
16866         {
16867                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16868                 RET(4)
16869         }
16870 RET(16)
16871 }
16872
16873 // MOVEaSR
16874 OPCODE(0x46DF)
16875 {
16876         u32 adr, res;
16877         u32 src, dst;
16878
16879         if (flag_S)
16880         {
16881                 adr = AREG(7);
16882                 AREG(7) += 2;
16883                 PRE_IO
16884                 READ_WORD_F(adr, res)
16885                 SET_SR(res)
16886                 if (!flag_S)
16887                 {
16888                         res = AREG(7);
16889                         AREG(7) = ASP;
16890                         ASP = res;
16891                 }
16892                 POST_IO
16893                 CHECK_INT_TO_JUMP(16)
16894         }
16895         else
16896         {
16897                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16898                 RET(4)
16899         }
16900 RET(16)
16901 }
16902
16903 // MOVEaSR
16904 OPCODE(0x46E7)
16905 {
16906         u32 adr, res;
16907         u32 src, dst;
16908
16909         if (flag_S)
16910         {
16911                 adr = AREG(7) - 2;
16912                 AREG(7) = adr;
16913                 PRE_IO
16914                 READ_WORD_F(adr, res)
16915                 SET_SR(res)
16916                 if (!flag_S)
16917                 {
16918                         res = AREG(7);
16919                         AREG(7) = ASP;
16920                         ASP = res;
16921                 }
16922                 POST_IO
16923                 CHECK_INT_TO_JUMP(18)
16924         }
16925         else
16926         {
16927                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16928                 RET(4)
16929         }
16930 RET(18)
16931 }
16932
16933 // NBCD
16934 OPCODE(0x4800)
16935 {
16936         u32 adr, res;
16937         u32 src, dst;
16938
16939         res = DREGu8((Opcode >> 0) & 7);
16940         res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
16941
16942         if (res != 0x9a)
16943         {
16944                 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
16945                 res &= 0xFF;
16946         DREGu8((Opcode >> 0) & 7) = res;
16947                 flag_NotZ |= res;
16948                 flag_X = flag_C = M68K_SR_C;
16949         }
16950         else flag_X = flag_C = 0;
16951         flag_N = res;
16952 RET(6)
16953 }
16954
16955 // NBCD
16956 OPCODE(0x4810)
16957 {
16958         u32 adr, res;
16959         u32 src, dst;
16960
16961         adr = AREG((Opcode >> 0) & 7);
16962         PRE_IO
16963         READ_BYTE_F(adr, res)
16964         res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
16965
16966         if (res != 0x9a)
16967         {
16968                 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
16969                 res &= 0xFF;
16970         WRITE_BYTE_F(adr, res)
16971                 flag_NotZ |= res;
16972                 flag_X = flag_C = M68K_SR_C;
16973         }
16974         else flag_X = flag_C = 0;
16975         flag_N = res;
16976         POST_IO
16977 RET(12)
16978 }
16979
16980 // NBCD
16981 OPCODE(0x4818)
16982 {
16983         u32 adr, res;
16984         u32 src, dst;
16985
16986         adr = AREG((Opcode >> 0) & 7);
16987         AREG((Opcode >> 0) & 7) += 1;
16988         PRE_IO
16989         READ_BYTE_F(adr, res)
16990         res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
16991
16992         if (res != 0x9a)
16993         {
16994                 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
16995                 res &= 0xFF;
16996         WRITE_BYTE_F(adr, res)
16997                 flag_NotZ |= res;
16998                 flag_X = flag_C = M68K_SR_C;
16999         }
17000         else flag_X = flag_C = 0;
17001         flag_N = res;
17002         POST_IO
17003 RET(12)
17004 }
17005
17006 // NBCD
17007 OPCODE(0x4820)
17008 {
17009         u32 adr, res;
17010         u32 src, dst;
17011
17012         adr = AREG((Opcode >> 0) & 7) - 1;
17013         AREG((Opcode >> 0) & 7) = adr;
17014         PRE_IO
17015         READ_BYTE_F(adr, res)
17016         res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17017
17018         if (res != 0x9a)
17019         {
17020                 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17021                 res &= 0xFF;
17022         WRITE_BYTE_F(adr, res)
17023                 flag_NotZ |= res;
17024                 flag_X = flag_C = M68K_SR_C;
17025         }
17026         else flag_X = flag_C = 0;
17027         flag_N = res;
17028         POST_IO
17029 RET(14)
17030 }
17031
17032 // NBCD
17033 OPCODE(0x4828)
17034 {
17035         u32 adr, res;
17036         u32 src, dst;
17037
17038         FETCH_SWORD(adr);
17039         adr += AREG((Opcode >> 0) & 7);
17040         PRE_IO
17041         READ_BYTE_F(adr, res)
17042         res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17043
17044         if (res != 0x9a)
17045         {
17046                 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17047                 res &= 0xFF;
17048         WRITE_BYTE_F(adr, res)
17049                 flag_NotZ |= res;
17050                 flag_X = flag_C = M68K_SR_C;
17051         }
17052         else flag_X = flag_C = 0;
17053         flag_N = res;
17054         POST_IO
17055 RET(16)
17056 }
17057
17058 // NBCD
17059 OPCODE(0x4830)
17060 {
17061         u32 adr, res;
17062         u32 src, dst;
17063
17064         adr = AREG((Opcode >> 0) & 7);
17065         DECODE_EXT_WORD
17066         PRE_IO
17067         READ_BYTE_F(adr, res)
17068         res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17069
17070         if (res != 0x9a)
17071         {
17072                 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17073                 res &= 0xFF;
17074         WRITE_BYTE_F(adr, res)
17075                 flag_NotZ |= res;
17076                 flag_X = flag_C = M68K_SR_C;
17077         }
17078         else flag_X = flag_C = 0;
17079         flag_N = res;
17080         POST_IO
17081 RET(18)
17082 }
17083
17084 // NBCD
17085 OPCODE(0x4838)
17086 {
17087         u32 adr, res;
17088         u32 src, dst;
17089
17090         FETCH_SWORD(adr);
17091         PRE_IO
17092         READ_BYTE_F(adr, res)
17093         res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17094
17095         if (res != 0x9a)
17096         {
17097                 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17098                 res &= 0xFF;
17099         WRITE_BYTE_F(adr, res)
17100                 flag_NotZ |= res;
17101                 flag_X = flag_C = M68K_SR_C;
17102         }
17103         else flag_X = flag_C = 0;
17104         flag_N = res;
17105         POST_IO
17106 RET(16)
17107 }
17108
17109 // NBCD
17110 OPCODE(0x4839)
17111 {
17112         u32 adr, res;
17113         u32 src, dst;
17114
17115         FETCH_LONG(adr);
17116         PRE_IO
17117         READ_BYTE_F(adr, res)
17118         res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17119
17120         if (res != 0x9a)
17121         {
17122                 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17123                 res &= 0xFF;
17124         WRITE_BYTE_F(adr, res)
17125                 flag_NotZ |= res;
17126                 flag_X = flag_C = M68K_SR_C;
17127         }
17128         else flag_X = flag_C = 0;
17129         flag_N = res;
17130         POST_IO
17131 RET(20)
17132 }
17133
17134 // NBCD
17135 OPCODE(0x481F)
17136 {
17137         u32 adr, res;
17138         u32 src, dst;
17139
17140         adr = AREG(7);
17141         AREG(7) += 2;
17142         PRE_IO
17143         READ_BYTE_F(adr, res)
17144         res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17145
17146         if (res != 0x9a)
17147         {
17148                 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17149                 res &= 0xFF;
17150         WRITE_BYTE_F(adr, res)
17151                 flag_NotZ |= res;
17152                 flag_X = flag_C = M68K_SR_C;
17153         }
17154         else flag_X = flag_C = 0;
17155         flag_N = res;
17156         POST_IO
17157 RET(12)
17158 }
17159
17160 // NBCD
17161 OPCODE(0x4827)
17162 {
17163         u32 adr, res;
17164         u32 src, dst;
17165
17166         adr = AREG(7) - 2;
17167         AREG(7) = adr;
17168         PRE_IO
17169         READ_BYTE_F(adr, res)
17170         res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17171
17172         if (res != 0x9a)
17173         {
17174                 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17175                 res &= 0xFF;
17176         WRITE_BYTE_F(adr, res)
17177                 flag_NotZ |= res;
17178                 flag_X = flag_C = M68K_SR_C;
17179         }
17180         else flag_X = flag_C = 0;
17181         flag_N = res;
17182         POST_IO
17183 RET(14)
17184 }
17185
17186 // PEA
17187 OPCODE(0x4850)
17188 {
17189         u32 adr, res;
17190         u32 src, dst;
17191
17192         adr = AREG((Opcode >> 0) & 7);
17193         PRE_IO
17194         PUSH_32_F(adr)
17195         POST_IO
17196 RET(12)
17197 }
17198
17199 // PEA
17200 OPCODE(0x4868)
17201 {
17202         u32 adr, res;
17203         u32 src, dst;
17204
17205         FETCH_SWORD(adr);
17206         adr += AREG((Opcode >> 0) & 7);
17207         PRE_IO
17208         PUSH_32_F(adr)
17209         POST_IO
17210 RET(16)
17211 }
17212
17213 // PEA
17214 OPCODE(0x4870)
17215 {
17216         u32 adr, res;
17217         u32 src, dst;
17218
17219         adr = AREG((Opcode >> 0) & 7);
17220         DECODE_EXT_WORD
17221         PRE_IO
17222         PUSH_32_F(adr)
17223         POST_IO
17224 RET(20)
17225 }
17226
17227 // PEA
17228 OPCODE(0x4878)
17229 {
17230         u32 adr, res;
17231         u32 src, dst;
17232
17233         FETCH_SWORD(adr);
17234         PRE_IO
17235         PUSH_32_F(adr)
17236         POST_IO
17237 RET(16)
17238 }
17239
17240 // PEA
17241 OPCODE(0x4879)
17242 {
17243         u32 adr, res;
17244         u32 src, dst;
17245
17246         FETCH_LONG(adr);
17247         PRE_IO
17248         PUSH_32_F(adr)
17249         POST_IO
17250 RET(20)
17251 }
17252
17253 // PEA
17254 OPCODE(0x487A)
17255 {
17256         u32 adr, res;
17257         u32 src, dst;
17258
17259         adr = GET_SWORD + GET_PC;
17260         PC++;
17261         PRE_IO
17262         PUSH_32_F(adr)
17263         POST_IO
17264 RET(16)
17265 }
17266
17267 // PEA
17268 OPCODE(0x487B)
17269 {
17270         u32 adr, res;
17271         u32 src, dst;
17272
17273         adr = GET_PC;
17274         DECODE_EXT_WORD
17275         PRE_IO
17276         PUSH_32_F(adr)
17277         POST_IO
17278 RET(20)
17279 }
17280
17281 // SWAP
17282 OPCODE(0x4840)
17283 {
17284         u32 adr, res;
17285         u32 src, dst;
17286
17287         res = DREGu32((Opcode >> 0) & 7);
17288         res = (res >> 16) | (res << 16);
17289         flag_C = 0;
17290         flag_V = 0;
17291         flag_NotZ = res;
17292         flag_N = res >> 24;
17293         DREGu32((Opcode >> 0) & 7) = res;
17294 RET(4)
17295 }
17296
17297 // MOVEMRa
17298 OPCODE(0x4890)
17299 {
17300         u32 adr, res;
17301         u32 src, dst;
17302
17303         u32 *psrc;
17304
17305         FETCH_WORD(res);
17306         adr = AREG((Opcode >> 0) & 7);
17307         psrc = &DREGu32(0);
17308         dst = adr;
17309         PRE_IO
17310         do
17311         {
17312                 if (res & 1)
17313                 {
17314                         WRITE_WORD_F(adr, *psrc)
17315                         adr += 2;
17316                 }
17317                 psrc++;
17318         } while (res >>= 1);
17319         POST_IO
17320         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17321 #ifdef USE_CYCLONE_TIMING
17322 RET(8)
17323 #else
17324 RET(12)
17325 #endif
17326 }
17327
17328 // MOVEMRa
17329 OPCODE(0x48A0)
17330 {
17331         u32 adr, res;
17332         u32 src, dst;
17333
17334         u32 *psrc;
17335
17336         FETCH_WORD(res);
17337         adr = AREG((Opcode >> 0) & 7);
17338         psrc = &AREGu32(7);
17339         dst = adr;
17340         PRE_IO
17341         do
17342         {
17343                 if (res & 1)
17344                 {
17345                         adr -= 2;
17346                         WRITE_WORD_F(adr, *psrc)
17347                 }
17348                 psrc--;
17349         } while (res >>= 1);
17350         AREG((Opcode >> 0) & 7) = adr;
17351         POST_IO
17352         m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17353 RET(8)
17354 }
17355
17356 // MOVEMRa
17357 OPCODE(0x48A8)
17358 {
17359         u32 adr, res;
17360         u32 src, dst;
17361
17362         u32 *psrc;
17363
17364         FETCH_WORD(res);
17365         FETCH_SWORD(adr);
17366         adr += AREG((Opcode >> 0) & 7);
17367         psrc = &DREGu32(0);
17368         dst = adr;
17369         PRE_IO
17370         do
17371         {
17372                 if (res & 1)
17373                 {
17374                         WRITE_WORD_F(adr, *psrc)
17375                         adr += 2;
17376                 }
17377                 psrc++;
17378         } while (res >>= 1);
17379         POST_IO
17380         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17381 #ifdef USE_CYCLONE_TIMING
17382 RET(12)
17383 #else
17384 RET(20)
17385 #endif
17386 }
17387
17388 // MOVEMRa
17389 OPCODE(0x48B0)
17390 {
17391         u32 adr, res;
17392         u32 src, dst;
17393
17394         u32 *psrc;
17395
17396         FETCH_WORD(res);
17397         adr = AREG((Opcode >> 0) & 7);
17398         DECODE_EXT_WORD
17399         psrc = &DREGu32(0);
17400         dst = adr;
17401         PRE_IO
17402         do
17403         {
17404                 if (res & 1)
17405                 {
17406                         WRITE_WORD_F(adr, *psrc)
17407                         adr += 2;
17408                 }
17409                 psrc++;
17410         } while (res >>= 1);
17411         POST_IO
17412         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17413 #ifdef USE_CYCLONE_TIMING
17414 RET(14)
17415 #else
17416 RET(24)
17417 #endif
17418 }
17419
17420 // MOVEMRa
17421 OPCODE(0x48B8)
17422 {
17423         u32 adr, res;
17424         u32 src, dst;
17425
17426         u32 *psrc;
17427
17428         FETCH_WORD(res);
17429         FETCH_SWORD(adr);
17430         psrc = &DREGu32(0);
17431         dst = adr;
17432         PRE_IO
17433         do
17434         {
17435                 if (res & 1)
17436                 {
17437                         WRITE_WORD_F(adr, *psrc)
17438                         adr += 2;
17439                 }
17440                 psrc++;
17441         } while (res >>= 1);
17442         POST_IO
17443         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17444 #ifdef USE_CYCLONE_TIMING
17445 RET(12)
17446 #else
17447 RET(20)
17448 #endif
17449 }
17450
17451 // MOVEMRa
17452 OPCODE(0x48B9)
17453 {
17454         u32 adr, res;
17455         u32 src, dst;
17456
17457         u32 *psrc;
17458
17459         FETCH_WORD(res);
17460         FETCH_LONG(adr);
17461         psrc = &DREGu32(0);
17462         dst = adr;
17463         PRE_IO
17464         do
17465         {
17466                 if (res & 1)
17467                 {
17468                         WRITE_WORD_F(adr, *psrc)
17469                         adr += 2;
17470                 }
17471                 psrc++;
17472         } while (res >>= 1);
17473         POST_IO
17474         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17475 #ifdef USE_CYCLONE_TIMING
17476 RET(16)
17477 #else
17478 RET(28)
17479 #endif
17480 }
17481
17482 // MOVEMRa
17483 OPCODE(0x48A7)
17484 {
17485         u32 adr, res;
17486         u32 src, dst;
17487
17488         u32 *psrc;
17489
17490         FETCH_WORD(res);
17491         adr = AREG(7);
17492         psrc = &AREGu32(7);
17493         dst = adr;
17494         PRE_IO
17495         do
17496         {
17497                 if (res & 1)
17498                 {
17499                         adr -= 2;
17500                         WRITE_WORD_F(adr, *psrc)
17501                 }
17502                 psrc--;
17503         } while (res >>= 1);
17504         AREG(7) = adr;
17505         POST_IO
17506         m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17507 RET(8)
17508 }
17509
17510 // MOVEMRa
17511 OPCODE(0x48D0)
17512 {
17513         u32 adr, res;
17514         u32 src, dst;
17515
17516         u32 *psrc;
17517
17518         FETCH_WORD(res);
17519         adr = AREG((Opcode >> 0) & 7);
17520         psrc = &DREGu32(0);
17521         dst = adr;
17522         PRE_IO
17523         do
17524         {
17525                 if (res & 1)
17526                 {
17527                         WRITE_LONG_F(adr, *psrc)
17528                         adr += 4;
17529                 }
17530                 psrc++;
17531         } while (res >>= 1);
17532         POST_IO
17533         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17534 #ifdef USE_CYCLONE_TIMING
17535 RET(8)
17536 #else
17537 RET(16)
17538 #endif
17539 }
17540
17541 // MOVEMRa
17542 OPCODE(0x48E0)
17543 {
17544         u32 adr, res;
17545         u32 src, dst;
17546
17547         u32 *psrc;
17548
17549         FETCH_WORD(res);
17550         adr = AREG((Opcode >> 0) & 7);
17551         psrc = &AREGu32(7);
17552         dst = adr;
17553         PRE_IO
17554         do
17555         {
17556                 if (res & 1)
17557                 {
17558                         adr -= 4;
17559                         WRITE_LONG_DEC_F(adr, *psrc)
17560                 }
17561                 psrc--;
17562         } while (res >>= 1);
17563         AREG((Opcode >> 0) & 7) = adr;
17564         POST_IO
17565         m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17566 RET(8)
17567 }
17568
17569 // MOVEMRa
17570 OPCODE(0x48E8)
17571 {
17572         u32 adr, res;
17573         u32 src, dst;
17574
17575         u32 *psrc;
17576
17577         FETCH_WORD(res);
17578         FETCH_SWORD(adr);
17579         adr += AREG((Opcode >> 0) & 7);
17580         psrc = &DREGu32(0);
17581         dst = adr;
17582         PRE_IO
17583         do
17584         {
17585                 if (res & 1)
17586                 {
17587                         WRITE_LONG_F(adr, *psrc)
17588                         adr += 4;
17589                 }
17590                 psrc++;
17591         } while (res >>= 1);
17592         POST_IO
17593         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17594 #ifdef USE_CYCLONE_TIMING
17595 RET(12)
17596 #else
17597 RET(24)
17598 #endif
17599 }
17600
17601 // MOVEMRa
17602 OPCODE(0x48F0)
17603 {
17604         u32 adr, res;
17605         u32 src, dst;
17606
17607         u32 *psrc;
17608
17609         FETCH_WORD(res);
17610         adr = AREG((Opcode >> 0) & 7);
17611         DECODE_EXT_WORD
17612         psrc = &DREGu32(0);
17613         dst = adr;
17614         PRE_IO
17615         do
17616         {
17617                 if (res & 1)
17618                 {
17619                         WRITE_LONG_F(adr, *psrc)
17620                         adr += 4;
17621                 }
17622                 psrc++;
17623         } while (res >>= 1);
17624         POST_IO
17625         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17626 #ifdef USE_CYCLONE_TIMING
17627 RET(14)
17628 #else
17629 RET(28)
17630 #endif
17631 }
17632
17633 // MOVEMRa
17634 OPCODE(0x48F8)
17635 {
17636         u32 adr, res;
17637         u32 src, dst;
17638
17639         u32 *psrc;
17640
17641         FETCH_WORD(res);
17642         FETCH_SWORD(adr);
17643         psrc = &DREGu32(0);
17644         dst = adr;
17645         PRE_IO
17646         do
17647         {
17648                 if (res & 1)
17649                 {
17650                         WRITE_LONG_F(adr, *psrc)
17651                         adr += 4;
17652                 }
17653                 psrc++;
17654         } while (res >>= 1);
17655         POST_IO
17656         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17657 #ifdef USE_CYCLONE_TIMING
17658 RET(12)
17659 #else
17660 RET(24)
17661 #endif
17662 }
17663
17664 // MOVEMRa
17665 OPCODE(0x48F9)
17666 {
17667         u32 adr, res;
17668         u32 src, dst;
17669
17670         u32 *psrc;
17671
17672         FETCH_WORD(res);
17673         FETCH_LONG(adr);
17674         psrc = &DREGu32(0);
17675         dst = adr;
17676         PRE_IO
17677         do
17678         {
17679                 if (res & 1)
17680                 {
17681                         WRITE_LONG_F(adr, *psrc)
17682                         adr += 4;
17683                 }
17684                 psrc++;
17685         } while (res >>= 1);
17686         POST_IO
17687         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17688 #ifdef USE_CYCLONE_TIMING
17689 RET(16)
17690 #else
17691 RET(32)
17692 #endif
17693 }
17694
17695 // MOVEMRa
17696 OPCODE(0x48E7)
17697 {
17698         u32 adr, res;
17699         u32 src, dst;
17700
17701         u32 *psrc;
17702
17703         FETCH_WORD(res);
17704         adr = AREG(7);
17705         psrc = &AREGu32(7);
17706         dst = adr;
17707         PRE_IO
17708         do
17709         {
17710                 if (res & 1)
17711                 {
17712                         adr -= 4;
17713                         WRITE_LONG_DEC_F(adr, *psrc)
17714                 }
17715                 psrc--;
17716         } while (res >>= 1);
17717         AREG(7) = adr;
17718         POST_IO
17719         m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17720 RET(8)
17721 }
17722
17723 // EXT
17724 OPCODE(0x4880)
17725 {
17726         u32 adr, res;
17727         u32 src, dst;
17728
17729         res = (s32)DREGs8((Opcode >> 0) & 7);
17730         flag_C = 0;
17731         flag_V = 0;
17732         flag_NotZ = res;
17733         flag_N = res;
17734         DREGu16((Opcode >> 0) & 7) = res;
17735 RET(4)
17736 }
17737
17738 // EXT
17739 OPCODE(0x48C0)
17740 {
17741         u32 adr, res;
17742         u32 src, dst;
17743
17744         res = (s32)DREGs16((Opcode >> 0) & 7);
17745         flag_C = 0;
17746         flag_V = 0;
17747         flag_NotZ = res;
17748         flag_N = res >> 8;
17749         DREGu32((Opcode >> 0) & 7) = res;
17750 RET(4)
17751 }
17752
17753 // TST
17754 OPCODE(0x4A00)
17755 {
17756         u32 adr, res;
17757         u32 src, dst;
17758
17759         res = DREGu8((Opcode >> 0) & 7);
17760         flag_C = 0;
17761         flag_V = 0;
17762         flag_NotZ = res;
17763         flag_N = res;
17764 RET(4)
17765 }
17766
17767 // TST
17768 OPCODE(0x4A10)
17769 {
17770         u32 adr, res;
17771         u32 src, dst;
17772
17773         adr = AREG((Opcode >> 0) & 7);
17774         PRE_IO
17775         READ_BYTE_F(adr, res)
17776         flag_C = 0;
17777         flag_V = 0;
17778         flag_NotZ = res;
17779         flag_N = res;
17780         POST_IO
17781 RET(8)
17782 }
17783
17784 // TST
17785 OPCODE(0x4A18)
17786 {
17787         u32 adr, res;
17788         u32 src, dst;
17789
17790         adr = AREG((Opcode >> 0) & 7);
17791         AREG((Opcode >> 0) & 7) += 1;
17792         PRE_IO
17793         READ_BYTE_F(adr, res)
17794         flag_C = 0;
17795         flag_V = 0;
17796         flag_NotZ = res;
17797         flag_N = res;
17798         POST_IO
17799 RET(8)
17800 }
17801
17802 // TST
17803 OPCODE(0x4A20)
17804 {
17805         u32 adr, res;
17806         u32 src, dst;
17807
17808         adr = AREG((Opcode >> 0) & 7) - 1;
17809         AREG((Opcode >> 0) & 7) = adr;
17810         PRE_IO
17811         READ_BYTE_F(adr, res)
17812         flag_C = 0;
17813         flag_V = 0;
17814         flag_NotZ = res;
17815         flag_N = res;
17816         POST_IO
17817 RET(10)
17818 }
17819
17820 // TST
17821 OPCODE(0x4A28)
17822 {
17823         u32 adr, res;
17824         u32 src, dst;
17825
17826         FETCH_SWORD(adr);
17827         adr += AREG((Opcode >> 0) & 7);
17828         PRE_IO
17829         READ_BYTE_F(adr, res)
17830         flag_C = 0;
17831         flag_V = 0;
17832         flag_NotZ = res;
17833         flag_N = res;
17834         POST_IO
17835 RET(12)
17836 }
17837
17838 // TST
17839 OPCODE(0x4A30)
17840 {
17841         u32 adr, res;
17842         u32 src, dst;
17843
17844         adr = AREG((Opcode >> 0) & 7);
17845         DECODE_EXT_WORD
17846         PRE_IO
17847         READ_BYTE_F(adr, res)
17848         flag_C = 0;
17849         flag_V = 0;
17850         flag_NotZ = res;
17851         flag_N = res;
17852         POST_IO
17853 RET(14)
17854 }
17855
17856 // TST
17857 OPCODE(0x4A38)
17858 {
17859         u32 adr, res;
17860         u32 src, dst;
17861
17862         FETCH_SWORD(adr);
17863         PRE_IO
17864         READ_BYTE_F(adr, res)
17865         flag_C = 0;
17866         flag_V = 0;
17867         flag_NotZ = res;
17868         flag_N = res;
17869         POST_IO
17870 RET(12)
17871 }
17872
17873 // TST
17874 OPCODE(0x4A39)
17875 {
17876         u32 adr, res;
17877         u32 src, dst;
17878
17879         FETCH_LONG(adr);
17880         PRE_IO
17881         READ_BYTE_F(adr, res)
17882         flag_C = 0;
17883         flag_V = 0;
17884         flag_NotZ = res;
17885         flag_N = res;
17886         POST_IO
17887 RET(16)
17888 }
17889
17890 // TST
17891 OPCODE(0x4A1F)
17892 {
17893         u32 adr, res;
17894         u32 src, dst;
17895
17896         adr = AREG(7);
17897         AREG(7) += 2;
17898         PRE_IO
17899         READ_BYTE_F(adr, res)
17900         flag_C = 0;
17901         flag_V = 0;
17902         flag_NotZ = res;
17903         flag_N = res;
17904         POST_IO
17905 RET(8)
17906 }
17907
17908 // TST
17909 OPCODE(0x4A27)
17910 {
17911         u32 adr, res;
17912         u32 src, dst;
17913
17914         adr = AREG(7) - 2;
17915         AREG(7) = adr;
17916         PRE_IO
17917         READ_BYTE_F(adr, res)
17918         flag_C = 0;
17919         flag_V = 0;
17920         flag_NotZ = res;
17921         flag_N = res;
17922         POST_IO
17923 RET(10)
17924 }
17925
17926 // TST
17927 OPCODE(0x4A40)
17928 {
17929         u32 adr, res;
17930         u32 src, dst;
17931
17932         res = DREGu16((Opcode >> 0) & 7);
17933         flag_C = 0;
17934         flag_V = 0;
17935         flag_NotZ = res;
17936         flag_N = res >> 8;
17937 RET(4)
17938 }
17939
17940 // TST
17941 OPCODE(0x4A50)
17942 {
17943         u32 adr, res;
17944         u32 src, dst;
17945
17946         adr = AREG((Opcode >> 0) & 7);
17947         PRE_IO
17948         READ_WORD_F(adr, res)
17949         flag_C = 0;
17950         flag_V = 0;
17951         flag_NotZ = res;
17952         flag_N = res >> 8;
17953         POST_IO
17954 RET(8)
17955 }
17956
17957 // TST
17958 OPCODE(0x4A58)
17959 {
17960         u32 adr, res;
17961         u32 src, dst;
17962
17963         adr = AREG((Opcode >> 0) & 7);
17964         AREG((Opcode >> 0) & 7) += 2;
17965         PRE_IO
17966         READ_WORD_F(adr, res)
17967         flag_C = 0;
17968         flag_V = 0;
17969         flag_NotZ = res;
17970         flag_N = res >> 8;
17971         POST_IO
17972 RET(8)
17973 }
17974
17975 // TST
17976 OPCODE(0x4A60)
17977 {
17978         u32 adr, res;
17979         u32 src, dst;
17980
17981         adr = AREG((Opcode >> 0) & 7) - 2;
17982         AREG((Opcode >> 0) & 7) = adr;
17983         PRE_IO
17984         READ_WORD_F(adr, res)
17985         flag_C = 0;
17986         flag_V = 0;
17987         flag_NotZ = res;
17988         flag_N = res >> 8;
17989         POST_IO
17990 RET(10)
17991 }
17992
17993 // TST
17994 OPCODE(0x4A68)
17995 {
17996         u32 adr, res;
17997         u32 src, dst;
17998
17999         FETCH_SWORD(adr);
18000         adr += AREG((Opcode >> 0) & 7);
18001         PRE_IO
18002         READ_WORD_F(adr, res)
18003         flag_C = 0;
18004         flag_V = 0;
18005         flag_NotZ = res;
18006         flag_N = res >> 8;
18007         POST_IO
18008 RET(12)
18009 }
18010
18011 // TST
18012 OPCODE(0x4A70)
18013 {
18014         u32 adr, res;
18015         u32 src, dst;
18016
18017         adr = AREG((Opcode >> 0) & 7);
18018         DECODE_EXT_WORD
18019         PRE_IO
18020         READ_WORD_F(adr, res)
18021         flag_C = 0;
18022         flag_V = 0;
18023         flag_NotZ = res;
18024         flag_N = res >> 8;
18025         POST_IO
18026 RET(14)
18027 }
18028
18029 // TST
18030 OPCODE(0x4A78)
18031 {
18032         u32 adr, res;
18033         u32 src, dst;
18034
18035         FETCH_SWORD(adr);
18036         PRE_IO
18037         READ_WORD_F(adr, res)
18038         flag_C = 0;
18039         flag_V = 0;
18040         flag_NotZ = res;
18041         flag_N = res >> 8;
18042         POST_IO
18043 RET(12)
18044 }
18045
18046 // TST
18047 OPCODE(0x4A79)
18048 {
18049         u32 adr, res;
18050         u32 src, dst;
18051
18052         FETCH_LONG(adr);
18053         PRE_IO
18054         READ_WORD_F(adr, res)
18055         flag_C = 0;
18056         flag_V = 0;
18057         flag_NotZ = res;
18058         flag_N = res >> 8;
18059         POST_IO
18060 RET(16)
18061 }
18062
18063 // TST
18064 OPCODE(0x4A5F)
18065 {
18066         u32 adr, res;
18067         u32 src, dst;
18068
18069         adr = AREG(7);
18070         AREG(7) += 2;
18071         PRE_IO
18072         READ_WORD_F(adr, res)
18073         flag_C = 0;
18074         flag_V = 0;
18075         flag_NotZ = res;
18076         flag_N = res >> 8;
18077         POST_IO
18078 RET(8)
18079 }
18080
18081 // TST
18082 OPCODE(0x4A67)
18083 {
18084         u32 adr, res;
18085         u32 src, dst;
18086
18087         adr = AREG(7) - 2;
18088         AREG(7) = adr;
18089         PRE_IO
18090         READ_WORD_F(adr, res)
18091         flag_C = 0;
18092         flag_V = 0;
18093         flag_NotZ = res;
18094         flag_N = res >> 8;
18095         POST_IO
18096 RET(10)
18097 }
18098
18099 // TST
18100 OPCODE(0x4A80)
18101 {
18102         u32 adr, res;
18103         u32 src, dst;
18104
18105         res = DREGu32((Opcode >> 0) & 7);
18106         flag_C = 0;
18107         flag_V = 0;
18108         flag_NotZ = res;
18109         flag_N = res >> 24;
18110 RET(4)
18111 }
18112
18113 // TST
18114 OPCODE(0x4A90)
18115 {
18116         u32 adr, res;
18117         u32 src, dst;
18118
18119         adr = AREG((Opcode >> 0) & 7);
18120         PRE_IO
18121         READ_LONG_F(adr, res)
18122         flag_C = 0;
18123         flag_V = 0;
18124         flag_NotZ = res;
18125         flag_N = res >> 24;
18126         POST_IO
18127 RET(12)
18128 }
18129
18130 // TST
18131 OPCODE(0x4A98)
18132 {
18133         u32 adr, res;
18134         u32 src, dst;
18135
18136         adr = AREG((Opcode >> 0) & 7);
18137         AREG((Opcode >> 0) & 7) += 4;
18138         PRE_IO
18139         READ_LONG_F(adr, res)
18140         flag_C = 0;
18141         flag_V = 0;
18142         flag_NotZ = res;
18143         flag_N = res >> 24;
18144         POST_IO
18145 RET(12)
18146 }
18147
18148 // TST
18149 OPCODE(0x4AA0)
18150 {
18151         u32 adr, res;
18152         u32 src, dst;
18153
18154         adr = AREG((Opcode >> 0) & 7) - 4;
18155         AREG((Opcode >> 0) & 7) = adr;
18156         PRE_IO
18157         READ_LONG_F(adr, res)
18158         flag_C = 0;
18159         flag_V = 0;
18160         flag_NotZ = res;
18161         flag_N = res >> 24;
18162         POST_IO
18163 RET(14)
18164 }
18165
18166 // TST
18167 OPCODE(0x4AA8)
18168 {
18169         u32 adr, res;
18170         u32 src, dst;
18171
18172         FETCH_SWORD(adr);
18173         adr += AREG((Opcode >> 0) & 7);
18174         PRE_IO
18175         READ_LONG_F(adr, res)
18176         flag_C = 0;
18177         flag_V = 0;
18178         flag_NotZ = res;
18179         flag_N = res >> 24;
18180         POST_IO
18181 RET(16)
18182 }
18183
18184 // TST
18185 OPCODE(0x4AB0)
18186 {
18187         u32 adr, res;
18188         u32 src, dst;
18189
18190         adr = AREG((Opcode >> 0) & 7);
18191         DECODE_EXT_WORD
18192         PRE_IO
18193         READ_LONG_F(adr, res)
18194         flag_C = 0;
18195         flag_V = 0;
18196         flag_NotZ = res;
18197         flag_N = res >> 24;
18198         POST_IO
18199 RET(18)
18200 }
18201
18202 // TST
18203 OPCODE(0x4AB8)
18204 {
18205         u32 adr, res;
18206         u32 src, dst;
18207
18208         FETCH_SWORD(adr);
18209         PRE_IO
18210         READ_LONG_F(adr, res)
18211         flag_C = 0;
18212         flag_V = 0;
18213         flag_NotZ = res;
18214         flag_N = res >> 24;
18215         POST_IO
18216 RET(16)
18217 }
18218
18219 // TST
18220 OPCODE(0x4AB9)
18221 {
18222         u32 adr, res;
18223         u32 src, dst;
18224
18225         FETCH_LONG(adr);
18226         PRE_IO
18227         READ_LONG_F(adr, res)
18228         flag_C = 0;
18229         flag_V = 0;
18230         flag_NotZ = res;
18231         flag_N = res >> 24;
18232         POST_IO
18233 RET(20)
18234 }
18235
18236 // TST
18237 OPCODE(0x4A9F)
18238 {
18239         u32 adr, res;
18240         u32 src, dst;
18241
18242         adr = AREG(7);
18243         AREG(7) += 4;
18244         PRE_IO
18245         READ_LONG_F(adr, res)
18246         flag_C = 0;
18247         flag_V = 0;
18248         flag_NotZ = res;
18249         flag_N = res >> 24;
18250         POST_IO
18251 RET(12)
18252 }
18253
18254 // TST
18255 OPCODE(0x4AA7)
18256 {
18257         u32 adr, res;
18258         u32 src, dst;
18259
18260         adr = AREG(7) - 4;
18261         AREG(7) = adr;
18262         PRE_IO
18263         READ_LONG_F(adr, res)
18264         flag_C = 0;
18265         flag_V = 0;
18266         flag_NotZ = res;
18267         flag_N = res >> 24;
18268         POST_IO
18269 RET(14)
18270 }
18271
18272 // TAS
18273 OPCODE(0x4AC0)
18274 {
18275         u32 adr, res;
18276         u32 src, dst;
18277
18278         res = DREGu8((Opcode >> 0) & 7);
18279         flag_C = 0;
18280         flag_V = 0;
18281         flag_NotZ = res;
18282         flag_N = res;
18283         res |= 0x80;
18284         DREGu8((Opcode >> 0) & 7) = res;
18285 RET(4)
18286 }
18287
18288 // TAS
18289 OPCODE(0x4AD0)
18290 {
18291         u32 adr, res;
18292         u32 src, dst;
18293
18294         adr = AREG((Opcode >> 0) & 7);
18295         PRE_IO
18296         READ_BYTE_F(adr, res)
18297         flag_C = 0;
18298         flag_V = 0;
18299         flag_NotZ = res;
18300         flag_N = res;
18301 #ifdef PICODRIVE_HACK
18302         if (g_m68kcontext == &PicoCpuFS68k) {
18303                 res |= 0x80;
18304                 WRITE_BYTE_F(adr, res);
18305         }
18306 #endif
18307
18308         POST_IO
18309 #ifdef USE_CYCLONE_TIMING
18310 RET(18)
18311 #else
18312 RET(8)
18313 #endif
18314 }
18315
18316 // TAS
18317 OPCODE(0x4AD8)
18318 {
18319         u32 adr, res;
18320         u32 src, dst;
18321
18322         adr = AREG((Opcode >> 0) & 7);
18323         AREG((Opcode >> 0) & 7) += 1;
18324         PRE_IO
18325         READ_BYTE_F(adr, res)
18326         flag_C = 0;
18327         flag_V = 0;
18328         flag_NotZ = res;
18329         flag_N = res;
18330
18331 #ifdef PICODRIVE_HACK
18332         if (g_m68kcontext == &PicoCpuFS68k) {
18333                 res |= 0x80;
18334                 WRITE_BYTE_F(adr, res);
18335         }
18336 #endif
18337
18338         POST_IO
18339 #ifdef USE_CYCLONE_TIMING
18340 RET(18)
18341 #else
18342 RET(8)
18343 #endif
18344 }
18345
18346 // TAS
18347 OPCODE(0x4AE0)
18348 {
18349         u32 adr, res;
18350         u32 src, dst;
18351
18352         adr = AREG((Opcode >> 0) & 7) - 1;
18353         AREG((Opcode >> 0) & 7) = adr;
18354         PRE_IO
18355         READ_BYTE_F(adr, res)
18356         flag_C = 0;
18357         flag_V = 0;
18358         flag_NotZ = res;
18359         flag_N = res;
18360
18361 #ifdef PICODRIVE_HACK
18362         if (g_m68kcontext == &PicoCpuFS68k) {
18363                 res |= 0x80;
18364                 WRITE_BYTE_F(adr, res);
18365         }
18366 #endif
18367
18368         POST_IO
18369 #ifdef USE_CYCLONE_TIMING
18370 RET(20)
18371 #else
18372 RET(10)
18373 #endif
18374 }
18375
18376 // TAS
18377 OPCODE(0x4AE8)
18378 {
18379         u32 adr, res;
18380         u32 src, dst;
18381
18382         FETCH_SWORD(adr);
18383         adr += AREG((Opcode >> 0) & 7);
18384         PRE_IO
18385         READ_BYTE_F(adr, res)
18386         flag_C = 0;
18387         flag_V = 0;
18388         flag_NotZ = res;
18389         flag_N = res;
18390
18391 #ifdef PICODRIVE_HACK
18392         if (g_m68kcontext == &PicoCpuFS68k) {
18393                 res |= 0x80;
18394                 WRITE_BYTE_F(adr, res);
18395         }
18396 #endif
18397
18398         POST_IO
18399 #ifdef USE_CYCLONE_TIMING
18400 RET(22)
18401 #else
18402 RET(12)
18403 #endif
18404 }
18405
18406 // TAS
18407 OPCODE(0x4AF0)
18408 {
18409         u32 adr, res;
18410         u32 src, dst;
18411
18412         adr = AREG((Opcode >> 0) & 7);
18413         DECODE_EXT_WORD
18414         PRE_IO
18415         READ_BYTE_F(adr, res)
18416         flag_C = 0;
18417         flag_V = 0;
18418         flag_NotZ = res;
18419         flag_N = res;
18420
18421 #ifdef PICODRIVE_HACK
18422         if (g_m68kcontext == &PicoCpuFS68k) {
18423                 res |= 0x80;
18424                 WRITE_BYTE_F(adr, res);
18425         }
18426 #endif
18427
18428         POST_IO
18429 #ifdef USE_CYCLONE_TIMING
18430 RET(24)
18431 #else
18432 RET(14)
18433 #endif
18434 }
18435
18436 // TAS
18437 OPCODE(0x4AF8)
18438 {
18439         u32 adr, res;
18440         u32 src, dst;
18441
18442         FETCH_SWORD(adr);
18443         PRE_IO
18444         READ_BYTE_F(adr, res)
18445         flag_C = 0;
18446         flag_V = 0;
18447         flag_NotZ = res;
18448         flag_N = res;
18449
18450 #ifdef PICODRIVE_HACK
18451         if (g_m68kcontext == &PicoCpuFS68k) {
18452                 res |= 0x80;
18453                 WRITE_BYTE_F(adr, res);
18454         }
18455 #endif
18456
18457         POST_IO
18458 #ifdef USE_CYCLONE_TIMING
18459 RET(22)
18460 #else
18461 RET(12)
18462 #endif
18463 }
18464
18465 // TAS
18466 OPCODE(0x4AF9)
18467 {
18468         u32 adr, res;
18469         u32 src, dst;
18470
18471         FETCH_LONG(adr);
18472         PRE_IO
18473         READ_BYTE_F(adr, res)
18474         flag_C = 0;
18475         flag_V = 0;
18476         flag_NotZ = res;
18477         flag_N = res;
18478
18479 #ifdef PICODRIVE_HACK
18480         if (g_m68kcontext == &PicoCpuFS68k) {
18481                 res |= 0x80;
18482                 WRITE_BYTE_F(adr, res);
18483         }
18484 #endif
18485
18486         POST_IO
18487 #ifdef USE_CYCLONE_TIMING
18488 RET(26)
18489 #else
18490 RET(16)
18491 #endif
18492 }
18493
18494 // TAS
18495 OPCODE(0x4ADF)
18496 {
18497         u32 adr, res;
18498         u32 src, dst;
18499
18500         adr = AREG(7);
18501         AREG(7) += 2;
18502         PRE_IO
18503         READ_BYTE_F(adr, res)
18504         flag_C = 0;
18505         flag_V = 0;
18506         flag_NotZ = res;
18507         flag_N = res;
18508
18509 #ifdef PICODRIVE_HACK
18510         if (g_m68kcontext == &PicoCpuFS68k) {
18511                 res |= 0x80;
18512                 WRITE_BYTE_F(adr, res);
18513         }
18514 #endif
18515
18516         POST_IO
18517 #ifdef USE_CYCLONE_TIMING
18518 RET(18)
18519 #else
18520 RET(8)
18521 #endif
18522 }
18523
18524 // TAS
18525 OPCODE(0x4AE7)
18526 {
18527         u32 adr, res;
18528         u32 src, dst;
18529
18530         adr = AREG(7) - 2;
18531         AREG(7) = adr;
18532         PRE_IO
18533         READ_BYTE_F(adr, res)
18534         flag_C = 0;
18535         flag_V = 0;
18536         flag_NotZ = res;
18537         flag_N = res;
18538
18539 #ifdef PICODRIVE_HACK
18540         if (g_m68kcontext == &PicoCpuFS68k) {
18541                 res |= 0x80;
18542                 WRITE_BYTE_F(adr, res);
18543         }
18544 #endif
18545
18546         POST_IO
18547 #ifdef USE_CYCLONE_TIMING
18548 RET(20)
18549 #else
18550 RET(8)
18551 #endif
18552 }
18553
18554 // ILLEGAL
18555 OPCODE(0x4AFC)
18556 {
18557         SET_PC(execute_exception(M68K_ILLEGAL_INSTRUCTION_EX, GET_PC-2, GET_SR));
18558 RET(0)
18559 }
18560
18561 // ILLEGAL A000-AFFF
18562 OPCODE(0xA000)
18563 {
18564         SET_PC(execute_exception(M68K_1010_EX, GET_PC-2, GET_SR));
18565 RET(0)
18566 }
18567
18568 // ILLEGAL F000-FFFF
18569 OPCODE(0xF000)
18570 {
18571         SET_PC(execute_exception(M68K_1111_EX, GET_PC-2, GET_SR));
18572 RET(0) // 4 already taken by exc. handler
18573 }
18574
18575 // MOVEMaR
18576 OPCODE(0x4C90)
18577 {
18578         u32 adr, res;
18579         u32 src, dst;
18580
18581         s32 *psrc;
18582
18583         FETCH_WORD(res);
18584         adr = AREG((Opcode >> 0) & 7);
18585         psrc = &DREGs32(0);
18586         dst = adr;
18587         PRE_IO
18588         do
18589         {
18590                 if (res & 1)
18591                 {
18592                         READSX_WORD_F(adr, *psrc)
18593                         adr += 2;
18594                 }
18595                 psrc++;
18596         } while (res >>= 1);
18597         POST_IO
18598         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18599 #ifdef USE_CYCLONE_TIMING
18600 RET(12)
18601 #else
18602 RET(16)
18603 #endif
18604 }
18605
18606 // MOVEMaR
18607 OPCODE(0x4C98)
18608 {
18609         u32 adr, res;
18610         u32 src, dst;
18611
18612         s32 *psrc;
18613
18614         FETCH_WORD(res);
18615         adr = AREG((Opcode >> 0) & 7);
18616         psrc = &DREGs32(0);
18617         dst = adr;
18618         PRE_IO
18619         do
18620         {
18621                 if (res & 1)
18622                 {
18623                         READSX_WORD_F(adr, *psrc)
18624                         adr += 2;
18625                 }
18626                 psrc++;
18627         } while (res >>= 1);
18628         AREG((Opcode >> 0) & 7) = adr;
18629         POST_IO
18630         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18631 RET(12)
18632 }
18633
18634 // MOVEMaR
18635 OPCODE(0x4CA8)
18636 {
18637         u32 adr, res;
18638         u32 src, dst;
18639
18640         s32 *psrc;
18641
18642         FETCH_WORD(res);
18643         FETCH_SWORD(adr);
18644         adr += AREG((Opcode >> 0) & 7);
18645         psrc = &DREGs32(0);
18646         dst = adr;
18647         PRE_IO
18648         do
18649         {
18650                 if (res & 1)
18651                 {
18652                         READSX_WORD_F(adr, *psrc)
18653                         adr += 2;
18654                 }
18655                 psrc++;
18656         } while (res >>= 1);
18657         POST_IO
18658         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18659 #ifdef USE_CYCLONE_TIMING
18660 RET(16)
18661 #else
18662 RET(24)
18663 #endif
18664 }
18665
18666 // MOVEMaR
18667 OPCODE(0x4CB0)
18668 {
18669         u32 adr, res;
18670         u32 src, dst;
18671
18672         s32 *psrc;
18673
18674         FETCH_WORD(res);
18675         adr = AREG((Opcode >> 0) & 7);
18676         DECODE_EXT_WORD
18677         psrc = &DREGs32(0);
18678         dst = adr;
18679         PRE_IO
18680         do
18681         {
18682                 if (res & 1)
18683                 {
18684                         READSX_WORD_F(adr, *psrc)
18685                         adr += 2;
18686                 }
18687                 psrc++;
18688         } while (res >>= 1);
18689         POST_IO
18690         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18691 #ifdef USE_CYCLONE_TIMING
18692 RET(18)
18693 #else
18694 RET(28)
18695 #endif
18696 }
18697
18698 // MOVEMaR
18699 OPCODE(0x4CB8)
18700 {
18701         u32 adr, res;
18702         u32 src, dst;
18703
18704         s32 *psrc;
18705
18706         FETCH_WORD(res);
18707         FETCH_SWORD(adr);
18708         psrc = &DREGs32(0);
18709         dst = adr;
18710         PRE_IO
18711         do
18712         {
18713                 if (res & 1)
18714                 {
18715                         READSX_WORD_F(adr, *psrc)
18716                         adr += 2;
18717                 }
18718                 psrc++;
18719         } while (res >>= 1);
18720         POST_IO
18721         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18722 #ifdef USE_CYCLONE_TIMING
18723 RET(16)
18724 #else
18725 RET(24)
18726 #endif
18727 }
18728
18729 // MOVEMaR
18730 OPCODE(0x4CB9)
18731 {
18732         u32 adr, res;
18733         u32 src, dst;
18734
18735         s32 *psrc;
18736
18737         FETCH_WORD(res);
18738         FETCH_LONG(adr);
18739         psrc = &DREGs32(0);
18740         dst = adr;
18741         PRE_IO
18742         do
18743         {
18744                 if (res & 1)
18745                 {
18746                         READSX_WORD_F(adr, *psrc)
18747                         adr += 2;
18748                 }
18749                 psrc++;
18750         } while (res >>= 1);
18751         POST_IO
18752         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18753 #ifdef USE_CYCLONE_TIMING
18754 RET(20)
18755 #else
18756 RET(32)
18757 #endif
18758 }
18759
18760 // MOVEMaR
18761 OPCODE(0x4CBA)
18762 {
18763         u32 adr, res;
18764         u32 src, dst;
18765
18766         s32 *psrc;
18767
18768         FETCH_WORD(res);
18769         adr = GET_SWORD + GET_PC;
18770         PC++;
18771         psrc = &DREGs32(0);
18772         dst = adr;
18773         PRE_IO
18774         do
18775         {
18776                 if (res & 1)
18777                 {
18778                         READSX_WORD_F(adr, *psrc)
18779                         adr += 2;
18780                 }
18781                 psrc++;
18782         } while (res >>= 1);
18783         POST_IO
18784         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18785 #ifdef USE_CYCLONE_TIMING
18786 RET(16)
18787 #else
18788 RET(24)
18789 #endif
18790 }
18791
18792 // MOVEMaR
18793 OPCODE(0x4CBB)
18794 {
18795         u32 adr, res;
18796         u32 src, dst;
18797
18798         s32 *psrc;
18799
18800         FETCH_WORD(res);
18801         adr = GET_PC;
18802         DECODE_EXT_WORD
18803         psrc = &DREGs32(0);
18804         dst = adr;
18805         PRE_IO
18806         do
18807         {
18808                 if (res & 1)
18809                 {
18810                         READSX_WORD_F(adr, *psrc)
18811                         adr += 2;
18812                 }
18813                 psrc++;
18814         } while (res >>= 1);
18815         POST_IO
18816         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18817 #ifdef USE_CYCLONE_TIMING
18818 RET(18)
18819 #else
18820 RET(28)
18821 #endif
18822 }
18823
18824 // MOVEMaR
18825 OPCODE(0x4C9F)
18826 {
18827         u32 adr, res;
18828         u32 src, dst;
18829
18830         s32 *psrc;
18831
18832         FETCH_WORD(res);
18833         adr = AREG(7);
18834         psrc = &DREGs32(0);
18835         dst = adr;
18836         PRE_IO
18837         do
18838         {
18839                 if (res & 1)
18840                 {
18841                         READSX_WORD_F(adr, *psrc)
18842                         adr += 2;
18843                 }
18844                 psrc++;
18845         } while (res >>= 1);
18846         AREG(7) = adr;
18847         POST_IO
18848         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18849 RET(12)
18850 }
18851
18852 // MOVEMaR
18853 OPCODE(0x4CD0)
18854 {
18855         u32 adr, res;
18856         u32 src, dst;
18857
18858         u32 *psrc;
18859
18860         FETCH_WORD(res);
18861         adr = AREG((Opcode >> 0) & 7);
18862         psrc = &DREGu32(0);
18863         dst = adr;
18864         PRE_IO
18865         do
18866         {
18867                 if (res & 1)
18868                 {
18869                         READ_LONG_F(adr, *psrc)
18870                         adr += 4;
18871                 }
18872                 psrc++;
18873         } while (res >>= 1);
18874         POST_IO
18875         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18876 #ifdef USE_CYCLONE_TIMING
18877 RET(12)
18878 #else
18879 RET(20)
18880 #endif
18881 }
18882
18883 // MOVEMaR
18884 OPCODE(0x4CD8)
18885 {
18886         u32 adr, res;
18887         u32 src, dst;
18888
18889         u32 *psrc;
18890
18891         FETCH_WORD(res);
18892         adr = AREG((Opcode >> 0) & 7);
18893         psrc = &DREGu32(0);
18894         dst = adr;
18895         PRE_IO
18896         do
18897         {
18898                 if (res & 1)
18899                 {
18900                         READ_LONG_F(adr, *psrc)
18901                         adr += 4;
18902                 }
18903                 psrc++;
18904         } while (res >>= 1);
18905         AREG((Opcode >> 0) & 7) = adr;
18906         POST_IO
18907         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18908 RET(12)
18909 }
18910
18911 // MOVEMaR
18912 OPCODE(0x4CE8)
18913 {
18914         u32 adr, res;
18915         u32 src, dst;
18916
18917         u32 *psrc;
18918
18919         FETCH_WORD(res);
18920         FETCH_SWORD(adr);
18921         adr += AREG((Opcode >> 0) & 7);
18922         psrc = &DREGu32(0);
18923         dst = adr;
18924         PRE_IO
18925         do
18926         {
18927                 if (res & 1)
18928                 {
18929                         READ_LONG_F(adr, *psrc)
18930                         adr += 4;
18931                 }
18932                 psrc++;
18933         } while (res >>= 1);
18934         POST_IO
18935         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18936 #ifdef USE_CYCLONE_TIMING
18937 RET(16)
18938 #else
18939 RET(28)
18940 #endif
18941 }
18942
18943 // MOVEMaR
18944 OPCODE(0x4CF0)
18945 {
18946         u32 adr, res;
18947         u32 src, dst;
18948
18949         u32 *psrc;
18950
18951         FETCH_WORD(res);
18952         adr = AREG((Opcode >> 0) & 7);
18953         DECODE_EXT_WORD
18954         psrc = &DREGu32(0);
18955         dst = adr;
18956         PRE_IO
18957         do
18958         {
18959                 if (res & 1)
18960                 {
18961                         READ_LONG_F(adr, *psrc)
18962                         adr += 4;
18963                 }
18964                 psrc++;
18965         } while (res >>= 1);
18966         POST_IO
18967         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18968 #ifdef USE_CYCLONE_TIMING
18969 RET(18)
18970 #else
18971 RET(32)
18972 #endif
18973 }
18974
18975 // MOVEMaR
18976 OPCODE(0x4CF8)
18977 {
18978         u32 adr, res;
18979         u32 src, dst;
18980
18981         u32 *psrc;
18982
18983         FETCH_WORD(res);
18984         FETCH_SWORD(adr);
18985         psrc = &DREGu32(0);
18986         dst = adr;
18987         PRE_IO
18988         do
18989         {
18990                 if (res & 1)
18991                 {
18992                         READ_LONG_F(adr, *psrc)
18993                         adr += 4;
18994                 }
18995                 psrc++;
18996         } while (res >>= 1);
18997         POST_IO
18998         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18999 #ifdef USE_CYCLONE_TIMING
19000 RET(16)
19001 #else
19002 RET(28)
19003 #endif
19004 }
19005
19006 // MOVEMaR
19007 OPCODE(0x4CF9)
19008 {
19009         u32 adr, res;
19010         u32 src, dst;
19011
19012         u32 *psrc;
19013
19014         FETCH_WORD(res);
19015         FETCH_LONG(adr);
19016         psrc = &DREGu32(0);
19017         dst = adr;
19018         PRE_IO
19019         do
19020         {
19021                 if (res & 1)
19022                 {
19023                         READ_LONG_F(adr, *psrc)
19024                         adr += 4;
19025                 }
19026                 psrc++;
19027         } while (res >>= 1);
19028         POST_IO
19029         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19030 #ifdef USE_CYCLONE_TIMING
19031 RET(20)
19032 #else
19033 RET(36)
19034 #endif
19035 }
19036
19037 // MOVEMaR
19038 OPCODE(0x4CFA)
19039 {
19040         u32 adr, res;
19041         u32 src, dst;
19042
19043         u32 *psrc;
19044
19045         FETCH_WORD(res);
19046         adr = GET_SWORD + GET_PC;
19047         PC++;
19048         psrc = &DREGu32(0);
19049         dst = adr;
19050         PRE_IO
19051         do
19052         {
19053                 if (res & 1)
19054                 {
19055                         READ_LONG_F(adr, *psrc)
19056                         adr += 4;
19057                 }
19058                 psrc++;
19059         } while (res >>= 1);
19060         POST_IO
19061         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19062 #ifdef USE_CYCLONE_TIMING
19063 RET(16)
19064 #else
19065 RET(28)
19066 #endif
19067 }
19068
19069 // MOVEMaR
19070 OPCODE(0x4CFB)
19071 {
19072         u32 adr, res;
19073         u32 src, dst;
19074
19075         u32 *psrc;
19076
19077         FETCH_WORD(res);
19078         adr = GET_PC;
19079         DECODE_EXT_WORD
19080         psrc = &DREGu32(0);
19081         dst = adr;
19082         PRE_IO
19083         do
19084         {
19085                 if (res & 1)
19086                 {
19087                         READ_LONG_F(adr, *psrc)
19088                         adr += 4;
19089                 }
19090                 psrc++;
19091         } while (res >>= 1);
19092         POST_IO
19093         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19094 #ifdef USE_CYCLONE_TIMING
19095 RET(18)
19096 #else
19097 RET(32)
19098 #endif
19099 }
19100
19101 // MOVEMaR
19102 OPCODE(0x4CDF)
19103 {
19104         u32 adr, res;
19105         u32 src, dst;
19106
19107         u32 *psrc;
19108
19109         FETCH_WORD(res);
19110         adr = AREG(7);
19111         psrc = &DREGu32(0);
19112         dst = adr;
19113         PRE_IO
19114         do
19115         {
19116                 if (res & 1)
19117                 {
19118                         READ_LONG_F(adr, *psrc)
19119                         adr += 4;
19120                 }
19121                 psrc++;
19122         } while (res >>= 1);
19123         AREG(7) = adr;
19124         POST_IO
19125         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19126 RET(12)
19127 }
19128
19129 // TRAP
19130 OPCODE(0x4E40)
19131 {
19132         SET_PC(execute_exception(M68K_TRAP_BASE_EX + (Opcode & 0xF), GET_PC, GET_SR));
19133 RET(4)
19134 }
19135
19136 // LINK
19137 OPCODE(0x4E50)
19138 {
19139         u32 adr, res;
19140         u32 src, dst;
19141
19142         res = AREGu32((Opcode >> 0) & 7);
19143         PRE_IO
19144         PUSH_32_F(res)
19145         res = AREG(7);
19146         AREG((Opcode >> 0) & 7) = res;
19147         FETCH_SWORD(res);
19148         AREG(7) += res;
19149         POST_IO
19150 RET(16)
19151 }
19152
19153 // LINKA7
19154 OPCODE(0x4E57)
19155 {
19156         u32 adr, res;
19157         u32 src, dst;
19158
19159         AREG(7) -= 4;
19160         PRE_IO
19161         WRITE_LONG_DEC_F(AREG(7), AREG(7))
19162         FETCH_SWORD(res);
19163         AREG(7) += res;
19164         POST_IO
19165 RET(16)
19166 }
19167
19168 // ULNK
19169 OPCODE(0x4E58)
19170 {
19171         u32 adr, res;
19172         u32 src, dst;
19173
19174         src = AREGu32((Opcode >> 0) & 7);
19175         AREG(7) = src + 4;
19176         PRE_IO
19177         READ_LONG_F(src, res)
19178         AREG((Opcode >> 0) & 7) = res;
19179         POST_IO
19180 RET(12)
19181 }
19182
19183 // ULNKA7
19184 OPCODE(0x4E5F)
19185 {
19186         u32 adr, res;
19187         u32 src, dst;
19188
19189         PRE_IO
19190         READ_LONG_F(AREG(7), AREG(7))
19191         POST_IO
19192 RET(12)
19193 }
19194
19195 // MOVEAUSP
19196 OPCODE(0x4E60)
19197 {
19198         u32 adr, res;
19199         u32 src, dst;
19200
19201         if (!flag_S)
19202         {
19203                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19204                 RET(4)
19205         }
19206         res = AREGu32((Opcode >> 0) & 7);
19207         ASP = res;
19208 RET(4)
19209 }
19210
19211 // MOVEUSPA
19212 OPCODE(0x4E68)
19213 {
19214         u32 adr, res;
19215         u32 src, dst;
19216
19217         if (!flag_S)
19218         {
19219                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19220                 RET(4)
19221         }
19222         res = ASP;
19223         AREG((Opcode >> 0) & 7) = res;
19224 RET(4)
19225 }
19226
19227 // RESET
19228 OPCODE(0x4E70)
19229 {
19230         u32 adr, res;
19231         u32 src, dst;
19232
19233         if (!flag_S)
19234         {
19235                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19236                 RET(4)
19237         }
19238         PRE_IO
19239         if (m68kcontext.reset_handler) m68kcontext.reset_handler();
19240 //      CPU->Reset_CallBack();
19241         POST_IO
19242 RET(132)
19243 }
19244
19245 // NOP
19246 OPCODE(0x4E71)
19247 {
19248 RET(4)
19249 }
19250
19251 // STOP
19252 OPCODE(0x4E72)
19253 {
19254         u32 adr, res;
19255         u32 src, dst;
19256
19257         if (!flag_S)
19258         {
19259                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19260                 RET(4)
19261         }
19262         FETCH_WORD(res);
19263         res &= M68K_SR_MASK;
19264         SET_SR(res)
19265         if (!flag_S)
19266         {
19267                 res = AREG(7);
19268                 AREG(7) = ASP;
19269                 ASP = res;
19270         }
19271         m68kcontext.execinfo |= FM68K_HALTED;
19272 RET0()
19273 }
19274
19275 // RTE
19276 OPCODE(0x4E73)
19277 {
19278         u32 adr, res;
19279         u32 src, dst;
19280
19281         if (!flag_S)
19282         {
19283                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19284                 RET(4)
19285         }
19286         PRE_IO
19287         POP_16_F(res)
19288         SET_SR(res)
19289         POP_32_F(res)
19290         SET_PC(res)
19291         if (!flag_S)
19292         {
19293                 res = AREG(7);
19294                 AREG(7) = ASP;
19295                 ASP = res;
19296         }
19297         POST_IO
19298         m68kcontext.execinfo &= ~(FM68K_EMULATE_GROUP_0|FM68K_EMULATE_TRACE|FM68K_DO_TRACE);
19299         CHECK_INT_TO_JUMP(20)
19300 RET(20)
19301 }
19302
19303 // RTS
19304 OPCODE(0x4E75)
19305 {
19306         u32 adr, res;
19307         u32 src, dst;
19308
19309         PRE_IO
19310         POP_32_F(res)
19311         SET_PC(res)
19312         CHECK_BRANCH_EXCEPTION(res)
19313         POST_IO
19314 RET(16)
19315 }
19316
19317 // TRAPV
19318 OPCODE(0x4E76)
19319 {
19320         if (flag_V & 0x80)
19321                 SET_PC(execute_exception(M68K_TRAPV_EX, GET_PC, GET_SR));
19322 RET(4)
19323 }
19324
19325 // RTR
19326 OPCODE(0x4E77)
19327 {
19328         u32 adr, res;
19329         u32 src, dst;
19330
19331         PRE_IO
19332         POP_16_F(res)
19333         SET_CCR(res)
19334         POP_32_F(res)
19335         SET_PC(res)
19336         CHECK_BRANCH_EXCEPTION(res)
19337         POST_IO
19338 RET(20)
19339 }
19340
19341 // JSR
19342 OPCODE(0x4E90)
19343 {
19344         u32 adr, res;
19345         u32 src, dst;
19346
19347         adr = AREG((Opcode >> 0) & 7);
19348         {
19349                 u32 oldPC;
19350
19351                 oldPC = GET_PC;
19352         PRE_IO
19353                 PUSH_32_F(oldPC)
19354         }
19355         SET_PC(adr)
19356         CHECK_BRANCH_EXCEPTION(adr)
19357         POST_IO
19358 RET(16)
19359 }
19360
19361 // JSR
19362 OPCODE(0x4EA8)
19363 {
19364         u32 adr, res;
19365         u32 src, dst;
19366
19367         FETCH_SWORD(adr);
19368         adr += AREG((Opcode >> 0) & 7);
19369         {
19370                 u32 oldPC;
19371
19372                 oldPC = GET_PC;
19373         PRE_IO
19374                 PUSH_32_F(oldPC)
19375         }
19376         SET_PC(adr)
19377         CHECK_BRANCH_EXCEPTION(adr)
19378         POST_IO
19379 RET(18)
19380 }
19381
19382 // JSR
19383 OPCODE(0x4EB0)
19384 {
19385         u32 adr, res;
19386         u32 src, dst;
19387
19388         adr = AREG((Opcode >> 0) & 7);
19389         DECODE_EXT_WORD
19390         {
19391                 u32 oldPC;
19392
19393                 oldPC = GET_PC;
19394         PRE_IO
19395                 PUSH_32_F(oldPC)
19396         }
19397         SET_PC(adr)
19398         CHECK_BRANCH_EXCEPTION(adr)
19399         POST_IO
19400 RET(22)
19401 }
19402
19403 // JSR
19404 OPCODE(0x4EB8)
19405 {
19406         u32 adr, res;
19407         u32 src, dst;
19408
19409         FETCH_SWORD(adr);
19410         {
19411                 u32 oldPC;
19412
19413                 oldPC = GET_PC;
19414         PRE_IO
19415                 PUSH_32_F(oldPC)
19416         }
19417         SET_PC(adr)
19418         CHECK_BRANCH_EXCEPTION(adr)
19419         POST_IO
19420 RET(18)
19421 }
19422
19423 // JSR
19424 OPCODE(0x4EB9)
19425 {
19426         u32 adr, res;
19427         u32 src, dst;
19428
19429         FETCH_LONG(adr);
19430         {
19431                 u32 oldPC;
19432
19433                 oldPC = GET_PC;
19434         PRE_IO
19435                 PUSH_32_F(oldPC)
19436         }
19437         SET_PC(adr)
19438         CHECK_BRANCH_EXCEPTION(adr)
19439         POST_IO
19440 RET(20)
19441 }
19442
19443 // JSR
19444 OPCODE(0x4EBA)
19445 {
19446         u32 adr, res;
19447         u32 src, dst;
19448
19449         adr = GET_SWORD + GET_PC;
19450         PC++;
19451         {
19452                 u32 oldPC;
19453
19454                 oldPC = GET_PC;
19455         PRE_IO
19456                 PUSH_32_F(oldPC)
19457         }
19458         SET_PC(adr)
19459         CHECK_BRANCH_EXCEPTION(adr)
19460         POST_IO
19461 RET(18)
19462 }
19463
19464 // JSR
19465 OPCODE(0x4EBB)
19466 {
19467         u32 adr, res;
19468         u32 src, dst;
19469
19470         adr = GET_PC;
19471         DECODE_EXT_WORD
19472         {
19473                 u32 oldPC;
19474
19475                 oldPC = GET_PC;
19476         PRE_IO
19477                 PUSH_32_F(oldPC)
19478         }
19479         SET_PC(adr)
19480         CHECK_BRANCH_EXCEPTION(adr)
19481         POST_IO
19482 RET(22)
19483 }
19484
19485 // JMP
19486 OPCODE(0x4ED0)
19487 {
19488         u32 adr, res;
19489         u32 src, dst;
19490
19491         adr = AREG((Opcode >> 0) & 7);
19492         SET_PC(adr)
19493         CHECK_BRANCH_EXCEPTION(adr)
19494 RET(8)
19495 }
19496
19497 // JMP
19498 OPCODE(0x4EE8)
19499 {
19500         u32 adr, res;
19501         u32 src, dst;
19502
19503         FETCH_SWORD(adr);
19504         adr += AREG((Opcode >> 0) & 7);
19505         SET_PC(adr)
19506         CHECK_BRANCH_EXCEPTION(adr)
19507 RET(10)
19508 }
19509
19510 // JMP
19511 OPCODE(0x4EF0)
19512 {
19513         u32 adr, res;
19514         u32 src, dst;
19515
19516         adr = AREG((Opcode >> 0) & 7);
19517         DECODE_EXT_WORD
19518         SET_PC(adr)
19519         CHECK_BRANCH_EXCEPTION(adr)
19520 RET(14)
19521 }
19522
19523 // JMP
19524 OPCODE(0x4EF8)
19525 {
19526         u32 adr, res;
19527         u32 src, dst;
19528
19529         FETCH_SWORD(adr);
19530         SET_PC(adr)
19531         CHECK_BRANCH_EXCEPTION(adr)
19532 RET(10)
19533 }
19534
19535 // JMP
19536 OPCODE(0x4EF9)
19537 {
19538         u32 adr, res;
19539         u32 src, dst;
19540
19541         FETCH_LONG(adr);
19542         SET_PC(adr)
19543         CHECK_BRANCH_EXCEPTION(adr)
19544 RET(12)
19545 }
19546
19547 // JMP
19548 OPCODE(0x4EFA)
19549 {
19550         u32 adr, res;
19551         u32 src, dst;
19552
19553         adr = GET_SWORD + GET_PC;
19554         PC++;
19555         SET_PC(adr)
19556         CHECK_BRANCH_EXCEPTION(adr)
19557 RET(10)
19558 }
19559
19560 // JMP
19561 OPCODE(0x4EFB)
19562 {
19563         u32 adr, res;
19564         u32 src, dst;
19565
19566         adr = GET_PC;
19567         DECODE_EXT_WORD
19568         SET_PC(adr)
19569         CHECK_BRANCH_EXCEPTION(adr)
19570 RET(14)
19571 }
19572
19573 // CHK
19574 OPCODE(0x4180)
19575 {
19576         u32 adr, res;
19577         u32 src, dst;
19578
19579         src = DREGu16((Opcode >> 0) & 7);
19580         res = DREGu16((Opcode >> 9) & 7);
19581         if (((s32)res < 0) || (res > src))
19582         {
19583                 flag_N = res >> 8;
19584                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19585         }
19586 RET(10)
19587 }
19588
19589 // CHK
19590 OPCODE(0x4190)
19591 {
19592         u32 adr, res;
19593         u32 src, dst;
19594
19595         adr = AREG((Opcode >> 0) & 7);
19596         PRE_IO
19597         READ_WORD_F(adr, src)
19598         res = DREGu16((Opcode >> 9) & 7);
19599         if (((s32)res < 0) || (res > src))
19600         {
19601                 flag_N = res >> 8;
19602                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19603         }
19604         POST_IO
19605 RET(14)
19606 }
19607
19608 // CHK
19609 OPCODE(0x4198)
19610 {
19611         u32 adr, res;
19612         u32 src, dst;
19613
19614         adr = AREG((Opcode >> 0) & 7);
19615         AREG((Opcode >> 0) & 7) += 2;
19616         PRE_IO
19617         READ_WORD_F(adr, src)
19618         res = DREGu16((Opcode >> 9) & 7);
19619         if (((s32)res < 0) || (res > src))
19620         {
19621                 flag_N = res >> 8;
19622                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19623         }
19624         POST_IO
19625 RET(14)
19626 }
19627
19628 // CHK
19629 OPCODE(0x41A0)
19630 {
19631         u32 adr, res;
19632         u32 src, dst;
19633
19634         adr = AREG((Opcode >> 0) & 7) - 2;
19635         AREG((Opcode >> 0) & 7) = adr;
19636         PRE_IO
19637         READ_WORD_F(adr, src)
19638         res = DREGu16((Opcode >> 9) & 7);
19639         if (((s32)res < 0) || (res > src))
19640         {
19641                 flag_N = res >> 8;
19642                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19643         }
19644         POST_IO
19645 RET(16)
19646 }
19647
19648 // CHK
19649 OPCODE(0x41A8)
19650 {
19651         u32 adr, res;
19652         u32 src, dst;
19653
19654         FETCH_SWORD(adr);
19655         adr += AREG((Opcode >> 0) & 7);
19656         PRE_IO
19657         READ_WORD_F(adr, src)
19658         res = DREGu16((Opcode >> 9) & 7);
19659         if (((s32)res < 0) || (res > src))
19660         {
19661                 flag_N = res >> 8;
19662                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19663         }
19664         POST_IO
19665 RET(18)
19666 }
19667
19668 // CHK
19669 OPCODE(0x41B0)
19670 {
19671         u32 adr, res;
19672         u32 src, dst;
19673
19674         adr = AREG((Opcode >> 0) & 7);
19675         DECODE_EXT_WORD
19676         PRE_IO
19677         READ_WORD_F(adr, src)
19678         res = DREGu16((Opcode >> 9) & 7);
19679         if (((s32)res < 0) || (res > src))
19680         {
19681                 flag_N = res >> 8;
19682                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19683         }
19684         POST_IO
19685 RET(20)
19686 }
19687
19688 // CHK
19689 OPCODE(0x41B8)
19690 {
19691         u32 adr, res;
19692         u32 src, dst;
19693
19694         FETCH_SWORD(adr);
19695         PRE_IO
19696         READ_WORD_F(adr, src)
19697         res = DREGu16((Opcode >> 9) & 7);
19698         if (((s32)res < 0) || (res > src))
19699         {
19700                 flag_N = res >> 8;
19701                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19702         }
19703         POST_IO
19704 RET(18)
19705 }
19706
19707 // CHK
19708 OPCODE(0x41B9)
19709 {
19710         u32 adr, res;
19711         u32 src, dst;
19712
19713         FETCH_LONG(adr);
19714         PRE_IO
19715         READ_WORD_F(adr, src)
19716         res = DREGu16((Opcode >> 9) & 7);
19717         if (((s32)res < 0) || (res > src))
19718         {
19719                 flag_N = res >> 8;
19720                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19721         }
19722         POST_IO
19723 RET(22)
19724 }
19725
19726 // CHK
19727 OPCODE(0x41BA)
19728 {
19729         u32 adr, res;
19730         u32 src, dst;
19731
19732         adr = GET_SWORD + GET_PC;
19733         PC++;
19734         PRE_IO
19735         READ_WORD_F(adr, src)
19736         res = DREGu16((Opcode >> 9) & 7);
19737         if (((s32)res < 0) || (res > src))
19738         {
19739                 flag_N = res >> 8;
19740                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19741         }
19742         POST_IO
19743 RET(18)
19744 }
19745
19746 // CHK
19747 OPCODE(0x41BB)
19748 {
19749         u32 adr, res;
19750         u32 src, dst;
19751
19752         adr = GET_PC;
19753         DECODE_EXT_WORD
19754         PRE_IO
19755         READ_WORD_F(adr, src)
19756         res = DREGu16((Opcode >> 9) & 7);
19757         if (((s32)res < 0) || (res > src))
19758         {
19759                 flag_N = res >> 8;
19760                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19761         }
19762         POST_IO
19763 RET(20)
19764 }
19765
19766 // CHK
19767 OPCODE(0x41BC)
19768 {
19769         u32 adr, res;
19770         u32 src, dst;
19771
19772         FETCH_WORD(src);
19773         res = DREGu16((Opcode >> 9) & 7);
19774         if (((s32)res < 0) || (res > src))
19775         {
19776                 flag_N = res >> 8;
19777                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19778         }
19779         POST_IO
19780 RET(14)
19781 }
19782
19783 // CHK
19784 OPCODE(0x419F)
19785 {
19786         u32 adr, res;
19787         u32 src, dst;
19788
19789         adr = AREG(7);
19790         AREG(7) += 2;
19791         PRE_IO
19792         READ_WORD_F(adr, src)
19793         res = DREGu16((Opcode >> 9) & 7);
19794         if (((s32)res < 0) || (res > src))
19795         {
19796                 flag_N = res >> 8;
19797                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19798         }
19799         POST_IO
19800 RET(14)
19801 }
19802
19803 // CHK
19804 OPCODE(0x41A7)
19805 {
19806         u32 adr, res;
19807         u32 src, dst;
19808
19809         adr = AREG(7) - 2;
19810         AREG(7) = adr;
19811         PRE_IO
19812         READ_WORD_F(adr, src)
19813         res = DREGu16((Opcode >> 9) & 7);
19814         if (((s32)res < 0) || (res > src))
19815         {
19816                 flag_N = res >> 8;
19817                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19818         }
19819         POST_IO
19820 RET(16)
19821 }
19822
19823 // LEA
19824 OPCODE(0x41D0)
19825 {
19826         u32 adr, res;
19827         u32 src, dst;
19828
19829         adr = AREG((Opcode >> 0) & 7);
19830         res = adr;
19831         AREG((Opcode >> 9) & 7) = res;
19832 RET(4)
19833 }
19834
19835 // LEA
19836 OPCODE(0x41E8)
19837 {
19838         u32 adr, res;
19839         u32 src, dst;
19840
19841         FETCH_SWORD(adr);
19842         adr += AREG((Opcode >> 0) & 7);
19843         res = adr;
19844         AREG((Opcode >> 9) & 7) = res;
19845 RET(8)
19846 }
19847
19848 // LEA
19849 OPCODE(0x41F0)
19850 {
19851         u32 adr, res;
19852         u32 src, dst;
19853
19854         adr = AREG((Opcode >> 0) & 7);
19855         DECODE_EXT_WORD
19856         res = adr;
19857         AREG((Opcode >> 9) & 7) = res;
19858 RET(12)
19859 }
19860
19861 // LEA
19862 OPCODE(0x41F8)
19863 {
19864         u32 adr, res;
19865         u32 src, dst;
19866
19867         FETCH_SWORD(adr);
19868         res = adr;
19869         AREG((Opcode >> 9) & 7) = res;
19870 RET(8)
19871 }
19872
19873 // LEA
19874 OPCODE(0x41F9)
19875 {
19876         u32 adr, res;
19877         u32 src, dst;
19878
19879         FETCH_LONG(adr);
19880         res = adr;
19881         AREG((Opcode >> 9) & 7) = res;
19882 RET(12)
19883 }
19884
19885 // LEA
19886 OPCODE(0x41FA)
19887 {
19888         u32 adr, res;
19889         u32 src, dst;
19890
19891         adr = GET_SWORD + GET_PC;
19892         PC++;
19893         res = adr;
19894         AREG((Opcode >> 9) & 7) = res;
19895 RET(8)
19896 }
19897
19898 // LEA
19899 OPCODE(0x41FB)
19900 {
19901         u32 adr, res;
19902         u32 src, dst;
19903
19904         adr = GET_PC;
19905         DECODE_EXT_WORD
19906         res = adr;
19907         AREG((Opcode >> 9) & 7) = res;
19908 RET(12)
19909 }
19910
19911 // STCC
19912 OPCODE(0x50C0)
19913 {
19914         u32 adr, res;
19915         u32 src, dst;
19916
19917         res = 0xFF;
19918         DREGu8((Opcode >> 0) & 7) = res;
19919         RET(6)
19920 }
19921
19922 // STCC
19923 OPCODE(0x51C0)
19924 {
19925         u32 adr, res;
19926         u32 src, dst;
19927
19928         res = 0;
19929         DREGu8((Opcode >> 0) & 7) = res;
19930         RET(4)
19931 }
19932
19933 // STCC
19934 OPCODE(0x52C0)
19935 {
19936         u32 adr, res;
19937         u32 src, dst;
19938
19939         if (flag_NotZ && (!(flag_C & 0x100)))
19940         {
19941         res = 0xFF;
19942         DREGu8((Opcode >> 0) & 7) = res;
19943         RET(6)
19944         }
19945         res = 0;
19946         DREGu8((Opcode >> 0) & 7) = res;
19947         RET(4)
19948 }
19949
19950 // STCC
19951 OPCODE(0x53C0)
19952 {
19953         u32 adr, res;
19954         u32 src, dst;
19955
19956         if ((!flag_NotZ) || (flag_C & 0x100))
19957         {
19958         res = 0xFF;
19959         DREGu8((Opcode >> 0) & 7) = res;
19960         RET(6)
19961         }
19962         res = 0;
19963         DREGu8((Opcode >> 0) & 7) = res;
19964         RET(4)
19965 }
19966
19967 // STCC
19968 OPCODE(0x54C0)
19969 {
19970         u32 adr, res;
19971         u32 src, dst;
19972
19973         if (!(flag_C & 0x100))
19974         {
19975         res = 0xFF;
19976         DREGu8((Opcode >> 0) & 7) = res;
19977         RET(6)
19978         }
19979         res = 0;
19980         DREGu8((Opcode >> 0) & 7) = res;
19981         RET(4)
19982 }
19983
19984 // STCC
19985 OPCODE(0x55C0)
19986 {
19987         u32 adr, res;
19988         u32 src, dst;
19989
19990         if (flag_C & 0x100)
19991         {
19992         res = 0xFF;
19993         DREGu8((Opcode >> 0) & 7) = res;
19994         RET(6)
19995         }
19996         res = 0;
19997         DREGu8((Opcode >> 0) & 7) = res;
19998         RET(4)
19999 }
20000
20001 // STCC
20002 OPCODE(0x56C0)
20003 {
20004         u32 adr, res;
20005         u32 src, dst;
20006
20007         if (flag_NotZ)
20008         {
20009         res = 0xFF;
20010         DREGu8((Opcode >> 0) & 7) = res;
20011         RET(6)
20012         }
20013         res = 0;
20014         DREGu8((Opcode >> 0) & 7) = res;
20015         RET(4)
20016 }
20017
20018 // STCC
20019 OPCODE(0x57C0)
20020 {
20021         u32 adr, res;
20022         u32 src, dst;
20023
20024         if (!flag_NotZ)
20025         {
20026         res = 0xFF;
20027         DREGu8((Opcode >> 0) & 7) = res;
20028         RET(6)
20029         }
20030         res = 0;
20031         DREGu8((Opcode >> 0) & 7) = res;
20032         RET(4)
20033 }
20034
20035 // STCC
20036 OPCODE(0x58C0)
20037 {
20038         u32 adr, res;
20039         u32 src, dst;
20040
20041         if (!(flag_V & 0x80))
20042         {
20043         res = 0xFF;
20044         DREGu8((Opcode >> 0) & 7) = res;
20045         RET(6)
20046         }
20047         res = 0;
20048         DREGu8((Opcode >> 0) & 7) = res;
20049         RET(4)
20050 }
20051
20052 // STCC
20053 OPCODE(0x59C0)
20054 {
20055         u32 adr, res;
20056         u32 src, dst;
20057
20058         if (flag_V & 0x80)
20059         {
20060         res = 0xFF;
20061         DREGu8((Opcode >> 0) & 7) = res;
20062         RET(6)
20063         }
20064         res = 0;
20065         DREGu8((Opcode >> 0) & 7) = res;
20066         RET(4)
20067 }
20068
20069 // STCC
20070 OPCODE(0x5AC0)
20071 {
20072         u32 adr, res;
20073         u32 src, dst;
20074
20075         if (!(flag_N & 0x80))
20076         {
20077         res = 0xFF;
20078         DREGu8((Opcode >> 0) & 7) = res;
20079         RET(6)
20080         }
20081         res = 0;
20082         DREGu8((Opcode >> 0) & 7) = res;
20083         RET(4)
20084 }
20085
20086 // STCC
20087 OPCODE(0x5BC0)
20088 {
20089         u32 adr, res;
20090         u32 src, dst;
20091
20092         if (flag_N & 0x80)
20093         {
20094         res = 0xFF;
20095         DREGu8((Opcode >> 0) & 7) = res;
20096         RET(6)
20097         }
20098         res = 0;
20099         DREGu8((Opcode >> 0) & 7) = res;
20100         RET(4)
20101 }
20102
20103 // STCC
20104 OPCODE(0x5CC0)
20105 {
20106         u32 adr, res;
20107         u32 src, dst;
20108
20109         if (!((flag_N ^ flag_V) & 0x80))
20110         {
20111         res = 0xFF;
20112         DREGu8((Opcode >> 0) & 7) = res;
20113         RET(6)
20114         }
20115         res = 0;
20116         DREGu8((Opcode >> 0) & 7) = res;
20117         RET(4)
20118 }
20119
20120 // STCC
20121 OPCODE(0x5DC0)
20122 {
20123         u32 adr, res;
20124         u32 src, dst;
20125
20126         if ((flag_N ^ flag_V) & 0x80)
20127         {
20128         res = 0xFF;
20129         DREGu8((Opcode >> 0) & 7) = res;
20130         RET(6)
20131         }
20132         res = 0;
20133         DREGu8((Opcode >> 0) & 7) = res;
20134         RET(4)
20135 }
20136
20137 // STCC
20138 OPCODE(0x5EC0)
20139 {
20140         u32 adr, res;
20141         u32 src, dst;
20142
20143         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20144         {
20145         res = 0xFF;
20146         DREGu8((Opcode >> 0) & 7) = res;
20147         RET(6)
20148         }
20149         res = 0;
20150         DREGu8((Opcode >> 0) & 7) = res;
20151         RET(4)
20152 }
20153
20154 // STCC
20155 OPCODE(0x5FC0)
20156 {
20157         u32 adr, res;
20158         u32 src, dst;
20159
20160         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20161         {
20162         res = 0xFF;
20163         DREGu8((Opcode >> 0) & 7) = res;
20164         RET(6)
20165         }
20166         res = 0;
20167         DREGu8((Opcode >> 0) & 7) = res;
20168         RET(4)
20169 }
20170
20171 // STCC
20172 OPCODE(0x50D0)
20173 {
20174         u32 adr, res;
20175         u32 src, dst;
20176
20177         adr = AREG((Opcode >> 0) & 7);
20178         res = 0xFF;
20179         PRE_IO
20180         WRITE_BYTE_F(adr, res)
20181         POST_IO
20182         RET(12)
20183 }
20184
20185 // STCC
20186 OPCODE(0x51D0)
20187 {
20188         u32 adr, res;
20189         u32 src, dst;
20190
20191         adr = AREG((Opcode >> 0) & 7);
20192         res = 0;
20193         PRE_IO
20194         WRITE_BYTE_F(adr, res)
20195         POST_IO
20196         RET(12)
20197 }
20198
20199 // STCC
20200 OPCODE(0x52D0)
20201 {
20202         u32 adr, res;
20203         u32 src, dst;
20204
20205         adr = AREG((Opcode >> 0) & 7);
20206         if (flag_NotZ && (!(flag_C & 0x100)))
20207         {
20208         res = 0xFF;
20209         PRE_IO
20210         WRITE_BYTE_F(adr, res)
20211         POST_IO
20212         RET(12)
20213         }
20214         res = 0;
20215         PRE_IO
20216         WRITE_BYTE_F(adr, res)
20217         POST_IO
20218         RET(12)
20219 }
20220
20221 // STCC
20222 OPCODE(0x53D0)
20223 {
20224         u32 adr, res;
20225         u32 src, dst;
20226
20227         adr = AREG((Opcode >> 0) & 7);
20228         if ((!flag_NotZ) || (flag_C & 0x100))
20229         {
20230         res = 0xFF;
20231         PRE_IO
20232         WRITE_BYTE_F(adr, res)
20233         POST_IO
20234         RET(12)
20235         }
20236         res = 0;
20237         PRE_IO
20238         WRITE_BYTE_F(adr, res)
20239         POST_IO
20240         RET(12)
20241 }
20242
20243 // STCC
20244 OPCODE(0x54D0)
20245 {
20246         u32 adr, res;
20247         u32 src, dst;
20248
20249         adr = AREG((Opcode >> 0) & 7);
20250         if (!(flag_C & 0x100))
20251         {
20252         res = 0xFF;
20253         PRE_IO
20254         WRITE_BYTE_F(adr, res)
20255         POST_IO
20256         RET(12)
20257         }
20258         res = 0;
20259         PRE_IO
20260         WRITE_BYTE_F(adr, res)
20261         POST_IO
20262         RET(12)
20263 }
20264
20265 // STCC
20266 OPCODE(0x55D0)
20267 {
20268         u32 adr, res;
20269         u32 src, dst;
20270
20271         adr = AREG((Opcode >> 0) & 7);
20272         if (flag_C & 0x100)
20273         {
20274         res = 0xFF;
20275         PRE_IO
20276         WRITE_BYTE_F(adr, res)
20277         POST_IO
20278         RET(12)
20279         }
20280         res = 0;
20281         PRE_IO
20282         WRITE_BYTE_F(adr, res)
20283         POST_IO
20284         RET(12)
20285 }
20286
20287 // STCC
20288 OPCODE(0x56D0)
20289 {
20290         u32 adr, res;
20291         u32 src, dst;
20292
20293         adr = AREG((Opcode >> 0) & 7);
20294         if (flag_NotZ)
20295         {
20296         res = 0xFF;
20297         PRE_IO
20298         WRITE_BYTE_F(adr, res)
20299         POST_IO
20300         RET(12)
20301         }
20302         res = 0;
20303         PRE_IO
20304         WRITE_BYTE_F(adr, res)
20305         POST_IO
20306         RET(12)
20307 }
20308
20309 // STCC
20310 OPCODE(0x57D0)
20311 {
20312         u32 adr, res;
20313         u32 src, dst;
20314
20315         adr = AREG((Opcode >> 0) & 7);
20316         if (!flag_NotZ)
20317         {
20318         res = 0xFF;
20319         PRE_IO
20320         WRITE_BYTE_F(adr, res)
20321         POST_IO
20322         RET(12)
20323         }
20324         res = 0;
20325         PRE_IO
20326         WRITE_BYTE_F(adr, res)
20327         POST_IO
20328         RET(12)
20329 }
20330
20331 // STCC
20332 OPCODE(0x58D0)
20333 {
20334         u32 adr, res;
20335         u32 src, dst;
20336
20337         adr = AREG((Opcode >> 0) & 7);
20338         if (!(flag_V & 0x80))
20339         {
20340         res = 0xFF;
20341         PRE_IO
20342         WRITE_BYTE_F(adr, res)
20343         POST_IO
20344         RET(12)
20345         }
20346         res = 0;
20347         PRE_IO
20348         WRITE_BYTE_F(adr, res)
20349         POST_IO
20350         RET(12)
20351 }
20352
20353 // STCC
20354 OPCODE(0x59D0)
20355 {
20356         u32 adr, res;
20357         u32 src, dst;
20358
20359         adr = AREG((Opcode >> 0) & 7);
20360         if (flag_V & 0x80)
20361         {
20362         res = 0xFF;
20363         PRE_IO
20364         WRITE_BYTE_F(adr, res)
20365         POST_IO
20366         RET(12)
20367         }
20368         res = 0;
20369         PRE_IO
20370         WRITE_BYTE_F(adr, res)
20371         POST_IO
20372         RET(12)
20373 }
20374
20375 // STCC
20376 OPCODE(0x5AD0)
20377 {
20378         u32 adr, res;
20379         u32 src, dst;
20380
20381         adr = AREG((Opcode >> 0) & 7);
20382         if (!(flag_N & 0x80))
20383         {
20384         res = 0xFF;
20385         PRE_IO
20386         WRITE_BYTE_F(adr, res)
20387         POST_IO
20388         RET(12)
20389         }
20390         res = 0;
20391         PRE_IO
20392         WRITE_BYTE_F(adr, res)
20393         POST_IO
20394         RET(12)
20395 }
20396
20397 // STCC
20398 OPCODE(0x5BD0)
20399 {
20400         u32 adr, res;
20401         u32 src, dst;
20402
20403         adr = AREG((Opcode >> 0) & 7);
20404         if (flag_N & 0x80)
20405         {
20406         res = 0xFF;
20407         PRE_IO
20408         WRITE_BYTE_F(adr, res)
20409         POST_IO
20410         RET(12)
20411         }
20412         res = 0;
20413         PRE_IO
20414         WRITE_BYTE_F(adr, res)
20415         POST_IO
20416         RET(12)
20417 }
20418
20419 // STCC
20420 OPCODE(0x5CD0)
20421 {
20422         u32 adr, res;
20423         u32 src, dst;
20424
20425         adr = AREG((Opcode >> 0) & 7);
20426         if (!((flag_N ^ flag_V) & 0x80))
20427         {
20428         res = 0xFF;
20429         PRE_IO
20430         WRITE_BYTE_F(adr, res)
20431         POST_IO
20432         RET(12)
20433         }
20434         res = 0;
20435         PRE_IO
20436         WRITE_BYTE_F(adr, res)
20437         POST_IO
20438         RET(12)
20439 }
20440
20441 // STCC
20442 OPCODE(0x5DD0)
20443 {
20444         u32 adr, res;
20445         u32 src, dst;
20446
20447         adr = AREG((Opcode >> 0) & 7);
20448         if ((flag_N ^ flag_V) & 0x80)
20449         {
20450         res = 0xFF;
20451         PRE_IO
20452         WRITE_BYTE_F(adr, res)
20453         POST_IO
20454         RET(12)
20455         }
20456         res = 0;
20457         PRE_IO
20458         WRITE_BYTE_F(adr, res)
20459         POST_IO
20460         RET(12)
20461 }
20462
20463 // STCC
20464 OPCODE(0x5ED0)
20465 {
20466         u32 adr, res;
20467         u32 src, dst;
20468
20469         adr = AREG((Opcode >> 0) & 7);
20470         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20471         {
20472         res = 0xFF;
20473         PRE_IO
20474         WRITE_BYTE_F(adr, res)
20475         POST_IO
20476         RET(12)
20477         }
20478         res = 0;
20479         PRE_IO
20480         WRITE_BYTE_F(adr, res)
20481         POST_IO
20482         RET(12)
20483 }
20484
20485 // STCC
20486 OPCODE(0x5FD0)
20487 {
20488         u32 adr, res;
20489         u32 src, dst;
20490
20491         adr = AREG((Opcode >> 0) & 7);
20492         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20493         {
20494         res = 0xFF;
20495         PRE_IO
20496         WRITE_BYTE_F(adr, res)
20497         POST_IO
20498         RET(12)
20499         }
20500         res = 0;
20501         PRE_IO
20502         WRITE_BYTE_F(adr, res)
20503         POST_IO
20504         RET(12)
20505 }
20506
20507 // STCC
20508 OPCODE(0x50D8)
20509 {
20510         u32 adr, res;
20511         u32 src, dst;
20512
20513         adr = AREG((Opcode >> 0) & 7);
20514         AREG((Opcode >> 0) & 7) += 1;
20515         res = 0xFF;
20516         PRE_IO
20517         WRITE_BYTE_F(adr, res)
20518         POST_IO
20519         RET(12)
20520 }
20521
20522 // STCC
20523 OPCODE(0x51D8)
20524 {
20525         u32 adr, res;
20526         u32 src, dst;
20527
20528         adr = AREG((Opcode >> 0) & 7);
20529         AREG((Opcode >> 0) & 7) += 1;
20530         res = 0;
20531         PRE_IO
20532         WRITE_BYTE_F(adr, res)
20533         POST_IO
20534         RET(12)
20535 }
20536
20537 // STCC
20538 OPCODE(0x52D8)
20539 {
20540         u32 adr, res;
20541         u32 src, dst;
20542
20543         adr = AREG((Opcode >> 0) & 7);
20544         AREG((Opcode >> 0) & 7) += 1;
20545         if (flag_NotZ && (!(flag_C & 0x100)))
20546         {
20547         res = 0xFF;
20548         PRE_IO
20549         WRITE_BYTE_F(adr, res)
20550         POST_IO
20551         RET(12)
20552         }
20553         res = 0;
20554         PRE_IO
20555         WRITE_BYTE_F(adr, res)
20556         POST_IO
20557         RET(12)
20558 }
20559
20560 // STCC
20561 OPCODE(0x53D8)
20562 {
20563         u32 adr, res;
20564         u32 src, dst;
20565
20566         adr = AREG((Opcode >> 0) & 7);
20567         AREG((Opcode >> 0) & 7) += 1;
20568         if ((!flag_NotZ) || (flag_C & 0x100))
20569         {
20570         res = 0xFF;
20571         PRE_IO
20572         WRITE_BYTE_F(adr, res)
20573         POST_IO
20574         RET(12)
20575         }
20576         res = 0;
20577         PRE_IO
20578         WRITE_BYTE_F(adr, res)
20579         POST_IO
20580         RET(12)
20581 }
20582
20583 // STCC
20584 OPCODE(0x54D8)
20585 {
20586         u32 adr, res;
20587         u32 src, dst;
20588
20589         adr = AREG((Opcode >> 0) & 7);
20590         AREG((Opcode >> 0) & 7) += 1;
20591         if (!(flag_C & 0x100))
20592         {
20593         res = 0xFF;
20594         PRE_IO
20595         WRITE_BYTE_F(adr, res)
20596         POST_IO
20597         RET(12)
20598         }
20599         res = 0;
20600         PRE_IO
20601         WRITE_BYTE_F(adr, res)
20602         POST_IO
20603         RET(12)
20604 }
20605
20606 // STCC
20607 OPCODE(0x55D8)
20608 {
20609         u32 adr, res;
20610         u32 src, dst;
20611
20612         adr = AREG((Opcode >> 0) & 7);
20613         AREG((Opcode >> 0) & 7) += 1;
20614         if (flag_C & 0x100)
20615         {
20616         res = 0xFF;
20617         PRE_IO
20618         WRITE_BYTE_F(adr, res)
20619         POST_IO
20620         RET(12)
20621         }
20622         res = 0;
20623         PRE_IO
20624         WRITE_BYTE_F(adr, res)
20625         POST_IO
20626         RET(12)
20627 }
20628
20629 // STCC
20630 OPCODE(0x56D8)
20631 {
20632         u32 adr, res;
20633         u32 src, dst;
20634
20635         adr = AREG((Opcode >> 0) & 7);
20636         AREG((Opcode >> 0) & 7) += 1;
20637         if (flag_NotZ)
20638         {
20639         res = 0xFF;
20640         PRE_IO
20641         WRITE_BYTE_F(adr, res)
20642         POST_IO
20643         RET(12)
20644         }
20645         res = 0;
20646         PRE_IO
20647         WRITE_BYTE_F(adr, res)
20648         POST_IO
20649         RET(12)
20650 }
20651
20652 // STCC
20653 OPCODE(0x57D8)
20654 {
20655         u32 adr, res;
20656         u32 src, dst;
20657
20658         adr = AREG((Opcode >> 0) & 7);
20659         AREG((Opcode >> 0) & 7) += 1;
20660         if (!flag_NotZ)
20661         {
20662         res = 0xFF;
20663         PRE_IO
20664         WRITE_BYTE_F(adr, res)
20665         POST_IO
20666         RET(12)
20667         }
20668         res = 0;
20669         PRE_IO
20670         WRITE_BYTE_F(adr, res)
20671         POST_IO
20672         RET(12)
20673 }
20674
20675 // STCC
20676 OPCODE(0x58D8)
20677 {
20678         u32 adr, res;
20679         u32 src, dst;
20680
20681         adr = AREG((Opcode >> 0) & 7);
20682         AREG((Opcode >> 0) & 7) += 1;
20683         if (!(flag_V & 0x80))
20684         {
20685         res = 0xFF;
20686         PRE_IO
20687         WRITE_BYTE_F(adr, res)
20688         POST_IO
20689         RET(12)
20690         }
20691         res = 0;
20692         PRE_IO
20693         WRITE_BYTE_F(adr, res)
20694         POST_IO
20695         RET(12)
20696 }
20697
20698 // STCC
20699 OPCODE(0x59D8)
20700 {
20701         u32 adr, res;
20702         u32 src, dst;
20703
20704         adr = AREG((Opcode >> 0) & 7);
20705         AREG((Opcode >> 0) & 7) += 1;
20706         if (flag_V & 0x80)
20707         {
20708         res = 0xFF;
20709         PRE_IO
20710         WRITE_BYTE_F(adr, res)
20711         POST_IO
20712         RET(12)
20713         }
20714         res = 0;
20715         PRE_IO
20716         WRITE_BYTE_F(adr, res)
20717         POST_IO
20718         RET(12)
20719 }
20720
20721 // STCC
20722 OPCODE(0x5AD8)
20723 {
20724         u32 adr, res;
20725         u32 src, dst;
20726
20727         adr = AREG((Opcode >> 0) & 7);
20728         AREG((Opcode >> 0) & 7) += 1;
20729         if (!(flag_N & 0x80))
20730         {
20731         res = 0xFF;
20732         PRE_IO
20733         WRITE_BYTE_F(adr, res)
20734         POST_IO
20735         RET(12)
20736         }
20737         res = 0;
20738         PRE_IO
20739         WRITE_BYTE_F(adr, res)
20740         POST_IO
20741         RET(12)
20742 }
20743
20744 // STCC
20745 OPCODE(0x5BD8)
20746 {
20747         u32 adr, res;
20748         u32 src, dst;
20749
20750         adr = AREG((Opcode >> 0) & 7);
20751         AREG((Opcode >> 0) & 7) += 1;
20752         if (flag_N & 0x80)
20753         {
20754         res = 0xFF;
20755         PRE_IO
20756         WRITE_BYTE_F(adr, res)
20757         POST_IO
20758         RET(12)
20759         }
20760         res = 0;
20761         PRE_IO
20762         WRITE_BYTE_F(adr, res)
20763         POST_IO
20764         RET(12)
20765 }
20766
20767 // STCC
20768 OPCODE(0x5CD8)
20769 {
20770         u32 adr, res;
20771         u32 src, dst;
20772
20773         adr = AREG((Opcode >> 0) & 7);
20774         AREG((Opcode >> 0) & 7) += 1;
20775         if (!((flag_N ^ flag_V) & 0x80))
20776         {
20777         res = 0xFF;
20778         PRE_IO
20779         WRITE_BYTE_F(adr, res)
20780         POST_IO
20781         RET(12)
20782         }
20783         res = 0;
20784         PRE_IO
20785         WRITE_BYTE_F(adr, res)
20786         POST_IO
20787         RET(12)
20788 }
20789
20790 // STCC
20791 OPCODE(0x5DD8)
20792 {
20793         u32 adr, res;
20794         u32 src, dst;
20795
20796         adr = AREG((Opcode >> 0) & 7);
20797         AREG((Opcode >> 0) & 7) += 1;
20798         if ((flag_N ^ flag_V) & 0x80)
20799         {
20800         res = 0xFF;
20801         PRE_IO
20802         WRITE_BYTE_F(adr, res)
20803         POST_IO
20804         RET(12)
20805         }
20806         res = 0;
20807         PRE_IO
20808         WRITE_BYTE_F(adr, res)
20809         POST_IO
20810         RET(12)
20811 }
20812
20813 // STCC
20814 OPCODE(0x5ED8)
20815 {
20816         u32 adr, res;
20817         u32 src, dst;
20818
20819         adr = AREG((Opcode >> 0) & 7);
20820         AREG((Opcode >> 0) & 7) += 1;
20821         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20822         {
20823         res = 0xFF;
20824         PRE_IO
20825         WRITE_BYTE_F(adr, res)
20826         POST_IO
20827         RET(12)
20828         }
20829         res = 0;
20830         PRE_IO
20831         WRITE_BYTE_F(adr, res)
20832         POST_IO
20833         RET(12)
20834 }
20835
20836 // STCC
20837 OPCODE(0x5FD8)
20838 {
20839         u32 adr, res;
20840         u32 src, dst;
20841
20842         adr = AREG((Opcode >> 0) & 7);
20843         AREG((Opcode >> 0) & 7) += 1;
20844         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20845         {
20846         res = 0xFF;
20847         PRE_IO
20848         WRITE_BYTE_F(adr, res)
20849         POST_IO
20850         RET(12)
20851         }
20852         res = 0;
20853         PRE_IO
20854         WRITE_BYTE_F(adr, res)
20855         POST_IO
20856         RET(12)
20857 }
20858
20859 // STCC
20860 OPCODE(0x50E0)
20861 {
20862         u32 adr, res;
20863         u32 src, dst;
20864
20865         adr = AREG((Opcode >> 0) & 7) - 1;
20866         AREG((Opcode >> 0) & 7) = adr;
20867         res = 0xFF;
20868         PRE_IO
20869         WRITE_BYTE_F(adr, res)
20870         POST_IO
20871         RET(14)
20872 }
20873
20874 // STCC
20875 OPCODE(0x51E0)
20876 {
20877         u32 adr, res;
20878         u32 src, dst;
20879
20880         adr = AREG((Opcode >> 0) & 7) - 1;
20881         AREG((Opcode >> 0) & 7) = adr;
20882         res = 0;
20883         PRE_IO
20884         WRITE_BYTE_F(adr, res)
20885         POST_IO
20886         RET(14)
20887 }
20888
20889 // STCC
20890 OPCODE(0x52E0)
20891 {
20892         u32 adr, res;
20893         u32 src, dst;
20894
20895         adr = AREG((Opcode >> 0) & 7) - 1;
20896         AREG((Opcode >> 0) & 7) = adr;
20897         if (flag_NotZ && (!(flag_C & 0x100)))
20898         {
20899         res = 0xFF;
20900         PRE_IO
20901         WRITE_BYTE_F(adr, res)
20902         POST_IO
20903         RET(14)
20904         }
20905         res = 0;
20906         PRE_IO
20907         WRITE_BYTE_F(adr, res)
20908         POST_IO
20909         RET(14)
20910 }
20911
20912 // STCC
20913 OPCODE(0x53E0)
20914 {
20915         u32 adr, res;
20916         u32 src, dst;
20917
20918         adr = AREG((Opcode >> 0) & 7) - 1;
20919         AREG((Opcode >> 0) & 7) = adr;
20920         if ((!flag_NotZ) || (flag_C & 0x100))
20921         {
20922         res = 0xFF;
20923         PRE_IO
20924         WRITE_BYTE_F(adr, res)
20925         POST_IO
20926         RET(14)
20927         }
20928         res = 0;
20929         PRE_IO
20930         WRITE_BYTE_F(adr, res)
20931         POST_IO
20932         RET(14)
20933 }
20934
20935 // STCC
20936 OPCODE(0x54E0)
20937 {
20938         u32 adr, res;
20939         u32 src, dst;
20940
20941         adr = AREG((Opcode >> 0) & 7) - 1;
20942         AREG((Opcode >> 0) & 7) = adr;
20943         if (!(flag_C & 0x100))
20944         {
20945         res = 0xFF;
20946         PRE_IO
20947         WRITE_BYTE_F(adr, res)
20948         POST_IO
20949         RET(14)
20950         }
20951         res = 0;
20952         PRE_IO
20953         WRITE_BYTE_F(adr, res)
20954         POST_IO
20955         RET(14)
20956 }
20957
20958 // STCC
20959 OPCODE(0x55E0)
20960 {
20961         u32 adr, res;
20962         u32 src, dst;
20963
20964         adr = AREG((Opcode >> 0) & 7) - 1;
20965         AREG((Opcode >> 0) & 7) = adr;
20966         if (flag_C & 0x100)
20967         {
20968         res = 0xFF;
20969         PRE_IO
20970         WRITE_BYTE_F(adr, res)
20971         POST_IO
20972         RET(14)
20973         }
20974         res = 0;
20975         PRE_IO
20976         WRITE_BYTE_F(adr, res)
20977         POST_IO
20978         RET(14)
20979 }
20980
20981 // STCC
20982 OPCODE(0x56E0)
20983 {
20984         u32 adr, res;
20985         u32 src, dst;
20986
20987         adr = AREG((Opcode >> 0) & 7) - 1;
20988         AREG((Opcode >> 0) & 7) = adr;
20989         if (flag_NotZ)
20990         {
20991         res = 0xFF;
20992         PRE_IO
20993         WRITE_BYTE_F(adr, res)
20994         POST_IO
20995         RET(14)
20996         }
20997         res = 0;
20998         PRE_IO
20999         WRITE_BYTE_F(adr, res)
21000         POST_IO
21001         RET(14)
21002 }
21003
21004 // STCC
21005 OPCODE(0x57E0)
21006 {
21007         u32 adr, res;
21008         u32 src, dst;
21009
21010         adr = AREG((Opcode >> 0) & 7) - 1;
21011         AREG((Opcode >> 0) & 7) = adr;
21012         if (!flag_NotZ)
21013         {
21014         res = 0xFF;
21015         PRE_IO
21016         WRITE_BYTE_F(adr, res)
21017         POST_IO
21018         RET(14)
21019         }
21020         res = 0;
21021         PRE_IO
21022         WRITE_BYTE_F(adr, res)
21023         POST_IO
21024         RET(14)
21025 }
21026
21027 // STCC
21028 OPCODE(0x58E0)
21029 {
21030         u32 adr, res;
21031         u32 src, dst;
21032
21033         adr = AREG((Opcode >> 0) & 7) - 1;
21034         AREG((Opcode >> 0) & 7) = adr;
21035         if (!(flag_V & 0x80))
21036         {
21037         res = 0xFF;
21038         PRE_IO
21039         WRITE_BYTE_F(adr, res)
21040         POST_IO
21041         RET(14)
21042         }
21043         res = 0;
21044         PRE_IO
21045         WRITE_BYTE_F(adr, res)
21046         POST_IO
21047         RET(14)
21048 }
21049
21050 // STCC
21051 OPCODE(0x59E0)
21052 {
21053         u32 adr, res;
21054         u32 src, dst;
21055
21056         adr = AREG((Opcode >> 0) & 7) - 1;
21057         AREG((Opcode >> 0) & 7) = adr;
21058         if (flag_V & 0x80)
21059         {
21060         res = 0xFF;
21061         PRE_IO
21062         WRITE_BYTE_F(adr, res)
21063         POST_IO
21064         RET(14)
21065         }
21066         res = 0;
21067         PRE_IO
21068         WRITE_BYTE_F(adr, res)
21069         POST_IO
21070         RET(14)
21071 }
21072
21073 // STCC
21074 OPCODE(0x5AE0)
21075 {
21076         u32 adr, res;
21077         u32 src, dst;
21078
21079         adr = AREG((Opcode >> 0) & 7) - 1;
21080         AREG((Opcode >> 0) & 7) = adr;
21081         if (!(flag_N & 0x80))
21082         {
21083         res = 0xFF;
21084         PRE_IO
21085         WRITE_BYTE_F(adr, res)
21086         POST_IO
21087         RET(14)
21088         }
21089         res = 0;
21090         PRE_IO
21091         WRITE_BYTE_F(adr, res)
21092         POST_IO
21093         RET(14)
21094 }
21095
21096 // STCC
21097 OPCODE(0x5BE0)
21098 {
21099         u32 adr, res;
21100         u32 src, dst;
21101
21102         adr = AREG((Opcode >> 0) & 7) - 1;
21103         AREG((Opcode >> 0) & 7) = adr;
21104         if (flag_N & 0x80)
21105         {
21106         res = 0xFF;
21107         PRE_IO
21108         WRITE_BYTE_F(adr, res)
21109         POST_IO
21110         RET(14)
21111         }
21112         res = 0;
21113         PRE_IO
21114         WRITE_BYTE_F(adr, res)
21115         POST_IO
21116         RET(14)
21117 }
21118
21119 // STCC
21120 OPCODE(0x5CE0)
21121 {
21122         u32 adr, res;
21123         u32 src, dst;
21124
21125         adr = AREG((Opcode >> 0) & 7) - 1;
21126         AREG((Opcode >> 0) & 7) = adr;
21127         if (!((flag_N ^ flag_V) & 0x80))
21128         {
21129         res = 0xFF;
21130         PRE_IO
21131         WRITE_BYTE_F(adr, res)
21132         POST_IO
21133         RET(14)
21134         }
21135         res = 0;
21136         PRE_IO
21137         WRITE_BYTE_F(adr, res)
21138         POST_IO
21139         RET(14)
21140 }
21141
21142 // STCC
21143 OPCODE(0x5DE0)
21144 {
21145         u32 adr, res;
21146         u32 src, dst;
21147
21148         adr = AREG((Opcode >> 0) & 7) - 1;
21149         AREG((Opcode >> 0) & 7) = adr;
21150         if ((flag_N ^ flag_V) & 0x80)
21151         {
21152         res = 0xFF;
21153         PRE_IO
21154         WRITE_BYTE_F(adr, res)
21155         POST_IO
21156         RET(14)
21157         }
21158         res = 0;
21159         PRE_IO
21160         WRITE_BYTE_F(adr, res)
21161         POST_IO
21162         RET(14)
21163 }
21164
21165 // STCC
21166 OPCODE(0x5EE0)
21167 {
21168         u32 adr, res;
21169         u32 src, dst;
21170
21171         adr = AREG((Opcode >> 0) & 7) - 1;
21172         AREG((Opcode >> 0) & 7) = adr;
21173         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21174         {
21175         res = 0xFF;
21176         PRE_IO
21177         WRITE_BYTE_F(adr, res)
21178         POST_IO
21179         RET(14)
21180         }
21181         res = 0;
21182         PRE_IO
21183         WRITE_BYTE_F(adr, res)
21184         POST_IO
21185         RET(14)
21186 }
21187
21188 // STCC
21189 OPCODE(0x5FE0)
21190 {
21191         u32 adr, res;
21192         u32 src, dst;
21193
21194         adr = AREG((Opcode >> 0) & 7) - 1;
21195         AREG((Opcode >> 0) & 7) = adr;
21196         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21197         {
21198         res = 0xFF;
21199         PRE_IO
21200         WRITE_BYTE_F(adr, res)
21201         POST_IO
21202         RET(14)
21203         }
21204         res = 0;
21205         PRE_IO
21206         WRITE_BYTE_F(adr, res)
21207         POST_IO
21208         RET(14)
21209 }
21210
21211 // STCC
21212 OPCODE(0x50E8)
21213 {
21214         u32 adr, res;
21215         u32 src, dst;
21216
21217         FETCH_SWORD(adr);
21218         adr += AREG((Opcode >> 0) & 7);
21219         res = 0xFF;
21220         PRE_IO
21221         WRITE_BYTE_F(adr, res)
21222         POST_IO
21223         RET(16)
21224 }
21225
21226 // STCC
21227 OPCODE(0x51E8)
21228 {
21229         u32 adr, res;
21230         u32 src, dst;
21231
21232         FETCH_SWORD(adr);
21233         adr += AREG((Opcode >> 0) & 7);
21234         res = 0;
21235         PRE_IO
21236         WRITE_BYTE_F(adr, res)
21237         POST_IO
21238         RET(16)
21239 }
21240
21241 // STCC
21242 OPCODE(0x52E8)
21243 {
21244         u32 adr, res;
21245         u32 src, dst;
21246
21247         FETCH_SWORD(adr);
21248         adr += AREG((Opcode >> 0) & 7);
21249         if (flag_NotZ && (!(flag_C & 0x100)))
21250         {
21251         res = 0xFF;
21252         PRE_IO
21253         WRITE_BYTE_F(adr, res)
21254         POST_IO
21255         RET(16)
21256         }
21257         res = 0;
21258         PRE_IO
21259         WRITE_BYTE_F(adr, res)
21260         POST_IO
21261         RET(16)
21262 }
21263
21264 // STCC
21265 OPCODE(0x53E8)
21266 {
21267         u32 adr, res;
21268         u32 src, dst;
21269
21270         FETCH_SWORD(adr);
21271         adr += AREG((Opcode >> 0) & 7);
21272         if ((!flag_NotZ) || (flag_C & 0x100))
21273         {
21274         res = 0xFF;
21275         PRE_IO
21276         WRITE_BYTE_F(adr, res)
21277         POST_IO
21278         RET(16)
21279         }
21280         res = 0;
21281         PRE_IO
21282         WRITE_BYTE_F(adr, res)
21283         POST_IO
21284         RET(16)
21285 }
21286
21287 // STCC
21288 OPCODE(0x54E8)
21289 {
21290         u32 adr, res;
21291         u32 src, dst;
21292
21293         FETCH_SWORD(adr);
21294         adr += AREG((Opcode >> 0) & 7);
21295         if (!(flag_C & 0x100))
21296         {
21297         res = 0xFF;
21298         PRE_IO
21299         WRITE_BYTE_F(adr, res)
21300         POST_IO
21301         RET(16)
21302         }
21303         res = 0;
21304         PRE_IO
21305         WRITE_BYTE_F(adr, res)
21306         POST_IO
21307         RET(16)
21308 }
21309
21310 // STCC
21311 OPCODE(0x55E8)
21312 {
21313         u32 adr, res;
21314         u32 src, dst;
21315
21316         FETCH_SWORD(adr);
21317         adr += AREG((Opcode >> 0) & 7);
21318         if (flag_C & 0x100)
21319         {
21320         res = 0xFF;
21321         PRE_IO
21322         WRITE_BYTE_F(adr, res)
21323         POST_IO
21324         RET(16)
21325         }
21326         res = 0;
21327         PRE_IO
21328         WRITE_BYTE_F(adr, res)
21329         POST_IO
21330         RET(16)
21331 }
21332
21333 // STCC
21334 OPCODE(0x56E8)
21335 {
21336         u32 adr, res;
21337         u32 src, dst;
21338
21339         FETCH_SWORD(adr);
21340         adr += AREG((Opcode >> 0) & 7);
21341         if (flag_NotZ)
21342         {
21343         res = 0xFF;
21344         PRE_IO
21345         WRITE_BYTE_F(adr, res)
21346         POST_IO
21347         RET(16)
21348         }
21349         res = 0;
21350         PRE_IO
21351         WRITE_BYTE_F(adr, res)
21352         POST_IO
21353         RET(16)
21354 }
21355
21356 // STCC
21357 OPCODE(0x57E8)
21358 {
21359         u32 adr, res;
21360         u32 src, dst;
21361
21362         FETCH_SWORD(adr);
21363         adr += AREG((Opcode >> 0) & 7);
21364         if (!flag_NotZ)
21365         {
21366         res = 0xFF;
21367         PRE_IO
21368         WRITE_BYTE_F(adr, res)
21369         POST_IO
21370         RET(16)
21371         }
21372         res = 0;
21373         PRE_IO
21374         WRITE_BYTE_F(adr, res)
21375         POST_IO
21376         RET(16)
21377 }
21378
21379 // STCC
21380 OPCODE(0x58E8)
21381 {
21382         u32 adr, res;
21383         u32 src, dst;
21384
21385         FETCH_SWORD(adr);
21386         adr += AREG((Opcode >> 0) & 7);
21387         if (!(flag_V & 0x80))
21388         {
21389         res = 0xFF;
21390         PRE_IO
21391         WRITE_BYTE_F(adr, res)
21392         POST_IO
21393         RET(16)
21394         }
21395         res = 0;
21396         PRE_IO
21397         WRITE_BYTE_F(adr, res)
21398         POST_IO
21399         RET(16)
21400 }
21401
21402 // STCC
21403 OPCODE(0x59E8)
21404 {
21405         u32 adr, res;
21406         u32 src, dst;
21407
21408         FETCH_SWORD(adr);
21409         adr += AREG((Opcode >> 0) & 7);
21410         if (flag_V & 0x80)
21411         {
21412         res = 0xFF;
21413         PRE_IO
21414         WRITE_BYTE_F(adr, res)
21415         POST_IO
21416         RET(16)
21417         }
21418         res = 0;
21419         PRE_IO
21420         WRITE_BYTE_F(adr, res)
21421         POST_IO
21422         RET(16)
21423 }
21424
21425 // STCC
21426 OPCODE(0x5AE8)
21427 {
21428         u32 adr, res;
21429         u32 src, dst;
21430
21431         FETCH_SWORD(adr);
21432         adr += AREG((Opcode >> 0) & 7);
21433         if (!(flag_N & 0x80))
21434         {
21435         res = 0xFF;
21436         PRE_IO
21437         WRITE_BYTE_F(adr, res)
21438         POST_IO
21439         RET(16)
21440         }
21441         res = 0;
21442         PRE_IO
21443         WRITE_BYTE_F(adr, res)
21444         POST_IO
21445         RET(16)
21446 }
21447
21448 // STCC
21449 OPCODE(0x5BE8)
21450 {
21451         u32 adr, res;
21452         u32 src, dst;
21453
21454         FETCH_SWORD(adr);
21455         adr += AREG((Opcode >> 0) & 7);
21456         if (flag_N & 0x80)
21457         {
21458         res = 0xFF;
21459         PRE_IO
21460         WRITE_BYTE_F(adr, res)
21461         POST_IO
21462         RET(16)
21463         }
21464         res = 0;
21465         PRE_IO
21466         WRITE_BYTE_F(adr, res)
21467         POST_IO
21468         RET(16)
21469 }
21470
21471 // STCC
21472 OPCODE(0x5CE8)
21473 {
21474         u32 adr, res;
21475         u32 src, dst;
21476
21477         FETCH_SWORD(adr);
21478         adr += AREG((Opcode >> 0) & 7);
21479         if (!((flag_N ^ flag_V) & 0x80))
21480         {
21481         res = 0xFF;
21482         PRE_IO
21483         WRITE_BYTE_F(adr, res)
21484         POST_IO
21485         RET(16)
21486         }
21487         res = 0;
21488         PRE_IO
21489         WRITE_BYTE_F(adr, res)
21490         POST_IO
21491         RET(16)
21492 }
21493
21494 // STCC
21495 OPCODE(0x5DE8)
21496 {
21497         u32 adr, res;
21498         u32 src, dst;
21499
21500         FETCH_SWORD(adr);
21501         adr += AREG((Opcode >> 0) & 7);
21502         if ((flag_N ^ flag_V) & 0x80)
21503         {
21504         res = 0xFF;
21505         PRE_IO
21506         WRITE_BYTE_F(adr, res)
21507         POST_IO
21508         RET(16)
21509         }
21510         res = 0;
21511         PRE_IO
21512         WRITE_BYTE_F(adr, res)
21513         POST_IO
21514         RET(16)
21515 }
21516
21517 // STCC
21518 OPCODE(0x5EE8)
21519 {
21520         u32 adr, res;
21521         u32 src, dst;
21522
21523         FETCH_SWORD(adr);
21524         adr += AREG((Opcode >> 0) & 7);
21525         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21526         {
21527         res = 0xFF;
21528         PRE_IO
21529         WRITE_BYTE_F(adr, res)
21530         POST_IO
21531         RET(16)
21532         }
21533         res = 0;
21534         PRE_IO
21535         WRITE_BYTE_F(adr, res)
21536         POST_IO
21537         RET(16)
21538 }
21539
21540 // STCC
21541 OPCODE(0x5FE8)
21542 {
21543         u32 adr, res;
21544         u32 src, dst;
21545
21546         FETCH_SWORD(adr);
21547         adr += AREG((Opcode >> 0) & 7);
21548         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21549         {
21550         res = 0xFF;
21551         PRE_IO
21552         WRITE_BYTE_F(adr, res)
21553         POST_IO
21554         RET(16)
21555         }
21556         res = 0;
21557         PRE_IO
21558         WRITE_BYTE_F(adr, res)
21559         POST_IO
21560         RET(16)
21561 }
21562
21563 // STCC
21564 OPCODE(0x50F0)
21565 {
21566         u32 adr, res;
21567         u32 src, dst;
21568
21569         adr = AREG((Opcode >> 0) & 7);
21570         DECODE_EXT_WORD
21571         res = 0xFF;
21572         PRE_IO
21573         WRITE_BYTE_F(adr, res)
21574         POST_IO
21575         RET(18)
21576 }
21577
21578 // STCC
21579 OPCODE(0x51F0)
21580 {
21581         u32 adr, res;
21582         u32 src, dst;
21583
21584         adr = AREG((Opcode >> 0) & 7);
21585         DECODE_EXT_WORD
21586         res = 0;
21587         PRE_IO
21588         WRITE_BYTE_F(adr, res)
21589         POST_IO
21590         RET(18)
21591 }
21592
21593 // STCC
21594 OPCODE(0x52F0)
21595 {
21596         u32 adr, res;
21597         u32 src, dst;
21598
21599         adr = AREG((Opcode >> 0) & 7);
21600         DECODE_EXT_WORD
21601         if (flag_NotZ && (!(flag_C & 0x100)))
21602         {
21603         res = 0xFF;
21604         PRE_IO
21605         WRITE_BYTE_F(adr, res)
21606         POST_IO
21607         RET(18)
21608         }
21609         res = 0;
21610         PRE_IO
21611         WRITE_BYTE_F(adr, res)
21612         POST_IO
21613         RET(18)
21614 }
21615
21616 // STCC
21617 OPCODE(0x53F0)
21618 {
21619         u32 adr, res;
21620         u32 src, dst;
21621
21622         adr = AREG((Opcode >> 0) & 7);
21623         DECODE_EXT_WORD
21624         if ((!flag_NotZ) || (flag_C & 0x100))
21625         {
21626         res = 0xFF;
21627         PRE_IO
21628         WRITE_BYTE_F(adr, res)
21629         POST_IO
21630         RET(18)
21631         }
21632         res = 0;
21633         PRE_IO
21634         WRITE_BYTE_F(adr, res)
21635         POST_IO
21636         RET(18)
21637 }
21638
21639 // STCC
21640 OPCODE(0x54F0)
21641 {
21642         u32 adr, res;
21643         u32 src, dst;
21644
21645         adr = AREG((Opcode >> 0) & 7);
21646         DECODE_EXT_WORD
21647         if (!(flag_C & 0x100))
21648         {
21649         res = 0xFF;
21650         PRE_IO
21651         WRITE_BYTE_F(adr, res)
21652         POST_IO
21653         RET(18)
21654         }
21655         res = 0;
21656         PRE_IO
21657         WRITE_BYTE_F(adr, res)
21658         POST_IO
21659         RET(18)
21660 }
21661
21662 // STCC
21663 OPCODE(0x55F0)
21664 {
21665         u32 adr, res;
21666         u32 src, dst;
21667
21668         adr = AREG((Opcode >> 0) & 7);
21669         DECODE_EXT_WORD
21670         if (flag_C & 0x100)
21671         {
21672         res = 0xFF;
21673         PRE_IO
21674         WRITE_BYTE_F(adr, res)
21675         POST_IO
21676         RET(18)
21677         }
21678         res = 0;
21679         PRE_IO
21680         WRITE_BYTE_F(adr, res)
21681         POST_IO
21682         RET(18)
21683 }
21684
21685 // STCC
21686 OPCODE(0x56F0)
21687 {
21688         u32 adr, res;
21689         u32 src, dst;
21690
21691         adr = AREG((Opcode >> 0) & 7);
21692         DECODE_EXT_WORD
21693         if (flag_NotZ)
21694         {
21695         res = 0xFF;
21696         PRE_IO
21697         WRITE_BYTE_F(adr, res)
21698         POST_IO
21699         RET(18)
21700         }
21701         res = 0;
21702         PRE_IO
21703         WRITE_BYTE_F(adr, res)
21704         POST_IO
21705         RET(18)
21706 }
21707
21708 // STCC
21709 OPCODE(0x57F0)
21710 {
21711         u32 adr, res;
21712         u32 src, dst;
21713
21714         adr = AREG((Opcode >> 0) & 7);
21715         DECODE_EXT_WORD
21716         if (!flag_NotZ)
21717         {
21718         res = 0xFF;
21719         PRE_IO
21720         WRITE_BYTE_F(adr, res)
21721         POST_IO
21722         RET(18)
21723         }
21724         res = 0;
21725         PRE_IO
21726         WRITE_BYTE_F(adr, res)
21727         POST_IO
21728         RET(18)
21729 }
21730
21731 // STCC
21732 OPCODE(0x58F0)
21733 {
21734         u32 adr, res;
21735         u32 src, dst;
21736
21737         adr = AREG((Opcode >> 0) & 7);
21738         DECODE_EXT_WORD
21739         if (!(flag_V & 0x80))
21740         {
21741         res = 0xFF;
21742         PRE_IO
21743         WRITE_BYTE_F(adr, res)
21744         POST_IO
21745         RET(18)
21746         }
21747         res = 0;
21748         PRE_IO
21749         WRITE_BYTE_F(adr, res)
21750         POST_IO
21751         RET(18)
21752 }
21753
21754 // STCC
21755 OPCODE(0x59F0)
21756 {
21757         u32 adr, res;
21758         u32 src, dst;
21759
21760         adr = AREG((Opcode >> 0) & 7);
21761         DECODE_EXT_WORD
21762         if (flag_V & 0x80)
21763         {
21764         res = 0xFF;
21765         PRE_IO
21766         WRITE_BYTE_F(adr, res)
21767         POST_IO
21768         RET(18)
21769         }
21770         res = 0;
21771         PRE_IO
21772         WRITE_BYTE_F(adr, res)
21773         POST_IO
21774         RET(18)
21775 }
21776
21777 // STCC
21778 OPCODE(0x5AF0)
21779 {
21780         u32 adr, res;
21781         u32 src, dst;
21782
21783         adr = AREG((Opcode >> 0) & 7);
21784         DECODE_EXT_WORD
21785         if (!(flag_N & 0x80))
21786         {
21787         res = 0xFF;
21788         PRE_IO
21789         WRITE_BYTE_F(adr, res)
21790         POST_IO
21791         RET(18)
21792         }
21793         res = 0;
21794         PRE_IO
21795         WRITE_BYTE_F(adr, res)
21796         POST_IO
21797         RET(18)
21798 }
21799
21800 // STCC
21801 OPCODE(0x5BF0)
21802 {
21803         u32 adr, res;
21804         u32 src, dst;
21805
21806         adr = AREG((Opcode >> 0) & 7);
21807         DECODE_EXT_WORD
21808         if (flag_N & 0x80)
21809         {
21810         res = 0xFF;
21811         PRE_IO
21812         WRITE_BYTE_F(adr, res)
21813         POST_IO
21814         RET(18)
21815         }
21816         res = 0;
21817         PRE_IO
21818         WRITE_BYTE_F(adr, res)
21819         POST_IO
21820         RET(18)
21821 }
21822
21823 // STCC
21824 OPCODE(0x5CF0)
21825 {
21826         u32 adr, res;
21827         u32 src, dst;
21828
21829         adr = AREG((Opcode >> 0) & 7);
21830         DECODE_EXT_WORD
21831         if (!((flag_N ^ flag_V) & 0x80))
21832         {
21833         res = 0xFF;
21834         PRE_IO
21835         WRITE_BYTE_F(adr, res)
21836         POST_IO
21837         RET(18)
21838         }
21839         res = 0;
21840         PRE_IO
21841         WRITE_BYTE_F(adr, res)
21842         POST_IO
21843         RET(18)
21844 }
21845
21846 // STCC
21847 OPCODE(0x5DF0)
21848 {
21849         u32 adr, res;
21850         u32 src, dst;
21851
21852         adr = AREG((Opcode >> 0) & 7);
21853         DECODE_EXT_WORD
21854         if ((flag_N ^ flag_V) & 0x80)
21855         {
21856         res = 0xFF;
21857         PRE_IO
21858         WRITE_BYTE_F(adr, res)
21859         POST_IO
21860         RET(18)
21861         }
21862         res = 0;
21863         PRE_IO
21864         WRITE_BYTE_F(adr, res)
21865         POST_IO
21866         RET(18)
21867 }
21868
21869 // STCC
21870 OPCODE(0x5EF0)
21871 {
21872         u32 adr, res;
21873         u32 src, dst;
21874
21875         adr = AREG((Opcode >> 0) & 7);
21876         DECODE_EXT_WORD
21877         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21878         {
21879         res = 0xFF;
21880         PRE_IO
21881         WRITE_BYTE_F(adr, res)
21882         POST_IO
21883         RET(18)
21884         }
21885         res = 0;
21886         PRE_IO
21887         WRITE_BYTE_F(adr, res)
21888         POST_IO
21889         RET(18)
21890 }
21891
21892 // STCC
21893 OPCODE(0x5FF0)
21894 {
21895         u32 adr, res;
21896         u32 src, dst;
21897
21898         adr = AREG((Opcode >> 0) & 7);
21899         DECODE_EXT_WORD
21900         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21901         {
21902         res = 0xFF;
21903         PRE_IO
21904         WRITE_BYTE_F(adr, res)
21905         POST_IO
21906         RET(18)
21907         }
21908         res = 0;
21909         PRE_IO
21910         WRITE_BYTE_F(adr, res)
21911         POST_IO
21912         RET(18)
21913 }
21914
21915 // STCC
21916 OPCODE(0x50F8)
21917 {
21918         u32 adr, res;
21919         u32 src, dst;
21920
21921         FETCH_SWORD(adr);
21922         res = 0xFF;
21923         PRE_IO
21924         WRITE_BYTE_F(adr, res)
21925         POST_IO
21926         RET(16)
21927 }
21928
21929 // STCC
21930 OPCODE(0x51F8)
21931 {
21932         u32 adr, res;
21933         u32 src, dst;
21934
21935         FETCH_SWORD(adr);
21936         res = 0;
21937         PRE_IO
21938         WRITE_BYTE_F(adr, res)
21939         POST_IO
21940         RET(16)
21941 }
21942
21943 // STCC
21944 OPCODE(0x52F8)
21945 {
21946         u32 adr, res;
21947         u32 src, dst;
21948
21949         FETCH_SWORD(adr);
21950         if (flag_NotZ && (!(flag_C & 0x100)))
21951         {
21952         res = 0xFF;
21953         PRE_IO
21954         WRITE_BYTE_F(adr, res)
21955         POST_IO
21956         RET(16)
21957         }
21958         res = 0;
21959         PRE_IO
21960         WRITE_BYTE_F(adr, res)
21961         POST_IO
21962         RET(16)
21963 }
21964
21965 // STCC
21966 OPCODE(0x53F8)
21967 {
21968         u32 adr, res;
21969         u32 src, dst;
21970
21971         FETCH_SWORD(adr);
21972         if ((!flag_NotZ) || (flag_C & 0x100))
21973         {
21974         res = 0xFF;
21975         PRE_IO
21976         WRITE_BYTE_F(adr, res)
21977         POST_IO
21978         RET(16)
21979         }
21980         res = 0;
21981         PRE_IO
21982         WRITE_BYTE_F(adr, res)
21983         POST_IO
21984         RET(16)
21985 }
21986
21987 // STCC
21988 OPCODE(0x54F8)
21989 {
21990         u32 adr, res;
21991         u32 src, dst;
21992
21993         FETCH_SWORD(adr);
21994         if (!(flag_C & 0x100))
21995         {
21996         res = 0xFF;
21997         PRE_IO
21998         WRITE_BYTE_F(adr, res)
21999         POST_IO
22000         RET(16)
22001         }
22002         res = 0;
22003         PRE_IO
22004         WRITE_BYTE_F(adr, res)
22005         POST_IO
22006         RET(16)
22007 }
22008
22009 // STCC
22010 OPCODE(0x55F8)
22011 {
22012         u32 adr, res;
22013         u32 src, dst;
22014
22015         FETCH_SWORD(adr);
22016         if (flag_C & 0x100)
22017         {
22018         res = 0xFF;
22019         PRE_IO
22020         WRITE_BYTE_F(adr, res)
22021         POST_IO
22022         RET(16)
22023         }
22024         res = 0;
22025         PRE_IO
22026         WRITE_BYTE_F(adr, res)
22027         POST_IO
22028         RET(16)
22029 }
22030
22031 // STCC
22032 OPCODE(0x56F8)
22033 {
22034         u32 adr, res;
22035         u32 src, dst;
22036
22037         FETCH_SWORD(adr);
22038         if (flag_NotZ)
22039         {
22040         res = 0xFF;
22041         PRE_IO
22042         WRITE_BYTE_F(adr, res)
22043         POST_IO
22044         RET(16)
22045         }
22046         res = 0;
22047         PRE_IO
22048         WRITE_BYTE_F(adr, res)
22049         POST_IO
22050         RET(16)
22051 }
22052
22053 // STCC
22054 OPCODE(0x57F8)
22055 {
22056         u32 adr, res;
22057         u32 src, dst;
22058
22059         FETCH_SWORD(adr);
22060         if (!flag_NotZ)
22061         {
22062         res = 0xFF;
22063         PRE_IO
22064         WRITE_BYTE_F(adr, res)
22065         POST_IO
22066         RET(16)
22067         }
22068         res = 0;
22069         PRE_IO
22070         WRITE_BYTE_F(adr, res)
22071         POST_IO
22072         RET(16)
22073 }
22074
22075 // STCC
22076 OPCODE(0x58F8)
22077 {
22078         u32 adr, res;
22079         u32 src, dst;
22080
22081         FETCH_SWORD(adr);
22082         if (!(flag_V & 0x80))
22083         {
22084         res = 0xFF;
22085         PRE_IO
22086         WRITE_BYTE_F(adr, res)
22087         POST_IO
22088         RET(16)
22089         }
22090         res = 0;
22091         PRE_IO
22092         WRITE_BYTE_F(adr, res)
22093         POST_IO
22094         RET(16)
22095 }
22096
22097 // STCC
22098 OPCODE(0x59F8)
22099 {
22100         u32 adr, res;
22101         u32 src, dst;
22102
22103         FETCH_SWORD(adr);
22104         if (flag_V & 0x80)
22105         {
22106         res = 0xFF;
22107         PRE_IO
22108         WRITE_BYTE_F(adr, res)
22109         POST_IO
22110         RET(16)
22111         }
22112         res = 0;
22113         PRE_IO
22114         WRITE_BYTE_F(adr, res)
22115         POST_IO
22116         RET(16)
22117 }
22118
22119 // STCC
22120 OPCODE(0x5AF8)
22121 {
22122         u32 adr, res;
22123         u32 src, dst;
22124
22125         FETCH_SWORD(adr);
22126         if (!(flag_N & 0x80))
22127         {
22128         res = 0xFF;
22129         PRE_IO
22130         WRITE_BYTE_F(adr, res)
22131         POST_IO
22132         RET(16)
22133         }
22134         res = 0;
22135         PRE_IO
22136         WRITE_BYTE_F(adr, res)
22137         POST_IO
22138         RET(16)
22139 }
22140
22141 // STCC
22142 OPCODE(0x5BF8)
22143 {
22144         u32 adr, res;
22145         u32 src, dst;
22146
22147         FETCH_SWORD(adr);
22148         if (flag_N & 0x80)
22149         {
22150         res = 0xFF;
22151         PRE_IO
22152         WRITE_BYTE_F(adr, res)
22153         POST_IO
22154         RET(16)
22155         }
22156         res = 0;
22157         PRE_IO
22158         WRITE_BYTE_F(adr, res)
22159         POST_IO
22160         RET(16)
22161 }
22162
22163 // STCC
22164 OPCODE(0x5CF8)
22165 {
22166         u32 adr, res;
22167         u32 src, dst;
22168
22169         FETCH_SWORD(adr);
22170         if (!((flag_N ^ flag_V) & 0x80))
22171         {
22172         res = 0xFF;
22173         PRE_IO
22174         WRITE_BYTE_F(adr, res)
22175         POST_IO
22176         RET(16)
22177         }
22178         res = 0;
22179         PRE_IO
22180         WRITE_BYTE_F(adr, res)
22181         POST_IO
22182         RET(16)
22183 }
22184
22185 // STCC
22186 OPCODE(0x5DF8)
22187 {
22188         u32 adr, res;
22189         u32 src, dst;
22190
22191         FETCH_SWORD(adr);
22192         if ((flag_N ^ flag_V) & 0x80)
22193         {
22194         res = 0xFF;
22195         PRE_IO
22196         WRITE_BYTE_F(adr, res)
22197         POST_IO
22198         RET(16)
22199         }
22200         res = 0;
22201         PRE_IO
22202         WRITE_BYTE_F(adr, res)
22203         POST_IO
22204         RET(16)
22205 }
22206
22207 // STCC
22208 OPCODE(0x5EF8)
22209 {
22210         u32 adr, res;
22211         u32 src, dst;
22212
22213         FETCH_SWORD(adr);
22214         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22215         {
22216         res = 0xFF;
22217         PRE_IO
22218         WRITE_BYTE_F(adr, res)
22219         POST_IO
22220         RET(16)
22221         }
22222         res = 0;
22223         PRE_IO
22224         WRITE_BYTE_F(adr, res)
22225         POST_IO
22226         RET(16)
22227 }
22228
22229 // STCC
22230 OPCODE(0x5FF8)
22231 {
22232         u32 adr, res;
22233         u32 src, dst;
22234
22235         FETCH_SWORD(adr);
22236         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22237         {
22238         res = 0xFF;
22239         PRE_IO
22240         WRITE_BYTE_F(adr, res)
22241         POST_IO
22242         RET(16)
22243         }
22244         res = 0;
22245         PRE_IO
22246         WRITE_BYTE_F(adr, res)
22247         POST_IO
22248         RET(16)
22249 }
22250
22251 // STCC
22252 OPCODE(0x50F9)
22253 {
22254         u32 adr, res;
22255         u32 src, dst;
22256
22257         FETCH_LONG(adr);
22258         res = 0xFF;
22259         PRE_IO
22260         WRITE_BYTE_F(adr, res)
22261         POST_IO
22262         RET(20)
22263 }
22264
22265 // STCC
22266 OPCODE(0x51F9)
22267 {
22268         u32 adr, res;
22269         u32 src, dst;
22270
22271         FETCH_LONG(adr);
22272         res = 0;
22273         PRE_IO
22274         WRITE_BYTE_F(adr, res)
22275         POST_IO
22276         RET(20)
22277 }
22278
22279 // STCC
22280 OPCODE(0x52F9)
22281 {
22282         u32 adr, res;
22283         u32 src, dst;
22284
22285         FETCH_LONG(adr);
22286         if (flag_NotZ && (!(flag_C & 0x100)))
22287         {
22288         res = 0xFF;
22289         PRE_IO
22290         WRITE_BYTE_F(adr, res)
22291         POST_IO
22292         RET(20)
22293         }
22294         res = 0;
22295         PRE_IO
22296         WRITE_BYTE_F(adr, res)
22297         POST_IO
22298         RET(20)
22299 }
22300
22301 // STCC
22302 OPCODE(0x53F9)
22303 {
22304         u32 adr, res;
22305         u32 src, dst;
22306
22307         FETCH_LONG(adr);
22308         if ((!flag_NotZ) || (flag_C & 0x100))
22309         {
22310         res = 0xFF;
22311         PRE_IO
22312         WRITE_BYTE_F(adr, res)
22313         POST_IO
22314         RET(20)
22315         }
22316         res = 0;
22317         PRE_IO
22318         WRITE_BYTE_F(adr, res)
22319         POST_IO
22320         RET(20)
22321 }
22322
22323 // STCC
22324 OPCODE(0x54F9)
22325 {
22326         u32 adr, res;
22327         u32 src, dst;
22328
22329         FETCH_LONG(adr);
22330         if (!(flag_C & 0x100))
22331         {
22332         res = 0xFF;
22333         PRE_IO
22334         WRITE_BYTE_F(adr, res)
22335         POST_IO
22336         RET(20)
22337         }
22338         res = 0;
22339         PRE_IO
22340         WRITE_BYTE_F(adr, res)
22341         POST_IO
22342         RET(20)
22343 }
22344
22345 // STCC
22346 OPCODE(0x55F9)
22347 {
22348         u32 adr, res;
22349         u32 src, dst;
22350
22351         FETCH_LONG(adr);
22352         if (flag_C & 0x100)
22353         {
22354         res = 0xFF;
22355         PRE_IO
22356         WRITE_BYTE_F(adr, res)
22357         POST_IO
22358         RET(20)
22359         }
22360         res = 0;
22361         PRE_IO
22362         WRITE_BYTE_F(adr, res)
22363         POST_IO
22364         RET(20)
22365 }
22366
22367 // STCC
22368 OPCODE(0x56F9)
22369 {
22370         u32 adr, res;
22371         u32 src, dst;
22372
22373         FETCH_LONG(adr);
22374         if (flag_NotZ)
22375         {
22376         res = 0xFF;
22377         PRE_IO
22378         WRITE_BYTE_F(adr, res)
22379         POST_IO
22380         RET(20)
22381         }
22382         res = 0;
22383         PRE_IO
22384         WRITE_BYTE_F(adr, res)
22385         POST_IO
22386         RET(20)
22387 }
22388
22389 // STCC
22390 OPCODE(0x57F9)
22391 {
22392         u32 adr, res;
22393         u32 src, dst;
22394
22395         FETCH_LONG(adr);
22396         if (!flag_NotZ)
22397         {
22398         res = 0xFF;
22399         PRE_IO
22400         WRITE_BYTE_F(adr, res)
22401         POST_IO
22402         RET(20)
22403         }
22404         res = 0;
22405         PRE_IO
22406         WRITE_BYTE_F(adr, res)
22407         POST_IO
22408         RET(20)
22409 }
22410
22411 // STCC
22412 OPCODE(0x58F9)
22413 {
22414         u32 adr, res;
22415         u32 src, dst;
22416
22417         FETCH_LONG(adr);
22418         if (!(flag_V & 0x80))
22419         {
22420         res = 0xFF;
22421         PRE_IO
22422         WRITE_BYTE_F(adr, res)
22423         POST_IO
22424         RET(20)
22425         }
22426         res = 0;
22427         PRE_IO
22428         WRITE_BYTE_F(adr, res)
22429         POST_IO
22430         RET(20)
22431 }
22432
22433 // STCC
22434 OPCODE(0x59F9)
22435 {
22436         u32 adr, res;
22437         u32 src, dst;
22438
22439         FETCH_LONG(adr);
22440         if (flag_V & 0x80)
22441         {
22442         res = 0xFF;
22443         PRE_IO
22444         WRITE_BYTE_F(adr, res)
22445         POST_IO
22446         RET(20)
22447         }
22448         res = 0;
22449         PRE_IO
22450         WRITE_BYTE_F(adr, res)
22451         POST_IO
22452         RET(20)
22453 }
22454
22455 // STCC
22456 OPCODE(0x5AF9)
22457 {
22458         u32 adr, res;
22459         u32 src, dst;
22460
22461         FETCH_LONG(adr);
22462         if (!(flag_N & 0x80))
22463         {
22464         res = 0xFF;
22465         PRE_IO
22466         WRITE_BYTE_F(adr, res)
22467         POST_IO
22468         RET(20)
22469         }
22470         res = 0;
22471         PRE_IO
22472         WRITE_BYTE_F(adr, res)
22473         POST_IO
22474         RET(20)
22475 }
22476
22477 // STCC
22478 OPCODE(0x5BF9)
22479 {
22480         u32 adr, res;
22481         u32 src, dst;
22482
22483         FETCH_LONG(adr);
22484         if (flag_N & 0x80)
22485         {
22486         res = 0xFF;
22487         PRE_IO
22488         WRITE_BYTE_F(adr, res)
22489         POST_IO
22490         RET(20)
22491         }
22492         res = 0;
22493         PRE_IO
22494         WRITE_BYTE_F(adr, res)
22495         POST_IO
22496         RET(20)
22497 }
22498
22499 // STCC
22500 OPCODE(0x5CF9)
22501 {
22502         u32 adr, res;
22503         u32 src, dst;
22504
22505         FETCH_LONG(adr);
22506         if (!((flag_N ^ flag_V) & 0x80))
22507         {
22508         res = 0xFF;
22509         PRE_IO
22510         WRITE_BYTE_F(adr, res)
22511         POST_IO
22512         RET(20)
22513         }
22514         res = 0;
22515         PRE_IO
22516         WRITE_BYTE_F(adr, res)
22517         POST_IO
22518         RET(20)
22519 }
22520
22521 // STCC
22522 OPCODE(0x5DF9)
22523 {
22524         u32 adr, res;
22525         u32 src, dst;
22526
22527         FETCH_LONG(adr);
22528         if ((flag_N ^ flag_V) & 0x80)
22529         {
22530         res = 0xFF;
22531         PRE_IO
22532         WRITE_BYTE_F(adr, res)
22533         POST_IO
22534         RET(20)
22535         }
22536         res = 0;
22537         PRE_IO
22538         WRITE_BYTE_F(adr, res)
22539         POST_IO
22540         RET(20)
22541 }
22542
22543 // STCC
22544 OPCODE(0x5EF9)
22545 {
22546         u32 adr, res;
22547         u32 src, dst;
22548
22549         FETCH_LONG(adr);
22550         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22551         {
22552         res = 0xFF;
22553         PRE_IO
22554         WRITE_BYTE_F(adr, res)
22555         POST_IO
22556         RET(20)
22557         }
22558         res = 0;
22559         PRE_IO
22560         WRITE_BYTE_F(adr, res)
22561         POST_IO
22562         RET(20)
22563 }
22564
22565 // STCC
22566 OPCODE(0x5FF9)
22567 {
22568         u32 adr, res;
22569         u32 src, dst;
22570
22571         FETCH_LONG(adr);
22572         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22573         {
22574         res = 0xFF;
22575         PRE_IO
22576         WRITE_BYTE_F(adr, res)
22577         POST_IO
22578         RET(20)
22579         }
22580         res = 0;
22581         PRE_IO
22582         WRITE_BYTE_F(adr, res)
22583         POST_IO
22584         RET(20)
22585 }
22586
22587 // STCC
22588 OPCODE(0x50DF)
22589 {
22590         u32 adr, res;
22591         u32 src, dst;
22592
22593         adr = AREG(7);
22594         AREG(7) += 2;
22595         res = 0xFF;
22596         PRE_IO
22597         WRITE_BYTE_F(adr, res)
22598         POST_IO
22599         RET(12)
22600 }
22601
22602 // STCC
22603 OPCODE(0x51DF)
22604 {
22605         u32 adr, res;
22606         u32 src, dst;
22607
22608         adr = AREG(7);
22609         AREG(7) += 2;
22610         res = 0;
22611         PRE_IO
22612         WRITE_BYTE_F(adr, res)
22613         POST_IO
22614         RET(12)
22615 }
22616
22617 // STCC
22618 OPCODE(0x52DF)
22619 {
22620         u32 adr, res;
22621         u32 src, dst;
22622
22623         adr = AREG(7);
22624         AREG(7) += 2;
22625         if (flag_NotZ && (!(flag_C & 0x100)))
22626         {
22627         res = 0xFF;
22628         PRE_IO
22629         WRITE_BYTE_F(adr, res)
22630         POST_IO
22631         RET(12)
22632         }
22633         res = 0;
22634         PRE_IO
22635         WRITE_BYTE_F(adr, res)
22636         POST_IO
22637         RET(12)
22638 }
22639
22640 // STCC
22641 OPCODE(0x53DF)
22642 {
22643         u32 adr, res;
22644         u32 src, dst;
22645
22646         adr = AREG(7);
22647         AREG(7) += 2;
22648         if ((!flag_NotZ) || (flag_C & 0x100))
22649         {
22650         res = 0xFF;
22651         PRE_IO
22652         WRITE_BYTE_F(adr, res)
22653         POST_IO
22654         RET(12)
22655         }
22656         res = 0;
22657         PRE_IO
22658         WRITE_BYTE_F(adr, res)
22659         POST_IO
22660         RET(12)
22661 }
22662
22663 // STCC
22664 OPCODE(0x54DF)
22665 {
22666         u32 adr, res;
22667         u32 src, dst;
22668
22669         adr = AREG(7);
22670         AREG(7) += 2;
22671         if (!(flag_C & 0x100))
22672         {
22673         res = 0xFF;
22674         PRE_IO
22675         WRITE_BYTE_F(adr, res)
22676         POST_IO
22677         RET(12)
22678         }
22679         res = 0;
22680         PRE_IO
22681         WRITE_BYTE_F(adr, res)
22682         POST_IO
22683         RET(12)
22684 }
22685
22686 // STCC
22687 OPCODE(0x55DF)
22688 {
22689         u32 adr, res;
22690         u32 src, dst;
22691
22692         adr = AREG(7);
22693         AREG(7) += 2;
22694         if (flag_C & 0x100)
22695         {
22696         res = 0xFF;
22697         PRE_IO
22698         WRITE_BYTE_F(adr, res)
22699         POST_IO
22700         RET(12)
22701         }
22702         res = 0;
22703         PRE_IO
22704         WRITE_BYTE_F(adr, res)
22705         POST_IO
22706         RET(12)
22707 }
22708
22709 // STCC
22710 OPCODE(0x56DF)
22711 {
22712         u32 adr, res;
22713         u32 src, dst;
22714
22715         adr = AREG(7);
22716         AREG(7) += 2;
22717         if (flag_NotZ)
22718         {
22719         res = 0xFF;
22720         PRE_IO
22721         WRITE_BYTE_F(adr, res)
22722         POST_IO
22723         RET(12)
22724         }
22725         res = 0;
22726         PRE_IO
22727         WRITE_BYTE_F(adr, res)
22728         POST_IO
22729         RET(12)
22730 }
22731
22732 // STCC
22733 OPCODE(0x57DF)
22734 {
22735         u32 adr, res;
22736         u32 src, dst;
22737
22738         adr = AREG(7);
22739         AREG(7) += 2;
22740         if (!flag_NotZ)
22741         {
22742         res = 0xFF;
22743         PRE_IO
22744         WRITE_BYTE_F(adr, res)
22745         POST_IO
22746         RET(12)
22747         }
22748         res = 0;
22749         PRE_IO
22750         WRITE_BYTE_F(adr, res)
22751         POST_IO
22752         RET(12)
22753 }
22754
22755 // STCC
22756 OPCODE(0x58DF)
22757 {
22758         u32 adr, res;
22759         u32 src, dst;
22760
22761         adr = AREG(7);
22762         AREG(7) += 2;
22763         if (!(flag_V & 0x80))
22764         {
22765         res = 0xFF;
22766         PRE_IO
22767         WRITE_BYTE_F(adr, res)
22768         POST_IO
22769         RET(12)
22770         }
22771         res = 0;
22772         PRE_IO
22773         WRITE_BYTE_F(adr, res)
22774         POST_IO
22775         RET(12)
22776 }
22777
22778 // STCC
22779 OPCODE(0x59DF)
22780 {
22781         u32 adr, res;
22782         u32 src, dst;
22783
22784         adr = AREG(7);
22785         AREG(7) += 2;
22786         if (flag_V & 0x80)
22787         {
22788         res = 0xFF;
22789         PRE_IO
22790         WRITE_BYTE_F(adr, res)
22791         POST_IO
22792         RET(12)
22793         }
22794         res = 0;
22795         PRE_IO
22796         WRITE_BYTE_F(adr, res)
22797         POST_IO
22798         RET(12)
22799 }
22800
22801 // STCC
22802 OPCODE(0x5ADF)
22803 {
22804         u32 adr, res;
22805         u32 src, dst;
22806
22807         adr = AREG(7);
22808         AREG(7) += 2;
22809         if (!(flag_N & 0x80))
22810         {
22811         res = 0xFF;
22812         PRE_IO
22813         WRITE_BYTE_F(adr, res)
22814         POST_IO
22815         RET(12)
22816         }
22817         res = 0;
22818         PRE_IO
22819         WRITE_BYTE_F(adr, res)
22820         POST_IO
22821         RET(12)
22822 }
22823
22824 // STCC
22825 OPCODE(0x5BDF)
22826 {
22827         u32 adr, res;
22828         u32 src, dst;
22829
22830         adr = AREG(7);
22831         AREG(7) += 2;
22832         if (flag_N & 0x80)
22833         {
22834         res = 0xFF;
22835         PRE_IO
22836         WRITE_BYTE_F(adr, res)
22837         POST_IO
22838         RET(12)
22839         }
22840         res = 0;
22841         PRE_IO
22842         WRITE_BYTE_F(adr, res)
22843         POST_IO
22844         RET(12)
22845 }
22846
22847 // STCC
22848 OPCODE(0x5CDF)
22849 {
22850         u32 adr, res;
22851         u32 src, dst;
22852
22853         adr = AREG(7);
22854         AREG(7) += 2;
22855         if (!((flag_N ^ flag_V) & 0x80))
22856         {
22857         res = 0xFF;
22858         PRE_IO
22859         WRITE_BYTE_F(adr, res)
22860         POST_IO
22861         RET(12)
22862         }
22863         res = 0;
22864         PRE_IO
22865         WRITE_BYTE_F(adr, res)
22866         POST_IO
22867         RET(12)
22868 }
22869
22870 // STCC
22871 OPCODE(0x5DDF)
22872 {
22873         u32 adr, res;
22874         u32 src, dst;
22875
22876         adr = AREG(7);
22877         AREG(7) += 2;
22878         if ((flag_N ^ flag_V) & 0x80)
22879         {
22880         res = 0xFF;
22881         PRE_IO
22882         WRITE_BYTE_F(adr, res)
22883         POST_IO
22884         RET(12)
22885         }
22886         res = 0;
22887         PRE_IO
22888         WRITE_BYTE_F(adr, res)
22889         POST_IO
22890         RET(12)
22891 }
22892
22893 // STCC
22894 OPCODE(0x5EDF)
22895 {
22896         u32 adr, res;
22897         u32 src, dst;
22898
22899         adr = AREG(7);
22900         AREG(7) += 2;
22901         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22902         {
22903         res = 0xFF;
22904         PRE_IO
22905         WRITE_BYTE_F(adr, res)
22906         POST_IO
22907         RET(12)
22908         }
22909         res = 0;
22910         PRE_IO
22911         WRITE_BYTE_F(adr, res)
22912         POST_IO
22913         RET(12)
22914 }
22915
22916 // STCC
22917 OPCODE(0x5FDF)
22918 {
22919         u32 adr, res;
22920         u32 src, dst;
22921
22922         adr = AREG(7);
22923         AREG(7) += 2;
22924         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22925         {
22926         res = 0xFF;
22927         PRE_IO
22928         WRITE_BYTE_F(adr, res)
22929         POST_IO
22930         RET(12)
22931         }
22932         res = 0;
22933         PRE_IO
22934         WRITE_BYTE_F(adr, res)
22935         POST_IO
22936         RET(12)
22937 }
22938
22939 // STCC
22940 OPCODE(0x50E7)
22941 {
22942         u32 adr, res;
22943         u32 src, dst;
22944
22945         adr = AREG(7) - 2;
22946         AREG(7) = adr;
22947         res = 0xFF;
22948         PRE_IO
22949         WRITE_BYTE_F(adr, res)
22950         POST_IO
22951         RET(14)
22952 }
22953
22954 // STCC
22955 OPCODE(0x51E7)
22956 {
22957         u32 adr, res;
22958         u32 src, dst;
22959
22960         adr = AREG(7) - 2;
22961         AREG(7) = adr;
22962         res = 0;
22963         PRE_IO
22964         WRITE_BYTE_F(adr, res)
22965         POST_IO
22966         RET(14)
22967 }
22968
22969 // STCC
22970 OPCODE(0x52E7)
22971 {
22972         u32 adr, res;
22973         u32 src, dst;
22974
22975         adr = AREG(7) - 2;
22976         AREG(7) = adr;
22977         if (flag_NotZ && (!(flag_C & 0x100)))
22978         {
22979         res = 0xFF;
22980         PRE_IO
22981         WRITE_BYTE_F(adr, res)
22982         POST_IO
22983         RET(14)
22984         }
22985         res = 0;
22986         PRE_IO
22987         WRITE_BYTE_F(adr, res)
22988         POST_IO
22989         RET(14)
22990 }
22991
22992 // STCC
22993 OPCODE(0x53E7)
22994 {
22995         u32 adr, res;
22996         u32 src, dst;
22997
22998         adr = AREG(7) - 2;
22999         AREG(7) = adr;
23000         if ((!flag_NotZ) || (flag_C & 0x100))
23001         {
23002         res = 0xFF;
23003         PRE_IO
23004         WRITE_BYTE_F(adr, res)
23005         POST_IO
23006         RET(14)
23007         }
23008         res = 0;
23009         PRE_IO
23010         WRITE_BYTE_F(adr, res)
23011         POST_IO
23012         RET(14)
23013 }
23014
23015 // STCC
23016 OPCODE(0x54E7)
23017 {
23018         u32 adr, res;
23019         u32 src, dst;
23020
23021         adr = AREG(7) - 2;
23022         AREG(7) = adr;
23023         if (!(flag_C & 0x100))
23024         {
23025         res = 0xFF;
23026         PRE_IO
23027         WRITE_BYTE_F(adr, res)
23028         POST_IO
23029         RET(14)
23030         }
23031         res = 0;
23032         PRE_IO
23033         WRITE_BYTE_F(adr, res)
23034         POST_IO
23035         RET(14)
23036 }
23037
23038 // STCC
23039 OPCODE(0x55E7)
23040 {
23041         u32 adr, res;
23042         u32 src, dst;
23043
23044         adr = AREG(7) - 2;
23045         AREG(7) = adr;
23046         if (flag_C & 0x100)
23047         {
23048         res = 0xFF;
23049         PRE_IO
23050         WRITE_BYTE_F(adr, res)
23051         POST_IO
23052         RET(14)
23053         }
23054         res = 0;
23055         PRE_IO
23056         WRITE_BYTE_F(adr, res)
23057         POST_IO
23058         RET(14)
23059 }
23060
23061 // STCC
23062 OPCODE(0x56E7)
23063 {
23064         u32 adr, res;
23065         u32 src, dst;
23066
23067         adr = AREG(7) - 2;
23068         AREG(7) = adr;
23069         if (flag_NotZ)
23070         {
23071         res = 0xFF;
23072         PRE_IO
23073         WRITE_BYTE_F(adr, res)
23074         POST_IO
23075         RET(14)
23076         }
23077         res = 0;
23078         PRE_IO
23079         WRITE_BYTE_F(adr, res)
23080         POST_IO
23081         RET(14)
23082 }
23083
23084 // STCC
23085 OPCODE(0x57E7)
23086 {
23087         u32 adr, res;
23088         u32 src, dst;
23089
23090         adr = AREG(7) - 2;
23091         AREG(7) = adr;
23092         if (!flag_NotZ)
23093         {
23094         res = 0xFF;
23095         PRE_IO
23096         WRITE_BYTE_F(adr, res)
23097         POST_IO
23098         RET(14)
23099         }
23100         res = 0;
23101         PRE_IO
23102         WRITE_BYTE_F(adr, res)
23103         POST_IO
23104         RET(14)
23105 }
23106
23107 // STCC
23108 OPCODE(0x58E7)
23109 {
23110         u32 adr, res;
23111         u32 src, dst;
23112
23113         adr = AREG(7) - 2;
23114         AREG(7) = adr;
23115         if (!(flag_V & 0x80))
23116         {
23117         res = 0xFF;
23118         PRE_IO
23119         WRITE_BYTE_F(adr, res)
23120         POST_IO
23121         RET(14)
23122         }
23123         res = 0;
23124         PRE_IO
23125         WRITE_BYTE_F(adr, res)
23126         POST_IO
23127         RET(14)
23128 }
23129
23130 // STCC
23131 OPCODE(0x59E7)
23132 {
23133         u32 adr, res;
23134         u32 src, dst;
23135
23136         adr = AREG(7) - 2;
23137         AREG(7) = adr;
23138         if (flag_V & 0x80)
23139         {
23140         res = 0xFF;
23141         PRE_IO
23142         WRITE_BYTE_F(adr, res)
23143         POST_IO
23144         RET(14)
23145         }
23146         res = 0;
23147         PRE_IO
23148         WRITE_BYTE_F(adr, res)
23149         POST_IO
23150         RET(14)
23151 }
23152
23153 // STCC
23154 OPCODE(0x5AE7)
23155 {
23156         u32 adr, res;
23157         u32 src, dst;
23158
23159         adr = AREG(7) - 2;
23160         AREG(7) = adr;
23161         if (!(flag_N & 0x80))
23162         {
23163         res = 0xFF;
23164         PRE_IO
23165         WRITE_BYTE_F(adr, res)
23166         POST_IO
23167         RET(14)
23168         }
23169         res = 0;
23170         PRE_IO
23171         WRITE_BYTE_F(adr, res)
23172         POST_IO
23173         RET(14)
23174 }
23175
23176 // STCC
23177 OPCODE(0x5BE7)
23178 {
23179         u32 adr, res;
23180         u32 src, dst;
23181
23182         adr = AREG(7) - 2;
23183         AREG(7) = adr;
23184         if (flag_N & 0x80)
23185         {
23186         res = 0xFF;
23187         PRE_IO
23188         WRITE_BYTE_F(adr, res)
23189         POST_IO
23190         RET(14)
23191         }
23192         res = 0;
23193         PRE_IO
23194         WRITE_BYTE_F(adr, res)
23195         POST_IO
23196         RET(14)
23197 }
23198
23199 // STCC
23200 OPCODE(0x5CE7)
23201 {
23202         u32 adr, res;
23203         u32 src, dst;
23204
23205         adr = AREG(7) - 2;
23206         AREG(7) = adr;
23207         if (!((flag_N ^ flag_V) & 0x80))
23208         {
23209         res = 0xFF;
23210         PRE_IO
23211         WRITE_BYTE_F(adr, res)
23212         POST_IO
23213         RET(14)
23214         }
23215         res = 0;
23216         PRE_IO
23217         WRITE_BYTE_F(adr, res)
23218         POST_IO
23219         RET(14)
23220 }
23221
23222 // STCC
23223 OPCODE(0x5DE7)
23224 {
23225         u32 adr, res;
23226         u32 src, dst;
23227
23228         adr = AREG(7) - 2;
23229         AREG(7) = adr;
23230         if ((flag_N ^ flag_V) & 0x80)
23231         {
23232         res = 0xFF;
23233         PRE_IO
23234         WRITE_BYTE_F(adr, res)
23235         POST_IO
23236         RET(14)
23237         }
23238         res = 0;
23239         PRE_IO
23240         WRITE_BYTE_F(adr, res)
23241         POST_IO
23242         RET(14)
23243 }
23244
23245 // STCC
23246 OPCODE(0x5EE7)
23247 {
23248         u32 adr, res;
23249         u32 src, dst;
23250
23251         adr = AREG(7) - 2;
23252         AREG(7) = adr;
23253         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
23254         {
23255         res = 0xFF;
23256         PRE_IO
23257         WRITE_BYTE_F(adr, res)
23258         POST_IO
23259         RET(14)
23260         }
23261         res = 0;
23262         PRE_IO
23263         WRITE_BYTE_F(adr, res)
23264         POST_IO
23265         RET(14)
23266 }
23267
23268 // STCC
23269 OPCODE(0x5FE7)
23270 {
23271         u32 adr, res;
23272         u32 src, dst;
23273
23274         adr = AREG(7) - 2;
23275         AREG(7) = adr;
23276         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
23277         {
23278         res = 0xFF;
23279         PRE_IO
23280         WRITE_BYTE_F(adr, res)
23281         POST_IO
23282         RET(14)
23283         }
23284         res = 0;
23285         PRE_IO
23286         WRITE_BYTE_F(adr, res)
23287         POST_IO
23288         RET(14)
23289 }
23290
23291 // DBCC
23292 OPCODE(0x50C8)
23293 {
23294         u32 adr, res;
23295         u32 src, dst;
23296
23297         PC++;
23298 RET(12)
23299 }
23300
23301 // DBCC
23302 OPCODE(0x51C8)
23303 {
23304         u32 adr, res;
23305         u32 src, dst;
23306
23307         NOT_POLLING
23308
23309         res = DREGu16((Opcode >> 0) & 7);
23310         res--;
23311         DREGu16((Opcode >> 0) & 7) = res;
23312         if ((s32)res != -1)
23313         {
23314                 u32 newPC;
23315
23316                 newPC = GET_PC;
23317                 newPC += GET_SWORD;
23318                 SET_PC(newPC);
23319                 CHECK_BRANCH_EXCEPTION(newPC)
23320         RET(10)
23321         }
23322         PC++;
23323 RET(14)
23324 }
23325
23326 // DBCC
23327 OPCODE(0x52C8)
23328 {
23329         u32 adr, res;
23330         u32 src, dst;
23331
23332         NOT_POLLING
23333
23334         if ((!flag_NotZ) || (flag_C & 0x100))
23335         {
23336         res = DREGu16((Opcode >> 0) & 7);
23337         res--;
23338         DREGu16((Opcode >> 0) & 7) = res;
23339         if ((s32)res != -1)
23340         {
23341                 u32 newPC;
23342
23343                 newPC = GET_PC;
23344                 newPC += GET_SWORD;
23345                 SET_PC(newPC);
23346                 CHECK_BRANCH_EXCEPTION(newPC)
23347         RET(10)
23348         }
23349         }
23350         else
23351         {
23352                 PC++;
23353         RET(12)
23354         }
23355         PC++;
23356 RET(14)
23357 }
23358
23359 // DBCC
23360 OPCODE(0x53C8)
23361 {
23362         u32 adr, res;
23363         u32 src, dst;
23364
23365         NOT_POLLING
23366
23367         if (flag_NotZ && (!(flag_C & 0x100)))
23368         {
23369         res = DREGu16((Opcode >> 0) & 7);
23370         res--;
23371         DREGu16((Opcode >> 0) & 7) = res;
23372         if ((s32)res != -1)
23373         {
23374                 u32 newPC;
23375
23376                 newPC = GET_PC;
23377                 newPC += GET_SWORD;
23378                 SET_PC(newPC);
23379                 CHECK_BRANCH_EXCEPTION(newPC)
23380         RET(10)
23381         }
23382         }
23383         else
23384         {
23385                 PC++;
23386         RET(12)
23387         }
23388         PC++;
23389 RET(14)
23390 }
23391
23392 // DBCC
23393 OPCODE(0x54C8)
23394 {
23395         u32 adr, res;
23396         u32 src, dst;
23397
23398         NOT_POLLING
23399
23400         if (flag_C & 0x100)
23401         {
23402         res = DREGu16((Opcode >> 0) & 7);
23403         res--;
23404         DREGu16((Opcode >> 0) & 7) = res;
23405         if ((s32)res != -1)
23406         {
23407                 u32 newPC;
23408
23409                 newPC = GET_PC;
23410                 newPC += GET_SWORD;
23411                 SET_PC(newPC);
23412                 CHECK_BRANCH_EXCEPTION(newPC)
23413         RET(10)
23414         }
23415         }
23416         else
23417         {
23418                 PC++;
23419         RET(12)
23420         }
23421         PC++;
23422 RET(14)
23423 }
23424
23425 // DBCC
23426 OPCODE(0x55C8)
23427 {
23428         u32 adr, res;
23429         u32 src, dst;
23430
23431         NOT_POLLING
23432
23433         if (!(flag_C & 0x100))
23434         {
23435         res = DREGu16((Opcode >> 0) & 7);
23436         res--;
23437         DREGu16((Opcode >> 0) & 7) = res;
23438         if ((s32)res != -1)
23439         {
23440                 u32 newPC;
23441
23442                 newPC = GET_PC;
23443                 newPC += GET_SWORD;
23444                 SET_PC(newPC);
23445                 CHECK_BRANCH_EXCEPTION(newPC)
23446         RET(10)
23447         }
23448         }
23449         else
23450         {
23451                 PC++;
23452         RET(12)
23453         }
23454         PC++;
23455 RET(14)
23456 }
23457
23458 // DBCC
23459 OPCODE(0x56C8)
23460 {
23461         u32 adr, res;
23462         u32 src, dst;
23463
23464         NOT_POLLING
23465
23466         if (!flag_NotZ)
23467         {
23468         res = DREGu16((Opcode >> 0) & 7);
23469         res--;
23470         DREGu16((Opcode >> 0) & 7) = res;
23471         if ((s32)res != -1)
23472         {
23473                 u32 newPC;
23474
23475                 newPC = GET_PC;
23476                 newPC += GET_SWORD;
23477                 SET_PC(newPC);
23478                 CHECK_BRANCH_EXCEPTION(newPC)
23479         RET(10)
23480         }
23481         }
23482         else
23483         {
23484                 PC++;
23485         RET(12)
23486         }
23487         PC++;
23488 RET(14)
23489 }
23490
23491 // DBCC
23492 OPCODE(0x57C8)
23493 {
23494         u32 adr, res;
23495         u32 src, dst;
23496
23497         NOT_POLLING
23498
23499         if (flag_NotZ)
23500         {
23501         res = DREGu16((Opcode >> 0) & 7);
23502         res--;
23503         DREGu16((Opcode >> 0) & 7) = res;
23504         if ((s32)res != -1)
23505         {
23506                 u32 newPC;
23507
23508                 newPC = GET_PC;
23509                 newPC += GET_SWORD;
23510                 SET_PC(newPC);
23511                 CHECK_BRANCH_EXCEPTION(newPC)
23512         RET(10)
23513         }
23514         }
23515         else
23516         {
23517                 PC++;
23518         RET(12)
23519         }
23520         PC++;
23521 RET(14)
23522 }
23523
23524 // DBCC
23525 OPCODE(0x58C8)
23526 {
23527         u32 adr, res;
23528         u32 src, dst;
23529
23530         NOT_POLLING
23531
23532         if (flag_V & 0x80)
23533         {
23534         res = DREGu16((Opcode >> 0) & 7);
23535         res--;
23536         DREGu16((Opcode >> 0) & 7) = res;
23537         if ((s32)res != -1)
23538         {
23539                 u32 newPC;
23540
23541                 newPC = GET_PC;
23542                 newPC += GET_SWORD;
23543                 SET_PC(newPC);
23544                 CHECK_BRANCH_EXCEPTION(newPC)
23545         RET(10)
23546         }
23547         }
23548         else
23549         {
23550                 PC++;
23551         RET(12)
23552         }
23553         PC++;
23554 RET(14)
23555 }
23556
23557 // DBCC
23558 OPCODE(0x59C8)
23559 {
23560         u32 adr, res;
23561         u32 src, dst;
23562
23563         NOT_POLLING
23564
23565         if (!(flag_V & 0x80))
23566         {
23567         res = DREGu16((Opcode >> 0) & 7);
23568         res--;
23569         DREGu16((Opcode >> 0) & 7) = res;
23570         if ((s32)res != -1)
23571         {
23572                 u32 newPC;
23573
23574                 newPC = GET_PC;
23575                 newPC += GET_SWORD;
23576                 SET_PC(newPC);
23577                 CHECK_BRANCH_EXCEPTION(newPC)
23578         RET(10)
23579         }
23580         }
23581         else
23582         {
23583                 PC++;
23584         RET(12)
23585         }
23586         PC++;
23587 RET(14)
23588 }
23589
23590 // DBCC
23591 OPCODE(0x5AC8)
23592 {
23593         u32 adr, res;
23594         u32 src, dst;
23595
23596         NOT_POLLING
23597
23598         if (flag_N & 0x80)
23599         {
23600         res = DREGu16((Opcode >> 0) & 7);
23601         res--;
23602         DREGu16((Opcode >> 0) & 7) = res;
23603         if ((s32)res != -1)
23604         {
23605                 u32 newPC;
23606
23607                 newPC = GET_PC;
23608                 newPC += GET_SWORD;
23609                 SET_PC(newPC);
23610                 CHECK_BRANCH_EXCEPTION(newPC)
23611         RET(10)
23612         }
23613         }
23614         else
23615         {
23616                 PC++;
23617         RET(12)
23618         }
23619         PC++;
23620 RET(14)
23621 }
23622
23623 // DBCC
23624 OPCODE(0x5BC8)
23625 {
23626         u32 adr, res;
23627         u32 src, dst;
23628
23629         NOT_POLLING
23630
23631         if (!(flag_N & 0x80))
23632         {
23633         res = DREGu16((Opcode >> 0) & 7);
23634         res--;
23635         DREGu16((Opcode >> 0) & 7) = res;
23636         if ((s32)res != -1)
23637         {
23638                 u32 newPC;
23639
23640                 newPC = GET_PC;
23641                 newPC += GET_SWORD;
23642                 SET_PC(newPC);
23643                 CHECK_BRANCH_EXCEPTION(newPC)
23644         RET(10)
23645         }
23646         }
23647         else
23648         {
23649                 PC++;
23650         RET(12)
23651         }
23652         PC++;
23653 RET(14)
23654 }
23655
23656 // DBCC
23657 OPCODE(0x5CC8)
23658 {
23659         u32 adr, res;
23660         u32 src, dst;
23661
23662         NOT_POLLING
23663
23664         if ((flag_N ^ flag_V) & 0x80)
23665         {
23666         res = DREGu16((Opcode >> 0) & 7);
23667         res--;
23668         DREGu16((Opcode >> 0) & 7) = res;
23669         if ((s32)res != -1)
23670         {
23671                 u32 newPC;
23672
23673                 newPC = GET_PC;
23674                 newPC += GET_SWORD;
23675                 SET_PC(newPC);
23676                 CHECK_BRANCH_EXCEPTION(newPC)
23677         RET(10)
23678         }
23679         }
23680         else
23681         {
23682                 PC++;
23683         RET(12)
23684         }
23685         PC++;
23686 RET(14)
23687 }
23688
23689 // DBCC
23690 OPCODE(0x5DC8)
23691 {
23692         u32 adr, res;
23693         u32 src, dst;
23694
23695         NOT_POLLING
23696
23697         if (!((flag_N ^ flag_V) & 0x80))
23698         {
23699         res = DREGu16((Opcode >> 0) & 7);
23700         res--;
23701         DREGu16((Opcode >> 0) & 7) = res;
23702         if ((s32)res != -1)
23703         {
23704                 u32 newPC;
23705
23706                 newPC = GET_PC;
23707                 newPC += GET_SWORD;
23708                 SET_PC(newPC);
23709                 CHECK_BRANCH_EXCEPTION(newPC)
23710         RET(10)
23711         }
23712         }
23713         else
23714         {
23715                 PC++;
23716         RET(12)
23717         }
23718         PC++;
23719 RET(14)
23720 }
23721
23722 // DBCC
23723 OPCODE(0x5EC8)
23724 {
23725         u32 adr, res;
23726         u32 src, dst;
23727
23728         NOT_POLLING
23729
23730         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
23731         {
23732         res = DREGu16((Opcode >> 0) & 7);
23733         res--;
23734         DREGu16((Opcode >> 0) & 7) = res;
23735         if ((s32)res != -1)
23736         {
23737                 u32 newPC;
23738
23739                 newPC = GET_PC;
23740                 newPC += GET_SWORD;
23741                 SET_PC(newPC);
23742                 CHECK_BRANCH_EXCEPTION(newPC)
23743         RET(10)
23744         }
23745         }
23746         else
23747         {
23748                 PC++;
23749         RET(12)
23750         }
23751         PC++;
23752 RET(14)
23753 }
23754
23755 // DBCC
23756 OPCODE(0x5FC8)
23757 {
23758         u32 adr, res;
23759         u32 src, dst;
23760
23761         NOT_POLLING
23762
23763         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
23764         {
23765         res = DREGu16((Opcode >> 0) & 7);
23766         res--;
23767         DREGu16((Opcode >> 0) & 7) = res;
23768         if ((s32)res != -1)
23769         {
23770                 u32 newPC;
23771
23772                 newPC = GET_PC;
23773                 newPC += GET_SWORD;
23774                 SET_PC(newPC);
23775                 CHECK_BRANCH_EXCEPTION(newPC)
23776         RET(10)
23777         }
23778         }
23779         else
23780         {
23781                 PC++;
23782         RET(12)
23783         }
23784         PC++;
23785 RET(14)
23786 }
23787
23788 // ADDQ
23789 OPCODE(0x5000)
23790 {
23791         u32 adr, res;
23792         u32 src, dst;
23793
23794         src = (((Opcode >> 9) - 1) & 7) + 1;
23795         dst = DREGu8((Opcode >> 0) & 7);
23796         res = dst + src;
23797         flag_N = flag_X = flag_C = res;
23798         flag_V = (src ^ res) & (dst ^ res);
23799         flag_NotZ = res & 0xFF;
23800         DREGu8((Opcode >> 0) & 7) = res;
23801 RET(4)
23802 }
23803
23804 // ADDQ
23805 OPCODE(0x5010)
23806 {
23807         u32 adr, res;
23808         u32 src, dst;
23809
23810         src = (((Opcode >> 9) - 1) & 7) + 1;
23811         adr = AREG((Opcode >> 0) & 7);
23812         PRE_IO
23813         READ_BYTE_F(adr, dst)
23814         res = dst + src;
23815         flag_N = flag_X = flag_C = res;
23816         flag_V = (src ^ res) & (dst ^ res);
23817         flag_NotZ = res & 0xFF;
23818         WRITE_BYTE_F(adr, res)
23819         POST_IO
23820 RET(12)
23821 }
23822
23823 // ADDQ
23824 OPCODE(0x5018)
23825 {
23826         u32 adr, res;
23827         u32 src, dst;
23828
23829         src = (((Opcode >> 9) - 1) & 7) + 1;
23830         adr = AREG((Opcode >> 0) & 7);
23831         AREG((Opcode >> 0) & 7) += 1;
23832         PRE_IO
23833         READ_BYTE_F(adr, dst)
23834         res = dst + src;
23835         flag_N = flag_X = flag_C = res;
23836         flag_V = (src ^ res) & (dst ^ res);
23837         flag_NotZ = res & 0xFF;
23838         WRITE_BYTE_F(adr, res)
23839         POST_IO
23840 RET(12)
23841 }
23842
23843 // ADDQ
23844 OPCODE(0x5020)
23845 {
23846         u32 adr, res;
23847         u32 src, dst;
23848
23849         src = (((Opcode >> 9) - 1) & 7) + 1;
23850         adr = AREG((Opcode >> 0) & 7) - 1;
23851         AREG((Opcode >> 0) & 7) = adr;
23852         PRE_IO
23853         READ_BYTE_F(adr, dst)
23854         res = dst + src;
23855         flag_N = flag_X = flag_C = res;
23856         flag_V = (src ^ res) & (dst ^ res);
23857         flag_NotZ = res & 0xFF;
23858         WRITE_BYTE_F(adr, res)
23859         POST_IO
23860 RET(14)
23861 }
23862
23863 // ADDQ
23864 OPCODE(0x5028)
23865 {
23866         u32 adr, res;
23867         u32 src, dst;
23868
23869         src = (((Opcode >> 9) - 1) & 7) + 1;
23870         FETCH_SWORD(adr);
23871         adr += AREG((Opcode >> 0) & 7);
23872         PRE_IO
23873         READ_BYTE_F(adr, dst)
23874         res = dst + src;
23875         flag_N = flag_X = flag_C = res;
23876         flag_V = (src ^ res) & (dst ^ res);
23877         flag_NotZ = res & 0xFF;
23878         WRITE_BYTE_F(adr, res)
23879         POST_IO
23880 RET(16)
23881 }
23882
23883 // ADDQ
23884 OPCODE(0x5030)
23885 {
23886         u32 adr, res;
23887         u32 src, dst;
23888
23889         src = (((Opcode >> 9) - 1) & 7) + 1;
23890         adr = AREG((Opcode >> 0) & 7);
23891         DECODE_EXT_WORD
23892         PRE_IO
23893         READ_BYTE_F(adr, dst)
23894         res = dst + src;
23895         flag_N = flag_X = flag_C = res;
23896         flag_V = (src ^ res) & (dst ^ res);
23897         flag_NotZ = res & 0xFF;
23898         WRITE_BYTE_F(adr, res)
23899         POST_IO
23900 RET(18)
23901 }
23902
23903 // ADDQ
23904 OPCODE(0x5038)
23905 {
23906         u32 adr, res;
23907         u32 src, dst;
23908
23909         src = (((Opcode >> 9) - 1) & 7) + 1;
23910         FETCH_SWORD(adr);
23911         PRE_IO
23912         READ_BYTE_F(adr, dst)
23913         res = dst + src;
23914         flag_N = flag_X = flag_C = res;
23915         flag_V = (src ^ res) & (dst ^ res);
23916         flag_NotZ = res & 0xFF;
23917         WRITE_BYTE_F(adr, res)
23918         POST_IO
23919 RET(16)
23920 }
23921
23922 // ADDQ
23923 OPCODE(0x5039)
23924 {
23925         u32 adr, res;
23926         u32 src, dst;
23927
23928         src = (((Opcode >> 9) - 1) & 7) + 1;
23929         FETCH_LONG(adr);
23930         PRE_IO
23931         READ_BYTE_F(adr, dst)
23932         res = dst + src;
23933         flag_N = flag_X = flag_C = res;
23934         flag_V = (src ^ res) & (dst ^ res);
23935         flag_NotZ = res & 0xFF;
23936         WRITE_BYTE_F(adr, res)
23937         POST_IO
23938 RET(20)
23939 }
23940
23941 // ADDQ
23942 OPCODE(0x501F)
23943 {
23944         u32 adr, res;
23945         u32 src, dst;
23946
23947         src = (((Opcode >> 9) - 1) & 7) + 1;
23948         adr = AREG(7);
23949         AREG(7) += 2;
23950         PRE_IO
23951         READ_BYTE_F(adr, dst)
23952         res = dst + src;
23953         flag_N = flag_X = flag_C = res;
23954         flag_V = (src ^ res) & (dst ^ res);
23955         flag_NotZ = res & 0xFF;
23956         WRITE_BYTE_F(adr, res)
23957         POST_IO
23958 RET(12)
23959 }
23960
23961 // ADDQ
23962 OPCODE(0x5027)
23963 {
23964         u32 adr, res;
23965         u32 src, dst;
23966
23967         src = (((Opcode >> 9) - 1) & 7) + 1;
23968         adr = AREG(7) - 2;
23969         AREG(7) = adr;
23970         PRE_IO
23971         READ_BYTE_F(adr, dst)
23972         res = dst + src;
23973         flag_N = flag_X = flag_C = res;
23974         flag_V = (src ^ res) & (dst ^ res);
23975         flag_NotZ = res & 0xFF;
23976         WRITE_BYTE_F(adr, res)
23977         POST_IO
23978 RET(14)
23979 }
23980
23981 // ADDQ
23982 OPCODE(0x5040)
23983 {
23984         u32 adr, res;
23985         u32 src, dst;
23986
23987         src = (((Opcode >> 9) - 1) & 7) + 1;
23988         dst = DREGu16((Opcode >> 0) & 7);
23989         res = dst + src;
23990         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
23991         flag_N = flag_X = flag_C = res >> 8;
23992         flag_NotZ = res & 0xFFFF;
23993         DREGu16((Opcode >> 0) & 7) = res;
23994 RET(4)
23995 }
23996
23997 // ADDQ
23998 OPCODE(0x5048)
23999 {
24000         u32 adr, res;
24001         u32 src, dst;
24002
24003         src = (((Opcode >> 9) - 1) & 7) + 1;
24004         dst = AREGu32((Opcode >> 0) & 7);
24005         res = dst + src;
24006         AREG((Opcode >> 0) & 7) = res;
24007 #ifdef USE_CYCLONE_TIMING
24008 RET(4)
24009 #else
24010 RET(8)
24011 #endif
24012 }
24013
24014 // ADDQ
24015 OPCODE(0x5050)
24016 {
24017         u32 adr, res;
24018         u32 src, dst;
24019
24020         src = (((Opcode >> 9) - 1) & 7) + 1;
24021         adr = AREG((Opcode >> 0) & 7);
24022         PRE_IO
24023         READ_WORD_F(adr, dst)
24024         res = dst + src;
24025         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24026         flag_N = flag_X = flag_C = res >> 8;
24027         flag_NotZ = res & 0xFFFF;
24028         WRITE_WORD_F(adr, res)
24029         POST_IO
24030 RET(12)
24031 }
24032
24033 // ADDQ
24034 OPCODE(0x5058)
24035 {
24036         u32 adr, res;
24037         u32 src, dst;
24038
24039         src = (((Opcode >> 9) - 1) & 7) + 1;
24040         adr = AREG((Opcode >> 0) & 7);
24041         AREG((Opcode >> 0) & 7) += 2;
24042         PRE_IO
24043         READ_WORD_F(adr, dst)
24044         res = dst + src;
24045         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24046         flag_N = flag_X = flag_C = res >> 8;
24047         flag_NotZ = res & 0xFFFF;
24048         WRITE_WORD_F(adr, res)
24049         POST_IO
24050 RET(12)
24051 }
24052
24053 // ADDQ
24054 OPCODE(0x5060)
24055 {
24056         u32 adr, res;
24057         u32 src, dst;
24058
24059         src = (((Opcode >> 9) - 1) & 7) + 1;
24060         adr = AREG((Opcode >> 0) & 7) - 2;
24061         AREG((Opcode >> 0) & 7) = adr;
24062         PRE_IO
24063         READ_WORD_F(adr, dst)
24064         res = dst + src;
24065         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24066         flag_N = flag_X = flag_C = res >> 8;
24067         flag_NotZ = res & 0xFFFF;
24068         WRITE_WORD_F(adr, res)
24069         POST_IO
24070 RET(14)
24071 }
24072
24073 // ADDQ
24074 OPCODE(0x5068)
24075 {
24076         u32 adr, res;
24077         u32 src, dst;
24078
24079         src = (((Opcode >> 9) - 1) & 7) + 1;
24080         FETCH_SWORD(adr);
24081         adr += AREG((Opcode >> 0) & 7);
24082         PRE_IO
24083         READ_WORD_F(adr, dst)
24084         res = dst + src;
24085         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24086         flag_N = flag_X = flag_C = res >> 8;
24087         flag_NotZ = res & 0xFFFF;
24088         WRITE_WORD_F(adr, res)
24089         POST_IO
24090 RET(16)
24091 }
24092
24093 // ADDQ
24094 OPCODE(0x5070)
24095 {
24096         u32 adr, res;
24097         u32 src, dst;
24098
24099         src = (((Opcode >> 9) - 1) & 7) + 1;
24100         adr = AREG((Opcode >> 0) & 7);
24101         DECODE_EXT_WORD
24102         PRE_IO
24103         READ_WORD_F(adr, dst)
24104         res = dst + src;
24105         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24106         flag_N = flag_X = flag_C = res >> 8;
24107         flag_NotZ = res & 0xFFFF;
24108         WRITE_WORD_F(adr, res)
24109         POST_IO
24110 RET(18)
24111 }
24112
24113 // ADDQ
24114 OPCODE(0x5078)
24115 {
24116         u32 adr, res;
24117         u32 src, dst;
24118
24119         src = (((Opcode >> 9) - 1) & 7) + 1;
24120         FETCH_SWORD(adr);
24121         PRE_IO
24122         READ_WORD_F(adr, dst)
24123         res = dst + src;
24124         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24125         flag_N = flag_X = flag_C = res >> 8;
24126         flag_NotZ = res & 0xFFFF;
24127         WRITE_WORD_F(adr, res)
24128         POST_IO
24129 RET(16)
24130 }
24131
24132 // ADDQ
24133 OPCODE(0x5079)
24134 {
24135         u32 adr, res;
24136         u32 src, dst;
24137
24138         src = (((Opcode >> 9) - 1) & 7) + 1;
24139         FETCH_LONG(adr);
24140         PRE_IO
24141         READ_WORD_F(adr, dst)
24142         res = dst + src;
24143         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24144         flag_N = flag_X = flag_C = res >> 8;
24145         flag_NotZ = res & 0xFFFF;
24146         WRITE_WORD_F(adr, res)
24147         POST_IO
24148 RET(20)
24149 }
24150
24151 // ADDQ
24152 OPCODE(0x505F)
24153 {
24154         u32 adr, res;
24155         u32 src, dst;
24156
24157         src = (((Opcode >> 9) - 1) & 7) + 1;
24158         adr = AREG(7);
24159         AREG(7) += 2;
24160         PRE_IO
24161         READ_WORD_F(adr, dst)
24162         res = dst + src;
24163         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24164         flag_N = flag_X = flag_C = res >> 8;
24165         flag_NotZ = res & 0xFFFF;
24166         WRITE_WORD_F(adr, res)
24167         POST_IO
24168 RET(12)
24169 }
24170
24171 // ADDQ
24172 OPCODE(0x5067)
24173 {
24174         u32 adr, res;
24175         u32 src, dst;
24176
24177         src = (((Opcode >> 9) - 1) & 7) + 1;
24178         adr = AREG(7) - 2;
24179         AREG(7) = adr;
24180         PRE_IO
24181         READ_WORD_F(adr, dst)
24182         res = dst + src;
24183         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24184         flag_N = flag_X = flag_C = res >> 8;
24185         flag_NotZ = res & 0xFFFF;
24186         WRITE_WORD_F(adr, res)
24187         POST_IO
24188 RET(14)
24189 }
24190
24191 // ADDQ
24192 OPCODE(0x5080)
24193 {
24194         u32 adr, res;
24195         u32 src, dst;
24196
24197         src = (((Opcode >> 9) - 1) & 7) + 1;
24198         dst = DREGu32((Opcode >> 0) & 7);
24199         res = dst + src;
24200         flag_NotZ = res;
24201         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24202         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24203         flag_N = res >> 24;
24204         DREGu32((Opcode >> 0) & 7) = res;
24205 RET(8)
24206 }
24207
24208 // ADDQ
24209 OPCODE(0x5088)
24210 {
24211         u32 adr, res;
24212         u32 src, dst;
24213
24214         src = (((Opcode >> 9) - 1) & 7) + 1;
24215         dst = AREGu32((Opcode >> 0) & 7);
24216         res = dst + src;
24217         AREG((Opcode >> 0) & 7) = res;
24218 RET(8)
24219 }
24220
24221 // ADDQ
24222 OPCODE(0x5090)
24223 {
24224         u32 adr, res;
24225         u32 src, dst;
24226
24227         src = (((Opcode >> 9) - 1) & 7) + 1;
24228         adr = AREG((Opcode >> 0) & 7);
24229         PRE_IO
24230         READ_LONG_F(adr, dst)
24231         res = dst + src;
24232         flag_NotZ = res;
24233         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24234         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24235         flag_N = res >> 24;
24236         WRITE_LONG_F(adr, res)
24237         POST_IO
24238 RET(20)
24239 }
24240
24241 // ADDQ
24242 OPCODE(0x5098)
24243 {
24244         u32 adr, res;
24245         u32 src, dst;
24246
24247         src = (((Opcode >> 9) - 1) & 7) + 1;
24248         adr = AREG((Opcode >> 0) & 7);
24249         AREG((Opcode >> 0) & 7) += 4;
24250         PRE_IO
24251         READ_LONG_F(adr, dst)
24252         res = dst + src;
24253         flag_NotZ = res;
24254         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24255         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24256         flag_N = res >> 24;
24257         WRITE_LONG_F(adr, res)
24258         POST_IO
24259 RET(20)
24260 }
24261
24262 // ADDQ
24263 OPCODE(0x50A0)
24264 {
24265         u32 adr, res;
24266         u32 src, dst;
24267
24268         src = (((Opcode >> 9) - 1) & 7) + 1;
24269         adr = AREG((Opcode >> 0) & 7) - 4;
24270         AREG((Opcode >> 0) & 7) = adr;
24271         PRE_IO
24272         READ_LONG_F(adr, dst)
24273         res = dst + src;
24274         flag_NotZ = res;
24275         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24276         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24277         flag_N = res >> 24;
24278         WRITE_LONG_F(adr, res)
24279         POST_IO
24280 RET(22)
24281 }
24282
24283 // ADDQ
24284 OPCODE(0x50A8)
24285 {
24286         u32 adr, res;
24287         u32 src, dst;
24288
24289         src = (((Opcode >> 9) - 1) & 7) + 1;
24290         FETCH_SWORD(adr);
24291         adr += AREG((Opcode >> 0) & 7);
24292         PRE_IO
24293         READ_LONG_F(adr, dst)
24294         res = dst + src;
24295         flag_NotZ = res;
24296         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24297         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24298         flag_N = res >> 24;
24299         WRITE_LONG_F(adr, res)
24300         POST_IO
24301 RET(24)
24302 }
24303
24304 // ADDQ
24305 OPCODE(0x50B0)
24306 {
24307         u32 adr, res;
24308         u32 src, dst;
24309
24310         src = (((Opcode >> 9) - 1) & 7) + 1;
24311         adr = AREG((Opcode >> 0) & 7);
24312         DECODE_EXT_WORD
24313         PRE_IO
24314         READ_LONG_F(adr, dst)
24315         res = dst + src;
24316         flag_NotZ = res;
24317         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24318         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24319         flag_N = res >> 24;
24320         WRITE_LONG_F(adr, res)
24321         POST_IO
24322 RET(26)
24323 }
24324
24325 // ADDQ
24326 OPCODE(0x50B8)
24327 {
24328         u32 adr, res;
24329         u32 src, dst;
24330
24331         src = (((Opcode >> 9) - 1) & 7) + 1;
24332         FETCH_SWORD(adr);
24333         PRE_IO
24334         READ_LONG_F(adr, dst)
24335         res = dst + src;
24336         flag_NotZ = res;
24337         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24338         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24339         flag_N = res >> 24;
24340         WRITE_LONG_F(adr, res)
24341         POST_IO
24342 RET(24)
24343 }
24344
24345 // ADDQ
24346 OPCODE(0x50B9)
24347 {
24348         u32 adr, res;
24349         u32 src, dst;
24350
24351         src = (((Opcode >> 9) - 1) & 7) + 1;
24352         FETCH_LONG(adr);
24353         PRE_IO
24354         READ_LONG_F(adr, dst)
24355         res = dst + src;
24356         flag_NotZ = res;
24357         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24358         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24359         flag_N = res >> 24;
24360         WRITE_LONG_F(adr, res)
24361         POST_IO
24362 RET(28)
24363 }
24364
24365 // ADDQ
24366 OPCODE(0x509F)
24367 {
24368         u32 adr, res;
24369         u32 src, dst;
24370
24371         src = (((Opcode >> 9) - 1) & 7) + 1;
24372         adr = AREG(7);
24373         AREG(7) += 4;
24374         PRE_IO
24375         READ_LONG_F(adr, dst)
24376         res = dst + src;
24377         flag_NotZ = res;
24378         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24379         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24380         flag_N = res >> 24;
24381         WRITE_LONG_F(adr, res)
24382         POST_IO
24383 RET(20)
24384 }
24385
24386 // ADDQ
24387 OPCODE(0x50A7)
24388 {
24389         u32 adr, res;
24390         u32 src, dst;
24391
24392         src = (((Opcode >> 9) - 1) & 7) + 1;
24393         adr = AREG(7) - 4;
24394         AREG(7) = adr;
24395         PRE_IO
24396         READ_LONG_F(adr, dst)
24397         res = dst + src;
24398         flag_NotZ = res;
24399         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24400         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24401         flag_N = res >> 24;
24402         WRITE_LONG_F(adr, res)
24403         POST_IO
24404 RET(22)
24405 }
24406
24407 // SUBQ
24408 OPCODE(0x5100)
24409 {
24410         u32 adr, res;
24411         u32 src, dst;
24412
24413         src = (((Opcode >> 9) - 1) & 7) + 1;
24414         dst = DREGu8((Opcode >> 0) & 7);
24415         res = dst - src;
24416         flag_N = flag_X = flag_C = res;
24417         flag_V = (src ^ dst) & (res ^ dst);
24418         flag_NotZ = res & 0xFF;
24419         DREGu8((Opcode >> 0) & 7) = res;
24420 RET(4)
24421 }
24422
24423 // SUBQ
24424 OPCODE(0x5110)
24425 {
24426         u32 adr, res;
24427         u32 src, dst;
24428
24429         src = (((Opcode >> 9) - 1) & 7) + 1;
24430         adr = AREG((Opcode >> 0) & 7);
24431         PRE_IO
24432         READ_BYTE_F(adr, dst)
24433         res = dst - src;
24434         flag_N = flag_X = flag_C = res;
24435         flag_V = (src ^ dst) & (res ^ dst);
24436         flag_NotZ = res & 0xFF;
24437         WRITE_BYTE_F(adr, res)
24438         POST_IO
24439 RET(12)
24440 }
24441
24442 // SUBQ
24443 OPCODE(0x5118)
24444 {
24445         u32 adr, res;
24446         u32 src, dst;
24447
24448         src = (((Opcode >> 9) - 1) & 7) + 1;
24449         adr = AREG((Opcode >> 0) & 7);
24450         AREG((Opcode >> 0) & 7) += 1;
24451         PRE_IO
24452         READ_BYTE_F(adr, dst)
24453         res = dst - src;
24454         flag_N = flag_X = flag_C = res;
24455         flag_V = (src ^ dst) & (res ^ dst);
24456         flag_NotZ = res & 0xFF;
24457         WRITE_BYTE_F(adr, res)
24458         POST_IO
24459 RET(12)
24460 }
24461
24462 // SUBQ
24463 OPCODE(0x5120)
24464 {
24465         u32 adr, res;
24466         u32 src, dst;
24467
24468         src = (((Opcode >> 9) - 1) & 7) + 1;
24469         adr = AREG((Opcode >> 0) & 7) - 1;
24470         AREG((Opcode >> 0) & 7) = adr;
24471         PRE_IO
24472         READ_BYTE_F(adr, dst)
24473         res = dst - src;
24474         flag_N = flag_X = flag_C = res;
24475         flag_V = (src ^ dst) & (res ^ dst);
24476         flag_NotZ = res & 0xFF;
24477         WRITE_BYTE_F(adr, res)
24478         POST_IO
24479 RET(14)
24480 }
24481
24482 // SUBQ
24483 OPCODE(0x5128)
24484 {
24485         u32 adr, res;
24486         u32 src, dst;
24487
24488         src = (((Opcode >> 9) - 1) & 7) + 1;
24489         FETCH_SWORD(adr);
24490         adr += AREG((Opcode >> 0) & 7);
24491         PRE_IO
24492         READ_BYTE_F(adr, dst)
24493         res = dst - src;
24494         flag_N = flag_X = flag_C = res;
24495         flag_V = (src ^ dst) & (res ^ dst);
24496         flag_NotZ = res & 0xFF;
24497         WRITE_BYTE_F(adr, res)
24498         POST_IO
24499 RET(16)
24500 }
24501
24502 // SUBQ
24503 OPCODE(0x5130)
24504 {
24505         u32 adr, res;
24506         u32 src, dst;
24507
24508         src = (((Opcode >> 9) - 1) & 7) + 1;
24509         adr = AREG((Opcode >> 0) & 7);
24510         DECODE_EXT_WORD
24511         PRE_IO
24512         READ_BYTE_F(adr, dst)
24513         res = dst - src;
24514         flag_N = flag_X = flag_C = res;
24515         flag_V = (src ^ dst) & (res ^ dst);
24516         flag_NotZ = res & 0xFF;
24517         WRITE_BYTE_F(adr, res)
24518         POST_IO
24519 RET(18)
24520 }
24521
24522 // SUBQ
24523 OPCODE(0x5138)
24524 {
24525         u32 adr, res;
24526         u32 src, dst;
24527
24528         src = (((Opcode >> 9) - 1) & 7) + 1;
24529         FETCH_SWORD(adr);
24530         PRE_IO
24531         READ_BYTE_F(adr, dst)
24532         res = dst - src;
24533         flag_N = flag_X = flag_C = res;
24534         flag_V = (src ^ dst) & (res ^ dst);
24535         flag_NotZ = res & 0xFF;
24536         WRITE_BYTE_F(adr, res)
24537         POST_IO
24538 RET(16)
24539 }
24540
24541 // SUBQ
24542 OPCODE(0x5139)
24543 {
24544         u32 adr, res;
24545         u32 src, dst;
24546
24547         src = (((Opcode >> 9) - 1) & 7) + 1;
24548         FETCH_LONG(adr);
24549         PRE_IO
24550         READ_BYTE_F(adr, dst)
24551         res = dst - src;
24552         flag_N = flag_X = flag_C = res;
24553         flag_V = (src ^ dst) & (res ^ dst);
24554         flag_NotZ = res & 0xFF;
24555         WRITE_BYTE_F(adr, res)
24556         POST_IO
24557 RET(20)
24558 }
24559
24560 // SUBQ
24561 OPCODE(0x511F)
24562 {
24563         u32 adr, res;
24564         u32 src, dst;
24565
24566         src = (((Opcode >> 9) - 1) & 7) + 1;
24567         adr = AREG(7);
24568         AREG(7) += 2;
24569         PRE_IO
24570         READ_BYTE_F(adr, dst)
24571         res = dst - src;
24572         flag_N = flag_X = flag_C = res;
24573         flag_V = (src ^ dst) & (res ^ dst);
24574         flag_NotZ = res & 0xFF;
24575         WRITE_BYTE_F(adr, res)
24576         POST_IO
24577 RET(12)
24578 }
24579
24580 // SUBQ
24581 OPCODE(0x5127)
24582 {
24583         u32 adr, res;
24584         u32 src, dst;
24585
24586         src = (((Opcode >> 9) - 1) & 7) + 1;
24587         adr = AREG(7) - 2;
24588         AREG(7) = adr;
24589         PRE_IO
24590         READ_BYTE_F(adr, dst)
24591         res = dst - src;
24592         flag_N = flag_X = flag_C = res;
24593         flag_V = (src ^ dst) & (res ^ dst);
24594         flag_NotZ = res & 0xFF;
24595         WRITE_BYTE_F(adr, res)
24596         POST_IO
24597 RET(14)
24598 }
24599
24600 // SUBQ
24601 OPCODE(0x5140)
24602 {
24603         u32 adr, res;
24604         u32 src, dst;
24605
24606         src = (((Opcode >> 9) - 1) & 7) + 1;
24607         dst = DREGu16((Opcode >> 0) & 7);
24608         res = dst - src;
24609         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24610         flag_N = flag_X = flag_C = res >> 8;
24611         flag_NotZ = res & 0xFFFF;
24612         DREGu16((Opcode >> 0) & 7) = res;
24613 RET(4)
24614 }
24615
24616 // SUBQ
24617 OPCODE(0x5148)
24618 {
24619         u32 adr, res;
24620         u32 src, dst;
24621
24622         src = (((Opcode >> 9) - 1) & 7) + 1;
24623         dst = AREGu32((Opcode >> 0) & 7);
24624         res = dst - src;
24625         AREG((Opcode >> 0) & 7) = res;
24626 RET(8)
24627 }
24628
24629 // SUBQ
24630 OPCODE(0x5150)
24631 {
24632         u32 adr, res;
24633         u32 src, dst;
24634
24635         src = (((Opcode >> 9) - 1) & 7) + 1;
24636         adr = AREG((Opcode >> 0) & 7);
24637         PRE_IO
24638         READ_WORD_F(adr, dst)
24639         res = dst - src;
24640         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24641         flag_N = flag_X = flag_C = res >> 8;
24642         flag_NotZ = res & 0xFFFF;
24643         WRITE_WORD_F(adr, res)
24644         POST_IO
24645 RET(12)
24646 }
24647
24648 // SUBQ
24649 OPCODE(0x5158)
24650 {
24651         u32 adr, res;
24652         u32 src, dst;
24653
24654         src = (((Opcode >> 9) - 1) & 7) + 1;
24655         adr = AREG((Opcode >> 0) & 7);
24656         AREG((Opcode >> 0) & 7) += 2;
24657         PRE_IO
24658         READ_WORD_F(adr, dst)
24659         res = dst - src;
24660         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24661         flag_N = flag_X = flag_C = res >> 8;
24662         flag_NotZ = res & 0xFFFF;
24663         WRITE_WORD_F(adr, res)
24664         POST_IO
24665 RET(12)
24666 }
24667
24668 // SUBQ
24669 OPCODE(0x5160)
24670 {
24671         u32 adr, res;
24672         u32 src, dst;
24673
24674         src = (((Opcode >> 9) - 1) & 7) + 1;
24675         adr = AREG((Opcode >> 0) & 7) - 2;
24676         AREG((Opcode >> 0) & 7) = adr;
24677         PRE_IO
24678         READ_WORD_F(adr, dst)
24679         res = dst - src;
24680         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24681         flag_N = flag_X = flag_C = res >> 8;
24682         flag_NotZ = res & 0xFFFF;
24683         WRITE_WORD_F(adr, res)
24684         POST_IO
24685 RET(14)
24686 }
24687
24688 // SUBQ
24689 OPCODE(0x5168)
24690 {
24691         u32 adr, res;
24692         u32 src, dst;
24693
24694         src = (((Opcode >> 9) - 1) & 7) + 1;
24695         FETCH_SWORD(adr);
24696         adr += AREG((Opcode >> 0) & 7);
24697         PRE_IO
24698         READ_WORD_F(adr, dst)
24699         res = dst - src;
24700         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24701         flag_N = flag_X = flag_C = res >> 8;
24702         flag_NotZ = res & 0xFFFF;
24703         WRITE_WORD_F(adr, res)
24704         POST_IO
24705 RET(16)
24706 }
24707
24708 // SUBQ
24709 OPCODE(0x5170)
24710 {
24711         u32 adr, res;
24712         u32 src, dst;
24713
24714         src = (((Opcode >> 9) - 1) & 7) + 1;
24715         adr = AREG((Opcode >> 0) & 7);
24716         DECODE_EXT_WORD
24717         PRE_IO
24718         READ_WORD_F(adr, dst)
24719         res = dst - src;
24720         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24721         flag_N = flag_X = flag_C = res >> 8;
24722         flag_NotZ = res & 0xFFFF;
24723         WRITE_WORD_F(adr, res)
24724         POST_IO
24725 RET(18)
24726 }
24727
24728 // SUBQ
24729 OPCODE(0x5178)
24730 {
24731         u32 adr, res;
24732         u32 src, dst;
24733
24734         src = (((Opcode >> 9) - 1) & 7) + 1;
24735         FETCH_SWORD(adr);
24736         PRE_IO
24737         READ_WORD_F(adr, dst)
24738         res = dst - src;
24739         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24740         flag_N = flag_X = flag_C = res >> 8;
24741         flag_NotZ = res & 0xFFFF;
24742         WRITE_WORD_F(adr, res)
24743         POST_IO
24744 RET(16)
24745 }
24746
24747 // SUBQ
24748 OPCODE(0x5179)
24749 {
24750         u32 adr, res;
24751         u32 src, dst;
24752
24753         src = (((Opcode >> 9) - 1) & 7) + 1;
24754         FETCH_LONG(adr);
24755         PRE_IO
24756         READ_WORD_F(adr, dst)
24757         res = dst - src;
24758         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24759         flag_N = flag_X = flag_C = res >> 8;
24760         flag_NotZ = res & 0xFFFF;
24761         WRITE_WORD_F(adr, res)
24762         POST_IO
24763 RET(20)
24764 }
24765
24766 // SUBQ
24767 OPCODE(0x515F)
24768 {
24769         u32 adr, res;
24770         u32 src, dst;
24771
24772         src = (((Opcode >> 9) - 1) & 7) + 1;
24773         adr = AREG(7);
24774         AREG(7) += 2;
24775         PRE_IO
24776         READ_WORD_F(adr, dst)
24777         res = dst - src;
24778         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24779         flag_N = flag_X = flag_C = res >> 8;
24780         flag_NotZ = res & 0xFFFF;
24781         WRITE_WORD_F(adr, res)
24782         POST_IO
24783 RET(12)
24784 }
24785
24786 // SUBQ
24787 OPCODE(0x5167)
24788 {
24789         u32 adr, res;
24790         u32 src, dst;
24791
24792         src = (((Opcode >> 9) - 1) & 7) + 1;
24793         adr = AREG(7) - 2;
24794         AREG(7) = adr;
24795         PRE_IO
24796         READ_WORD_F(adr, dst)
24797         res = dst - src;
24798         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24799         flag_N = flag_X = flag_C = res >> 8;
24800         flag_NotZ = res & 0xFFFF;
24801         WRITE_WORD_F(adr, res)
24802         POST_IO
24803 RET(14)
24804 }
24805
24806 // SUBQ
24807 OPCODE(0x5180)
24808 {
24809         u32 adr, res;
24810         u32 src, dst;
24811
24812         src = (((Opcode >> 9) - 1) & 7) + 1;
24813         dst = DREGu32((Opcode >> 0) & 7);
24814         res = dst - src;
24815         flag_NotZ = res;
24816         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24817         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24818         flag_N = res >> 24;
24819         DREGu32((Opcode >> 0) & 7) = res;
24820 RET(8)
24821 }
24822
24823 // SUBQ
24824 OPCODE(0x5188)
24825 {
24826         u32 adr, res;
24827         u32 src, dst;
24828
24829         src = (((Opcode >> 9) - 1) & 7) + 1;
24830         dst = AREGu32((Opcode >> 0) & 7);
24831         res = dst - src;
24832         AREG((Opcode >> 0) & 7) = res;
24833 RET(8)
24834 }
24835
24836 // SUBQ
24837 OPCODE(0x5190)
24838 {
24839         u32 adr, res;
24840         u32 src, dst;
24841
24842         src = (((Opcode >> 9) - 1) & 7) + 1;
24843         adr = AREG((Opcode >> 0) & 7);
24844         PRE_IO
24845         READ_LONG_F(adr, dst)
24846         res = dst - src;
24847         flag_NotZ = res;
24848         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24849         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24850         flag_N = res >> 24;
24851         WRITE_LONG_F(adr, res)
24852         POST_IO
24853 RET(20)
24854 }
24855
24856 // SUBQ
24857 OPCODE(0x5198)
24858 {
24859         u32 adr, res;
24860         u32 src, dst;
24861
24862         src = (((Opcode >> 9) - 1) & 7) + 1;
24863         adr = AREG((Opcode >> 0) & 7);
24864         AREG((Opcode >> 0) & 7) += 4;
24865         PRE_IO
24866         READ_LONG_F(adr, dst)
24867         res = dst - src;
24868         flag_NotZ = res;
24869         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24870         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24871         flag_N = res >> 24;
24872         WRITE_LONG_F(adr, res)
24873         POST_IO
24874 RET(20)
24875 }
24876
24877 // SUBQ
24878 OPCODE(0x51A0)
24879 {
24880         u32 adr, res;
24881         u32 src, dst;
24882
24883         src = (((Opcode >> 9) - 1) & 7) + 1;
24884         adr = AREG((Opcode >> 0) & 7) - 4;
24885         AREG((Opcode >> 0) & 7) = adr;
24886         PRE_IO
24887         READ_LONG_F(adr, dst)
24888         res = dst - src;
24889         flag_NotZ = res;
24890         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24891         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24892         flag_N = res >> 24;
24893         WRITE_LONG_F(adr, res)
24894         POST_IO
24895 RET(22)
24896 }
24897
24898 // SUBQ
24899 OPCODE(0x51A8)
24900 {
24901         u32 adr, res;
24902         u32 src, dst;
24903
24904         src = (((Opcode >> 9) - 1) & 7) + 1;
24905         FETCH_SWORD(adr);
24906         adr += AREG((Opcode >> 0) & 7);
24907         PRE_IO
24908         READ_LONG_F(adr, dst)
24909         res = dst - src;
24910         flag_NotZ = res;
24911         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24912         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24913         flag_N = res >> 24;
24914         WRITE_LONG_F(adr, res)
24915         POST_IO
24916 RET(24)
24917 }
24918
24919 // SUBQ
24920 OPCODE(0x51B0)
24921 {
24922         u32 adr, res;
24923         u32 src, dst;
24924
24925         src = (((Opcode >> 9) - 1) & 7) + 1;
24926         adr = AREG((Opcode >> 0) & 7);
24927         DECODE_EXT_WORD
24928         PRE_IO
24929         READ_LONG_F(adr, dst)
24930         res = dst - src;
24931         flag_NotZ = res;
24932         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24933         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24934         flag_N = res >> 24;
24935         WRITE_LONG_F(adr, res)
24936         POST_IO
24937 RET(26)
24938 }
24939
24940 // SUBQ
24941 OPCODE(0x51B8)
24942 {
24943         u32 adr, res;
24944         u32 src, dst;
24945
24946         src = (((Opcode >> 9) - 1) & 7) + 1;
24947         FETCH_SWORD(adr);
24948         PRE_IO
24949         READ_LONG_F(adr, dst)
24950         res = dst - src;
24951         flag_NotZ = res;
24952         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24953         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24954         flag_N = res >> 24;
24955         WRITE_LONG_F(adr, res)
24956         POST_IO
24957 RET(24)
24958 }
24959
24960 // SUBQ
24961 OPCODE(0x51B9)
24962 {
24963         u32 adr, res;
24964         u32 src, dst;
24965
24966         src = (((Opcode >> 9) - 1) & 7) + 1;
24967         FETCH_LONG(adr);
24968         PRE_IO
24969         READ_LONG_F(adr, dst)
24970         res = dst - src;
24971         flag_NotZ = res;
24972         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24973         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24974         flag_N = res >> 24;
24975         WRITE_LONG_F(adr, res)
24976         POST_IO
24977 RET(28)
24978 }
24979
24980 // SUBQ
24981 OPCODE(0x519F)
24982 {
24983         u32 adr, res;
24984         u32 src, dst;
24985
24986         src = (((Opcode >> 9) - 1) & 7) + 1;
24987         adr = AREG(7);
24988         AREG(7) += 4;
24989         PRE_IO
24990         READ_LONG_F(adr, dst)
24991         res = dst - src;
24992         flag_NotZ = res;
24993         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24994         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24995         flag_N = res >> 24;
24996         WRITE_LONG_F(adr, res)
24997         POST_IO
24998 RET(20)
24999 }
25000
25001 // SUBQ
25002 OPCODE(0x51A7)
25003 {
25004         u32 adr, res;
25005         u32 src, dst;
25006
25007         src = (((Opcode >> 9) - 1) & 7) + 1;
25008         adr = AREG(7) - 4;
25009         AREG(7) = adr;
25010         PRE_IO
25011         READ_LONG_F(adr, dst)
25012         res = dst - src;
25013         flag_NotZ = res;
25014         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25015         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25016         flag_N = res >> 24;
25017         WRITE_LONG_F(adr, res)
25018         POST_IO
25019 RET(22)
25020 }
25021
25022 // BCC
25023 OPCODE(0x6201)
25024 {
25025         u32 adr, res;
25026         u32 src, dst;
25027
25028         if (flag_NotZ && (!(flag_C & 0x100)))
25029         {
25030                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25031         m68kcontext.io_cycle_counter -= 2;
25032         }
25033 RET(8)
25034 }
25035
25036 // BCC
25037 OPCODE(0x6301)
25038 {
25039         u32 adr, res;
25040         u32 src, dst;
25041
25042         if ((!flag_NotZ) || (flag_C & 0x100))
25043         {
25044                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25045         m68kcontext.io_cycle_counter -= 2;
25046         }
25047 RET(8)
25048 }
25049
25050 // BCC
25051 OPCODE(0x6401)
25052 {
25053         u32 adr, res;
25054         u32 src, dst;
25055
25056         if (!(flag_C & 0x100))
25057         {
25058                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25059         m68kcontext.io_cycle_counter -= 2;
25060         }
25061 RET(8)
25062 }
25063
25064 // BCC
25065 OPCODE(0x6501)
25066 {
25067         u32 adr, res;
25068         u32 src, dst;
25069
25070         if (flag_C & 0x100)
25071         {
25072                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25073         m68kcontext.io_cycle_counter -= 2;
25074         }
25075 RET(8)
25076 }
25077
25078 // BCC
25079 OPCODE(0x6601)
25080 {
25081         u32 adr, res;
25082         u32 src, dst;
25083
25084         if (flag_NotZ)
25085         {
25086                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25087         m68kcontext.io_cycle_counter -= 2;
25088         }
25089 RET(8)
25090 }
25091
25092 // BCC
25093 OPCODE(0x6701)
25094 {
25095         u32 adr, res;
25096         u32 src, dst;
25097
25098         if (!flag_NotZ)
25099         {
25100                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25101         m68kcontext.io_cycle_counter -= 2;
25102         }
25103 RET(8)
25104 }
25105
25106 // BCC
25107 OPCODE(0x6801)
25108 {
25109         u32 adr, res;
25110         u32 src, dst;
25111
25112         if (!(flag_V & 0x80))
25113         {
25114                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25115         m68kcontext.io_cycle_counter -= 2;
25116         }
25117 RET(8)
25118 }
25119
25120 // BCC
25121 OPCODE(0x6901)
25122 {
25123         u32 adr, res;
25124         u32 src, dst;
25125
25126         if (flag_V & 0x80)
25127         {
25128                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25129         m68kcontext.io_cycle_counter -= 2;
25130         }
25131 RET(8)
25132 }
25133
25134 // BCC
25135 OPCODE(0x6A01)
25136 {
25137         u32 adr, res;
25138         u32 src, dst;
25139
25140         if (!(flag_N & 0x80))
25141         {
25142                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25143         m68kcontext.io_cycle_counter -= 2;
25144         }
25145 RET(8)
25146 }
25147
25148 // BCC
25149 OPCODE(0x6B01)
25150 {
25151         u32 adr, res;
25152         u32 src, dst;
25153
25154         if (flag_N & 0x80)
25155         {
25156                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25157         m68kcontext.io_cycle_counter -= 2;
25158         }
25159 RET(8)
25160 }
25161
25162 // BCC
25163 OPCODE(0x6C01)
25164 {
25165         u32 adr, res;
25166         u32 src, dst;
25167
25168         if (!((flag_N ^ flag_V) & 0x80))
25169         {
25170                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25171         m68kcontext.io_cycle_counter -= 2;
25172         }
25173 RET(8)
25174 }
25175
25176 // BCC
25177 OPCODE(0x6D01)
25178 {
25179         u32 adr, res;
25180         u32 src, dst;
25181
25182         if ((flag_N ^ flag_V) & 0x80)
25183         {
25184                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25185         m68kcontext.io_cycle_counter -= 2;
25186         }
25187 RET(8)
25188 }
25189
25190 // BCC
25191 OPCODE(0x6E01)
25192 {
25193         u32 adr, res;
25194         u32 src, dst;
25195
25196         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
25197         {
25198                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25199         m68kcontext.io_cycle_counter -= 2;
25200         }
25201 RET(8)
25202 }
25203
25204 // BCC
25205 OPCODE(0x6F01)
25206 {
25207         u32 adr, res;
25208         u32 src, dst;
25209
25210         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
25211         {
25212                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25213         m68kcontext.io_cycle_counter -= 2;
25214         }
25215 RET(8)
25216 }
25217
25218 // BCC16
25219 OPCODE(0x6200)
25220 {
25221         u32 adr, res;
25222         u32 src, dst;
25223
25224         if (flag_NotZ && (!(flag_C & 0x100)))
25225         {
25226                 u32 newPC;
25227
25228                 newPC = GET_PC;
25229                 newPC += GET_SWORD;
25230                 SET_PC(newPC);
25231                 CHECK_BRANCH_EXCEPTION(newPC)
25232                 RET(10)
25233         }
25234         PC++;
25235 RET(12)
25236 }
25237
25238 // BCC16
25239 OPCODE(0x6300)
25240 {
25241         u32 adr, res;
25242         u32 src, dst;
25243
25244         if ((!flag_NotZ) || (flag_C & 0x100))
25245         {
25246                 u32 newPC;
25247
25248                 newPC = GET_PC;
25249                 newPC += GET_SWORD;
25250                 SET_PC(newPC);
25251                 CHECK_BRANCH_EXCEPTION(newPC)
25252                 RET(10)
25253         }
25254         PC++;
25255 RET(12)
25256 }
25257
25258 // BCC16
25259 OPCODE(0x6400)
25260 {
25261         u32 adr, res;
25262         u32 src, dst;
25263
25264         if (!(flag_C & 0x100))
25265         {
25266                 u32 newPC;
25267
25268                 newPC = GET_PC;
25269                 newPC += GET_SWORD;
25270                 SET_PC(newPC);
25271                 CHECK_BRANCH_EXCEPTION(newPC)
25272                 RET(10)
25273         }
25274         PC++;
25275 RET(12)
25276 }
25277
25278 // BCC16
25279 OPCODE(0x6500)
25280 {
25281         u32 adr, res;
25282         u32 src, dst;
25283
25284         if (flag_C & 0x100)
25285         {
25286                 u32 newPC;
25287
25288                 newPC = GET_PC;
25289                 newPC += GET_SWORD;
25290                 SET_PC(newPC);
25291                 CHECK_BRANCH_EXCEPTION(newPC)
25292                 RET(10)
25293         }
25294         PC++;
25295 RET(12)
25296 }
25297
25298 // BCC16
25299 OPCODE(0x6600)
25300 {
25301         u32 adr, res;
25302         u32 src, dst;
25303
25304         if (flag_NotZ)
25305         {
25306                 u32 newPC;
25307
25308                 newPC = GET_PC;
25309                 newPC += GET_SWORD;
25310                 SET_PC(newPC);
25311                 CHECK_BRANCH_EXCEPTION(newPC)
25312                 RET(10)
25313         }
25314         PC++;
25315 RET(12)
25316 }
25317
25318 // BCC16
25319 OPCODE(0x6700)
25320 {
25321         u32 adr, res;
25322         u32 src, dst;
25323
25324         if (!flag_NotZ)
25325         {
25326                 u32 newPC;
25327
25328                 newPC = GET_PC;
25329                 newPC += GET_SWORD;
25330                 SET_PC(newPC);
25331                 CHECK_BRANCH_EXCEPTION(newPC)
25332                 RET(10)
25333         }
25334         PC++;
25335 RET(12)
25336 }
25337
25338 // BCC16
25339 OPCODE(0x6800)
25340 {
25341         u32 adr, res;
25342         u32 src, dst;
25343
25344         if (!(flag_V & 0x80))
25345         {
25346                 u32 newPC;
25347
25348                 newPC = GET_PC;
25349                 newPC += GET_SWORD;
25350                 SET_PC(newPC);
25351                 CHECK_BRANCH_EXCEPTION(newPC)
25352                 RET(10)
25353         }
25354         PC++;
25355 RET(12)
25356 }
25357
25358 // BCC16
25359 OPCODE(0x6900)
25360 {
25361         u32 adr, res;
25362         u32 src, dst;
25363
25364         if (flag_V & 0x80)
25365         {
25366                 u32 newPC;
25367
25368                 newPC = GET_PC;
25369                 newPC += GET_SWORD;
25370                 SET_PC(newPC);
25371                 CHECK_BRANCH_EXCEPTION(newPC)
25372                 RET(10)
25373         }
25374         PC++;
25375 RET(12)
25376 }
25377
25378 // BCC16
25379 OPCODE(0x6A00)
25380 {
25381         u32 adr, res;
25382         u32 src, dst;
25383
25384         if (!(flag_N & 0x80))
25385         {
25386                 u32 newPC;
25387
25388                 newPC = GET_PC;
25389                 newPC += GET_SWORD;
25390                 SET_PC(newPC);
25391                 CHECK_BRANCH_EXCEPTION(newPC)
25392                 RET(10)
25393         }
25394         PC++;
25395 RET(12)
25396 }
25397
25398 // BCC16
25399 OPCODE(0x6B00)
25400 {
25401         u32 adr, res;
25402         u32 src, dst;
25403
25404         if (flag_N & 0x80)
25405         {
25406                 u32 newPC;
25407
25408                 newPC = GET_PC;
25409                 newPC += GET_SWORD;
25410                 SET_PC(newPC);
25411                 CHECK_BRANCH_EXCEPTION(newPC)
25412                 RET(10)
25413         }
25414         PC++;
25415 RET(12)
25416 }
25417
25418 // BCC16
25419 OPCODE(0x6C00)
25420 {
25421         u32 adr, res;
25422         u32 src, dst;
25423
25424         if (!((flag_N ^ flag_V) & 0x80))
25425         {
25426                 u32 newPC;
25427
25428                 newPC = GET_PC;
25429                 newPC += GET_SWORD;
25430                 SET_PC(newPC);
25431                 CHECK_BRANCH_EXCEPTION(newPC)
25432                 RET(10)
25433         }
25434         PC++;
25435 RET(12)
25436 }
25437
25438 // BCC16
25439 OPCODE(0x6D00)
25440 {
25441         u32 adr, res;
25442         u32 src, dst;
25443
25444         if ((flag_N ^ flag_V) & 0x80)
25445         {
25446                 u32 newPC;
25447
25448                 newPC = GET_PC;
25449                 newPC += GET_SWORD;
25450                 SET_PC(newPC);
25451                 CHECK_BRANCH_EXCEPTION(newPC)
25452                 RET(10)
25453         }
25454         PC++;
25455 RET(12)
25456 }
25457
25458 // BCC16
25459 OPCODE(0x6E00)
25460 {
25461         u32 adr, res;
25462         u32 src, dst;
25463
25464         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
25465         {
25466                 u32 newPC;
25467
25468                 newPC = GET_PC;
25469                 newPC += GET_SWORD;
25470                 SET_PC(newPC);
25471                 CHECK_BRANCH_EXCEPTION(newPC)
25472                 RET(10)
25473         }
25474         PC++;
25475 RET(12)
25476 }
25477
25478 // BCC16
25479 OPCODE(0x6F00)
25480 {
25481         u32 adr, res;
25482         u32 src, dst;
25483
25484         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
25485         {
25486                 u32 newPC;
25487
25488                 newPC = GET_PC;
25489                 newPC += GET_SWORD;
25490                 SET_PC(newPC);
25491                 CHECK_BRANCH_EXCEPTION(newPC)
25492                 RET(10)
25493         }
25494         PC++;
25495 RET(12)
25496 }
25497
25498 // BRA
25499 OPCODE(0x6001)
25500 {
25501 #ifdef FAMEC_CHECK_BRANCHES
25502         u32 newPC = GET_PC;
25503         s8 offs=Opcode;
25504         newPC += offs;
25505         SET_PC(newPC);
25506         CHECK_BRANCH_EXCEPTION(offs)
25507 #else
25508         PC += ((s8)(Opcode & 0xFE)) >> 1;
25509 #endif
25510 RET(10)
25511 }
25512
25513 // BRA16
25514 OPCODE(0x6000)
25515 {
25516         u32 adr, res;
25517         u32 src, dst;
25518
25519         {
25520                 u32 newPC;
25521
25522                 newPC = GET_PC;
25523                 newPC += GET_SWORD;
25524                 SET_PC(newPC);
25525                 CHECK_BRANCH_EXCEPTION(newPC)
25526         }
25527 RET(10)
25528 }
25529
25530 // BSR
25531 OPCODE(0x6101)
25532 {
25533         u32 adr, res;
25534         u32 src, dst;
25535         u32 oldPC;
25536         s8 offs;
25537
25538         PRE_IO
25539
25540         oldPC = GET_PC;
25541         PUSH_32_F(oldPC)
25542 #ifdef FAMEC_CHECK_BRANCHES
25543         offs = Opcode;
25544         oldPC += offs;
25545         SET_PC(oldPC);
25546         CHECK_BRANCH_EXCEPTION(offs)
25547 #else
25548         PC += ((s8)(Opcode & 0xFE)) >> 1;
25549 #endif
25550         POST_IO
25551 RET(18)
25552 }
25553
25554 // BSR16
25555 OPCODE(0x6100)
25556 {
25557         u32 adr, res;
25558         u32 src, dst;
25559
25560         PRE_IO
25561         {
25562                 u32 oldPC, newPC;
25563
25564                 newPC = GET_PC;
25565                 oldPC = newPC + 2;
25566                 PUSH_32_F(oldPC)
25567                 newPC += GET_SWORD;
25568                 SET_PC(newPC);
25569                 CHECK_BRANCH_EXCEPTION(newPC)
25570         }
25571         POST_IO
25572 RET(18)
25573 }
25574
25575 // MOVEQ
25576 OPCODE(0x7000)
25577 {
25578         u32 adr, res;
25579         u32 src, dst;
25580
25581         res = (s32)(s8)Opcode;
25582         flag_C = flag_V = 0;
25583         flag_N = flag_NotZ = res;
25584         DREGu32((Opcode >> 9) & 7) = res;
25585 RET(4)
25586 }
25587
25588 // ORaD
25589 OPCODE(0x8000)
25590 {
25591         u32 adr, res;
25592         u32 src, dst;
25593
25594         src = DREGu8((Opcode >> 0) & 7);
25595         res = DREGu8((Opcode >> 9) & 7);
25596         res |= src;
25597         flag_C = 0;
25598         flag_V = 0;
25599         flag_NotZ = res;
25600         flag_N = res;
25601         DREGu8((Opcode >> 9) & 7) = res;
25602 RET(4)
25603 }
25604
25605 // ORaD
25606 OPCODE(0x8010)
25607 {
25608         u32 adr, res;
25609         u32 src, dst;
25610
25611         adr = AREG((Opcode >> 0) & 7);
25612         PRE_IO
25613         READ_BYTE_F(adr, src)
25614         res = DREGu8((Opcode >> 9) & 7);
25615         res |= src;
25616         flag_C = 0;
25617         flag_V = 0;
25618         flag_NotZ = res;
25619         flag_N = res;
25620         DREGu8((Opcode >> 9) & 7) = res;
25621         POST_IO
25622 RET(8)
25623 }
25624
25625 // ORaD
25626 OPCODE(0x8018)
25627 {
25628         u32 adr, res;
25629         u32 src, dst;
25630
25631         adr = AREG((Opcode >> 0) & 7);
25632         AREG((Opcode >> 0) & 7) += 1;
25633         PRE_IO
25634         READ_BYTE_F(adr, src)
25635         res = DREGu8((Opcode >> 9) & 7);
25636         res |= src;
25637         flag_C = 0;
25638         flag_V = 0;
25639         flag_NotZ = res;
25640         flag_N = res;
25641         DREGu8((Opcode >> 9) & 7) = res;
25642         POST_IO
25643 RET(8)
25644 }
25645
25646 // ORaD
25647 OPCODE(0x8020)
25648 {
25649         u32 adr, res;
25650         u32 src, dst;
25651
25652         adr = AREG((Opcode >> 0) & 7) - 1;
25653         AREG((Opcode >> 0) & 7) = adr;
25654         PRE_IO
25655         READ_BYTE_F(adr, src)
25656         res = DREGu8((Opcode >> 9) & 7);
25657         res |= src;
25658         flag_C = 0;
25659         flag_V = 0;
25660         flag_NotZ = res;
25661         flag_N = res;
25662         DREGu8((Opcode >> 9) & 7) = res;
25663         POST_IO
25664 RET(10)
25665 }
25666
25667 // ORaD
25668 OPCODE(0x8028)
25669 {
25670         u32 adr, res;
25671         u32 src, dst;
25672
25673         FETCH_SWORD(adr);
25674         adr += AREG((Opcode >> 0) & 7);
25675         PRE_IO
25676         READ_BYTE_F(adr, src)
25677         res = DREGu8((Opcode >> 9) & 7);
25678         res |= src;
25679         flag_C = 0;
25680         flag_V = 0;
25681         flag_NotZ = res;
25682         flag_N = res;
25683         DREGu8((Opcode >> 9) & 7) = res;
25684         POST_IO
25685 RET(12)
25686 }
25687
25688 // ORaD
25689 OPCODE(0x8030)
25690 {
25691         u32 adr, res;
25692         u32 src, dst;
25693
25694         adr = AREG((Opcode >> 0) & 7);
25695         DECODE_EXT_WORD
25696         PRE_IO
25697         READ_BYTE_F(adr, src)
25698         res = DREGu8((Opcode >> 9) & 7);
25699         res |= src;
25700         flag_C = 0;
25701         flag_V = 0;
25702         flag_NotZ = res;
25703         flag_N = res;
25704         DREGu8((Opcode >> 9) & 7) = res;
25705         POST_IO
25706 RET(14)
25707 }
25708
25709 // ORaD
25710 OPCODE(0x8038)
25711 {
25712         u32 adr, res;
25713         u32 src, dst;
25714
25715         FETCH_SWORD(adr);
25716         PRE_IO
25717         READ_BYTE_F(adr, src)
25718         res = DREGu8((Opcode >> 9) & 7);
25719         res |= src;
25720         flag_C = 0;
25721         flag_V = 0;
25722         flag_NotZ = res;
25723         flag_N = res;
25724         DREGu8((Opcode >> 9) & 7) = res;
25725         POST_IO
25726 RET(12)
25727 }
25728
25729 // ORaD
25730 OPCODE(0x8039)
25731 {
25732         u32 adr, res;
25733         u32 src, dst;
25734
25735         FETCH_LONG(adr);
25736         PRE_IO
25737         READ_BYTE_F(adr, src)
25738         res = DREGu8((Opcode >> 9) & 7);
25739         res |= src;
25740         flag_C = 0;
25741         flag_V = 0;
25742         flag_NotZ = res;
25743         flag_N = res;
25744         DREGu8((Opcode >> 9) & 7) = res;
25745         POST_IO
25746 RET(16)
25747 }
25748
25749 // ORaD
25750 OPCODE(0x803A)
25751 {
25752         u32 adr, res;
25753         u32 src, dst;
25754
25755         adr = GET_SWORD + GET_PC;
25756         PC++;
25757         PRE_IO
25758         READ_BYTE_F(adr, src)
25759         res = DREGu8((Opcode >> 9) & 7);
25760         res |= src;
25761         flag_C = 0;
25762         flag_V = 0;
25763         flag_NotZ = res;
25764         flag_N = res;
25765         DREGu8((Opcode >> 9) & 7) = res;
25766         POST_IO
25767 RET(12)
25768 }
25769
25770 // ORaD
25771 OPCODE(0x803B)
25772 {
25773         u32 adr, res;
25774         u32 src, dst;
25775
25776         adr = GET_PC;
25777         DECODE_EXT_WORD
25778         PRE_IO
25779         READ_BYTE_F(adr, src)
25780         res = DREGu8((Opcode >> 9) & 7);
25781         res |= src;
25782         flag_C = 0;
25783         flag_V = 0;
25784         flag_NotZ = res;
25785         flag_N = res;
25786         DREGu8((Opcode >> 9) & 7) = res;
25787         POST_IO
25788 RET(14)
25789 }
25790
25791 // ORaD
25792 OPCODE(0x803C)
25793 {
25794         u32 adr, res;
25795         u32 src, dst;
25796
25797         FETCH_BYTE(src);
25798         res = DREGu8((Opcode >> 9) & 7);
25799         res |= src;
25800         flag_C = 0;
25801         flag_V = 0;
25802         flag_NotZ = res;
25803         flag_N = res;
25804         DREGu8((Opcode >> 9) & 7) = res;
25805 RET(8)
25806 }
25807
25808 // ORaD
25809 OPCODE(0x801F)
25810 {
25811         u32 adr, res;
25812         u32 src, dst;
25813
25814         adr = AREG(7);
25815         AREG(7) += 2;
25816         PRE_IO
25817         READ_BYTE_F(adr, src)
25818         res = DREGu8((Opcode >> 9) & 7);
25819         res |= src;
25820         flag_C = 0;
25821         flag_V = 0;
25822         flag_NotZ = res;
25823         flag_N = res;
25824         DREGu8((Opcode >> 9) & 7) = res;
25825         POST_IO
25826 RET(8)
25827 }
25828
25829 // ORaD
25830 OPCODE(0x8027)
25831 {
25832         u32 adr, res;
25833         u32 src, dst;
25834
25835         adr = AREG(7) - 2;
25836         AREG(7) = adr;
25837         PRE_IO
25838         READ_BYTE_F(adr, src)
25839         res = DREGu8((Opcode >> 9) & 7);
25840         res |= src;
25841         flag_C = 0;
25842         flag_V = 0;
25843         flag_NotZ = res;
25844         flag_N = res;
25845         DREGu8((Opcode >> 9) & 7) = res;
25846         POST_IO
25847 RET(10)
25848 }
25849
25850 // ORaD
25851 OPCODE(0x8040)
25852 {
25853         u32 adr, res;
25854         u32 src, dst;
25855
25856         src = DREGu16((Opcode >> 0) & 7);
25857         res = DREGu16((Opcode >> 9) & 7);
25858         res |= src;
25859         flag_C = 0;
25860         flag_V = 0;
25861         flag_NotZ = res;
25862         flag_N = res >> 8;
25863         DREGu16((Opcode >> 9) & 7) = res;
25864 RET(4)
25865 }
25866
25867 // ORaD
25868 OPCODE(0x8050)
25869 {
25870         u32 adr, res;
25871         u32 src, dst;
25872
25873         adr = AREG((Opcode >> 0) & 7);
25874         PRE_IO
25875         READ_WORD_F(adr, src)
25876         res = DREGu16((Opcode >> 9) & 7);
25877         res |= src;
25878         flag_C = 0;
25879         flag_V = 0;
25880         flag_NotZ = res;
25881         flag_N = res >> 8;
25882         DREGu16((Opcode >> 9) & 7) = res;
25883         POST_IO
25884 RET(8)
25885 }
25886
25887 // ORaD
25888 OPCODE(0x8058)
25889 {
25890         u32 adr, res;
25891         u32 src, dst;
25892
25893         adr = AREG((Opcode >> 0) & 7);
25894         AREG((Opcode >> 0) & 7) += 2;
25895         PRE_IO
25896         READ_WORD_F(adr, src)
25897         res = DREGu16((Opcode >> 9) & 7);
25898         res |= src;
25899         flag_C = 0;
25900         flag_V = 0;
25901         flag_NotZ = res;
25902         flag_N = res >> 8;
25903         DREGu16((Opcode >> 9) & 7) = res;
25904         POST_IO
25905 RET(8)
25906 }
25907
25908 // ORaD
25909 OPCODE(0x8060)
25910 {
25911         u32 adr, res;
25912         u32 src, dst;
25913
25914         adr = AREG((Opcode >> 0) & 7) - 2;
25915         AREG((Opcode >> 0) & 7) = adr;
25916         PRE_IO
25917         READ_WORD_F(adr, src)
25918         res = DREGu16((Opcode >> 9) & 7);
25919         res |= src;
25920         flag_C = 0;
25921         flag_V = 0;
25922         flag_NotZ = res;
25923         flag_N = res >> 8;
25924         DREGu16((Opcode >> 9) & 7) = res;
25925         POST_IO
25926 RET(10)
25927 }
25928
25929 // ORaD
25930 OPCODE(0x8068)
25931 {
25932         u32 adr, res;
25933         u32 src, dst;
25934
25935         FETCH_SWORD(adr);
25936         adr += AREG((Opcode >> 0) & 7);
25937         PRE_IO
25938         READ_WORD_F(adr, src)
25939         res = DREGu16((Opcode >> 9) & 7);
25940         res |= src;
25941         flag_C = 0;
25942         flag_V = 0;
25943         flag_NotZ = res;
25944         flag_N = res >> 8;
25945         DREGu16((Opcode >> 9) & 7) = res;
25946         POST_IO
25947 RET(12)
25948 }
25949
25950 // ORaD
25951 OPCODE(0x8070)
25952 {
25953         u32 adr, res;
25954         u32 src, dst;
25955
25956         adr = AREG((Opcode >> 0) & 7);
25957         DECODE_EXT_WORD
25958         PRE_IO
25959         READ_WORD_F(adr, src)
25960         res = DREGu16((Opcode >> 9) & 7);
25961         res |= src;
25962         flag_C = 0;
25963         flag_V = 0;
25964         flag_NotZ = res;
25965         flag_N = res >> 8;
25966         DREGu16((Opcode >> 9) & 7) = res;
25967         POST_IO
25968 RET(14)
25969 }
25970
25971 // ORaD
25972 OPCODE(0x8078)
25973 {
25974         u32 adr, res;
25975         u32 src, dst;
25976
25977         FETCH_SWORD(adr);
25978         PRE_IO
25979         READ_WORD_F(adr, src)
25980         res = DREGu16((Opcode >> 9) & 7);
25981         res |= src;
25982         flag_C = 0;
25983         flag_V = 0;
25984         flag_NotZ = res;
25985         flag_N = res >> 8;
25986         DREGu16((Opcode >> 9) & 7) = res;
25987         POST_IO
25988 RET(12)
25989 }
25990
25991 // ORaD
25992 OPCODE(0x8079)
25993 {
25994         u32 adr, res;
25995         u32 src, dst;
25996
25997         FETCH_LONG(adr);
25998         PRE_IO
25999         READ_WORD_F(adr, src)
26000         res = DREGu16((Opcode >> 9) & 7);
26001         res |= src;
26002         flag_C = 0;
26003         flag_V = 0;
26004         flag_NotZ = res;
26005         flag_N = res >> 8;
26006         DREGu16((Opcode >> 9) & 7) = res;
26007         POST_IO
26008 RET(16)
26009 }
26010
26011 // ORaD
26012 OPCODE(0x807A)
26013 {
26014         u32 adr, res;
26015         u32 src, dst;
26016
26017         adr = GET_SWORD + GET_PC;
26018         PC++;
26019         PRE_IO
26020         READ_WORD_F(adr, src)
26021         res = DREGu16((Opcode >> 9) & 7);
26022         res |= src;
26023         flag_C = 0;
26024         flag_V = 0;
26025         flag_NotZ = res;
26026         flag_N = res >> 8;
26027         DREGu16((Opcode >> 9) & 7) = res;
26028         POST_IO
26029 RET(12)
26030 }
26031
26032 // ORaD
26033 OPCODE(0x807B)
26034 {
26035         u32 adr, res;
26036         u32 src, dst;
26037
26038         adr = GET_PC;
26039         DECODE_EXT_WORD
26040         PRE_IO
26041         READ_WORD_F(adr, src)
26042         res = DREGu16((Opcode >> 9) & 7);
26043         res |= src;
26044         flag_C = 0;
26045         flag_V = 0;
26046         flag_NotZ = res;
26047         flag_N = res >> 8;
26048         DREGu16((Opcode >> 9) & 7) = res;
26049         POST_IO
26050 RET(14)
26051 }
26052
26053 // ORaD
26054 OPCODE(0x807C)
26055 {
26056         u32 adr, res;
26057         u32 src, dst;
26058
26059         FETCH_WORD(src);
26060         res = DREGu16((Opcode >> 9) & 7);
26061         res |= src;
26062         flag_C = 0;
26063         flag_V = 0;
26064         flag_NotZ = res;
26065         flag_N = res >> 8;
26066         DREGu16((Opcode >> 9) & 7) = res;
26067 RET(8)
26068 }
26069
26070 // ORaD
26071 OPCODE(0x805F)
26072 {
26073         u32 adr, res;
26074         u32 src, dst;
26075
26076         adr = AREG(7);
26077         AREG(7) += 2;
26078         PRE_IO
26079         READ_WORD_F(adr, src)
26080         res = DREGu16((Opcode >> 9) & 7);
26081         res |= src;
26082         flag_C = 0;
26083         flag_V = 0;
26084         flag_NotZ = res;
26085         flag_N = res >> 8;
26086         DREGu16((Opcode >> 9) & 7) = res;
26087         POST_IO
26088 RET(8)
26089 }
26090
26091 // ORaD
26092 OPCODE(0x8067)
26093 {
26094         u32 adr, res;
26095         u32 src, dst;
26096
26097         adr = AREG(7) - 2;
26098         AREG(7) = adr;
26099         PRE_IO
26100         READ_WORD_F(adr, src)
26101         res = DREGu16((Opcode >> 9) & 7);
26102         res |= src;
26103         flag_C = 0;
26104         flag_V = 0;
26105         flag_NotZ = res;
26106         flag_N = res >> 8;
26107         DREGu16((Opcode >> 9) & 7) = res;
26108         POST_IO
26109 RET(10)
26110 }
26111
26112 // ORaD
26113 OPCODE(0x8080)
26114 {
26115         u32 adr, res;
26116         u32 src, dst;
26117
26118         src = DREGu32((Opcode >> 0) & 7);
26119         res = DREGu32((Opcode >> 9) & 7);
26120         res |= src;
26121         flag_C = 0;
26122         flag_V = 0;
26123         flag_NotZ = res;
26124         flag_N = res >> 24;
26125         DREGu32((Opcode >> 9) & 7) = res;
26126 RET(8)
26127 }
26128
26129 // ORaD
26130 OPCODE(0x8090)
26131 {
26132         u32 adr, res;
26133         u32 src, dst;
26134
26135         adr = AREG((Opcode >> 0) & 7);
26136         PRE_IO
26137         READ_LONG_F(adr, src)
26138         res = DREGu32((Opcode >> 9) & 7);
26139         res |= src;
26140         flag_C = 0;
26141         flag_V = 0;
26142         flag_NotZ = res;
26143         flag_N = res >> 24;
26144         DREGu32((Opcode >> 9) & 7) = res;
26145         POST_IO
26146 RET(14)
26147 }
26148
26149 // ORaD
26150 OPCODE(0x8098)
26151 {
26152         u32 adr, res;
26153         u32 src, dst;
26154
26155         adr = AREG((Opcode >> 0) & 7);
26156         AREG((Opcode >> 0) & 7) += 4;
26157         PRE_IO
26158         READ_LONG_F(adr, src)
26159         res = DREGu32((Opcode >> 9) & 7);
26160         res |= src;
26161         flag_C = 0;
26162         flag_V = 0;
26163         flag_NotZ = res;
26164         flag_N = res >> 24;
26165         DREGu32((Opcode >> 9) & 7) = res;
26166         POST_IO
26167 RET(14)
26168 }
26169
26170 // ORaD
26171 OPCODE(0x80A0)
26172 {
26173         u32 adr, res;
26174         u32 src, dst;
26175
26176         adr = AREG((Opcode >> 0) & 7) - 4;
26177         AREG((Opcode >> 0) & 7) = adr;
26178         PRE_IO
26179         READ_LONG_F(adr, src)
26180         res = DREGu32((Opcode >> 9) & 7);
26181         res |= src;
26182         flag_C = 0;
26183         flag_V = 0;
26184         flag_NotZ = res;
26185         flag_N = res >> 24;
26186         DREGu32((Opcode >> 9) & 7) = res;
26187         POST_IO
26188 RET(16)
26189 }
26190
26191 // ORaD
26192 OPCODE(0x80A8)
26193 {
26194         u32 adr, res;
26195         u32 src, dst;
26196
26197         FETCH_SWORD(adr);
26198         adr += AREG((Opcode >> 0) & 7);
26199         PRE_IO
26200         READ_LONG_F(adr, src)
26201         res = DREGu32((Opcode >> 9) & 7);
26202         res |= src;
26203         flag_C = 0;
26204         flag_V = 0;
26205         flag_NotZ = res;
26206         flag_N = res >> 24;
26207         DREGu32((Opcode >> 9) & 7) = res;
26208         POST_IO
26209 RET(18)
26210 }
26211
26212 // ORaD
26213 OPCODE(0x80B0)
26214 {
26215         u32 adr, res;
26216         u32 src, dst;
26217
26218         adr = AREG((Opcode >> 0) & 7);
26219         DECODE_EXT_WORD
26220         PRE_IO
26221         READ_LONG_F(adr, src)
26222         res = DREGu32((Opcode >> 9) & 7);
26223         res |= src;
26224         flag_C = 0;
26225         flag_V = 0;
26226         flag_NotZ = res;
26227         flag_N = res >> 24;
26228         DREGu32((Opcode >> 9) & 7) = res;
26229         POST_IO
26230 RET(20)
26231 }
26232
26233 // ORaD
26234 OPCODE(0x80B8)
26235 {
26236         u32 adr, res;
26237         u32 src, dst;
26238
26239         FETCH_SWORD(adr);
26240         PRE_IO
26241         READ_LONG_F(adr, src)
26242         res = DREGu32((Opcode >> 9) & 7);
26243         res |= src;
26244         flag_C = 0;
26245         flag_V = 0;
26246         flag_NotZ = res;
26247         flag_N = res >> 24;
26248         DREGu32((Opcode >> 9) & 7) = res;
26249         POST_IO
26250 RET(18)
26251 }
26252
26253 // ORaD
26254 OPCODE(0x80B9)
26255 {
26256         u32 adr, res;
26257         u32 src, dst;
26258
26259         FETCH_LONG(adr);
26260         PRE_IO
26261         READ_LONG_F(adr, src)
26262         res = DREGu32((Opcode >> 9) & 7);
26263         res |= src;
26264         flag_C = 0;
26265         flag_V = 0;
26266         flag_NotZ = res;
26267         flag_N = res >> 24;
26268         DREGu32((Opcode >> 9) & 7) = res;
26269         POST_IO
26270 RET(22)
26271 }
26272
26273 // ORaD
26274 OPCODE(0x80BA)
26275 {
26276         u32 adr, res;
26277         u32 src, dst;
26278
26279         adr = GET_SWORD + GET_PC;
26280         PC++;
26281         PRE_IO
26282         READ_LONG_F(adr, src)
26283         res = DREGu32((Opcode >> 9) & 7);
26284         res |= src;
26285         flag_C = 0;
26286         flag_V = 0;
26287         flag_NotZ = res;
26288         flag_N = res >> 24;
26289         DREGu32((Opcode >> 9) & 7) = res;
26290         POST_IO
26291 RET(18)
26292 }
26293
26294 // ORaD
26295 OPCODE(0x80BB)
26296 {
26297         u32 adr, res;
26298         u32 src, dst;
26299
26300         adr = GET_PC;
26301         DECODE_EXT_WORD
26302         PRE_IO
26303         READ_LONG_F(adr, src)
26304         res = DREGu32((Opcode >> 9) & 7);
26305         res |= src;
26306         flag_C = 0;
26307         flag_V = 0;
26308         flag_NotZ = res;
26309         flag_N = res >> 24;
26310         DREGu32((Opcode >> 9) & 7) = res;
26311         POST_IO
26312 RET(20)
26313 }
26314
26315 // ORaD
26316 OPCODE(0x80BC)
26317 {
26318         u32 adr, res;
26319         u32 src, dst;
26320
26321         FETCH_LONG(src);
26322         res = DREGu32((Opcode >> 9) & 7);
26323         res |= src;
26324         flag_C = 0;
26325         flag_V = 0;
26326         flag_NotZ = res;
26327         flag_N = res >> 24;
26328         DREGu32((Opcode >> 9) & 7) = res;
26329 RET(16)
26330 }
26331
26332 // ORaD
26333 OPCODE(0x809F)
26334 {
26335         u32 adr, res;
26336         u32 src, dst;
26337
26338         adr = AREG(7);
26339         AREG(7) += 4;
26340         PRE_IO
26341         READ_LONG_F(adr, src)
26342         res = DREGu32((Opcode >> 9) & 7);
26343         res |= src;
26344         flag_C = 0;
26345         flag_V = 0;
26346         flag_NotZ = res;
26347         flag_N = res >> 24;
26348         DREGu32((Opcode >> 9) & 7) = res;
26349         POST_IO
26350 RET(14)
26351 }
26352
26353 // ORaD
26354 OPCODE(0x80A7)
26355 {
26356         u32 adr, res;
26357         u32 src, dst;
26358
26359         adr = AREG(7) - 4;
26360         AREG(7) = adr;
26361         PRE_IO
26362         READ_LONG_F(adr, src)
26363         res = DREGu32((Opcode >> 9) & 7);
26364         res |= src;
26365         flag_C = 0;
26366         flag_V = 0;
26367         flag_NotZ = res;
26368         flag_N = res >> 24;
26369         DREGu32((Opcode >> 9) & 7) = res;
26370         POST_IO
26371 RET(16)
26372 }
26373
26374 // ORDa
26375 OPCODE(0x8110)
26376 {
26377         u32 adr, res;
26378         u32 src, dst;
26379
26380         src = DREGu8((Opcode >> 9) & 7);
26381         adr = AREG((Opcode >> 0) & 7);
26382         PRE_IO
26383         READ_BYTE_F(adr, res)
26384         res |= src;
26385         flag_C = 0;
26386         flag_V = 0;
26387         flag_NotZ = res;
26388         flag_N = res;
26389         WRITE_BYTE_F(adr, res)
26390         POST_IO
26391 RET(12)
26392 }
26393
26394 // ORDa
26395 OPCODE(0x8118)
26396 {
26397         u32 adr, res;
26398         u32 src, dst;
26399
26400         src = DREGu8((Opcode >> 9) & 7);
26401         adr = AREG((Opcode >> 0) & 7);
26402         AREG((Opcode >> 0) & 7) += 1;
26403         PRE_IO
26404         READ_BYTE_F(adr, res)
26405         res |= src;
26406         flag_C = 0;
26407         flag_V = 0;
26408         flag_NotZ = res;
26409         flag_N = res;
26410         WRITE_BYTE_F(adr, res)
26411         POST_IO
26412 RET(12)
26413 }
26414
26415 // ORDa
26416 OPCODE(0x8120)
26417 {
26418         u32 adr, res;
26419         u32 src, dst;
26420
26421         src = DREGu8((Opcode >> 9) & 7);
26422         adr = AREG((Opcode >> 0) & 7) - 1;
26423         AREG((Opcode >> 0) & 7) = adr;
26424         PRE_IO
26425         READ_BYTE_F(adr, res)
26426         res |= src;
26427         flag_C = 0;
26428         flag_V = 0;
26429         flag_NotZ = res;
26430         flag_N = res;
26431         WRITE_BYTE_F(adr, res)
26432         POST_IO
26433 RET(14)
26434 }
26435
26436 // ORDa
26437 OPCODE(0x8128)
26438 {
26439         u32 adr, res;
26440         u32 src, dst;
26441
26442         src = DREGu8((Opcode >> 9) & 7);
26443         FETCH_SWORD(adr);
26444         adr += AREG((Opcode >> 0) & 7);
26445         PRE_IO
26446         READ_BYTE_F(adr, res)
26447         res |= src;
26448         flag_C = 0;
26449         flag_V = 0;
26450         flag_NotZ = res;
26451         flag_N = res;
26452         WRITE_BYTE_F(adr, res)
26453         POST_IO
26454 RET(16)
26455 }
26456
26457 // ORDa
26458 OPCODE(0x8130)
26459 {
26460         u32 adr, res;
26461         u32 src, dst;
26462
26463         src = DREGu8((Opcode >> 9) & 7);
26464         adr = AREG((Opcode >> 0) & 7);
26465         DECODE_EXT_WORD
26466         PRE_IO
26467         READ_BYTE_F(adr, res)
26468         res |= src;
26469         flag_C = 0;
26470         flag_V = 0;
26471         flag_NotZ = res;
26472         flag_N = res;
26473         WRITE_BYTE_F(adr, res)
26474         POST_IO
26475 RET(18)
26476 }
26477
26478 // ORDa
26479 OPCODE(0x8138)
26480 {
26481         u32 adr, res;
26482         u32 src, dst;
26483
26484         src = DREGu8((Opcode >> 9) & 7);
26485         FETCH_SWORD(adr);
26486         PRE_IO
26487         READ_BYTE_F(adr, res)
26488         res |= src;
26489         flag_C = 0;
26490         flag_V = 0;
26491         flag_NotZ = res;
26492         flag_N = res;
26493         WRITE_BYTE_F(adr, res)
26494         POST_IO
26495 RET(16)
26496 }
26497
26498 // ORDa
26499 OPCODE(0x8139)
26500 {
26501         u32 adr, res;
26502         u32 src, dst;
26503
26504         src = DREGu8((Opcode >> 9) & 7);
26505         FETCH_LONG(adr);
26506         PRE_IO
26507         READ_BYTE_F(adr, res)
26508         res |= src;
26509         flag_C = 0;
26510         flag_V = 0;
26511         flag_NotZ = res;
26512         flag_N = res;
26513         WRITE_BYTE_F(adr, res)
26514         POST_IO
26515 RET(20)
26516 }
26517
26518 // ORDa
26519 OPCODE(0x811F)
26520 {
26521         u32 adr, res;
26522         u32 src, dst;
26523
26524         src = DREGu8((Opcode >> 9) & 7);
26525         adr = AREG(7);
26526         AREG(7) += 2;
26527         PRE_IO
26528         READ_BYTE_F(adr, res)
26529         res |= src;
26530         flag_C = 0;
26531         flag_V = 0;
26532         flag_NotZ = res;
26533         flag_N = res;
26534         WRITE_BYTE_F(adr, res)
26535         POST_IO
26536 RET(12)
26537 }
26538
26539 // ORDa
26540 OPCODE(0x8127)
26541 {
26542         u32 adr, res;
26543         u32 src, dst;
26544
26545         src = DREGu8((Opcode >> 9) & 7);
26546         adr = AREG(7) - 2;
26547         AREG(7) = adr;
26548         PRE_IO
26549         READ_BYTE_F(adr, res)
26550         res |= src;
26551         flag_C = 0;
26552         flag_V = 0;
26553         flag_NotZ = res;
26554         flag_N = res;
26555         WRITE_BYTE_F(adr, res)
26556         POST_IO
26557 RET(14)
26558 }
26559
26560 // ORDa
26561 OPCODE(0x8150)
26562 {
26563         u32 adr, res;
26564         u32 src, dst;
26565
26566         src = DREGu16((Opcode >> 9) & 7);
26567         adr = AREG((Opcode >> 0) & 7);
26568         PRE_IO
26569         READ_WORD_F(adr, res)
26570         res |= src;
26571         flag_C = 0;
26572         flag_V = 0;
26573         flag_NotZ = res;
26574         flag_N = res >> 8;
26575         WRITE_WORD_F(adr, res)
26576         POST_IO
26577 RET(12)
26578 }
26579
26580 // ORDa
26581 OPCODE(0x8158)
26582 {
26583         u32 adr, res;
26584         u32 src, dst;
26585
26586         src = DREGu16((Opcode >> 9) & 7);
26587         adr = AREG((Opcode >> 0) & 7);
26588         AREG((Opcode >> 0) & 7) += 2;
26589         PRE_IO
26590         READ_WORD_F(adr, res)
26591         res |= src;
26592         flag_C = 0;
26593         flag_V = 0;
26594         flag_NotZ = res;
26595         flag_N = res >> 8;
26596         WRITE_WORD_F(adr, res)
26597         POST_IO
26598 RET(12)
26599 }
26600
26601 // ORDa
26602 OPCODE(0x8160)
26603 {
26604         u32 adr, res;
26605         u32 src, dst;
26606
26607         src = DREGu16((Opcode >> 9) & 7);
26608         adr = AREG((Opcode >> 0) & 7) - 2;
26609         AREG((Opcode >> 0) & 7) = adr;
26610         PRE_IO
26611         READ_WORD_F(adr, res)
26612         res |= src;
26613         flag_C = 0;
26614         flag_V = 0;
26615         flag_NotZ = res;
26616         flag_N = res >> 8;
26617         WRITE_WORD_F(adr, res)
26618         POST_IO
26619 RET(14)
26620 }
26621
26622 // ORDa
26623 OPCODE(0x8168)
26624 {
26625         u32 adr, res;
26626         u32 src, dst;
26627
26628         src = DREGu16((Opcode >> 9) & 7);
26629         FETCH_SWORD(adr);
26630         adr += AREG((Opcode >> 0) & 7);
26631         PRE_IO
26632         READ_WORD_F(adr, res)
26633         res |= src;
26634         flag_C = 0;
26635         flag_V = 0;
26636         flag_NotZ = res;
26637         flag_N = res >> 8;
26638         WRITE_WORD_F(adr, res)
26639         POST_IO
26640 RET(16)
26641 }
26642
26643 // ORDa
26644 OPCODE(0x8170)
26645 {
26646         u32 adr, res;
26647         u32 src, dst;
26648
26649         src = DREGu16((Opcode >> 9) & 7);
26650         adr = AREG((Opcode >> 0) & 7);
26651         DECODE_EXT_WORD
26652         PRE_IO
26653         READ_WORD_F(adr, res)
26654         res |= src;
26655         flag_C = 0;
26656         flag_V = 0;
26657         flag_NotZ = res;
26658         flag_N = res >> 8;
26659         WRITE_WORD_F(adr, res)
26660         POST_IO
26661 RET(18)
26662 }
26663
26664 // ORDa
26665 OPCODE(0x8178)
26666 {
26667         u32 adr, res;
26668         u32 src, dst;
26669
26670         src = DREGu16((Opcode >> 9) & 7);
26671         FETCH_SWORD(adr);
26672         PRE_IO
26673         READ_WORD_F(adr, res)
26674         res |= src;
26675         flag_C = 0;
26676         flag_V = 0;
26677         flag_NotZ = res;
26678         flag_N = res >> 8;
26679         WRITE_WORD_F(adr, res)
26680         POST_IO
26681 RET(16)
26682 }
26683
26684 // ORDa
26685 OPCODE(0x8179)
26686 {
26687         u32 adr, res;
26688         u32 src, dst;
26689
26690         src = DREGu16((Opcode >> 9) & 7);
26691         FETCH_LONG(adr);
26692         PRE_IO
26693         READ_WORD_F(adr, res)
26694         res |= src;
26695         flag_C = 0;
26696         flag_V = 0;
26697         flag_NotZ = res;
26698         flag_N = res >> 8;
26699         WRITE_WORD_F(adr, res)
26700         POST_IO
26701 RET(20)
26702 }
26703
26704 // ORDa
26705 OPCODE(0x815F)
26706 {
26707         u32 adr, res;
26708         u32 src, dst;
26709
26710         src = DREGu16((Opcode >> 9) & 7);
26711         adr = AREG(7);
26712         AREG(7) += 2;
26713         PRE_IO
26714         READ_WORD_F(adr, res)
26715         res |= src;
26716         flag_C = 0;
26717         flag_V = 0;
26718         flag_NotZ = res;
26719         flag_N = res >> 8;
26720         WRITE_WORD_F(adr, res)
26721         POST_IO
26722 RET(12)
26723 }
26724
26725 // ORDa
26726 OPCODE(0x8167)
26727 {
26728         u32 adr, res;
26729         u32 src, dst;
26730
26731         src = DREGu16((Opcode >> 9) & 7);
26732         adr = AREG(7) - 2;
26733         AREG(7) = adr;
26734         PRE_IO
26735         READ_WORD_F(adr, res)
26736         res |= src;
26737         flag_C = 0;
26738         flag_V = 0;
26739         flag_NotZ = res;
26740         flag_N = res >> 8;
26741         WRITE_WORD_F(adr, res)
26742         POST_IO
26743 RET(14)
26744 }
26745
26746 // ORDa
26747 OPCODE(0x8190)
26748 {
26749         u32 adr, res;
26750         u32 src, dst;
26751
26752         src = DREGu32((Opcode >> 9) & 7);
26753         adr = AREG((Opcode >> 0) & 7);
26754         PRE_IO
26755         READ_LONG_F(adr, res)
26756         res |= src;
26757         flag_C = 0;
26758         flag_V = 0;
26759         flag_NotZ = res;
26760         flag_N = res >> 24;
26761         WRITE_LONG_F(adr, res)
26762         POST_IO
26763 RET(20)
26764 }
26765
26766 // ORDa
26767 OPCODE(0x8198)
26768 {
26769         u32 adr, res;
26770         u32 src, dst;
26771
26772         src = DREGu32((Opcode >> 9) & 7);
26773         adr = AREG((Opcode >> 0) & 7);
26774         AREG((Opcode >> 0) & 7) += 4;
26775         PRE_IO
26776         READ_LONG_F(adr, res)
26777         res |= src;
26778         flag_C = 0;
26779         flag_V = 0;
26780         flag_NotZ = res;
26781         flag_N = res >> 24;
26782         WRITE_LONG_F(adr, res)
26783         POST_IO
26784 RET(20)
26785 }
26786
26787 // ORDa
26788 OPCODE(0x81A0)
26789 {
26790         u32 adr, res;
26791         u32 src, dst;
26792
26793         src = DREGu32((Opcode >> 9) & 7);
26794         adr = AREG((Opcode >> 0) & 7) - 4;
26795         AREG((Opcode >> 0) & 7) = adr;
26796         PRE_IO
26797         READ_LONG_F(adr, res)
26798         res |= src;
26799         flag_C = 0;
26800         flag_V = 0;
26801         flag_NotZ = res;
26802         flag_N = res >> 24;
26803         WRITE_LONG_F(adr, res)
26804         POST_IO
26805 RET(22)
26806 }
26807
26808 // ORDa
26809 OPCODE(0x81A8)
26810 {
26811         u32 adr, res;
26812         u32 src, dst;
26813
26814         src = DREGu32((Opcode >> 9) & 7);
26815         FETCH_SWORD(adr);
26816         adr += AREG((Opcode >> 0) & 7);
26817         PRE_IO
26818         READ_LONG_F(adr, res)
26819         res |= src;
26820         flag_C = 0;
26821         flag_V = 0;
26822         flag_NotZ = res;
26823         flag_N = res >> 24;
26824         WRITE_LONG_F(adr, res)
26825         POST_IO
26826 RET(24)
26827 }
26828
26829 // ORDa
26830 OPCODE(0x81B0)
26831 {
26832         u32 adr, res;
26833         u32 src, dst;
26834
26835         src = DREGu32((Opcode >> 9) & 7);
26836         adr = AREG((Opcode >> 0) & 7);
26837         DECODE_EXT_WORD
26838         PRE_IO
26839         READ_LONG_F(adr, res)
26840         res |= src;
26841         flag_C = 0;
26842         flag_V = 0;
26843         flag_NotZ = res;
26844         flag_N = res >> 24;
26845         WRITE_LONG_F(adr, res)
26846         POST_IO
26847 RET(26)
26848 }
26849
26850 // ORDa
26851 OPCODE(0x81B8)
26852 {
26853         u32 adr, res;
26854         u32 src, dst;
26855
26856         src = DREGu32((Opcode >> 9) & 7);
26857         FETCH_SWORD(adr);
26858         PRE_IO
26859         READ_LONG_F(adr, res)
26860         res |= src;
26861         flag_C = 0;
26862         flag_V = 0;
26863         flag_NotZ = res;
26864         flag_N = res >> 24;
26865         WRITE_LONG_F(adr, res)
26866         POST_IO
26867 RET(24)
26868 }
26869
26870 // ORDa
26871 OPCODE(0x81B9)
26872 {
26873         u32 adr, res;
26874         u32 src, dst;
26875
26876         src = DREGu32((Opcode >> 9) & 7);
26877         FETCH_LONG(adr);
26878         PRE_IO
26879         READ_LONG_F(adr, res)
26880         res |= src;
26881         flag_C = 0;
26882         flag_V = 0;
26883         flag_NotZ = res;
26884         flag_N = res >> 24;
26885         WRITE_LONG_F(adr, res)
26886         POST_IO
26887 RET(28)
26888 }
26889
26890 // ORDa
26891 OPCODE(0x819F)
26892 {
26893         u32 adr, res;
26894         u32 src, dst;
26895
26896         src = DREGu32((Opcode >> 9) & 7);
26897         adr = AREG(7);
26898         AREG(7) += 4;
26899         PRE_IO
26900         READ_LONG_F(adr, res)
26901         res |= src;
26902         flag_C = 0;
26903         flag_V = 0;
26904         flag_NotZ = res;
26905         flag_N = res >> 24;
26906         WRITE_LONG_F(adr, res)
26907         POST_IO
26908 RET(20)
26909 }
26910
26911 // ORDa
26912 OPCODE(0x81A7)
26913 {
26914         u32 adr, res;
26915         u32 src, dst;
26916
26917         src = DREGu32((Opcode >> 9) & 7);
26918         adr = AREG(7) - 4;
26919         AREG(7) = adr;
26920         PRE_IO
26921         READ_LONG_F(adr, res)
26922         res |= src;
26923         flag_C = 0;
26924         flag_V = 0;
26925         flag_NotZ = res;
26926         flag_N = res >> 24;
26927         WRITE_LONG_F(adr, res)
26928         POST_IO
26929 RET(22)
26930 }
26931
26932 // SBCD
26933 OPCODE(0x8100)
26934 {
26935         u32 adr, res;
26936         u32 src, dst;
26937
26938         src = DREGu8((Opcode >> 0) & 7);
26939         dst = DREGu8((Opcode >> 9) & 7);
26940         res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
26941         if (res > 9) res -= 6;
26942         res += (dst & 0xF0) - (src & 0xF0);
26943         if (res > 0x99)
26944         {
26945                 res += 0xA0;
26946                 flag_X = flag_C = M68K_SR_C;
26947         }
26948         else flag_X = flag_C = 0;
26949         flag_NotZ |= res & 0xFF;
26950         flag_N = res;
26951         DREGu8((Opcode >> 9) & 7) = res;
26952 RET(6)
26953 }
26954
26955 // SBCDM
26956 OPCODE(0x8108)
26957 {
26958         u32 adr, res;
26959         u32 src, dst;
26960
26961         adr = AREG((Opcode >> 0) & 7) - 1;
26962         AREG((Opcode >> 0) & 7) = adr;
26963         PRE_IO
26964         READ_BYTE_F(adr, src)
26965         adr = AREG((Opcode >> 9) & 7) - 1;
26966         AREG((Opcode >> 9) & 7) = adr;
26967         READ_BYTE_F(adr, dst)
26968         res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
26969         if (res > 9) res -= 6;
26970         res += (dst & 0xF0) - (src & 0xF0);
26971         if (res > 0x99)
26972         {
26973                 res += 0xA0;
26974                 flag_X = flag_C = M68K_SR_C;
26975         }
26976         else flag_X = flag_C = 0;
26977         flag_NotZ |= res & 0xFF;
26978         flag_N = res;
26979         WRITE_BYTE_F(adr, res)
26980         POST_IO
26981 RET(18)
26982 }
26983
26984 // SBCD7M
26985 OPCODE(0x810F)
26986 {
26987         u32 adr, res;
26988         u32 src, dst;
26989
26990         adr = AREG(7) - 2;
26991         AREG(7) = adr;
26992         PRE_IO
26993         READ_BYTE_F(adr, src)
26994         adr = AREG((Opcode >> 9) & 7) - 1;
26995         AREG((Opcode >> 9) & 7) = adr;
26996         READ_BYTE_F(adr, dst)
26997         res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
26998         if (res > 9) res -= 6;
26999         res += (dst & 0xF0) - (src & 0xF0);
27000         if (res > 0x99)
27001         {
27002                 res += 0xA0;
27003                 flag_X = flag_C = M68K_SR_C;
27004         }
27005         else flag_X = flag_C = 0;
27006         flag_NotZ |= res & 0xFF;
27007         flag_N = res;
27008         WRITE_BYTE_F(adr, res)
27009         POST_IO
27010 RET(18)
27011 }
27012
27013 // SBCDM7
27014 OPCODE(0x8F08)
27015 {
27016         u32 adr, res;
27017         u32 src, dst;
27018
27019         adr = AREG((Opcode >> 0) & 7) - 1;
27020         AREG((Opcode >> 0) & 7) = adr;
27021         PRE_IO
27022         READ_BYTE_F(adr, src)
27023         adr = AREG(7) - 2;
27024         AREG(7) = adr;
27025         READ_BYTE_F(adr, dst)
27026         res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
27027         if (res > 9) res -= 6;
27028         res += (dst & 0xF0) - (src & 0xF0);
27029         if (res > 0x99)
27030         {
27031                 res += 0xA0;
27032                 flag_X = flag_C = M68K_SR_C;
27033         }
27034         else flag_X = flag_C = 0;
27035         flag_NotZ |= res & 0xFF;
27036         flag_N = res;
27037         WRITE_BYTE_F(adr, res)
27038         POST_IO
27039 RET(18)
27040 }
27041
27042 // SBCD7M7
27043 OPCODE(0x8F0F)
27044 {
27045         u32 adr, res;
27046         u32 src, dst;
27047
27048         adr = AREG(7) - 2;
27049         AREG(7) = adr;
27050         PRE_IO
27051         READ_BYTE_F(adr, src)
27052         adr = AREG(7) - 2;
27053         AREG(7) = adr;
27054         READ_BYTE_F(adr, dst)
27055         res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
27056         if (res > 9) res -= 6;
27057         res += (dst & 0xF0) - (src & 0xF0);
27058         if (res > 0x99)
27059         {
27060                 res += 0xA0;
27061                 flag_X = flag_C = M68K_SR_C;
27062         }
27063         else flag_X = flag_C = 0;
27064         flag_NotZ |= res & 0xFF;
27065         flag_N = res;
27066         WRITE_BYTE_F(adr, res)
27067         POST_IO
27068 RET(18)
27069 }
27070
27071 // DIVU
27072 OPCODE(0x80C0)
27073 {
27074         u32 adr, res;
27075         u32 src, dst;
27076
27077         src = DREGu16((Opcode >> 0) & 7);
27078         if (src == 0)
27079         {
27080                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27081 #ifdef USE_CYCLONE_TIMING_DIV
27082 RET(140)
27083 #else
27084 RET(10)
27085 #endif
27086         }
27087         dst = DREGu32((Opcode >> 9) & 7);
27088         {
27089                 u32 q, r;
27090
27091                 q = dst / src;
27092                 r = dst % src;
27093
27094                 if (q & 0xFFFF0000)
27095                 {
27096                         flag_V = M68K_SR_V;
27097 #ifdef USE_CYCLONE_TIMING_DIV
27098 RET(140)
27099 #else
27100 RET(70)
27101 #endif
27102                 }
27103                 q &= 0x0000FFFF;
27104                 flag_NotZ = q;
27105                 flag_N = q >> 8;
27106                 flag_V = flag_C = 0;
27107                 res = q | (r << 16);
27108         DREGu32((Opcode >> 9) & 7) = res;
27109         }
27110 #ifdef USE_CYCLONE_TIMING_DIV
27111 RET(140)
27112 #else
27113 RET(90)
27114 #endif
27115 }
27116
27117 // DIVU
27118 OPCODE(0x80D0)
27119 {
27120         u32 adr, res;
27121         u32 src, dst;
27122
27123         adr = AREG((Opcode >> 0) & 7);
27124         PRE_IO
27125         READ_WORD_F(adr, src)
27126         if (src == 0)
27127         {
27128                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27129 #ifdef USE_CYCLONE_TIMING_DIV
27130 RET(144)
27131 #else
27132 RET(14)
27133 #endif
27134         }
27135         dst = DREGu32((Opcode >> 9) & 7);
27136         {
27137                 u32 q, r;
27138
27139                 q = dst / src;
27140                 r = dst % src;
27141
27142                 if (q & 0xFFFF0000)
27143                 {
27144                         flag_V = M68K_SR_V;
27145 #ifdef USE_CYCLONE_TIMING_DIV
27146 RET(144)
27147 #else
27148         RET(74)
27149 #endif
27150                 }
27151                 q &= 0x0000FFFF;
27152                 flag_NotZ = q;
27153                 flag_N = q >> 8;
27154                 flag_V = flag_C = 0;
27155                 res = q | (r << 16);
27156         DREGu32((Opcode >> 9) & 7) = res;
27157         }
27158 #ifdef USE_CYCLONE_TIMING_DIV
27159 RET(144)
27160 #else
27161 RET(94)
27162 #endif
27163 }
27164
27165 // DIVU
27166 OPCODE(0x80D8)
27167 {
27168         u32 adr, res;
27169         u32 src, dst;
27170
27171         adr = AREG((Opcode >> 0) & 7);
27172         AREG((Opcode >> 0) & 7) += 2;
27173         PRE_IO
27174         READ_WORD_F(adr, src)
27175         if (src == 0)
27176         {
27177                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27178 #ifdef USE_CYCLONE_TIMING_DIV
27179 RET(144)
27180 #else
27181 RET(14)
27182 #endif
27183         }
27184         dst = DREGu32((Opcode >> 9) & 7);
27185         {
27186                 u32 q, r;
27187
27188                 q = dst / src;
27189                 r = dst % src;
27190
27191                 if (q & 0xFFFF0000)
27192                 {
27193                         flag_V = M68K_SR_V;
27194 #ifdef USE_CYCLONE_TIMING_DIV
27195 RET(144)
27196 #else
27197         RET(74)
27198 #endif
27199                 }
27200                 q &= 0x0000FFFF;
27201                 flag_NotZ = q;
27202                 flag_N = q >> 8;
27203                 flag_V = flag_C = 0;
27204                 res = q | (r << 16);
27205         DREGu32((Opcode >> 9) & 7) = res;
27206         }
27207 #ifdef USE_CYCLONE_TIMING_DIV
27208 RET(144)
27209 #else
27210 RET(94)
27211 #endif
27212 }
27213
27214 // DIVU
27215 OPCODE(0x80E0)
27216 {
27217         u32 adr, res;
27218         u32 src, dst;
27219
27220         adr = AREG((Opcode >> 0) & 7) - 2;
27221         AREG((Opcode >> 0) & 7) = adr;
27222         PRE_IO
27223         READ_WORD_F(adr, src)
27224         if (src == 0)
27225         {
27226                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27227 #ifdef USE_CYCLONE_TIMING_DIV
27228 RET(146)
27229 #else
27230 RET(16)
27231 #endif
27232         }
27233         dst = DREGu32((Opcode >> 9) & 7);
27234         {
27235                 u32 q, r;
27236
27237                 q = dst / src;
27238                 r = dst % src;
27239
27240                 if (q & 0xFFFF0000)
27241                 {
27242                         flag_V = M68K_SR_V;
27243 #ifdef USE_CYCLONE_TIMING_DIV
27244 RET(146)
27245 #else
27246         RET(76)
27247 #endif
27248                 }
27249                 q &= 0x0000FFFF;
27250                 flag_NotZ = q;
27251                 flag_N = q >> 8;
27252                 flag_V = flag_C = 0;
27253                 res = q | (r << 16);
27254         DREGu32((Opcode >> 9) & 7) = res;
27255         }
27256 #ifdef USE_CYCLONE_TIMING_DIV
27257 RET(146)
27258 #else
27259 RET(96)
27260 #endif
27261 }
27262
27263 // DIVU
27264 OPCODE(0x80E8)
27265 {
27266         u32 adr, res;
27267         u32 src, dst;
27268
27269         FETCH_SWORD(adr);
27270         adr += AREG((Opcode >> 0) & 7);
27271         PRE_IO
27272         READ_WORD_F(adr, src)
27273         if (src == 0)
27274         {
27275                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27276 #ifdef USE_CYCLONE_TIMING_DIV
27277 RET(148)
27278 #else
27279 RET(18)
27280 #endif
27281         }
27282         dst = DREGu32((Opcode >> 9) & 7);
27283         {
27284                 u32 q, r;
27285
27286                 q = dst / src;
27287                 r = dst % src;
27288
27289                 if (q & 0xFFFF0000)
27290                 {
27291                         flag_V = M68K_SR_V;
27292 #ifdef USE_CYCLONE_TIMING_DIV
27293 RET(148)
27294 #else
27295         RET(78)
27296 #endif
27297                 }
27298                 q &= 0x0000FFFF;
27299                 flag_NotZ = q;
27300                 flag_N = q >> 8;
27301                 flag_V = flag_C = 0;
27302                 res = q | (r << 16);
27303         DREGu32((Opcode >> 9) & 7) = res;
27304         }
27305 #ifdef USE_CYCLONE_TIMING_DIV
27306 RET(148)
27307 #else
27308 RET(98)
27309 #endif
27310 }
27311
27312 // DIVU
27313 OPCODE(0x80F0)
27314 {
27315         u32 adr, res;
27316         u32 src, dst;
27317
27318         adr = AREG((Opcode >> 0) & 7);
27319         DECODE_EXT_WORD
27320         PRE_IO
27321         READ_WORD_F(adr, src)
27322         if (src == 0)
27323         {
27324                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27325 #ifdef USE_CYCLONE_TIMING_DIV
27326 RET(150)
27327 #else
27328 RET(20)
27329 #endif
27330         }
27331         dst = DREGu32((Opcode >> 9) & 7);
27332         {
27333                 u32 q, r;
27334
27335                 q = dst / src;
27336                 r = dst % src;
27337
27338                 if (q & 0xFFFF0000)
27339                 {
27340                         flag_V = M68K_SR_V;
27341 #ifdef USE_CYCLONE_TIMING_DIV
27342 RET(150)
27343 #else
27344         RET(80)
27345 #endif
27346                 }
27347                 q &= 0x0000FFFF;
27348                 flag_NotZ = q;
27349                 flag_N = q >> 8;
27350                 flag_V = flag_C = 0;
27351                 res = q | (r << 16);
27352         DREGu32((Opcode >> 9) & 7) = res;
27353         }
27354 #ifdef USE_CYCLONE_TIMING_DIV
27355 RET(150)
27356 #else
27357 RET(100)
27358 #endif
27359 }
27360
27361 // DIVU
27362 OPCODE(0x80F8)
27363 {
27364         u32 adr, res;
27365         u32 src, dst;
27366
27367         FETCH_SWORD(adr);
27368         PRE_IO
27369         READ_WORD_F(adr, src)
27370         if (src == 0)
27371         {
27372                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27373 #ifdef USE_CYCLONE_TIMING_DIV
27374 RET(148)
27375 #else
27376 RET(18)
27377 #endif
27378         }
27379         dst = DREGu32((Opcode >> 9) & 7);
27380         {
27381                 u32 q, r;
27382
27383                 q = dst / src;
27384                 r = dst % src;
27385
27386                 if (q & 0xFFFF0000)
27387                 {
27388                         flag_V = M68K_SR_V;
27389 #ifdef USE_CYCLONE_TIMING_DIV
27390 RET(148)
27391 #else
27392         RET(78)
27393 #endif
27394                 }
27395                 q &= 0x0000FFFF;
27396                 flag_NotZ = q;
27397                 flag_N = q >> 8;
27398                 flag_V = flag_C = 0;
27399                 res = q | (r << 16);
27400         DREGu32((Opcode >> 9) & 7) = res;
27401         }
27402 #ifdef USE_CYCLONE_TIMING_DIV
27403 RET(148)
27404 #else
27405 RET(98)
27406 #endif
27407 }
27408
27409 // DIVU
27410 OPCODE(0x80F9)
27411 {
27412         u32 adr, res;
27413         u32 src, dst;
27414
27415         FETCH_LONG(adr);
27416         PRE_IO
27417         READ_WORD_F(adr, src)
27418         if (src == 0)
27419         {
27420                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27421 #ifdef USE_CYCLONE_TIMING_DIV
27422 RET(162)
27423 #else
27424 RET(22)
27425 #endif
27426         }
27427         dst = DREGu32((Opcode >> 9) & 7);
27428         {
27429                 u32 q, r;
27430
27431                 q = dst / src;
27432                 r = dst % src;
27433
27434                 if (q & 0xFFFF0000)
27435                 {
27436                         flag_V = M68K_SR_V;
27437 #ifdef USE_CYCLONE_TIMING_DIV
27438 RET(162)
27439 #else
27440         RET(82)
27441 #endif
27442                 }
27443                 q &= 0x0000FFFF;
27444                 flag_NotZ = q;
27445                 flag_N = q >> 8;
27446                 flag_V = flag_C = 0;
27447                 res = q | (r << 16);
27448         DREGu32((Opcode >> 9) & 7) = res;
27449         }
27450 #ifdef USE_CYCLONE_TIMING_DIV
27451 RET(162)
27452 #else
27453 RET(102)
27454 #endif
27455 }
27456
27457 // DIVU
27458 OPCODE(0x80FA)
27459 {
27460         u32 adr, res;
27461         u32 src, dst;
27462
27463         adr = GET_SWORD + GET_PC;
27464         PC++;
27465         PRE_IO
27466         READ_WORD_F(adr, src)
27467         if (src == 0)
27468         {
27469                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27470 #ifdef USE_CYCLONE_TIMING_DIV
27471 RET(148)
27472 #else
27473 RET(18)
27474 #endif
27475         }
27476         dst = DREGu32((Opcode >> 9) & 7);
27477         {
27478                 u32 q, r;
27479
27480                 q = dst / src;
27481                 r = dst % src;
27482
27483                 if (q & 0xFFFF0000)
27484                 {
27485                         flag_V = M68K_SR_V;
27486 #ifdef USE_CYCLONE_TIMING_DIV
27487 RET(148)
27488 #else
27489         RET(78)
27490 #endif
27491                 }
27492                 q &= 0x0000FFFF;
27493                 flag_NotZ = q;
27494                 flag_N = q >> 8;
27495                 flag_V = flag_C = 0;
27496                 res = q | (r << 16);
27497         DREGu32((Opcode >> 9) & 7) = res;
27498         }
27499 #ifdef USE_CYCLONE_TIMING_DIV
27500 RET(148)
27501 #else
27502 RET(98)
27503 #endif
27504 }
27505
27506 // DIVU
27507 OPCODE(0x80FB)
27508 {
27509         u32 adr, res;
27510         u32 src, dst;
27511
27512         adr = GET_PC;
27513         DECODE_EXT_WORD
27514         PRE_IO
27515         READ_WORD_F(adr, src)
27516         if (src == 0)
27517         {
27518                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27519 #ifdef USE_CYCLONE_TIMING_DIV
27520 RET(160)
27521 #else
27522 RET(20)
27523 #endif
27524         }
27525         dst = DREGu32((Opcode >> 9) & 7);
27526         {
27527                 u32 q, r;
27528
27529                 q = dst / src;
27530                 r = dst % src;
27531
27532                 if (q & 0xFFFF0000)
27533                 {
27534                         flag_V = M68K_SR_V;
27535 #ifdef USE_CYCLONE_TIMING_DIV
27536 RET(160)
27537 #else
27538         RET(80)
27539 #endif
27540                 }
27541                 q &= 0x0000FFFF;
27542                 flag_NotZ = q;
27543                 flag_N = q >> 8;
27544                 flag_V = flag_C = 0;
27545                 res = q | (r << 16);
27546         DREGu32((Opcode >> 9) & 7) = res;
27547         }
27548 #ifdef USE_CYCLONE_TIMING_DIV
27549 RET(160)
27550 #else
27551 RET(100)
27552 #endif
27553 }
27554
27555 // DIVU
27556 OPCODE(0x80FC)
27557 {
27558         u32 adr, res;
27559         u32 src, dst;
27560
27561         FETCH_WORD(src);
27562         if (src == 0)
27563         {
27564                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27565 #ifdef USE_CYCLONE_TIMING_DIV
27566 RET(144)
27567 #else
27568 RET(14)
27569 #endif
27570         }
27571         dst = DREGu32((Opcode >> 9) & 7);
27572         {
27573                 u32 q, r;
27574
27575                 q = dst / src;
27576                 r = dst % src;
27577
27578                 if (q & 0xFFFF0000)
27579                 {
27580                         flag_V = M68K_SR_V;
27581 #ifdef USE_CYCLONE_TIMING_DIV
27582 RET(144)
27583 #else
27584         RET(74)
27585 #endif
27586                 }
27587                 q &= 0x0000FFFF;
27588                 flag_NotZ = q;
27589                 flag_N = q >> 8;
27590                 flag_V = flag_C = 0;
27591                 res = q | (r << 16);
27592         DREGu32((Opcode >> 9) & 7) = res;
27593         }
27594 #ifdef USE_CYCLONE_TIMING_DIV
27595 RET(144)
27596 #else
27597 RET(94)
27598 #endif
27599 }
27600
27601 // DIVU
27602 OPCODE(0x80DF)
27603 {
27604         u32 adr, res;
27605         u32 src, dst;
27606
27607         adr = AREG(7);
27608         AREG(7) += 2;
27609         PRE_IO
27610         READ_WORD_F(adr, src)
27611         if (src == 0)
27612         {
27613                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27614 #ifdef USE_CYCLONE_TIMING_DIV
27615 RET(144)
27616 #else
27617 RET(14)
27618 #endif
27619         }
27620         dst = DREGu32((Opcode >> 9) & 7);
27621         {
27622                 u32 q, r;
27623
27624                 q = dst / src;
27625                 r = dst % src;
27626
27627                 if (q & 0xFFFF0000)
27628                 {
27629                         flag_V = M68K_SR_V;
27630 #ifdef USE_CYCLONE_TIMING_DIV
27631 RET(144)
27632 #else
27633         RET(74)
27634 #endif
27635                 }
27636                 q &= 0x0000FFFF;
27637                 flag_NotZ = q;
27638                 flag_N = q >> 8;
27639                 flag_V = flag_C = 0;
27640                 res = q | (r << 16);
27641         DREGu32((Opcode >> 9) & 7) = res;
27642         }
27643 #ifdef USE_CYCLONE_TIMING_DIV
27644 RET(144)
27645 #else
27646 RET(94)
27647 #endif
27648 }
27649
27650 // DIVU
27651 OPCODE(0x80E7)
27652 {
27653         u32 adr, res;
27654         u32 src, dst;
27655
27656         adr = AREG(7) - 2;
27657         AREG(7) = adr;
27658         PRE_IO
27659         READ_WORD_F(adr, src)
27660         if (src == 0)
27661         {
27662                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27663 #ifdef USE_CYCLONE_TIMING_DIV
27664 RET(146)
27665 #else
27666 RET(16)
27667 #endif
27668         }
27669         dst = DREGu32((Opcode >> 9) & 7);
27670         {
27671                 u32 q, r;
27672
27673                 q = dst / src;
27674                 r = dst % src;
27675
27676                 if (q & 0xFFFF0000)
27677                 {
27678                         flag_V = M68K_SR_V;
27679 #ifdef USE_CYCLONE_TIMING_DIV
27680 RET(146)
27681 #else
27682         RET(76)
27683 #endif
27684                 }
27685                 q &= 0x0000FFFF;
27686                 flag_NotZ = q;
27687                 flag_N = q >> 8;
27688                 flag_V = flag_C = 0;
27689                 res = q | (r << 16);
27690         DREGu32((Opcode >> 9) & 7) = res;
27691         }
27692 #ifdef USE_CYCLONE_TIMING_DIV
27693 RET(146)
27694 #else
27695 RET(96)
27696 #endif
27697 }
27698
27699 // DIVS
27700 OPCODE(0x81C0)
27701 {
27702         u32 adr, res;
27703         u32 src, dst;
27704
27705         src = (s32)DREGs16((Opcode >> 0) & 7);
27706         if (src == 0)
27707         {
27708                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27709 #ifdef USE_CYCLONE_TIMING_DIV
27710 goto end81C0;
27711 #endif
27712                 RET(10)
27713         }
27714         dst = DREGu32((Opcode >> 9) & 7);
27715         if ((dst == 0x80000000) && (src == (u32)-1))
27716         {
27717                 flag_NotZ = flag_N = 0;
27718                 flag_V = flag_C = 0;
27719                 res = 0;
27720         DREGu32((Opcode >> 9) & 7) = res;
27721 #ifdef USE_CYCLONE_TIMING_DIV
27722 goto end81C0;
27723 #endif
27724         RET(50)
27725         }
27726         {
27727                 s32 q, r;
27728
27729                 q = (s32)dst / (s32)src;
27730                 r = (s32)dst % (s32)src;
27731
27732                 if ((q > 0x7FFF) || (q < -0x8000))
27733                 {
27734                         flag_V = M68K_SR_V;
27735 #ifdef USE_CYCLONE_TIMING_DIV
27736 goto end81C0;
27737 #endif
27738         RET(80)
27739                 }
27740                 q &= 0x0000FFFF;
27741                 flag_NotZ = q;
27742                 flag_N = q >> 8;
27743                 flag_V = flag_C = 0;
27744                 res = q | (r << 16);
27745         DREGu32((Opcode >> 9) & 7) = res;
27746         }
27747 #ifdef USE_CYCLONE_TIMING_DIV
27748 end81C0: m68kcontext.io_cycle_counter -= 50;
27749 #endif
27750 RET(108)
27751 }
27752
27753 // DIVS
27754 OPCODE(0x81D0)
27755 {
27756         u32 adr, res;
27757         u32 src, dst;
27758
27759         adr = AREG((Opcode >> 0) & 7);
27760         PRE_IO
27761         READSX_WORD_F(adr, src)
27762         if (src == 0)
27763         {
27764                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27765 #ifdef USE_CYCLONE_TIMING_DIV
27766 goto end81D0;
27767 #endif
27768                 RET(14)
27769         }
27770         dst = DREGu32((Opcode >> 9) & 7);
27771         if ((dst == 0x80000000) && (src == (u32)-1))
27772         {
27773                 flag_NotZ = flag_N = 0;
27774                 flag_V = flag_C = 0;
27775                 res = 0;
27776         DREGu32((Opcode >> 9) & 7) = res;
27777 #ifdef USE_CYCLONE_TIMING_DIV
27778 goto end81D0;
27779 #endif
27780         RET(54)
27781         }
27782         {
27783                 s32 q, r;
27784
27785                 q = (s32)dst / (s32)src;
27786                 r = (s32)dst % (s32)src;
27787
27788                 if ((q > 0x7FFF) || (q < -0x8000))
27789                 {
27790                         flag_V = M68K_SR_V;
27791 #ifdef USE_CYCLONE_TIMING_DIV
27792 goto end81D0;
27793 #endif
27794         RET(84)
27795                 }
27796                 q &= 0x0000FFFF;
27797                 flag_NotZ = q;
27798                 flag_N = q >> 8;
27799                 flag_V = flag_C = 0;
27800                 res = q | (r << 16);
27801         DREGu32((Opcode >> 9) & 7) = res;
27802         }
27803 #ifdef USE_CYCLONE_TIMING_DIV
27804 end81D0: m68kcontext.io_cycle_counter -= 50;
27805 #endif
27806 RET(112)
27807 }
27808
27809 // DIVS
27810 OPCODE(0x81D8)
27811 {
27812         u32 adr, res;
27813         u32 src, dst;
27814
27815         adr = AREG((Opcode >> 0) & 7);
27816         AREG((Opcode >> 0) & 7) += 2;
27817         PRE_IO
27818         READSX_WORD_F(adr, src)
27819         if (src == 0)
27820         {
27821                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27822 #ifdef USE_CYCLONE_TIMING_DIV
27823 goto end81D8;
27824 #endif
27825                 RET(14)
27826         }
27827         dst = DREGu32((Opcode >> 9) & 7);
27828         if ((dst == 0x80000000) && (src == (u32)-1))
27829         {
27830                 flag_NotZ = flag_N = 0;
27831                 flag_V = flag_C = 0;
27832                 res = 0;
27833         DREGu32((Opcode >> 9) & 7) = res;
27834 #ifdef USE_CYCLONE_TIMING_DIV
27835 goto end81D8;
27836 #endif
27837         RET(54)
27838         }
27839         {
27840                 s32 q, r;
27841
27842                 q = (s32)dst / (s32)src;
27843                 r = (s32)dst % (s32)src;
27844
27845                 if ((q > 0x7FFF) || (q < -0x8000))
27846                 {
27847                         flag_V = M68K_SR_V;
27848 #ifdef USE_CYCLONE_TIMING_DIV
27849 goto end81D8;
27850 #endif
27851         RET(84)
27852                 }
27853                 q &= 0x0000FFFF;
27854                 flag_NotZ = q;
27855                 flag_N = q >> 8;
27856                 flag_V = flag_C = 0;
27857                 res = q | (r << 16);
27858         DREGu32((Opcode >> 9) & 7) = res;
27859         }
27860 #ifdef USE_CYCLONE_TIMING_DIV
27861 end81D8: m68kcontext.io_cycle_counter -= 50;
27862 #endif
27863 RET(112)
27864 }
27865
27866 // DIVS
27867 OPCODE(0x81E0)
27868 {
27869         u32 adr, res;
27870         u32 src, dst;
27871
27872         adr = AREG((Opcode >> 0) & 7) - 2;
27873         AREG((Opcode >> 0) & 7) = adr;
27874         PRE_IO
27875         READSX_WORD_F(adr, src)
27876         if (src == 0)
27877         {
27878                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27879 #ifdef USE_CYCLONE_TIMING_DIV
27880 goto end81E0;
27881 #endif
27882                 RET(16)
27883         }
27884         dst = DREGu32((Opcode >> 9) & 7);
27885         if ((dst == 0x80000000) && (src == (u32)-1))
27886         {
27887                 flag_NotZ = flag_N = 0;
27888                 flag_V = flag_C = 0;
27889                 res = 0;
27890         DREGu32((Opcode >> 9) & 7) = res;
27891 #ifdef USE_CYCLONE_TIMING_DIV
27892 goto end81E0;
27893 #endif
27894         RET(56)
27895         }
27896         {
27897                 s32 q, r;
27898
27899                 q = (s32)dst / (s32)src;
27900                 r = (s32)dst % (s32)src;
27901
27902                 if ((q > 0x7FFF) || (q < -0x8000))
27903                 {
27904                         flag_V = M68K_SR_V;
27905 #ifdef USE_CYCLONE_TIMING_DIV
27906 goto end81E0;
27907 #endif
27908         RET(86)
27909                 }
27910                 q &= 0x0000FFFF;
27911                 flag_NotZ = q;
27912                 flag_N = q >> 8;
27913                 flag_V = flag_C = 0;
27914                 res = q | (r << 16);
27915         DREGu32((Opcode >> 9) & 7) = res;
27916         }
27917 #ifdef USE_CYCLONE_TIMING_DIV
27918 end81E0: m68kcontext.io_cycle_counter -= 50;
27919 #endif
27920 RET(114)
27921 }
27922
27923 // DIVS
27924 OPCODE(0x81E8)
27925 {
27926         u32 adr, res;
27927         u32 src, dst;
27928
27929         FETCH_SWORD(adr);
27930         adr += AREG((Opcode >> 0) & 7);
27931         PRE_IO
27932         READSX_WORD_F(adr, src)
27933         if (src == 0)
27934         {
27935                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27936 #ifdef USE_CYCLONE_TIMING_DIV
27937 goto end81E8;
27938 #endif
27939                 RET(18)
27940         }
27941         dst = DREGu32((Opcode >> 9) & 7);
27942         if ((dst == 0x80000000) && (src == (u32)-1))
27943         {
27944                 flag_NotZ = flag_N = 0;
27945                 flag_V = flag_C = 0;
27946                 res = 0;
27947         DREGu32((Opcode >> 9) & 7) = res;
27948 #ifdef USE_CYCLONE_TIMING_DIV
27949 goto end81E8;
27950 #endif
27951         RET(58)
27952         }
27953         {
27954                 s32 q, r;
27955
27956                 q = (s32)dst / (s32)src;
27957                 r = (s32)dst % (s32)src;
27958
27959                 if ((q > 0x7FFF) || (q < -0x8000))
27960                 {
27961                         flag_V = M68K_SR_V;
27962 #ifdef USE_CYCLONE_TIMING_DIV
27963 goto end81E8;
27964 #endif
27965         RET(88)
27966                 }
27967                 q &= 0x0000FFFF;
27968                 flag_NotZ = q;
27969                 flag_N = q >> 8;
27970                 flag_V = flag_C = 0;
27971                 res = q | (r << 16);
27972         DREGu32((Opcode >> 9) & 7) = res;
27973         }
27974 #ifdef USE_CYCLONE_TIMING_DIV
27975 end81E8: m68kcontext.io_cycle_counter -= 50;
27976 #endif
27977 RET(116)
27978 }
27979
27980 // DIVS
27981 OPCODE(0x81F0)
27982 {
27983         u32 adr, res;
27984         u32 src, dst;
27985
27986         adr = AREG((Opcode >> 0) & 7);
27987         DECODE_EXT_WORD
27988         PRE_IO
27989         READSX_WORD_F(adr, src)
27990         if (src == 0)
27991         {
27992                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27993 #ifdef USE_CYCLONE_TIMING_DIV
27994 goto end81F0;
27995 #endif
27996                 RET(20)
27997         }
27998         dst = DREGu32((Opcode >> 9) & 7);
27999         if ((dst == 0x80000000) && (src == (u32)-1))
28000         {
28001                 flag_NotZ = flag_N = 0;
28002                 flag_V = flag_C = 0;
28003                 res = 0;
28004         DREGu32((Opcode >> 9) & 7) = res;
28005 #ifdef USE_CYCLONE_TIMING_DIV
28006 goto end81F0;
28007 #endif
28008         RET(60)
28009         }
28010         {
28011                 s32 q, r;
28012
28013                 q = (s32)dst / (s32)src;
28014                 r = (s32)dst % (s32)src;
28015
28016                 if ((q > 0x7FFF) || (q < -0x8000))
28017                 {
28018                         flag_V = M68K_SR_V;
28019 #ifdef USE_CYCLONE_TIMING_DIV
28020 goto end81F0;
28021 #endif
28022         RET(90)
28023                 }
28024                 q &= 0x0000FFFF;
28025                 flag_NotZ = q;
28026                 flag_N = q >> 8;
28027                 flag_V = flag_C = 0;
28028                 res = q | (r << 16);
28029         DREGu32((Opcode >> 9) & 7) = res;
28030         }
28031 #ifdef USE_CYCLONE_TIMING_DIV
28032 end81F0: m68kcontext.io_cycle_counter -= 50;
28033 #endif
28034 RET(118)
28035 }
28036
28037 // DIVS
28038 OPCODE(0x81F8)
28039 {
28040         u32 adr, res;
28041         u32 src, dst;
28042
28043         FETCH_SWORD(adr);
28044         PRE_IO
28045         READSX_WORD_F(adr, src)
28046         if (src == 0)
28047         {
28048                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28049 #ifdef USE_CYCLONE_TIMING_DIV
28050 goto end81F8;
28051 #endif
28052                 RET(18)
28053         }
28054         dst = DREGu32((Opcode >> 9) & 7);
28055         if ((dst == 0x80000000) && (src == (u32)-1))
28056         {
28057                 flag_NotZ = flag_N = 0;
28058                 flag_V = flag_C = 0;
28059                 res = 0;
28060         DREGu32((Opcode >> 9) & 7) = res;
28061 #ifdef USE_CYCLONE_TIMING_DIV
28062 goto end81F8;
28063 #endif
28064         RET(58)
28065         }
28066         {
28067                 s32 q, r;
28068
28069                 q = (s32)dst / (s32)src;
28070                 r = (s32)dst % (s32)src;
28071
28072                 if ((q > 0x7FFF) || (q < -0x8000))
28073                 {
28074                         flag_V = M68K_SR_V;
28075 #ifdef USE_CYCLONE_TIMING_DIV
28076 goto end81F8;
28077 #endif
28078         RET(88)
28079                 }
28080                 q &= 0x0000FFFF;
28081                 flag_NotZ = q;
28082                 flag_N = q >> 8;
28083                 flag_V = flag_C = 0;
28084                 res = q | (r << 16);
28085         DREGu32((Opcode >> 9) & 7) = res;
28086         }
28087 #ifdef USE_CYCLONE_TIMING_DIV
28088 end81F8: m68kcontext.io_cycle_counter -= 50;
28089 #endif
28090 RET(116)
28091 }
28092
28093 // DIVS
28094 OPCODE(0x81F9)
28095 {
28096         u32 adr, res;
28097         u32 src, dst;
28098
28099         FETCH_LONG(adr);
28100         PRE_IO
28101         READSX_WORD_F(adr, src)
28102         if (src == 0)
28103         {
28104                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28105 #ifdef USE_CYCLONE_TIMING_DIV
28106 goto end81F9;
28107 #endif
28108                 RET(22)
28109         }
28110         dst = DREGu32((Opcode >> 9) & 7);
28111         if ((dst == 0x80000000) && (src == (u32)-1))
28112         {
28113                 flag_NotZ = flag_N = 0;
28114                 flag_V = flag_C = 0;
28115                 res = 0;
28116         DREGu32((Opcode >> 9) & 7) = res;
28117 #ifdef USE_CYCLONE_TIMING_DIV
28118 goto end81F9;
28119 #endif
28120         RET(62)
28121         }
28122         {
28123                 s32 q, r;
28124
28125                 q = (s32)dst / (s32)src;
28126                 r = (s32)dst % (s32)src;
28127
28128                 if ((q > 0x7FFF) || (q < -0x8000))
28129                 {
28130                         flag_V = M68K_SR_V;
28131 #ifdef USE_CYCLONE_TIMING_DIV
28132 goto end81F9;
28133 #endif
28134         RET(92)
28135                 }
28136                 q &= 0x0000FFFF;
28137                 flag_NotZ = q;
28138                 flag_N = q >> 8;
28139                 flag_V = flag_C = 0;
28140                 res = q | (r << 16);
28141         DREGu32((Opcode >> 9) & 7) = res;
28142         }
28143 #ifdef USE_CYCLONE_TIMING_DIV
28144 end81F9: m68kcontext.io_cycle_counter -= 50;
28145 #endif
28146 RET(120)
28147 }
28148
28149 // DIVS
28150 OPCODE(0x81FA)
28151 {
28152         u32 adr, res;
28153         u32 src, dst;
28154
28155         adr = GET_SWORD + GET_PC;
28156         PC++;
28157         PRE_IO
28158         READSX_WORD_F(adr, src)
28159         if (src == 0)
28160         {
28161                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28162 #ifdef USE_CYCLONE_TIMING_DIV
28163 goto end81FA;
28164 #endif
28165                 RET(18)
28166         }
28167         dst = DREGu32((Opcode >> 9) & 7);
28168         if ((dst == 0x80000000) && (src == (u32)-1))
28169         {
28170                 flag_NotZ = flag_N = 0;
28171                 flag_V = flag_C = 0;
28172                 res = 0;
28173         DREGu32((Opcode >> 9) & 7) = res;
28174 #ifdef USE_CYCLONE_TIMING_DIV
28175 goto end81FA;
28176 #endif
28177         RET(58)
28178         }
28179         {
28180                 s32 q, r;
28181
28182                 q = (s32)dst / (s32)src;
28183                 r = (s32)dst % (s32)src;
28184
28185                 if ((q > 0x7FFF) || (q < -0x8000))
28186                 {
28187                         flag_V = M68K_SR_V;
28188 #ifdef USE_CYCLONE_TIMING_DIV
28189 goto end81FA;
28190 #endif
28191         RET(88)
28192                 }
28193                 q &= 0x0000FFFF;
28194                 flag_NotZ = q;
28195                 flag_N = q >> 8;
28196                 flag_V = flag_C = 0;
28197                 res = q | (r << 16);
28198         DREGu32((Opcode >> 9) & 7) = res;
28199         }
28200 #ifdef USE_CYCLONE_TIMING_DIV
28201 end81FA: m68kcontext.io_cycle_counter -= 50;
28202 #endif
28203 RET(116)
28204 }
28205
28206 // DIVS
28207 OPCODE(0x81FB)
28208 {
28209         u32 adr, res;
28210         u32 src, dst;
28211
28212         adr = GET_PC;
28213         DECODE_EXT_WORD
28214         PRE_IO
28215         READSX_WORD_F(adr, src)
28216         if (src == 0)
28217         {
28218                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28219 #ifdef USE_CYCLONE_TIMING_DIV
28220 goto end81FB;
28221 #endif
28222                 RET(20)
28223         }
28224         dst = DREGu32((Opcode >> 9) & 7);
28225         if ((dst == 0x80000000) && (src == (u32)-1))
28226         {
28227                 flag_NotZ = flag_N = 0;
28228                 flag_V = flag_C = 0;
28229                 res = 0;
28230         DREGu32((Opcode >> 9) & 7) = res;
28231 #ifdef USE_CYCLONE_TIMING_DIV
28232 goto end81FB;
28233 #endif
28234         RET(60)
28235         }
28236         {
28237                 s32 q, r;
28238
28239                 q = (s32)dst / (s32)src;
28240                 r = (s32)dst % (s32)src;
28241
28242                 if ((q > 0x7FFF) || (q < -0x8000))
28243                 {
28244                         flag_V = M68K_SR_V;
28245 #ifdef USE_CYCLONE_TIMING_DIV
28246 goto end81FB;
28247 #endif
28248         RET(90)
28249                 }
28250                 q &= 0x0000FFFF;
28251                 flag_NotZ = q;
28252                 flag_N = q >> 8;
28253                 flag_V = flag_C = 0;
28254                 res = q | (r << 16);
28255         DREGu32((Opcode >> 9) & 7) = res;
28256         }
28257 #ifdef USE_CYCLONE_TIMING_DIV
28258 end81FB: m68kcontext.io_cycle_counter -= 50;
28259 #endif
28260 RET(118)
28261 }
28262
28263 // DIVS
28264 OPCODE(0x81FC)
28265 {
28266         u32 adr, res;
28267         u32 src, dst;
28268
28269         FETCH_SWORD(src);
28270         if (src == 0)
28271         {
28272                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28273 #ifdef USE_CYCLONE_TIMING_DIV
28274 goto end81FC;
28275 #endif
28276                 RET(14)
28277         }
28278         dst = DREGu32((Opcode >> 9) & 7);
28279         if ((dst == 0x80000000) && (src == (u32)-1))
28280         {
28281                 flag_NotZ = flag_N = 0;
28282                 flag_V = flag_C = 0;
28283                 res = 0;
28284         DREGu32((Opcode >> 9) & 7) = res;
28285 #ifdef USE_CYCLONE_TIMING_DIV
28286 goto end81FC;
28287 #endif
28288         RET(54)
28289         }
28290         {
28291                 s32 q, r;
28292
28293                 q = (s32)dst / (s32)src;
28294                 r = (s32)dst % (s32)src;
28295
28296                 if ((q > 0x7FFF) || (q < -0x8000))
28297                 {
28298                         flag_V = M68K_SR_V;
28299 #ifdef USE_CYCLONE_TIMING_DIV
28300 goto end81FC;
28301 #endif
28302         RET(84)
28303                 }
28304                 q &= 0x0000FFFF;
28305                 flag_NotZ = q;
28306                 flag_N = q >> 8;
28307                 flag_V = flag_C = 0;
28308                 res = q | (r << 16);
28309         DREGu32((Opcode >> 9) & 7) = res;
28310         }
28311 #ifdef USE_CYCLONE_TIMING_DIV
28312 end81FC: m68kcontext.io_cycle_counter -= 50;
28313 #endif
28314 RET(112)
28315 }
28316
28317 // DIVS
28318 OPCODE(0x81DF)
28319 {
28320         u32 adr, res;
28321         u32 src, dst;
28322
28323         adr = AREG(7);
28324         AREG(7) += 2;
28325         PRE_IO
28326         READSX_WORD_F(adr, src)
28327         if (src == 0)
28328         {
28329                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28330 #ifdef USE_CYCLONE_TIMING_DIV
28331 goto end81DF;
28332 #endif
28333                 RET(14)
28334         }
28335         dst = DREGu32((Opcode >> 9) & 7);
28336         if ((dst == 0x80000000) && (src == (u32)-1))
28337         {
28338                 flag_NotZ = flag_N = 0;
28339                 flag_V = flag_C = 0;
28340                 res = 0;
28341         DREGu32((Opcode >> 9) & 7) = res;
28342 #ifdef USE_CYCLONE_TIMING_DIV
28343 goto end81DF;
28344 #endif
28345         RET(54)
28346         }
28347         {
28348                 s32 q, r;
28349
28350                 q = (s32)dst / (s32)src;
28351                 r = (s32)dst % (s32)src;
28352
28353                 if ((q > 0x7FFF) || (q < -0x8000))
28354                 {
28355                         flag_V = M68K_SR_V;
28356 #ifdef USE_CYCLONE_TIMING_DIV
28357 goto end81DF;
28358 #endif
28359         RET(84)
28360                 }
28361                 q &= 0x0000FFFF;
28362                 flag_NotZ = q;
28363                 flag_N = q >> 8;
28364                 flag_V = flag_C = 0;
28365                 res = q | (r << 16);
28366         DREGu32((Opcode >> 9) & 7) = res;
28367         }
28368 #ifdef USE_CYCLONE_TIMING_DIV
28369 end81DF: m68kcontext.io_cycle_counter -= 50;
28370 #endif
28371 RET(112)
28372 }
28373
28374 // DIVS
28375 OPCODE(0x81E7)
28376 {
28377         u32 adr, res;
28378         u32 src, dst;
28379
28380         adr = AREG(7) - 2;
28381         AREG(7) = adr;
28382         PRE_IO
28383         READSX_WORD_F(adr, src)
28384         if (src == 0)
28385         {
28386                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28387 #ifdef USE_CYCLONE_TIMING_DIV
28388 goto end81E7;
28389 #endif
28390                 RET(16)
28391         }
28392         dst = DREGu32((Opcode >> 9) & 7);
28393         if ((dst == 0x80000000) && (src == (u32)-1))
28394         {
28395                 flag_NotZ = flag_N = 0;
28396                 flag_V = flag_C = 0;
28397                 res = 0;
28398         DREGu32((Opcode >> 9) & 7) = res;
28399 #ifdef USE_CYCLONE_TIMING_DIV
28400 goto end81E7;
28401 #endif
28402         RET(56)
28403         }
28404         {
28405                 s32 q, r;
28406
28407                 q = (s32)dst / (s32)src;
28408                 r = (s32)dst % (s32)src;
28409
28410                 if ((q > 0x7FFF) || (q < -0x8000))
28411                 {
28412                         flag_V = M68K_SR_V;
28413 #ifdef USE_CYCLONE_TIMING_DIV
28414 goto end81E7;
28415 #endif
28416         RET(86)
28417                 }
28418                 q &= 0x0000FFFF;
28419                 flag_NotZ = q;
28420                 flag_N = q >> 8;
28421                 flag_V = flag_C = 0;
28422                 res = q | (r << 16);
28423         DREGu32((Opcode >> 9) & 7) = res;
28424         }
28425 #ifdef USE_CYCLONE_TIMING_DIV
28426 end81E7: m68kcontext.io_cycle_counter -= 50;
28427 #endif
28428 RET(114)
28429 }
28430
28431 // SUBaD
28432 OPCODE(0x9000)
28433 {
28434         u32 adr, res;
28435         u32 src, dst;
28436
28437         src = DREGu8((Opcode >> 0) & 7);
28438         dst = DREGu8((Opcode >> 9) & 7);
28439         res = dst - src;
28440         flag_N = flag_X = flag_C = res;
28441         flag_V = (src ^ dst) & (res ^ dst);
28442         flag_NotZ = res & 0xFF;
28443         DREGu8((Opcode >> 9) & 7) = res;
28444 RET(4)
28445 }
28446
28447 // SUBaD
28448 #if 0
28449 OPCODE(0x9008)
28450 {
28451         u32 adr, res;
28452         u32 src, dst;
28453
28454         // can't read byte from Ax registers !
28455         m68kcontext.execinfo |= M68K_FAULTED;
28456         m68kcontext.io_cycle_counter = 0;
28457 /*
28458         goto famec_Exec_End;
28459         dst = DREGu8((Opcode >> 9) & 7);
28460         res = dst - src;
28461         flag_N = flag_X = flag_C = res;
28462         flag_V = (src ^ dst) & (res ^ dst);
28463         flag_NotZ = res & 0xFF;
28464         DREGu8((Opcode >> 9) & 7) = res;
28465 */
28466 RET(4)
28467 }
28468 #endif
28469
28470 // SUBaD
28471 OPCODE(0x9010)
28472 {
28473         u32 adr, res;
28474         u32 src, dst;
28475
28476         adr = AREG((Opcode >> 0) & 7);
28477         PRE_IO
28478         READ_BYTE_F(adr, src)
28479         dst = DREGu8((Opcode >> 9) & 7);
28480         res = dst - src;
28481         flag_N = flag_X = flag_C = res;
28482         flag_V = (src ^ dst) & (res ^ dst);
28483         flag_NotZ = res & 0xFF;
28484         DREGu8((Opcode >> 9) & 7) = res;
28485         POST_IO
28486 RET(8)
28487 }
28488
28489 // SUBaD
28490 OPCODE(0x9018)
28491 {
28492         u32 adr, res;
28493         u32 src, dst;
28494
28495         adr = AREG((Opcode >> 0) & 7);
28496         AREG((Opcode >> 0) & 7) += 1;
28497         PRE_IO
28498         READ_BYTE_F(adr, src)
28499         dst = DREGu8((Opcode >> 9) & 7);
28500         res = dst - src;
28501         flag_N = flag_X = flag_C = res;
28502         flag_V = (src ^ dst) & (res ^ dst);
28503         flag_NotZ = res & 0xFF;
28504         DREGu8((Opcode >> 9) & 7) = res;
28505         POST_IO
28506 RET(8)
28507 }
28508
28509 // SUBaD
28510 OPCODE(0x9020)
28511 {
28512         u32 adr, res;
28513         u32 src, dst;
28514
28515         adr = AREG((Opcode >> 0) & 7) - 1;
28516         AREG((Opcode >> 0) & 7) = adr;
28517         PRE_IO
28518         READ_BYTE_F(adr, src)
28519         dst = DREGu8((Opcode >> 9) & 7);
28520         res = dst - src;
28521         flag_N = flag_X = flag_C = res;
28522         flag_V = (src ^ dst) & (res ^ dst);
28523         flag_NotZ = res & 0xFF;
28524         DREGu8((Opcode >> 9) & 7) = res;
28525         POST_IO
28526 RET(10)
28527 }
28528
28529 // SUBaD
28530 OPCODE(0x9028)
28531 {
28532         u32 adr, res;
28533         u32 src, dst;
28534
28535         FETCH_SWORD(adr);
28536         adr += AREG((Opcode >> 0) & 7);
28537         PRE_IO
28538         READ_BYTE_F(adr, src)
28539         dst = DREGu8((Opcode >> 9) & 7);
28540         res = dst - src;
28541         flag_N = flag_X = flag_C = res;
28542         flag_V = (src ^ dst) & (res ^ dst);
28543         flag_NotZ = res & 0xFF;
28544         DREGu8((Opcode >> 9) & 7) = res;
28545         POST_IO
28546 RET(12)
28547 }
28548
28549 // SUBaD
28550 OPCODE(0x9030)
28551 {
28552         u32 adr, res;
28553         u32 src, dst;
28554
28555         adr = AREG((Opcode >> 0) & 7);
28556         DECODE_EXT_WORD
28557         PRE_IO
28558         READ_BYTE_F(adr, src)
28559         dst = DREGu8((Opcode >> 9) & 7);
28560         res = dst - src;
28561         flag_N = flag_X = flag_C = res;
28562         flag_V = (src ^ dst) & (res ^ dst);
28563         flag_NotZ = res & 0xFF;
28564         DREGu8((Opcode >> 9) & 7) = res;
28565         POST_IO
28566 RET(14)
28567 }
28568
28569 // SUBaD
28570 OPCODE(0x9038)
28571 {
28572         u32 adr, res;
28573         u32 src, dst;
28574
28575         FETCH_SWORD(adr);
28576         PRE_IO
28577         READ_BYTE_F(adr, src)
28578         dst = DREGu8((Opcode >> 9) & 7);
28579         res = dst - src;
28580         flag_N = flag_X = flag_C = res;
28581         flag_V = (src ^ dst) & (res ^ dst);
28582         flag_NotZ = res & 0xFF;
28583         DREGu8((Opcode >> 9) & 7) = res;
28584         POST_IO
28585 RET(12)
28586 }
28587
28588 // SUBaD
28589 OPCODE(0x9039)
28590 {
28591         u32 adr, res;
28592         u32 src, dst;
28593
28594         FETCH_LONG(adr);
28595         PRE_IO
28596         READ_BYTE_F(adr, src)
28597         dst = DREGu8((Opcode >> 9) & 7);
28598         res = dst - src;
28599         flag_N = flag_X = flag_C = res;
28600         flag_V = (src ^ dst) & (res ^ dst);
28601         flag_NotZ = res & 0xFF;
28602         DREGu8((Opcode >> 9) & 7) = res;
28603         POST_IO
28604 RET(16)
28605 }
28606
28607 // SUBaD
28608 OPCODE(0x903A)
28609 {
28610         u32 adr, res;
28611         u32 src, dst;
28612
28613         adr = GET_SWORD + GET_PC;
28614         PC++;
28615         PRE_IO
28616         READ_BYTE_F(adr, src)
28617         dst = DREGu8((Opcode >> 9) & 7);
28618         res = dst - src;
28619         flag_N = flag_X = flag_C = res;
28620         flag_V = (src ^ dst) & (res ^ dst);
28621         flag_NotZ = res & 0xFF;
28622         DREGu8((Opcode >> 9) & 7) = res;
28623         POST_IO
28624 RET(12)
28625 }
28626
28627 // SUBaD
28628 OPCODE(0x903B)
28629 {
28630         u32 adr, res;
28631         u32 src, dst;
28632
28633         adr = GET_PC;
28634         DECODE_EXT_WORD
28635         PRE_IO
28636         READ_BYTE_F(adr, src)
28637         dst = DREGu8((Opcode >> 9) & 7);
28638         res = dst - src;
28639         flag_N = flag_X = flag_C = res;
28640         flag_V = (src ^ dst) & (res ^ dst);
28641         flag_NotZ = res & 0xFF;
28642         DREGu8((Opcode >> 9) & 7) = res;
28643         POST_IO
28644 RET(14)
28645 }
28646
28647 // SUBaD
28648 OPCODE(0x903C)
28649 {
28650         u32 adr, res;
28651         u32 src, dst;
28652
28653         FETCH_BYTE(src);
28654         dst = DREGu8((Opcode >> 9) & 7);
28655         res = dst - src;
28656         flag_N = flag_X = flag_C = res;
28657         flag_V = (src ^ dst) & (res ^ dst);
28658         flag_NotZ = res & 0xFF;
28659         DREGu8((Opcode >> 9) & 7) = res;
28660 RET(8)
28661 }
28662
28663 // SUBaD
28664 OPCODE(0x901F)
28665 {
28666         u32 adr, res;
28667         u32 src, dst;
28668
28669         adr = AREG(7);
28670         AREG(7) += 2;
28671         PRE_IO
28672         READ_BYTE_F(adr, src)
28673         dst = DREGu8((Opcode >> 9) & 7);
28674         res = dst - src;
28675         flag_N = flag_X = flag_C = res;
28676         flag_V = (src ^ dst) & (res ^ dst);
28677         flag_NotZ = res & 0xFF;
28678         DREGu8((Opcode >> 9) & 7) = res;
28679         POST_IO
28680 RET(8)
28681 }
28682
28683 // SUBaD
28684 OPCODE(0x9027)
28685 {
28686         u32 adr, res;
28687         u32 src, dst;
28688
28689         adr = AREG(7) - 2;
28690         AREG(7) = adr;
28691         PRE_IO
28692         READ_BYTE_F(adr, src)
28693         dst = DREGu8((Opcode >> 9) & 7);
28694         res = dst - src;
28695         flag_N = flag_X = flag_C = res;
28696         flag_V = (src ^ dst) & (res ^ dst);
28697         flag_NotZ = res & 0xFF;
28698         DREGu8((Opcode >> 9) & 7) = res;
28699         POST_IO
28700 RET(10)
28701 }
28702
28703 // SUBaD
28704 OPCODE(0x9040)
28705 {
28706         u32 adr, res;
28707         u32 src, dst;
28708
28709         src = DREGu16((Opcode >> 0) & 7);
28710         dst = DREGu16((Opcode >> 9) & 7);
28711         res = dst - src;
28712         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28713         flag_N = flag_X = flag_C = res >> 8;
28714         flag_NotZ = res & 0xFFFF;
28715         DREGu16((Opcode >> 9) & 7) = res;
28716 RET(4)
28717 }
28718
28719 // SUBaD
28720 OPCODE(0x9048)
28721 {
28722         u32 adr, res;
28723         u32 src, dst;
28724
28725         src = AREGu16((Opcode >> 0) & 7);
28726         dst = DREGu16((Opcode >> 9) & 7);
28727         res = dst - src;
28728         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28729         flag_N = flag_X = flag_C = res >> 8;
28730         flag_NotZ = res & 0xFFFF;
28731         DREGu16((Opcode >> 9) & 7) = res;
28732 RET(4)
28733 }
28734
28735 // SUBaD
28736 OPCODE(0x9050)
28737 {
28738         u32 adr, res;
28739         u32 src, dst;
28740
28741         adr = AREG((Opcode >> 0) & 7);
28742         PRE_IO
28743         READ_WORD_F(adr, src)
28744         dst = DREGu16((Opcode >> 9) & 7);
28745         res = dst - src;
28746         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28747         flag_N = flag_X = flag_C = res >> 8;
28748         flag_NotZ = res & 0xFFFF;
28749         DREGu16((Opcode >> 9) & 7) = res;
28750         POST_IO
28751 RET(8)
28752 }
28753
28754 // SUBaD
28755 OPCODE(0x9058)
28756 {
28757         u32 adr, res;
28758         u32 src, dst;
28759
28760         adr = AREG((Opcode >> 0) & 7);
28761         AREG((Opcode >> 0) & 7) += 2;
28762         PRE_IO
28763         READ_WORD_F(adr, src)
28764         dst = DREGu16((Opcode >> 9) & 7);
28765         res = dst - src;
28766         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28767         flag_N = flag_X = flag_C = res >> 8;
28768         flag_NotZ = res & 0xFFFF;
28769         DREGu16((Opcode >> 9) & 7) = res;
28770         POST_IO
28771 RET(8)
28772 }
28773
28774 // SUBaD
28775 OPCODE(0x9060)
28776 {
28777         u32 adr, res;
28778         u32 src, dst;
28779
28780         adr = AREG((Opcode >> 0) & 7) - 2;
28781         AREG((Opcode >> 0) & 7) = adr;
28782         PRE_IO
28783         READ_WORD_F(adr, src)
28784         dst = DREGu16((Opcode >> 9) & 7);
28785         res = dst - src;
28786         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28787         flag_N = flag_X = flag_C = res >> 8;
28788         flag_NotZ = res & 0xFFFF;
28789         DREGu16((Opcode >> 9) & 7) = res;
28790         POST_IO
28791 RET(10)
28792 }
28793
28794 // SUBaD
28795 OPCODE(0x9068)
28796 {
28797         u32 adr, res;
28798         u32 src, dst;
28799
28800         FETCH_SWORD(adr);
28801         adr += AREG((Opcode >> 0) & 7);
28802         PRE_IO
28803         READ_WORD_F(adr, src)
28804         dst = DREGu16((Opcode >> 9) & 7);
28805         res = dst - src;
28806         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28807         flag_N = flag_X = flag_C = res >> 8;
28808         flag_NotZ = res & 0xFFFF;
28809         DREGu16((Opcode >> 9) & 7) = res;
28810         POST_IO
28811 RET(12)
28812 }
28813
28814 // SUBaD
28815 OPCODE(0x9070)
28816 {
28817         u32 adr, res;
28818         u32 src, dst;
28819
28820         adr = AREG((Opcode >> 0) & 7);
28821         DECODE_EXT_WORD
28822         PRE_IO
28823         READ_WORD_F(adr, src)
28824         dst = DREGu16((Opcode >> 9) & 7);
28825         res = dst - src;
28826         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28827         flag_N = flag_X = flag_C = res >> 8;
28828         flag_NotZ = res & 0xFFFF;
28829         DREGu16((Opcode >> 9) & 7) = res;
28830         POST_IO
28831 RET(14)
28832 }
28833
28834 // SUBaD
28835 OPCODE(0x9078)
28836 {
28837         u32 adr, res;
28838         u32 src, dst;
28839
28840         FETCH_SWORD(adr);
28841         PRE_IO
28842         READ_WORD_F(adr, src)
28843         dst = DREGu16((Opcode >> 9) & 7);
28844         res = dst - src;
28845         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28846         flag_N = flag_X = flag_C = res >> 8;
28847         flag_NotZ = res & 0xFFFF;
28848         DREGu16((Opcode >> 9) & 7) = res;
28849         POST_IO
28850 RET(12)
28851 }
28852
28853 // SUBaD
28854 OPCODE(0x9079)
28855 {
28856         u32 adr, res;
28857         u32 src, dst;
28858
28859         FETCH_LONG(adr);
28860         PRE_IO
28861         READ_WORD_F(adr, src)
28862         dst = DREGu16((Opcode >> 9) & 7);
28863         res = dst - src;
28864         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28865         flag_N = flag_X = flag_C = res >> 8;
28866         flag_NotZ = res & 0xFFFF;
28867         DREGu16((Opcode >> 9) & 7) = res;
28868         POST_IO
28869 RET(16)
28870 }
28871
28872 // SUBaD
28873 OPCODE(0x907A)
28874 {
28875         u32 adr, res;
28876         u32 src, dst;
28877
28878         adr = GET_SWORD + GET_PC;
28879         PC++;
28880         PRE_IO
28881         READ_WORD_F(adr, src)
28882         dst = DREGu16((Opcode >> 9) & 7);
28883         res = dst - src;
28884         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28885         flag_N = flag_X = flag_C = res >> 8;
28886         flag_NotZ = res & 0xFFFF;
28887         DREGu16((Opcode >> 9) & 7) = res;
28888         POST_IO
28889 RET(12)
28890 }
28891
28892 // SUBaD
28893 OPCODE(0x907B)
28894 {
28895         u32 adr, res;
28896         u32 src, dst;
28897
28898         adr = GET_PC;
28899         DECODE_EXT_WORD
28900         PRE_IO
28901         READ_WORD_F(adr, src)
28902         dst = DREGu16((Opcode >> 9) & 7);
28903         res = dst - src;
28904         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28905         flag_N = flag_X = flag_C = res >> 8;
28906         flag_NotZ = res & 0xFFFF;
28907         DREGu16((Opcode >> 9) & 7) = res;
28908         POST_IO
28909 RET(14)
28910 }
28911
28912 // SUBaD
28913 OPCODE(0x907C)
28914 {
28915         u32 adr, res;
28916         u32 src, dst;
28917
28918         FETCH_WORD(src);
28919         dst = DREGu16((Opcode >> 9) & 7);
28920         res = dst - src;
28921         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28922         flag_N = flag_X = flag_C = res >> 8;
28923         flag_NotZ = res & 0xFFFF;
28924         DREGu16((Opcode >> 9) & 7) = res;
28925 RET(8)
28926 }
28927
28928 // SUBaD
28929 OPCODE(0x905F)
28930 {
28931         u32 adr, res;
28932         u32 src, dst;
28933
28934         adr = AREG(7);
28935         AREG(7) += 2;
28936         PRE_IO
28937         READ_WORD_F(adr, src)
28938         dst = DREGu16((Opcode >> 9) & 7);
28939         res = dst - src;
28940         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28941         flag_N = flag_X = flag_C = res >> 8;
28942         flag_NotZ = res & 0xFFFF;
28943         DREGu16((Opcode >> 9) & 7) = res;
28944         POST_IO
28945 RET(8)
28946 }
28947
28948 // SUBaD
28949 OPCODE(0x9067)
28950 {
28951         u32 adr, res;
28952         u32 src, dst;
28953
28954         adr = AREG(7) - 2;
28955         AREG(7) = adr;
28956         PRE_IO
28957         READ_WORD_F(adr, src)
28958         dst = DREGu16((Opcode >> 9) & 7);
28959         res = dst - src;
28960         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28961         flag_N = flag_X = flag_C = res >> 8;
28962         flag_NotZ = res & 0xFFFF;
28963         DREGu16((Opcode >> 9) & 7) = res;
28964         POST_IO
28965 RET(10)
28966 }
28967
28968 // SUBaD
28969 OPCODE(0x9080)
28970 {
28971         u32 adr, res;
28972         u32 src, dst;
28973
28974         src = DREGu32((Opcode >> 0) & 7);
28975         dst = DREGu32((Opcode >> 9) & 7);
28976         res = dst - src;
28977         flag_NotZ = res;
28978         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
28979         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
28980         flag_N = res >> 24;
28981         DREGu32((Opcode >> 9) & 7) = res;
28982 RET(8)
28983 }
28984
28985 // SUBaD
28986 OPCODE(0x9088)
28987 {
28988         u32 adr, res;
28989         u32 src, dst;
28990
28991         src = AREGu32((Opcode >> 0) & 7);
28992         dst = DREGu32((Opcode >> 9) & 7);
28993         res = dst - src;
28994         flag_NotZ = res;
28995         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
28996         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
28997         flag_N = res >> 24;
28998         DREGu32((Opcode >> 9) & 7) = res;
28999 RET(8)
29000 }
29001
29002 // SUBaD
29003 OPCODE(0x9090)
29004 {
29005         u32 adr, res;
29006         u32 src, dst;
29007
29008         adr = AREG((Opcode >> 0) & 7);
29009         PRE_IO
29010         READ_LONG_F(adr, src)
29011         dst = DREGu32((Opcode >> 9) & 7);
29012         res = dst - src;
29013         flag_NotZ = res;
29014         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29015         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29016         flag_N = res >> 24;
29017         DREGu32((Opcode >> 9) & 7) = res;
29018         POST_IO
29019 RET(14)
29020 }
29021
29022 // SUBaD
29023 OPCODE(0x9098)
29024 {
29025         u32 adr, res;
29026         u32 src, dst;
29027
29028         adr = AREG((Opcode >> 0) & 7);
29029         AREG((Opcode >> 0) & 7) += 4;
29030         PRE_IO
29031         READ_LONG_F(adr, src)
29032         dst = DREGu32((Opcode >> 9) & 7);
29033         res = dst - src;
29034         flag_NotZ = res;
29035         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29036         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29037         flag_N = res >> 24;
29038         DREGu32((Opcode >> 9) & 7) = res;
29039         POST_IO
29040 RET(14)
29041 }
29042
29043 // SUBaD
29044 OPCODE(0x90A0)
29045 {
29046         u32 adr, res;
29047         u32 src, dst;
29048
29049         adr = AREG((Opcode >> 0) & 7) - 4;
29050         AREG((Opcode >> 0) & 7) = adr;
29051         PRE_IO
29052         READ_LONG_F(adr, src)
29053         dst = DREGu32((Opcode >> 9) & 7);
29054         res = dst - src;
29055         flag_NotZ = res;
29056         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29057         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29058         flag_N = res >> 24;
29059         DREGu32((Opcode >> 9) & 7) = res;
29060         POST_IO
29061 RET(16)
29062 }
29063
29064 // SUBaD
29065 OPCODE(0x90A8)
29066 {
29067         u32 adr, res;
29068         u32 src, dst;
29069
29070         FETCH_SWORD(adr);
29071         adr += AREG((Opcode >> 0) & 7);
29072         PRE_IO
29073         READ_LONG_F(adr, src)
29074         dst = DREGu32((Opcode >> 9) & 7);
29075         res = dst - src;
29076         flag_NotZ = res;
29077         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29078         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29079         flag_N = res >> 24;
29080         DREGu32((Opcode >> 9) & 7) = res;
29081         POST_IO
29082 RET(18)
29083 }
29084
29085 // SUBaD
29086 OPCODE(0x90B0)
29087 {
29088         u32 adr, res;
29089         u32 src, dst;
29090
29091         adr = AREG((Opcode >> 0) & 7);
29092         DECODE_EXT_WORD
29093         PRE_IO
29094         READ_LONG_F(adr, src)
29095         dst = DREGu32((Opcode >> 9) & 7);
29096         res = dst - src;
29097         flag_NotZ = res;
29098         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29099         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29100         flag_N = res >> 24;
29101         DREGu32((Opcode >> 9) & 7) = res;
29102         POST_IO
29103 RET(20)
29104 }
29105
29106 // SUBaD
29107 OPCODE(0x90B8)
29108 {
29109         u32 adr, res;
29110         u32 src, dst;
29111
29112         FETCH_SWORD(adr);
29113         PRE_IO
29114         READ_LONG_F(adr, src)
29115         dst = DREGu32((Opcode >> 9) & 7);
29116         res = dst - src;
29117         flag_NotZ = res;
29118         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29119         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29120         flag_N = res >> 24;
29121         DREGu32((Opcode >> 9) & 7) = res;
29122         POST_IO
29123 RET(18)
29124 }
29125
29126 // SUBaD
29127 OPCODE(0x90B9)
29128 {
29129         u32 adr, res;
29130         u32 src, dst;
29131
29132         FETCH_LONG(adr);
29133         PRE_IO
29134         READ_LONG_F(adr, src)
29135         dst = DREGu32((Opcode >> 9) & 7);
29136         res = dst - src;
29137         flag_NotZ = res;
29138         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29139         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29140         flag_N = res >> 24;
29141         DREGu32((Opcode >> 9) & 7) = res;
29142         POST_IO
29143 RET(22)
29144 }
29145
29146 // SUBaD
29147 OPCODE(0x90BA)
29148 {
29149         u32 adr, res;
29150         u32 src, dst;
29151
29152         adr = GET_SWORD + GET_PC;
29153         PC++;
29154         PRE_IO
29155         READ_LONG_F(adr, src)
29156         dst = DREGu32((Opcode >> 9) & 7);
29157         res = dst - src;
29158         flag_NotZ = res;
29159         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29160         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29161         flag_N = res >> 24;
29162         DREGu32((Opcode >> 9) & 7) = res;
29163         POST_IO
29164 RET(18)
29165 }
29166
29167 // SUBaD
29168 OPCODE(0x90BB)
29169 {
29170         u32 adr, res;
29171         u32 src, dst;
29172
29173         adr = GET_PC;
29174         DECODE_EXT_WORD
29175         PRE_IO
29176         READ_LONG_F(adr, src)
29177         dst = DREGu32((Opcode >> 9) & 7);
29178         res = dst - src;
29179         flag_NotZ = res;
29180         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29181         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29182         flag_N = res >> 24;
29183         DREGu32((Opcode >> 9) & 7) = res;
29184         POST_IO
29185 RET(20)
29186 }
29187
29188 // SUBaD
29189 OPCODE(0x90BC)
29190 {
29191         u32 adr, res;
29192         u32 src, dst;
29193
29194         FETCH_LONG(src);
29195         dst = DREGu32((Opcode >> 9) & 7);
29196         res = dst - src;
29197         flag_NotZ = res;
29198         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29199         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29200         flag_N = res >> 24;
29201         DREGu32((Opcode >> 9) & 7) = res;
29202 RET(16)
29203 }
29204
29205 // SUBaD
29206 OPCODE(0x909F)
29207 {
29208         u32 adr, res;
29209         u32 src, dst;
29210
29211         adr = AREG(7);
29212         AREG(7) += 4;
29213         PRE_IO
29214         READ_LONG_F(adr, src)
29215         dst = DREGu32((Opcode >> 9) & 7);
29216         res = dst - src;
29217         flag_NotZ = res;
29218         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29219         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29220         flag_N = res >> 24;
29221         DREGu32((Opcode >> 9) & 7) = res;
29222         POST_IO
29223 RET(14)
29224 }
29225
29226 // SUBaD
29227 OPCODE(0x90A7)
29228 {
29229         u32 adr, res;
29230         u32 src, dst;
29231
29232         adr = AREG(7) - 4;
29233         AREG(7) = adr;
29234         PRE_IO
29235         READ_LONG_F(adr, src)
29236         dst = DREGu32((Opcode >> 9) & 7);
29237         res = dst - src;
29238         flag_NotZ = res;
29239         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29240         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29241         flag_N = res >> 24;
29242         DREGu32((Opcode >> 9) & 7) = res;
29243         POST_IO
29244 RET(16)
29245 }
29246
29247 // SUBDa
29248 OPCODE(0x9110)
29249 {
29250         u32 adr, res;
29251         u32 src, dst;
29252
29253         src = DREGu8((Opcode >> 9) & 7);
29254         adr = AREG((Opcode >> 0) & 7);
29255         PRE_IO
29256         READ_BYTE_F(adr, dst)
29257         res = dst - src;
29258         flag_N = flag_X = flag_C = res;
29259         flag_V = (src ^ dst) & (res ^ dst);
29260         flag_NotZ = res & 0xFF;
29261         WRITE_BYTE_F(adr, res)
29262         POST_IO
29263 RET(12)
29264 }
29265
29266 // SUBDa
29267 OPCODE(0x9118)
29268 {
29269         u32 adr, res;
29270         u32 src, dst;
29271
29272         src = DREGu8((Opcode >> 9) & 7);
29273         adr = AREG((Opcode >> 0) & 7);
29274         AREG((Opcode >> 0) & 7) += 1;
29275         PRE_IO
29276         READ_BYTE_F(adr, dst)
29277         res = dst - src;
29278         flag_N = flag_X = flag_C = res;
29279         flag_V = (src ^ dst) & (res ^ dst);
29280         flag_NotZ = res & 0xFF;
29281         WRITE_BYTE_F(adr, res)
29282         POST_IO
29283 RET(12)
29284 }
29285
29286 // SUBDa
29287 OPCODE(0x9120)
29288 {
29289         u32 adr, res;
29290         u32 src, dst;
29291
29292         src = DREGu8((Opcode >> 9) & 7);
29293         adr = AREG((Opcode >> 0) & 7) - 1;
29294         AREG((Opcode >> 0) & 7) = adr;
29295         PRE_IO
29296         READ_BYTE_F(adr, dst)
29297         res = dst - src;
29298         flag_N = flag_X = flag_C = res;
29299         flag_V = (src ^ dst) & (res ^ dst);
29300         flag_NotZ = res & 0xFF;
29301         WRITE_BYTE_F(adr, res)
29302         POST_IO
29303 RET(14)
29304 }
29305
29306 // SUBDa
29307 OPCODE(0x9128)
29308 {
29309         u32 adr, res;
29310         u32 src, dst;
29311
29312         src = DREGu8((Opcode >> 9) & 7);
29313         FETCH_SWORD(adr);
29314         adr += AREG((Opcode >> 0) & 7);
29315         PRE_IO
29316         READ_BYTE_F(adr, dst)
29317         res = dst - src;
29318         flag_N = flag_X = flag_C = res;
29319         flag_V = (src ^ dst) & (res ^ dst);
29320         flag_NotZ = res & 0xFF;
29321         WRITE_BYTE_F(adr, res)
29322         POST_IO
29323 RET(16)
29324 }
29325
29326 // SUBDa
29327 OPCODE(0x9130)
29328 {
29329         u32 adr, res;
29330         u32 src, dst;
29331
29332         src = DREGu8((Opcode >> 9) & 7);
29333         adr = AREG((Opcode >> 0) & 7);
29334         DECODE_EXT_WORD
29335         PRE_IO
29336         READ_BYTE_F(adr, dst)
29337         res = dst - src;
29338         flag_N = flag_X = flag_C = res;
29339         flag_V = (src ^ dst) & (res ^ dst);
29340         flag_NotZ = res & 0xFF;
29341         WRITE_BYTE_F(adr, res)
29342         POST_IO
29343 RET(18)
29344 }
29345
29346 // SUBDa
29347 OPCODE(0x9138)
29348 {
29349         u32 adr, res;
29350         u32 src, dst;
29351
29352         src = DREGu8((Opcode >> 9) & 7);
29353         FETCH_SWORD(adr);
29354         PRE_IO
29355         READ_BYTE_F(adr, dst)
29356         res = dst - src;
29357         flag_N = flag_X = flag_C = res;
29358         flag_V = (src ^ dst) & (res ^ dst);
29359         flag_NotZ = res & 0xFF;
29360         WRITE_BYTE_F(adr, res)
29361         POST_IO
29362 RET(16)
29363 }
29364
29365 // SUBDa
29366 OPCODE(0x9139)
29367 {
29368         u32 adr, res;
29369         u32 src, dst;
29370
29371         src = DREGu8((Opcode >> 9) & 7);
29372         FETCH_LONG(adr);
29373         PRE_IO
29374         READ_BYTE_F(adr, dst)
29375         res = dst - src;
29376         flag_N = flag_X = flag_C = res;
29377         flag_V = (src ^ dst) & (res ^ dst);
29378         flag_NotZ = res & 0xFF;
29379         WRITE_BYTE_F(adr, res)
29380         POST_IO
29381 RET(20)
29382 }
29383
29384 // SUBDa
29385 OPCODE(0x911F)
29386 {
29387         u32 adr, res;
29388         u32 src, dst;
29389
29390         src = DREGu8((Opcode >> 9) & 7);
29391         adr = AREG(7);
29392         AREG(7) += 2;
29393         PRE_IO
29394         READ_BYTE_F(adr, dst)
29395         res = dst - src;
29396         flag_N = flag_X = flag_C = res;
29397         flag_V = (src ^ dst) & (res ^ dst);
29398         flag_NotZ = res & 0xFF;
29399         WRITE_BYTE_F(adr, res)
29400         POST_IO
29401 RET(12)
29402 }
29403
29404 // SUBDa
29405 OPCODE(0x9127)
29406 {
29407         u32 adr, res;
29408         u32 src, dst;
29409
29410         src = DREGu8((Opcode >> 9) & 7);
29411         adr = AREG(7) - 2;
29412         AREG(7) = adr;
29413         PRE_IO
29414         READ_BYTE_F(adr, dst)
29415         res = dst - src;
29416         flag_N = flag_X = flag_C = res;
29417         flag_V = (src ^ dst) & (res ^ dst);
29418         flag_NotZ = res & 0xFF;
29419         WRITE_BYTE_F(adr, res)
29420         POST_IO
29421 RET(14)
29422 }
29423
29424 // SUBDa
29425 OPCODE(0x9150)
29426 {
29427         u32 adr, res;
29428         u32 src, dst;
29429
29430         src = DREGu16((Opcode >> 9) & 7);
29431         adr = AREG((Opcode >> 0) & 7);
29432         PRE_IO
29433         READ_WORD_F(adr, dst)
29434         res = dst - src;
29435         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29436         flag_N = flag_X = flag_C = res >> 8;
29437         flag_NotZ = res & 0xFFFF;
29438         WRITE_WORD_F(adr, res)
29439         POST_IO
29440 RET(12)
29441 }
29442
29443 // SUBDa
29444 OPCODE(0x9158)
29445 {
29446         u32 adr, res;
29447         u32 src, dst;
29448
29449         src = DREGu16((Opcode >> 9) & 7);
29450         adr = AREG((Opcode >> 0) & 7);
29451         AREG((Opcode >> 0) & 7) += 2;
29452         PRE_IO
29453         READ_WORD_F(adr, dst)
29454         res = dst - src;
29455         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29456         flag_N = flag_X = flag_C = res >> 8;
29457         flag_NotZ = res & 0xFFFF;
29458         WRITE_WORD_F(adr, res)
29459         POST_IO
29460 RET(12)
29461 }
29462
29463 // SUBDa
29464 OPCODE(0x9160)
29465 {
29466         u32 adr, res;
29467         u32 src, dst;
29468
29469         src = DREGu16((Opcode >> 9) & 7);
29470         adr = AREG((Opcode >> 0) & 7) - 2;
29471         AREG((Opcode >> 0) & 7) = adr;
29472         PRE_IO
29473         READ_WORD_F(adr, dst)
29474         res = dst - src;
29475         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29476         flag_N = flag_X = flag_C = res >> 8;
29477         flag_NotZ = res & 0xFFFF;
29478         WRITE_WORD_F(adr, res)
29479         POST_IO
29480 RET(14)
29481 }
29482
29483 // SUBDa
29484 OPCODE(0x9168)
29485 {
29486         u32 adr, res;
29487         u32 src, dst;
29488
29489         src = DREGu16((Opcode >> 9) & 7);
29490         FETCH_SWORD(adr);
29491         adr += AREG((Opcode >> 0) & 7);
29492         PRE_IO
29493         READ_WORD_F(adr, dst)
29494         res = dst - src;
29495         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29496         flag_N = flag_X = flag_C = res >> 8;
29497         flag_NotZ = res & 0xFFFF;
29498         WRITE_WORD_F(adr, res)
29499         POST_IO
29500 RET(16)
29501 }
29502
29503 // SUBDa
29504 OPCODE(0x9170)
29505 {
29506         u32 adr, res;
29507         u32 src, dst;
29508
29509         src = DREGu16((Opcode >> 9) & 7);
29510         adr = AREG((Opcode >> 0) & 7);
29511         DECODE_EXT_WORD
29512         PRE_IO
29513         READ_WORD_F(adr, dst)
29514         res = dst - src;
29515         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29516         flag_N = flag_X = flag_C = res >> 8;
29517         flag_NotZ = res & 0xFFFF;
29518         WRITE_WORD_F(adr, res)
29519         POST_IO
29520 RET(18)
29521 }
29522
29523 // SUBDa
29524 OPCODE(0x9178)
29525 {
29526         u32 adr, res;
29527         u32 src, dst;
29528
29529         src = DREGu16((Opcode >> 9) & 7);
29530         FETCH_SWORD(adr);
29531         PRE_IO
29532         READ_WORD_F(adr, dst)
29533         res = dst - src;
29534         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29535         flag_N = flag_X = flag_C = res >> 8;
29536         flag_NotZ = res & 0xFFFF;
29537         WRITE_WORD_F(adr, res)
29538         POST_IO
29539 RET(16)
29540 }
29541
29542 // SUBDa
29543 OPCODE(0x9179)
29544 {
29545         u32 adr, res;
29546         u32 src, dst;
29547
29548         src = DREGu16((Opcode >> 9) & 7);
29549         FETCH_LONG(adr);
29550         PRE_IO
29551         READ_WORD_F(adr, dst)
29552         res = dst - src;
29553         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29554         flag_N = flag_X = flag_C = res >> 8;
29555         flag_NotZ = res & 0xFFFF;
29556         WRITE_WORD_F(adr, res)
29557         POST_IO
29558 RET(20)
29559 }
29560
29561 // SUBDa
29562 OPCODE(0x915F)
29563 {
29564         u32 adr, res;
29565         u32 src, dst;
29566
29567         src = DREGu16((Opcode >> 9) & 7);
29568         adr = AREG(7);
29569         AREG(7) += 2;
29570         PRE_IO
29571         READ_WORD_F(adr, dst)
29572         res = dst - src;
29573         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29574         flag_N = flag_X = flag_C = res >> 8;
29575         flag_NotZ = res & 0xFFFF;
29576         WRITE_WORD_F(adr, res)
29577         POST_IO
29578 RET(12)
29579 }
29580
29581 // SUBDa
29582 OPCODE(0x9167)
29583 {
29584         u32 adr, res;
29585         u32 src, dst;
29586
29587         src = DREGu16((Opcode >> 9) & 7);
29588         adr = AREG(7) - 2;
29589         AREG(7) = adr;
29590         PRE_IO
29591         READ_WORD_F(adr, dst)
29592         res = dst - src;
29593         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29594         flag_N = flag_X = flag_C = res >> 8;
29595         flag_NotZ = res & 0xFFFF;
29596         WRITE_WORD_F(adr, res)
29597         POST_IO
29598 RET(14)
29599 }
29600
29601 // SUBDa
29602 OPCODE(0x9190)
29603 {
29604         u32 adr, res;
29605         u32 src, dst;
29606
29607         src = DREGu32((Opcode >> 9) & 7);
29608         adr = AREG((Opcode >> 0) & 7);
29609         PRE_IO
29610         READ_LONG_F(adr, dst)
29611         res = dst - src;
29612         flag_NotZ = res;
29613         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29614         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29615         flag_N = res >> 24;
29616         WRITE_LONG_F(adr, res)
29617         POST_IO
29618 RET(20)
29619 }
29620
29621 // SUBDa
29622 OPCODE(0x9198)
29623 {
29624         u32 adr, res;
29625         u32 src, dst;
29626
29627         src = DREGu32((Opcode >> 9) & 7);
29628         adr = AREG((Opcode >> 0) & 7);
29629         AREG((Opcode >> 0) & 7) += 4;
29630         PRE_IO
29631         READ_LONG_F(adr, dst)
29632         res = dst - src;
29633         flag_NotZ = res;
29634         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29635         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29636         flag_N = res >> 24;
29637         WRITE_LONG_F(adr, res)
29638         POST_IO
29639 RET(20)
29640 }
29641
29642 // SUBDa
29643 OPCODE(0x91A0)
29644 {
29645         u32 adr, res;
29646         u32 src, dst;
29647
29648         src = DREGu32((Opcode >> 9) & 7);
29649         adr = AREG((Opcode >> 0) & 7) - 4;
29650         AREG((Opcode >> 0) & 7) = adr;
29651         PRE_IO
29652         READ_LONG_F(adr, dst)
29653         res = dst - src;
29654         flag_NotZ = res;
29655         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29656         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29657         flag_N = res >> 24;
29658         WRITE_LONG_F(adr, res)
29659         POST_IO
29660 RET(22)
29661 }
29662
29663 // SUBDa
29664 OPCODE(0x91A8)
29665 {
29666         u32 adr, res;
29667         u32 src, dst;
29668
29669         src = DREGu32((Opcode >> 9) & 7);
29670         FETCH_SWORD(adr);
29671         adr += AREG((Opcode >> 0) & 7);
29672         PRE_IO
29673         READ_LONG_F(adr, dst)
29674         res = dst - src;
29675         flag_NotZ = res;
29676         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29677         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29678         flag_N = res >> 24;
29679         WRITE_LONG_F(adr, res)
29680         POST_IO
29681 RET(24)
29682 }
29683
29684 // SUBDa
29685 OPCODE(0x91B0)
29686 {
29687         u32 adr, res;
29688         u32 src, dst;
29689
29690         src = DREGu32((Opcode >> 9) & 7);
29691         adr = AREG((Opcode >> 0) & 7);
29692         DECODE_EXT_WORD
29693         PRE_IO
29694         READ_LONG_F(adr, dst)
29695         res = dst - src;
29696         flag_NotZ = res;
29697         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29698         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29699         flag_N = res >> 24;
29700         WRITE_LONG_F(adr, res)
29701         POST_IO
29702 RET(26)
29703 }
29704
29705 // SUBDa
29706 OPCODE(0x91B8)
29707 {
29708         u32 adr, res;
29709         u32 src, dst;
29710
29711         src = DREGu32((Opcode >> 9) & 7);
29712         FETCH_SWORD(adr);
29713         PRE_IO
29714         READ_LONG_F(adr, dst)
29715         res = dst - src;
29716         flag_NotZ = res;
29717         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29718         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29719         flag_N = res >> 24;
29720         WRITE_LONG_F(adr, res)
29721         POST_IO
29722 RET(24)
29723 }
29724
29725 // SUBDa
29726 OPCODE(0x91B9)
29727 {
29728         u32 adr, res;
29729         u32 src, dst;
29730
29731         src = DREGu32((Opcode >> 9) & 7);
29732         FETCH_LONG(adr);
29733         PRE_IO
29734         READ_LONG_F(adr, dst)
29735         res = dst - src;
29736         flag_NotZ = res;
29737         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29738         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29739         flag_N = res >> 24;
29740         WRITE_LONG_F(adr, res)
29741         POST_IO
29742 RET(28)
29743 }
29744
29745 // SUBDa
29746 OPCODE(0x919F)
29747 {
29748         u32 adr, res;
29749         u32 src, dst;
29750
29751         src = DREGu32((Opcode >> 9) & 7);
29752         adr = AREG(7);
29753         AREG(7) += 4;
29754         PRE_IO
29755         READ_LONG_F(adr, dst)
29756         res = dst - src;
29757         flag_NotZ = res;
29758         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29759         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29760         flag_N = res >> 24;
29761         WRITE_LONG_F(adr, res)
29762         POST_IO
29763 RET(20)
29764 }
29765
29766 // SUBDa
29767 OPCODE(0x91A7)
29768 {
29769         u32 adr, res;
29770         u32 src, dst;
29771
29772         src = DREGu32((Opcode >> 9) & 7);
29773         adr = AREG(7) - 4;
29774         AREG(7) = adr;
29775         PRE_IO
29776         READ_LONG_F(adr, dst)
29777         res = dst - src;
29778         flag_NotZ = res;
29779         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29780         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29781         flag_N = res >> 24;
29782         WRITE_LONG_F(adr, res)
29783         POST_IO
29784 RET(22)
29785 }
29786
29787 // SUBX
29788 OPCODE(0x9100)
29789 {
29790         u32 adr, res;
29791         u32 src, dst;
29792
29793         src = DREGu8((Opcode >> 0) & 7);
29794         dst = DREGu8((Opcode >> 9) & 7);
29795         res = dst - src - ((flag_X >> 8) & 1);
29796         flag_N = flag_X = flag_C = res;
29797         flag_V = (src ^ dst) & (res ^ dst);
29798         flag_NotZ |= res & 0xFF;
29799         DREGu8((Opcode >> 9) & 7) = res;
29800 RET(4)
29801 }
29802
29803 // SUBX
29804 OPCODE(0x9140)
29805 {
29806         u32 adr, res;
29807         u32 src, dst;
29808
29809         src = DREGu16((Opcode >> 0) & 7);
29810         dst = DREGu16((Opcode >> 9) & 7);
29811         res = dst - src - ((flag_X >> 8) & 1);
29812         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29813         flag_N = flag_X = flag_C = res >> 8;
29814         flag_NotZ |= res & 0xFFFF;
29815         DREGu16((Opcode >> 9) & 7) = res;
29816 RET(4)
29817 }
29818
29819 // SUBX
29820 OPCODE(0x9180)
29821 {
29822         u32 adr, res;
29823         u32 src, dst;
29824
29825         src = DREGu32((Opcode >> 0) & 7);
29826         dst = DREGu32((Opcode >> 9) & 7);
29827         res = dst - src - ((flag_X >> 8) & 1);
29828         flag_NotZ |= res;
29829         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29830         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29831         flag_N = res >> 24;
29832         DREGu32((Opcode >> 9) & 7) = res;
29833 RET(8)
29834 }
29835
29836 // SUBXM
29837 OPCODE(0x9108)
29838 {
29839         u32 adr, res;
29840         u32 src, dst;
29841
29842         adr = AREG((Opcode >> 0) & 7) - 1;
29843         AREG((Opcode >> 0) & 7) = adr;
29844         PRE_IO
29845         READ_BYTE_F(adr, src)
29846         adr = AREG((Opcode >> 9) & 7) - 1;
29847         AREG((Opcode >> 9) & 7) = adr;
29848         READ_BYTE_F(adr, dst)
29849         res = dst - src - ((flag_X >> 8) & 1);
29850         flag_N = flag_X = flag_C = res;
29851         flag_V = (src ^ dst) & (res ^ dst);
29852         flag_NotZ |= res & 0xFF;
29853         WRITE_BYTE_F(adr, res)
29854         POST_IO
29855 RET(18)
29856 }
29857
29858 // SUBXM
29859 OPCODE(0x9148)
29860 {
29861         u32 adr, res;
29862         u32 src, dst;
29863
29864         adr = AREG((Opcode >> 0) & 7) - 2;
29865         AREG((Opcode >> 0) & 7) = adr;
29866         PRE_IO
29867         READ_WORD_F(adr, src)
29868         adr = AREG((Opcode >> 9) & 7) - 2;
29869         AREG((Opcode >> 9) & 7) = adr;
29870         READ_WORD_F(adr, dst)
29871         res = dst - src - ((flag_X >> 8) & 1);
29872         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29873         flag_N = flag_X = flag_C = res >> 8;
29874         flag_NotZ |= res & 0xFFFF;
29875         WRITE_WORD_F(adr, res)
29876         POST_IO
29877 RET(18)
29878 }
29879
29880 // SUBXM
29881 OPCODE(0x9188)
29882 {
29883         u32 adr, res;
29884         u32 src, dst;
29885
29886         adr = AREG((Opcode >> 0) & 7) - 4;
29887         AREG((Opcode >> 0) & 7) = adr;
29888         PRE_IO
29889         READ_LONG_F(adr, src)
29890         adr = AREG((Opcode >> 9) & 7) - 4;
29891         AREG((Opcode >> 9) & 7) = adr;
29892         READ_LONG_F(adr, dst)
29893         res = dst - src - ((flag_X >> 8) & 1);
29894         flag_NotZ |= res;
29895         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29896         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29897         flag_N = res >> 24;
29898         WRITE_LONG_F(adr, res)
29899         POST_IO
29900 RET(30)
29901 }
29902
29903 // SUBX7M
29904 OPCODE(0x910F)
29905 {
29906         u32 adr, res;
29907         u32 src, dst;
29908
29909         adr = AREG(7) - 2;
29910         AREG(7) = adr;
29911         PRE_IO
29912         READ_BYTE_F(adr, src)
29913         adr = AREG((Opcode >> 9) & 7) - 1;
29914         AREG((Opcode >> 9) & 7) = adr;
29915         READ_BYTE_F(adr, dst)
29916         res = dst - src - ((flag_X >> 8) & 1);
29917         flag_N = flag_X = flag_C = res;
29918         flag_V = (src ^ dst) & (res ^ dst);
29919         flag_NotZ |= res & 0xFF;
29920         WRITE_BYTE_F(adr, res)
29921         POST_IO
29922 RET(18)
29923 }
29924
29925 // SUBX7M
29926 OPCODE(0x914F)
29927 {
29928         u32 adr, res;
29929         u32 src, dst;
29930
29931         adr = AREG(7) - 2;
29932         AREG(7) = adr;
29933         PRE_IO
29934         READ_WORD_F(adr, src)
29935         adr = AREG((Opcode >> 9) & 7) - 2;
29936         AREG((Opcode >> 9) & 7) = adr;
29937         READ_WORD_F(adr, dst)
29938         res = dst - src - ((flag_X >> 8) & 1);
29939         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29940         flag_N = flag_X = flag_C = res >> 8;
29941         flag_NotZ |= res & 0xFFFF;
29942         WRITE_WORD_F(adr, res)
29943         POST_IO
29944 RET(18)
29945 }
29946
29947 // SUBX7M
29948 OPCODE(0x918F)
29949 {
29950         u32 adr, res;
29951         u32 src, dst;
29952
29953         adr = AREG(7) - 4;
29954         AREG(7) = adr;
29955         PRE_IO
29956         READ_LONG_F(adr, src)
29957         adr = AREG((Opcode >> 9) & 7) - 4;
29958         AREG((Opcode >> 9) & 7) = adr;
29959         READ_LONG_F(adr, dst)
29960         res = dst - src - ((flag_X >> 8) & 1);
29961         flag_NotZ |= res;
29962         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29963         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29964         flag_N = res >> 24;
29965         WRITE_LONG_F(adr, res)
29966         POST_IO
29967 RET(30)
29968 }
29969
29970 // SUBXM7
29971 OPCODE(0x9F08)
29972 {
29973         u32 adr, res;
29974         u32 src, dst;
29975
29976         adr = AREG((Opcode >> 0) & 7) - 1;
29977         AREG((Opcode >> 0) & 7) = adr;
29978         PRE_IO
29979         READ_BYTE_F(adr, src)
29980         adr = AREG(7) - 2;
29981         AREG(7) = adr;
29982         READ_BYTE_F(adr, dst)
29983         res = dst - src - ((flag_X >> 8) & 1);
29984         flag_N = flag_X = flag_C = res;
29985         flag_V = (src ^ dst) & (res ^ dst);
29986         flag_NotZ |= res & 0xFF;
29987         WRITE_BYTE_F(adr, res)
29988         POST_IO
29989 RET(18)
29990 }
29991
29992 // SUBXM7
29993 OPCODE(0x9F48)
29994 {
29995         u32 adr, res;
29996         u32 src, dst;
29997
29998         adr = AREG((Opcode >> 0) & 7) - 2;
29999         AREG((Opcode >> 0) & 7) = adr;
30000         PRE_IO
30001         READ_WORD_F(adr, src)
30002         adr = AREG(7) - 2;
30003         AREG(7) = adr;
30004         READ_WORD_F(adr, dst)
30005         res = dst - src - ((flag_X >> 8) & 1);
30006         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30007         flag_N = flag_X = flag_C = res >> 8;
30008         flag_NotZ |= res & 0xFFFF;
30009         WRITE_WORD_F(adr, res)
30010         POST_IO
30011 RET(18)
30012 }
30013
30014 // SUBXM7
30015 OPCODE(0x9F88)
30016 {
30017         u32 adr, res;
30018         u32 src, dst;
30019
30020         adr = AREG((Opcode >> 0) & 7) - 4;
30021         AREG((Opcode >> 0) & 7) = adr;
30022         PRE_IO
30023         READ_LONG_F(adr, src)
30024         adr = AREG(7) - 4;
30025         AREG(7) = adr;
30026         READ_LONG_F(adr, dst)
30027         res = dst - src - ((flag_X >> 8) & 1);
30028         flag_NotZ |= res;
30029         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30030         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30031         flag_N = res >> 24;
30032         WRITE_LONG_F(adr, res)
30033         POST_IO
30034 RET(30)
30035 }
30036
30037 // SUBX7M7
30038 OPCODE(0x9F0F)
30039 {
30040         u32 adr, res;
30041         u32 src, dst;
30042
30043         adr = AREG(7) - 2;
30044         AREG(7) = adr;
30045         PRE_IO
30046         READ_BYTE_F(adr, src)
30047         adr = AREG(7) - 2;
30048         AREG(7) = adr;
30049         READ_BYTE_F(adr, dst)
30050         res = dst - src - ((flag_X >> 8) & 1);
30051         flag_N = flag_X = flag_C = res;
30052         flag_V = (src ^ dst) & (res ^ dst);
30053         flag_NotZ |= res & 0xFF;
30054         WRITE_BYTE_F(adr, res)
30055         POST_IO
30056 RET(18)
30057 }
30058
30059 // SUBX7M7
30060 OPCODE(0x9F4F)
30061 {
30062         u32 adr, res;
30063         u32 src, dst;
30064
30065         adr = AREG(7) - 2;
30066         AREG(7) = adr;
30067         PRE_IO
30068         READ_WORD_F(adr, src)
30069         adr = AREG(7) - 2;
30070         AREG(7) = adr;
30071         READ_WORD_F(adr, dst)
30072         res = dst - src - ((flag_X >> 8) & 1);
30073         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30074         flag_N = flag_X = flag_C = res >> 8;
30075         flag_NotZ |= res & 0xFFFF;
30076         WRITE_WORD_F(adr, res)
30077         POST_IO
30078 RET(18)
30079 }
30080
30081 // SUBX7M7
30082 OPCODE(0x9F8F)
30083 {
30084         u32 adr, res;
30085         u32 src, dst;
30086
30087         adr = AREG(7) - 4;
30088         AREG(7) = adr;
30089         PRE_IO
30090         READ_LONG_F(adr, src)
30091         adr = AREG(7) - 4;
30092         AREG(7) = adr;
30093         READ_LONG_F(adr, dst)
30094         res = dst - src - ((flag_X >> 8) & 1);
30095         flag_NotZ |= res;
30096         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30097         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30098         flag_N = res >> 24;
30099         WRITE_LONG_F(adr, res)
30100         POST_IO
30101 RET(30)
30102 }
30103
30104 // SUBA
30105 OPCODE(0x90C0)
30106 {
30107         u32 adr, res;
30108         u32 src, dst;
30109
30110         src = (s32)DREGs16((Opcode >> 0) & 7);
30111         dst = AREGu32((Opcode >> 9) & 7);
30112         res = dst - src;
30113         AREG((Opcode >> 9) & 7) = res;
30114 RET(8)
30115 }
30116
30117 // SUBA
30118 OPCODE(0x90C8)
30119 {
30120         u32 adr, res;
30121         u32 src, dst;
30122
30123         src = (s32)AREGs16((Opcode >> 0) & 7);
30124         dst = AREGu32((Opcode >> 9) & 7);
30125         res = dst - src;
30126         AREG((Opcode >> 9) & 7) = res;
30127 RET(8)
30128 }
30129
30130 // SUBA
30131 OPCODE(0x90D0)
30132 {
30133         u32 adr, res;
30134         u32 src, dst;
30135
30136         adr = AREG((Opcode >> 0) & 7);
30137         PRE_IO
30138         READSX_WORD_F(adr, src)
30139         dst = AREGu32((Opcode >> 9) & 7);
30140         res = dst - src;
30141         AREG((Opcode >> 9) & 7) = res;
30142         POST_IO
30143 #ifdef USE_CYCLONE_TIMING
30144 RET(12)
30145 #else
30146 RET(10)
30147 #endif
30148 }
30149
30150 // SUBA
30151 OPCODE(0x90D8)
30152 {
30153         u32 adr, res;
30154         u32 src, dst;
30155
30156         adr = AREG((Opcode >> 0) & 7);
30157         AREG((Opcode >> 0) & 7) += 2;
30158         PRE_IO
30159         READSX_WORD_F(adr, src)
30160         dst = AREGu32((Opcode >> 9) & 7);
30161         res = dst - src;
30162         AREG((Opcode >> 9) & 7) = res;
30163         POST_IO
30164 #ifdef USE_CYCLONE_TIMING
30165 RET(12)
30166 #else
30167 RET(10)
30168 #endif
30169 }
30170
30171 // SUBA
30172 OPCODE(0x90E0)
30173 {
30174         u32 adr, res;
30175         u32 src, dst;
30176
30177         adr = AREG((Opcode >> 0) & 7) - 2;
30178         AREG((Opcode >> 0) & 7) = adr;
30179         PRE_IO
30180         READSX_WORD_F(adr, src)
30181         dst = AREGu32((Opcode >> 9) & 7);
30182         res = dst - src;
30183         AREG((Opcode >> 9) & 7) = res;
30184         POST_IO
30185 #ifdef USE_CYCLONE_TIMING
30186 RET(14)
30187 #else
30188 RET(12)
30189 #endif
30190 }
30191
30192 // SUBA
30193 OPCODE(0x90E8)
30194 {
30195         u32 adr, res;
30196         u32 src, dst;
30197
30198         FETCH_SWORD(adr);
30199         adr += AREG((Opcode >> 0) & 7);
30200         PRE_IO
30201         READSX_WORD_F(adr, src)
30202         dst = AREGu32((Opcode >> 9) & 7);
30203         res = dst - src;
30204         AREG((Opcode >> 9) & 7) = res;
30205         POST_IO
30206 #ifdef USE_CYCLONE_TIMING
30207 RET(16)
30208 #else
30209 RET(14)
30210 #endif
30211 }
30212
30213 // SUBA
30214 OPCODE(0x90F0)
30215 {
30216         u32 adr, res;
30217         u32 src, dst;
30218
30219         adr = AREG((Opcode >> 0) & 7);
30220         DECODE_EXT_WORD
30221         PRE_IO
30222         READSX_WORD_F(adr, src)
30223         dst = AREGu32((Opcode >> 9) & 7);
30224         res = dst - src;
30225         AREG((Opcode >> 9) & 7) = res;
30226         POST_IO
30227 #ifdef USE_CYCLONE_TIMING
30228 RET(18)
30229 #else
30230 RET(16)
30231 #endif
30232 }
30233
30234 // SUBA
30235 OPCODE(0x90F8)
30236 {
30237         u32 adr, res;
30238         u32 src, dst;
30239
30240         FETCH_SWORD(adr);
30241         PRE_IO
30242         READSX_WORD_F(adr, src)
30243         dst = AREGu32((Opcode >> 9) & 7);
30244         res = dst - src;
30245         AREG((Opcode >> 9) & 7) = res;
30246         POST_IO
30247 #ifdef USE_CYCLONE_TIMING
30248 RET(16)
30249 #else
30250 RET(14)
30251 #endif
30252 }
30253
30254 // SUBA
30255 OPCODE(0x90F9)
30256 {
30257         u32 adr, res;
30258         u32 src, dst;
30259
30260         FETCH_LONG(adr);
30261         PRE_IO
30262         READSX_WORD_F(adr, src)
30263         dst = AREGu32((Opcode >> 9) & 7);
30264         res = dst - src;
30265         AREG((Opcode >> 9) & 7) = res;
30266         POST_IO
30267 #ifdef USE_CYCLONE_TIMING
30268 RET(20)
30269 #else
30270 RET(18)
30271 #endif
30272 }
30273
30274 // SUBA
30275 OPCODE(0x90FA)
30276 {
30277         u32 adr, res;
30278         u32 src, dst;
30279
30280         adr = GET_SWORD + GET_PC;
30281         PC++;
30282         PRE_IO
30283         READSX_WORD_F(adr, src)
30284         dst = AREGu32((Opcode >> 9) & 7);
30285         res = dst - src;
30286         AREG((Opcode >> 9) & 7) = res;
30287         POST_IO
30288 #ifdef USE_CYCLONE_TIMING
30289 RET(16)
30290 #else
30291 RET(14)
30292 #endif
30293 }
30294
30295 // SUBA
30296 OPCODE(0x90FB)
30297 {
30298         u32 adr, res;
30299         u32 src, dst;
30300
30301         adr = GET_PC;
30302         DECODE_EXT_WORD
30303         PRE_IO
30304         READSX_WORD_F(adr, src)
30305         dst = AREGu32((Opcode >> 9) & 7);
30306         res = dst - src;
30307         AREG((Opcode >> 9) & 7) = res;
30308         POST_IO
30309 #ifdef USE_CYCLONE_TIMING
30310 RET(18)
30311 #else
30312 RET(16)
30313 #endif
30314 }
30315
30316 // SUBA
30317 OPCODE(0x90FC)
30318 {
30319         u32 adr, res;
30320         u32 src, dst;
30321
30322         FETCH_SWORD(src);
30323         dst = AREGu32((Opcode >> 9) & 7);
30324         res = dst - src;
30325         AREG((Opcode >> 9) & 7) = res;
30326 RET(12)
30327 }
30328
30329 // SUBA
30330 OPCODE(0x90DF)
30331 {
30332         u32 adr, res;
30333         u32 src, dst;
30334
30335         adr = AREG(7);
30336         AREG(7) += 2;
30337         PRE_IO
30338         READSX_WORD_F(adr, src)
30339         dst = AREGu32((Opcode >> 9) & 7);
30340         res = dst - src;
30341         AREG((Opcode >> 9) & 7) = res;
30342         POST_IO
30343 #ifdef USE_CYCLONE_TIMING
30344 RET(12)
30345 #else
30346 RET(10)
30347 #endif
30348 }
30349
30350 // SUBA
30351 OPCODE(0x90E7)
30352 {
30353         u32 adr, res;
30354         u32 src, dst;
30355
30356         adr = AREG(7) - 2;
30357         AREG(7) = adr;
30358         PRE_IO
30359         READSX_WORD_F(adr, src)
30360         dst = AREGu32((Opcode >> 9) & 7);
30361         res = dst - src;
30362         AREG((Opcode >> 9) & 7) = res;
30363         POST_IO
30364 #ifdef USE_CYCLONE_TIMING
30365 RET(14)
30366 #else
30367 RET(12)
30368 #endif
30369 }
30370
30371 // SUBA
30372 OPCODE(0x91C0)
30373 {
30374         u32 adr, res;
30375         u32 src, dst;
30376
30377         src = (s32)DREGs32((Opcode >> 0) & 7);
30378         dst = AREGu32((Opcode >> 9) & 7);
30379         res = dst - src;
30380         AREG((Opcode >> 9) & 7) = res;
30381 #ifdef USE_CYCLONE_TIMING
30382 RET(8)
30383 #else
30384 RET(6)
30385 #endif
30386 }
30387
30388 // SUBA
30389 OPCODE(0x91C8)
30390 {
30391         u32 adr, res;
30392         u32 src, dst;
30393
30394         src = (s32)AREGs32((Opcode >> 0) & 7);
30395         dst = AREGu32((Opcode >> 9) & 7);
30396         res = dst - src;
30397         AREG((Opcode >> 9) & 7) = res;
30398 #ifdef USE_CYCLONE_TIMING
30399 RET(8)
30400 #else
30401 RET(6)
30402 #endif
30403 }
30404
30405 // SUBA
30406 OPCODE(0x91D0)
30407 {
30408         u32 adr, res;
30409         u32 src, dst;
30410
30411         adr = AREG((Opcode >> 0) & 7);
30412         PRE_IO
30413         READSX_LONG_F(adr, src)
30414         dst = AREGu32((Opcode >> 9) & 7);
30415         res = dst - src;
30416         AREG((Opcode >> 9) & 7) = res;
30417         POST_IO
30418 RET(14)
30419 }
30420
30421 // SUBA
30422 OPCODE(0x91D8)
30423 {
30424         u32 adr, res;
30425         u32 src, dst;
30426
30427         adr = AREG((Opcode >> 0) & 7);
30428         AREG((Opcode >> 0) & 7) += 4;
30429         PRE_IO
30430         READSX_LONG_F(adr, src)
30431         dst = AREGu32((Opcode >> 9) & 7);
30432         res = dst - src;
30433         AREG((Opcode >> 9) & 7) = res;
30434         POST_IO
30435 RET(14)
30436 }
30437
30438 // SUBA
30439 OPCODE(0x91E0)
30440 {
30441         u32 adr, res;
30442         u32 src, dst;
30443
30444         adr = AREG((Opcode >> 0) & 7) - 4;
30445         AREG((Opcode >> 0) & 7) = adr;
30446         PRE_IO
30447         READSX_LONG_F(adr, src)
30448         dst = AREGu32((Opcode >> 9) & 7);
30449         res = dst - src;
30450         AREG((Opcode >> 9) & 7) = res;
30451         POST_IO
30452 RET(16)
30453 }
30454
30455 // SUBA
30456 OPCODE(0x91E8)
30457 {
30458         u32 adr, res;
30459         u32 src, dst;
30460
30461         FETCH_SWORD(adr);
30462         adr += AREG((Opcode >> 0) & 7);
30463         PRE_IO
30464         READSX_LONG_F(adr, src)
30465         dst = AREGu32((Opcode >> 9) & 7);
30466         res = dst - src;
30467         AREG((Opcode >> 9) & 7) = res;
30468         POST_IO
30469 RET(18)
30470 }
30471
30472 // SUBA
30473 OPCODE(0x91F0)
30474 {
30475         u32 adr, res;
30476         u32 src, dst;
30477
30478         adr = AREG((Opcode >> 0) & 7);
30479         DECODE_EXT_WORD
30480         PRE_IO
30481         READSX_LONG_F(adr, src)
30482         dst = AREGu32((Opcode >> 9) & 7);
30483         res = dst - src;
30484         AREG((Opcode >> 9) & 7) = res;
30485         POST_IO
30486 RET(20)
30487 }
30488
30489 // SUBA
30490 OPCODE(0x91F8)
30491 {
30492         u32 adr, res;
30493         u32 src, dst;
30494
30495         FETCH_SWORD(adr);
30496         PRE_IO
30497         READSX_LONG_F(adr, src)
30498         dst = AREGu32((Opcode >> 9) & 7);
30499         res = dst - src;
30500         AREG((Opcode >> 9) & 7) = res;
30501         POST_IO
30502 RET(18)
30503 }
30504
30505 // SUBA
30506 OPCODE(0x91F9)
30507 {
30508         u32 adr, res;
30509         u32 src, dst;
30510
30511         FETCH_LONG(adr);
30512         PRE_IO
30513         READSX_LONG_F(adr, src)
30514         dst = AREGu32((Opcode >> 9) & 7);
30515         res = dst - src;
30516         AREG((Opcode >> 9) & 7) = res;
30517         POST_IO
30518 RET(22)
30519 }
30520
30521 // SUBA
30522 OPCODE(0x91FA)
30523 {
30524         u32 adr, res;
30525         u32 src, dst;
30526
30527         adr = GET_SWORD + GET_PC;
30528         PC++;
30529         PRE_IO
30530         READSX_LONG_F(adr, src)
30531         dst = AREGu32((Opcode >> 9) & 7);
30532         res = dst - src;
30533         AREG((Opcode >> 9) & 7) = res;
30534         POST_IO
30535 RET(18)
30536 }
30537
30538 // SUBA
30539 OPCODE(0x91FB)
30540 {
30541         u32 adr, res;
30542         u32 src, dst;
30543
30544         adr = GET_PC;
30545         DECODE_EXT_WORD
30546         PRE_IO
30547         READSX_LONG_F(adr, src)
30548         dst = AREGu32((Opcode >> 9) & 7);
30549         res = dst - src;
30550         AREG((Opcode >> 9) & 7) = res;
30551         POST_IO
30552 RET(20)
30553 }
30554
30555 // SUBA
30556 OPCODE(0x91FC)
30557 {
30558         u32 adr, res;
30559         u32 src, dst;
30560
30561         FETCH_LONG(src);
30562         dst = AREGu32((Opcode >> 9) & 7);
30563         res = dst - src;
30564         AREG((Opcode >> 9) & 7) = res;
30565 #ifdef USE_CYCLONE_TIMING
30566 RET(16)
30567 #else
30568 RET(14)
30569 #endif
30570 }
30571
30572 // SUBA
30573 OPCODE(0x91DF)
30574 {
30575         u32 adr, res;
30576         u32 src, dst;
30577
30578         adr = AREG(7);
30579         AREG(7) += 4;
30580         PRE_IO
30581         READSX_LONG_F(adr, src)
30582         dst = AREGu32((Opcode >> 9) & 7);
30583         res = dst - src;
30584         AREG((Opcode >> 9) & 7) = res;
30585         POST_IO
30586 RET(14)
30587 }
30588
30589 // SUBA
30590 OPCODE(0x91E7)
30591 {
30592         u32 adr, res;
30593         u32 src, dst;
30594
30595         adr = AREG(7) - 4;
30596         AREG(7) = adr;
30597         PRE_IO
30598         READSX_LONG_F(adr, src)
30599         dst = AREGu32((Opcode >> 9) & 7);
30600         res = dst - src;
30601         AREG((Opcode >> 9) & 7) = res;
30602         POST_IO
30603 RET(16)
30604 }
30605
30606 // CMP
30607 OPCODE(0xB000)
30608 {
30609         u32 adr, res;
30610         u32 src, dst;
30611
30612         src = DREGu8((Opcode >> 0) & 7);
30613         dst = DREGu8((Opcode >> 9) & 7);
30614         res = dst - src;
30615         flag_N = flag_C = res;
30616         flag_V = (src ^ dst) & (res ^ dst);
30617         flag_NotZ = res & 0xFF;
30618 RET(4)
30619 }
30620
30621 // CMP
30622 #if 0
30623 OPCODE(0xB008)
30624 {
30625         u32 adr, res;
30626         u32 src, dst;
30627
30628         // can't read byte from Ax registers !
30629         m68kcontext.execinfo |= M68K_FAULTED;
30630         m68kcontext.io_cycle_counter = 0;
30631 /*
30632         goto famec_Exec_End;
30633         dst = DREGu8((Opcode >> 9) & 7);
30634         res = dst - src;
30635         flag_N = flag_C = res;
30636         flag_V = (src ^ dst) & (res ^ dst);
30637         flag_NotZ = res & 0xFF;
30638 */
30639 RET(4)
30640 }
30641 #endif
30642
30643 // CMP
30644 OPCODE(0xB010)
30645 {
30646         u32 adr, res;
30647         u32 src, dst;
30648
30649         adr = AREG((Opcode >> 0) & 7);
30650         PRE_IO
30651         READ_BYTE_F(adr, src)
30652         dst = DREGu8((Opcode >> 9) & 7);
30653         res = dst - src;
30654         flag_N = flag_C = res;
30655         flag_V = (src ^ dst) & (res ^ dst);
30656         flag_NotZ = res & 0xFF;
30657         POST_IO
30658 RET(8)
30659 }
30660
30661 // CMP
30662 OPCODE(0xB018)
30663 {
30664         u32 adr, res;
30665         u32 src, dst;
30666
30667         adr = AREG((Opcode >> 0) & 7);
30668         AREG((Opcode >> 0) & 7) += 1;
30669         PRE_IO
30670         READ_BYTE_F(adr, src)
30671         dst = DREGu8((Opcode >> 9) & 7);
30672         res = dst - src;
30673         flag_N = flag_C = res;
30674         flag_V = (src ^ dst) & (res ^ dst);
30675         flag_NotZ = res & 0xFF;
30676         POST_IO
30677 RET(8)
30678 }
30679
30680 // CMP
30681 OPCODE(0xB020)
30682 {
30683         u32 adr, res;
30684         u32 src, dst;
30685
30686         adr = AREG((Opcode >> 0) & 7) - 1;
30687         AREG((Opcode >> 0) & 7) = adr;
30688         PRE_IO
30689         READ_BYTE_F(adr, src)
30690         dst = DREGu8((Opcode >> 9) & 7);
30691         res = dst - src;
30692         flag_N = flag_C = res;
30693         flag_V = (src ^ dst) & (res ^ dst);
30694         flag_NotZ = res & 0xFF;
30695         POST_IO
30696 RET(10)
30697 }
30698
30699 // CMP
30700 OPCODE(0xB028)
30701 {
30702         u32 adr, res;
30703         u32 src, dst;
30704
30705         FETCH_SWORD(adr);
30706         adr += AREG((Opcode >> 0) & 7);
30707         PRE_IO
30708         READ_BYTE_F(adr, src)
30709         dst = DREGu8((Opcode >> 9) & 7);
30710         res = dst - src;
30711         flag_N = flag_C = res;
30712         flag_V = (src ^ dst) & (res ^ dst);
30713         flag_NotZ = res & 0xFF;
30714         POST_IO
30715 RET(12)
30716 }
30717
30718 // CMP
30719 OPCODE(0xB030)
30720 {
30721         u32 adr, res;
30722         u32 src, dst;
30723
30724         adr = AREG((Opcode >> 0) & 7);
30725         DECODE_EXT_WORD
30726         PRE_IO
30727         READ_BYTE_F(adr, src)
30728         dst = DREGu8((Opcode >> 9) & 7);
30729         res = dst - src;
30730         flag_N = flag_C = res;
30731         flag_V = (src ^ dst) & (res ^ dst);
30732         flag_NotZ = res & 0xFF;
30733         POST_IO
30734 RET(14)
30735 }
30736
30737 // CMP
30738 OPCODE(0xB038)
30739 {
30740         u32 adr, res;
30741         u32 src, dst;
30742
30743         FETCH_SWORD(adr);
30744         PRE_IO
30745         READ_BYTE_F(adr, src)
30746         dst = DREGu8((Opcode >> 9) & 7);
30747         res = dst - src;
30748         flag_N = flag_C = res;
30749         flag_V = (src ^ dst) & (res ^ dst);
30750         flag_NotZ = res & 0xFF;
30751         POST_IO
30752 RET(12)
30753 }
30754
30755 // CMP
30756 OPCODE(0xB039)
30757 {
30758         u32 adr, res;
30759         u32 src, dst;
30760
30761         FETCH_LONG(adr);
30762         PRE_IO
30763         READ_BYTE_F(adr, src)
30764         dst = DREGu8((Opcode >> 9) & 7);
30765         res = dst - src;
30766         flag_N = flag_C = res;
30767         flag_V = (src ^ dst) & (res ^ dst);
30768         flag_NotZ = res & 0xFF;
30769         POST_IO
30770 RET(16)
30771 }
30772
30773 // CMP
30774 OPCODE(0xB03A)
30775 {
30776         u32 adr, res;
30777         u32 src, dst;
30778
30779         adr = GET_SWORD + GET_PC;
30780         PC++;
30781         PRE_IO
30782         READ_BYTE_F(adr, src)
30783         dst = DREGu8((Opcode >> 9) & 7);
30784         res = dst - src;
30785         flag_N = flag_C = res;
30786         flag_V = (src ^ dst) & (res ^ dst);
30787         flag_NotZ = res & 0xFF;
30788         POST_IO
30789 RET(12)
30790 }
30791
30792 // CMP
30793 OPCODE(0xB03B)
30794 {
30795         u32 adr, res;
30796         u32 src, dst;
30797
30798         adr = GET_PC;
30799         DECODE_EXT_WORD
30800         PRE_IO
30801         READ_BYTE_F(adr, src)
30802         dst = DREGu8((Opcode >> 9) & 7);
30803         res = dst - src;
30804         flag_N = flag_C = res;
30805         flag_V = (src ^ dst) & (res ^ dst);
30806         flag_NotZ = res & 0xFF;
30807         POST_IO
30808 RET(14)
30809 }
30810
30811 // CMP
30812 OPCODE(0xB03C)
30813 {
30814         u32 adr, res;
30815         u32 src, dst;
30816
30817         FETCH_BYTE(src);
30818         dst = DREGu8((Opcode >> 9) & 7);
30819         res = dst - src;
30820         flag_N = flag_C = res;
30821         flag_V = (src ^ dst) & (res ^ dst);
30822         flag_NotZ = res & 0xFF;
30823 RET(8)
30824 }
30825
30826 // CMP
30827 OPCODE(0xB01F)
30828 {
30829         u32 adr, res;
30830         u32 src, dst;
30831
30832         adr = AREG(7);
30833         AREG(7) += 2;
30834         PRE_IO
30835         READ_BYTE_F(adr, src)
30836         dst = DREGu8((Opcode >> 9) & 7);
30837         res = dst - src;
30838         flag_N = flag_C = res;
30839         flag_V = (src ^ dst) & (res ^ dst);
30840         flag_NotZ = res & 0xFF;
30841         POST_IO
30842 RET(8)
30843 }
30844
30845 // CMP
30846 OPCODE(0xB027)
30847 {
30848         u32 adr, res;
30849         u32 src, dst;
30850
30851         adr = AREG(7) - 2;
30852         AREG(7) = adr;
30853         PRE_IO
30854         READ_BYTE_F(adr, src)
30855         dst = DREGu8((Opcode >> 9) & 7);
30856         res = dst - src;
30857         flag_N = flag_C = res;
30858         flag_V = (src ^ dst) & (res ^ dst);
30859         flag_NotZ = res & 0xFF;
30860         POST_IO
30861 RET(10)
30862 }
30863
30864 // CMP
30865 OPCODE(0xB040)
30866 {
30867         u32 adr, res;
30868         u32 src, dst;
30869
30870         src = DREGu16((Opcode >> 0) & 7);
30871         dst = DREGu16((Opcode >> 9) & 7);
30872         res = dst - src;
30873         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30874         flag_N = flag_C = res >> 8;
30875         flag_NotZ = res & 0xFFFF;
30876 RET(4)
30877 }
30878
30879 // CMP
30880 OPCODE(0xB048)
30881 {
30882         u32 adr, res;
30883         u32 src, dst;
30884
30885         src = AREGu16((Opcode >> 0) & 7);
30886         dst = DREGu16((Opcode >> 9) & 7);
30887         res = dst - src;
30888         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30889         flag_N = flag_C = res >> 8;
30890         flag_NotZ = res & 0xFFFF;
30891 RET(4)
30892 }
30893
30894 // CMP
30895 OPCODE(0xB050)
30896 {
30897         u32 adr, res;
30898         u32 src, dst;
30899
30900         adr = AREG((Opcode >> 0) & 7);
30901         PRE_IO
30902         READ_WORD_F(adr, src)
30903         dst = DREGu16((Opcode >> 9) & 7);
30904         res = dst - src;
30905         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30906         flag_N = flag_C = res >> 8;
30907         flag_NotZ = res & 0xFFFF;
30908         POST_IO
30909 RET(8)
30910 }
30911
30912 // CMP
30913 OPCODE(0xB058)
30914 {
30915         u32 adr, res;
30916         u32 src, dst;
30917
30918         adr = AREG((Opcode >> 0) & 7);
30919         AREG((Opcode >> 0) & 7) += 2;
30920         PRE_IO
30921         READ_WORD_F(adr, src)
30922         dst = DREGu16((Opcode >> 9) & 7);
30923         res = dst - src;
30924         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30925         flag_N = flag_C = res >> 8;
30926         flag_NotZ = res & 0xFFFF;
30927         POST_IO
30928 RET(8)
30929 }
30930
30931 // CMP
30932 OPCODE(0xB060)
30933 {
30934         u32 adr, res;
30935         u32 src, dst;
30936
30937         adr = AREG((Opcode >> 0) & 7) - 2;
30938         AREG((Opcode >> 0) & 7) = adr;
30939         PRE_IO
30940         READ_WORD_F(adr, src)
30941         dst = DREGu16((Opcode >> 9) & 7);
30942         res = dst - src;
30943         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30944         flag_N = flag_C = res >> 8;
30945         flag_NotZ = res & 0xFFFF;
30946         POST_IO
30947 RET(10)
30948 }
30949
30950 // CMP
30951 OPCODE(0xB068)
30952 {
30953         u32 adr, res;
30954         u32 src, dst;
30955
30956         FETCH_SWORD(adr);
30957         adr += AREG((Opcode >> 0) & 7);
30958         PRE_IO
30959         READ_WORD_F(adr, src)
30960         dst = DREGu16((Opcode >> 9) & 7);
30961         res = dst - src;
30962         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30963         flag_N = flag_C = res >> 8;
30964         flag_NotZ = res & 0xFFFF;
30965         POST_IO
30966 RET(12)
30967 }
30968
30969 // CMP
30970 OPCODE(0xB070)
30971 {
30972         u32 adr, res;
30973         u32 src, dst;
30974
30975         adr = AREG((Opcode >> 0) & 7);
30976         DECODE_EXT_WORD
30977         PRE_IO
30978         READ_WORD_F(adr, src)
30979         dst = DREGu16((Opcode >> 9) & 7);
30980         res = dst - src;
30981         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30982         flag_N = flag_C = res >> 8;
30983         flag_NotZ = res & 0xFFFF;
30984         POST_IO
30985 RET(14)
30986 }
30987
30988 // CMP
30989 OPCODE(0xB078)
30990 {
30991         u32 adr, res;
30992         u32 src, dst;
30993
30994         FETCH_SWORD(adr);
30995         PRE_IO
30996         READ_WORD_F(adr, src)
30997         dst = DREGu16((Opcode >> 9) & 7);
30998         res = dst - src;
30999         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31000         flag_N = flag_C = res >> 8;
31001         flag_NotZ = res & 0xFFFF;
31002         POST_IO
31003 RET(12)
31004 }
31005
31006 // CMP
31007 OPCODE(0xB079)
31008 {
31009         u32 adr, res;
31010         u32 src, dst;
31011
31012         FETCH_LONG(adr);
31013         PRE_IO
31014         READ_WORD_F(adr, src)
31015         dst = DREGu16((Opcode >> 9) & 7);
31016         res = dst - src;
31017         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31018         flag_N = flag_C = res >> 8;
31019         flag_NotZ = res & 0xFFFF;
31020         POST_IO
31021 RET(16)
31022 }
31023
31024 // CMP
31025 OPCODE(0xB07A)
31026 {
31027         u32 adr, res;
31028         u32 src, dst;
31029
31030         adr = GET_SWORD + GET_PC;
31031         PC++;
31032         PRE_IO
31033         READ_WORD_F(adr, src)
31034         dst = DREGu16((Opcode >> 9) & 7);
31035         res = dst - src;
31036         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31037         flag_N = flag_C = res >> 8;
31038         flag_NotZ = res & 0xFFFF;
31039         POST_IO
31040 RET(12)
31041 }
31042
31043 // CMP
31044 OPCODE(0xB07B)
31045 {
31046         u32 adr, res;
31047         u32 src, dst;
31048
31049         adr = GET_PC;
31050         DECODE_EXT_WORD
31051         PRE_IO
31052         READ_WORD_F(adr, src)
31053         dst = DREGu16((Opcode >> 9) & 7);
31054         res = dst - src;
31055         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31056         flag_N = flag_C = res >> 8;
31057         flag_NotZ = res & 0xFFFF;
31058         POST_IO
31059 RET(14)
31060 }
31061
31062 // CMP
31063 OPCODE(0xB07C)
31064 {
31065         u32 adr, res;
31066         u32 src, dst;
31067
31068         FETCH_WORD(src);
31069         dst = DREGu16((Opcode >> 9) & 7);
31070         res = dst - src;
31071         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31072         flag_N = flag_C = res >> 8;
31073         flag_NotZ = res & 0xFFFF;
31074 RET(8)
31075 }
31076
31077 // CMP
31078 OPCODE(0xB05F)
31079 {
31080         u32 adr, res;
31081         u32 src, dst;
31082
31083         adr = AREG(7);
31084         AREG(7) += 2;
31085         PRE_IO
31086         READ_WORD_F(adr, src)
31087         dst = DREGu16((Opcode >> 9) & 7);
31088         res = dst - src;
31089         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31090         flag_N = flag_C = res >> 8;
31091         flag_NotZ = res & 0xFFFF;
31092         POST_IO
31093 RET(8)
31094 }
31095
31096 // CMP
31097 OPCODE(0xB067)
31098 {
31099         u32 adr, res;
31100         u32 src, dst;
31101
31102         adr = AREG(7) - 2;
31103         AREG(7) = adr;
31104         PRE_IO
31105         READ_WORD_F(adr, src)
31106         dst = DREGu16((Opcode >> 9) & 7);
31107         res = dst - src;
31108         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31109         flag_N = flag_C = res >> 8;
31110         flag_NotZ = res & 0xFFFF;
31111         POST_IO
31112 RET(10)
31113 }
31114
31115 // CMP
31116 OPCODE(0xB080)
31117 {
31118         u32 adr, res;
31119         u32 src, dst;
31120
31121         src = DREGu32((Opcode >> 0) & 7);
31122         dst = DREGu32((Opcode >> 9) & 7);
31123         res = dst - src;
31124         flag_NotZ = res;
31125         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31126         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31127         flag_N = res >> 24;
31128 RET(6)
31129 }
31130
31131 // CMP
31132 OPCODE(0xB088)
31133 {
31134         u32 adr, res;
31135         u32 src, dst;
31136
31137         src = AREGu32((Opcode >> 0) & 7);
31138         dst = DREGu32((Opcode >> 9) & 7);
31139         res = dst - src;
31140         flag_NotZ = res;
31141         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31142         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31143         flag_N = res >> 24;
31144 RET(6)
31145 }
31146
31147 // CMP
31148 OPCODE(0xB090)
31149 {
31150         u32 adr, res;
31151         u32 src, dst;
31152
31153         adr = AREG((Opcode >> 0) & 7);
31154         PRE_IO
31155         READ_LONG_F(adr, src)
31156         dst = DREGu32((Opcode >> 9) & 7);
31157         res = dst - src;
31158         flag_NotZ = res;
31159         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31160         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31161         flag_N = res >> 24;
31162         POST_IO
31163 RET(14)
31164 }
31165
31166 // CMP
31167 OPCODE(0xB098)
31168 {
31169         u32 adr, res;
31170         u32 src, dst;
31171
31172         adr = AREG((Opcode >> 0) & 7);
31173         AREG((Opcode >> 0) & 7) += 4;
31174         PRE_IO
31175         READ_LONG_F(adr, src)
31176         dst = DREGu32((Opcode >> 9) & 7);
31177         res = dst - src;
31178         flag_NotZ = res;
31179         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31180         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31181         flag_N = res >> 24;
31182         POST_IO
31183 RET(14)
31184 }
31185
31186 // CMP
31187 OPCODE(0xB0A0)
31188 {
31189         u32 adr, res;
31190         u32 src, dst;
31191
31192         adr = AREG((Opcode >> 0) & 7) - 4;
31193         AREG((Opcode >> 0) & 7) = adr;
31194         PRE_IO
31195         READ_LONG_F(adr, src)
31196         dst = DREGu32((Opcode >> 9) & 7);
31197         res = dst - src;
31198         flag_NotZ = res;
31199         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31200         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31201         flag_N = res >> 24;
31202         POST_IO
31203 RET(16)
31204 }
31205
31206 // CMP
31207 OPCODE(0xB0A8)
31208 {
31209         u32 adr, res;
31210         u32 src, dst;
31211
31212         FETCH_SWORD(adr);
31213         adr += AREG((Opcode >> 0) & 7);
31214         PRE_IO
31215         READ_LONG_F(adr, src)
31216         dst = DREGu32((Opcode >> 9) & 7);
31217         res = dst - src;
31218         flag_NotZ = res;
31219         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31220         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31221         flag_N = res >> 24;
31222         POST_IO
31223 RET(18)
31224 }
31225
31226 // CMP
31227 OPCODE(0xB0B0)
31228 {
31229         u32 adr, res;
31230         u32 src, dst;
31231
31232         adr = AREG((Opcode >> 0) & 7);
31233         DECODE_EXT_WORD
31234         PRE_IO
31235         READ_LONG_F(adr, src)
31236         dst = DREGu32((Opcode >> 9) & 7);
31237         res = dst - src;
31238         flag_NotZ = res;
31239         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31240         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31241         flag_N = res >> 24;
31242         POST_IO
31243 RET(20)
31244 }
31245
31246 // CMP
31247 OPCODE(0xB0B8)
31248 {
31249         u32 adr, res;
31250         u32 src, dst;
31251
31252         FETCH_SWORD(adr);
31253         PRE_IO
31254         READ_LONG_F(adr, src)
31255         dst = DREGu32((Opcode >> 9) & 7);
31256         res = dst - src;
31257         flag_NotZ = res;
31258         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31259         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31260         flag_N = res >> 24;
31261         POST_IO
31262 RET(18)
31263 }
31264
31265 // CMP
31266 OPCODE(0xB0B9)
31267 {
31268         u32 adr, res;
31269         u32 src, dst;
31270
31271         FETCH_LONG(adr);
31272         PRE_IO
31273         READ_LONG_F(adr, src)
31274         dst = DREGu32((Opcode >> 9) & 7);
31275         res = dst - src;
31276         flag_NotZ = res;
31277         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31278         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31279         flag_N = res >> 24;
31280         POST_IO
31281 RET(22)
31282 }
31283
31284 // CMP
31285 OPCODE(0xB0BA)
31286 {
31287         u32 adr, res;
31288         u32 src, dst;
31289
31290         adr = GET_SWORD + GET_PC;
31291         PC++;
31292         PRE_IO
31293         READ_LONG_F(adr, src)
31294         dst = DREGu32((Opcode >> 9) & 7);
31295         res = dst - src;
31296         flag_NotZ = res;
31297         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31298         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31299         flag_N = res >> 24;
31300         POST_IO
31301 RET(18)
31302 }
31303
31304 // CMP
31305 OPCODE(0xB0BB)
31306 {
31307         u32 adr, res;
31308         u32 src, dst;
31309
31310         adr = GET_PC;
31311         DECODE_EXT_WORD
31312         PRE_IO
31313         READ_LONG_F(adr, src)
31314         dst = DREGu32((Opcode >> 9) & 7);
31315         res = dst - src;
31316         flag_NotZ = res;
31317         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31318         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31319         flag_N = res >> 24;
31320         POST_IO
31321 RET(20)
31322 }
31323
31324 // CMP
31325 OPCODE(0xB0BC)
31326 {
31327         u32 adr, res;
31328         u32 src, dst;
31329
31330         FETCH_LONG(src);
31331         dst = DREGu32((Opcode >> 9) & 7);
31332         res = dst - src;
31333         flag_NotZ = res;
31334         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31335         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31336         flag_N = res >> 24;
31337 RET(14)
31338 }
31339
31340 // CMP
31341 OPCODE(0xB09F)
31342 {
31343         u32 adr, res;
31344         u32 src, dst;
31345
31346         adr = AREG(7);
31347         AREG(7) += 4;
31348         PRE_IO
31349         READ_LONG_F(adr, src)
31350         dst = DREGu32((Opcode >> 9) & 7);
31351         res = dst - src;
31352         flag_NotZ = res;
31353         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31354         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31355         flag_N = res >> 24;
31356         POST_IO
31357 RET(14)
31358 }
31359
31360 // CMP
31361 OPCODE(0xB0A7)
31362 {
31363         u32 adr, res;
31364         u32 src, dst;
31365
31366         adr = AREG(7) - 4;
31367         AREG(7) = adr;
31368         PRE_IO
31369         READ_LONG_F(adr, src)
31370         dst = DREGu32((Opcode >> 9) & 7);
31371         res = dst - src;
31372         flag_NotZ = res;
31373         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31374         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31375         flag_N = res >> 24;
31376         POST_IO
31377 RET(16)
31378 }
31379
31380 // CMPM
31381 OPCODE(0xB108)
31382 {
31383         u32 adr, res;
31384         u32 src, dst;
31385
31386         adr = AREG((Opcode >> 0) & 7);
31387         AREG((Opcode >> 0) & 7) += 1;
31388         PRE_IO
31389         READ_BYTE_F(adr, src)
31390         adr = AREG((Opcode >> 9) & 7);
31391         AREG((Opcode >> 9) & 7) += 1;
31392         READ_BYTE_F(adr, dst)
31393         res = dst - src;
31394         flag_N = flag_C = res;
31395         flag_V = (src ^ dst) & (res ^ dst);
31396         flag_NotZ = res & 0xFF;
31397         POST_IO
31398 RET(12)
31399 }
31400
31401 // CMPM
31402 OPCODE(0xB148)
31403 {
31404         u32 adr, res;
31405         u32 src, dst;
31406
31407         adr = AREG((Opcode >> 0) & 7);
31408         AREG((Opcode >> 0) & 7) += 2;
31409         PRE_IO
31410         READ_WORD_F(adr, src)
31411         adr = AREG((Opcode >> 9) & 7);
31412         AREG((Opcode >> 9) & 7) += 2;
31413         READ_WORD_F(adr, dst)
31414         res = dst - src;
31415         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31416         flag_N = flag_C = res >> 8;
31417         flag_NotZ = res & 0xFFFF;
31418         POST_IO
31419 RET(12)
31420 }
31421
31422 // CMPM
31423 OPCODE(0xB188)
31424 {
31425         u32 adr, res;
31426         u32 src, dst;
31427
31428         adr = AREG((Opcode >> 0) & 7);
31429         AREG((Opcode >> 0) & 7) += 4;
31430         PRE_IO
31431         READ_LONG_F(adr, src)
31432         adr = AREG((Opcode >> 9) & 7);
31433         AREG((Opcode >> 9) & 7) += 4;
31434         READ_LONG_F(adr, dst)
31435         res = dst - src;
31436         flag_NotZ = res;
31437         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31438         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31439         flag_N = res >> 24;
31440         POST_IO
31441 RET(20)
31442 }
31443
31444 // CMP7M
31445 OPCODE(0xB10F)
31446 {
31447         u32 adr, res;
31448         u32 src, dst;
31449
31450         adr = AREG(7);
31451         AREG(7) += 2;
31452         PRE_IO
31453         READ_BYTE_F(adr, src)
31454         adr = AREG((Opcode >> 9) & 7);
31455         AREG((Opcode >> 9) & 7) += 1;
31456         READ_BYTE_F(adr, dst)
31457         res = dst - src;
31458         flag_N = flag_C = res;
31459         flag_V = (src ^ dst) & (res ^ dst);
31460         flag_NotZ = res & 0xFF;
31461         POST_IO
31462 RET(12)
31463 }
31464
31465 // CMP7M
31466 OPCODE(0xB14F)
31467 {
31468         u32 adr, res;
31469         u32 src, dst;
31470
31471         adr = AREG(7);
31472         AREG(7) += 2;
31473         PRE_IO
31474         READ_WORD_F(adr, src)
31475         adr = AREG((Opcode >> 9) & 7);
31476         AREG((Opcode >> 9) & 7) += 2;
31477         READ_WORD_F(adr, dst)
31478         res = dst - src;
31479         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31480         flag_N = flag_C = res >> 8;
31481         flag_NotZ = res & 0xFFFF;
31482         POST_IO
31483 RET(12)
31484 }
31485
31486 // CMP7M
31487 OPCODE(0xB18F)
31488 {
31489         u32 adr, res;
31490         u32 src, dst;
31491
31492         adr = AREG(7);
31493         AREG(7) += 4;
31494         PRE_IO
31495         READ_LONG_F(adr, src)
31496         adr = AREG((Opcode >> 9) & 7);
31497         AREG((Opcode >> 9) & 7) += 4;
31498         READ_LONG_F(adr, dst)
31499         res = dst - src;
31500         flag_NotZ = res;
31501         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31502         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31503         flag_N = res >> 24;
31504         POST_IO
31505 RET(20)
31506 }
31507
31508 // CMPM7
31509 OPCODE(0xBF08)
31510 {
31511         u32 adr, res;
31512         u32 src, dst;
31513
31514         adr = AREG((Opcode >> 0) & 7);
31515         AREG((Opcode >> 0) & 7) += 1;
31516         PRE_IO
31517         READ_BYTE_F(adr, src)
31518         adr = AREG(7);
31519         AREG(7) += 2;
31520         READ_BYTE_F(adr, dst)
31521         res = dst - src;
31522         flag_N = flag_C = res;
31523         flag_V = (src ^ dst) & (res ^ dst);
31524         flag_NotZ = res & 0xFF;
31525         POST_IO
31526 RET(12)
31527 }
31528
31529 // CMPM7
31530 OPCODE(0xBF48)
31531 {
31532         u32 adr, res;
31533         u32 src, dst;
31534
31535         adr = AREG((Opcode >> 0) & 7);
31536         AREG((Opcode >> 0) & 7) += 2;
31537         PRE_IO
31538         READ_WORD_F(adr, src)
31539         adr = AREG(7);
31540         AREG(7) += 2;
31541         READ_WORD_F(adr, dst)
31542         res = dst - src;
31543         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31544         flag_N = flag_C = res >> 8;
31545         flag_NotZ = res & 0xFFFF;
31546         POST_IO
31547 RET(12)
31548 }
31549
31550 // CMPM7
31551 OPCODE(0xBF88)
31552 {
31553         u32 adr, res;
31554         u32 src, dst;
31555
31556         adr = AREG((Opcode >> 0) & 7);
31557         AREG((Opcode >> 0) & 7) += 4;
31558         PRE_IO
31559         READ_LONG_F(adr, src)
31560         adr = AREG(7);
31561         AREG(7) += 4;
31562         READ_LONG_F(adr, dst)
31563         res = dst - src;
31564         flag_NotZ = res;
31565         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31566         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31567         flag_N = res >> 24;
31568         POST_IO
31569 RET(20)
31570 }
31571
31572 // CMP7M7
31573 OPCODE(0xBF0F)
31574 {
31575         u32 adr, res;
31576         u32 src, dst;
31577
31578         adr = AREG(7);
31579         AREG(7) += 2;
31580         PRE_IO
31581         READ_BYTE_F(adr, src)
31582         adr = AREG(7);
31583         AREG(7) += 2;
31584         READ_BYTE_F(adr, dst)
31585         res = dst - src;
31586         flag_N = flag_C = res;
31587         flag_V = (src ^ dst) & (res ^ dst);
31588         flag_NotZ = res & 0xFF;
31589         POST_IO
31590 RET(12)
31591 }
31592
31593 // CMP7M7
31594 OPCODE(0xBF4F)
31595 {
31596         u32 adr, res;
31597         u32 src, dst;
31598
31599         adr = AREG(7);
31600         AREG(7) += 2;
31601         PRE_IO
31602         READ_WORD_F(adr, src)
31603         adr = AREG(7);
31604         AREG(7) += 2;
31605         READ_WORD_F(adr, dst)
31606         res = dst - src;
31607         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31608         flag_N = flag_C = res >> 8;
31609         flag_NotZ = res & 0xFFFF;
31610         POST_IO
31611 RET(12)
31612 }
31613
31614 // CMP7M7
31615 OPCODE(0xBF8F)
31616 {
31617         u32 adr, res;
31618         u32 src, dst;
31619
31620         adr = AREG(7);
31621         AREG(7) += 4;
31622         PRE_IO
31623         READ_LONG_F(adr, src)
31624         adr = AREG(7);
31625         AREG(7) += 4;
31626         READ_LONG_F(adr, dst)
31627         res = dst - src;
31628         flag_NotZ = res;
31629         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31630         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31631         flag_N = res >> 24;
31632         POST_IO
31633 RET(20)
31634 }
31635
31636 // EORDa
31637 OPCODE(0xB100)
31638 {
31639         u32 adr, res;
31640         u32 src, dst;
31641
31642         src = DREGu8((Opcode >> 9) & 7);
31643         res = DREGu8((Opcode >> 0) & 7);
31644         res ^= src;
31645         flag_C = 0;
31646         flag_V = 0;
31647         flag_NotZ = res;
31648         flag_N = res;
31649         DREGu8((Opcode >> 0) & 7) = res;
31650 RET(4)
31651 }
31652
31653 // EORDa
31654 OPCODE(0xB110)
31655 {
31656         u32 adr, res;
31657         u32 src, dst;
31658
31659         src = DREGu8((Opcode >> 9) & 7);
31660         adr = AREG((Opcode >> 0) & 7);
31661         PRE_IO
31662         READ_BYTE_F(adr, res)
31663         res ^= src;
31664         flag_C = 0;
31665         flag_V = 0;
31666         flag_NotZ = res;
31667         flag_N = res;
31668         WRITE_BYTE_F(adr, res)
31669         POST_IO
31670 RET(12)
31671 }
31672
31673 // EORDa
31674 OPCODE(0xB118)
31675 {
31676         u32 adr, res;
31677         u32 src, dst;
31678
31679         src = DREGu8((Opcode >> 9) & 7);
31680         adr = AREG((Opcode >> 0) & 7);
31681         AREG((Opcode >> 0) & 7) += 1;
31682         PRE_IO
31683         READ_BYTE_F(adr, res)
31684         res ^= src;
31685         flag_C = 0;
31686         flag_V = 0;
31687         flag_NotZ = res;
31688         flag_N = res;
31689         WRITE_BYTE_F(adr, res)
31690         POST_IO
31691 RET(12)
31692 }
31693
31694 // EORDa
31695 OPCODE(0xB120)
31696 {
31697         u32 adr, res;
31698         u32 src, dst;
31699
31700         src = DREGu8((Opcode >> 9) & 7);
31701         adr = AREG((Opcode >> 0) & 7) - 1;
31702         AREG((Opcode >> 0) & 7) = adr;
31703         PRE_IO
31704         READ_BYTE_F(adr, res)
31705         res ^= src;
31706         flag_C = 0;
31707         flag_V = 0;
31708         flag_NotZ = res;
31709         flag_N = res;
31710         WRITE_BYTE_F(adr, res)
31711         POST_IO
31712 RET(14)
31713 }
31714
31715 // EORDa
31716 OPCODE(0xB128)
31717 {
31718         u32 adr, res;
31719         u32 src, dst;
31720
31721         src = DREGu8((Opcode >> 9) & 7);
31722         FETCH_SWORD(adr);
31723         adr += AREG((Opcode >> 0) & 7);
31724         PRE_IO
31725         READ_BYTE_F(adr, res)
31726         res ^= src;
31727         flag_C = 0;
31728         flag_V = 0;
31729         flag_NotZ = res;
31730         flag_N = res;
31731         WRITE_BYTE_F(adr, res)
31732         POST_IO
31733 RET(16)
31734 }
31735
31736 // EORDa
31737 OPCODE(0xB130)
31738 {
31739         u32 adr, res;
31740         u32 src, dst;
31741
31742         src = DREGu8((Opcode >> 9) & 7);
31743         adr = AREG((Opcode >> 0) & 7);
31744         DECODE_EXT_WORD
31745         PRE_IO
31746         READ_BYTE_F(adr, res)
31747         res ^= src;
31748         flag_C = 0;
31749         flag_V = 0;
31750         flag_NotZ = res;
31751         flag_N = res;
31752         WRITE_BYTE_F(adr, res)
31753         POST_IO
31754 RET(18)
31755 }
31756
31757 // EORDa
31758 OPCODE(0xB138)
31759 {
31760         u32 adr, res;
31761         u32 src, dst;
31762
31763         src = DREGu8((Opcode >> 9) & 7);
31764         FETCH_SWORD(adr);
31765         PRE_IO
31766         READ_BYTE_F(adr, res)
31767         res ^= src;
31768         flag_C = 0;
31769         flag_V = 0;
31770         flag_NotZ = res;
31771         flag_N = res;
31772         WRITE_BYTE_F(adr, res)
31773         POST_IO
31774 RET(16)
31775 }
31776
31777 // EORDa
31778 OPCODE(0xB139)
31779 {
31780         u32 adr, res;
31781         u32 src, dst;
31782
31783         src = DREGu8((Opcode >> 9) & 7);
31784         FETCH_LONG(adr);
31785         PRE_IO
31786         READ_BYTE_F(adr, res)
31787         res ^= src;
31788         flag_C = 0;
31789         flag_V = 0;
31790         flag_NotZ = res;
31791         flag_N = res;
31792         WRITE_BYTE_F(adr, res)
31793         POST_IO
31794 RET(20)
31795 }
31796
31797 // EORDa
31798 OPCODE(0xB11F)
31799 {
31800         u32 adr, res;
31801         u32 src, dst;
31802
31803         src = DREGu8((Opcode >> 9) & 7);
31804         adr = AREG(7);
31805         AREG(7) += 2;
31806         PRE_IO
31807         READ_BYTE_F(adr, res)
31808         res ^= src;
31809         flag_C = 0;
31810         flag_V = 0;
31811         flag_NotZ = res;
31812         flag_N = res;
31813         WRITE_BYTE_F(adr, res)
31814         POST_IO
31815 RET(12)
31816 }
31817
31818 // EORDa
31819 OPCODE(0xB127)
31820 {
31821         u32 adr, res;
31822         u32 src, dst;
31823
31824         src = DREGu8((Opcode >> 9) & 7);
31825         adr = AREG(7) - 2;
31826         AREG(7) = adr;
31827         PRE_IO
31828         READ_BYTE_F(adr, res)
31829         res ^= src;
31830         flag_C = 0;
31831         flag_V = 0;
31832         flag_NotZ = res;
31833         flag_N = res;
31834         WRITE_BYTE_F(adr, res)
31835         POST_IO
31836 RET(14)
31837 }
31838
31839 // EORDa
31840 OPCODE(0xB140)
31841 {
31842         u32 adr, res;
31843         u32 src, dst;
31844
31845         src = DREGu16((Opcode >> 9) & 7);
31846         res = DREGu16((Opcode >> 0) & 7);
31847         res ^= src;
31848         flag_C = 0;
31849         flag_V = 0;
31850         flag_NotZ = res;
31851         flag_N = res >> 8;
31852         DREGu16((Opcode >> 0) & 7) = res;
31853 RET(4)
31854 }
31855
31856 // EORDa
31857 OPCODE(0xB150)
31858 {
31859         u32 adr, res;
31860         u32 src, dst;
31861
31862         src = DREGu16((Opcode >> 9) & 7);
31863         adr = AREG((Opcode >> 0) & 7);
31864         PRE_IO
31865         READ_WORD_F(adr, res)
31866         res ^= src;
31867         flag_C = 0;
31868         flag_V = 0;
31869         flag_NotZ = res;
31870         flag_N = res >> 8;
31871         WRITE_WORD_F(adr, res)
31872         POST_IO
31873 RET(12)
31874 }
31875
31876 // EORDa
31877 OPCODE(0xB158)
31878 {
31879         u32 adr, res;
31880         u32 src, dst;
31881
31882         src = DREGu16((Opcode >> 9) & 7);
31883         adr = AREG((Opcode >> 0) & 7);
31884         AREG((Opcode >> 0) & 7) += 2;
31885         PRE_IO
31886         READ_WORD_F(adr, res)
31887         res ^= src;
31888         flag_C = 0;
31889         flag_V = 0;
31890         flag_NotZ = res;
31891         flag_N = res >> 8;
31892         WRITE_WORD_F(adr, res)
31893         POST_IO
31894 RET(12)
31895 }
31896
31897 // EORDa
31898 OPCODE(0xB160)
31899 {
31900         u32 adr, res;
31901         u32 src, dst;
31902
31903         src = DREGu16((Opcode >> 9) & 7);
31904         adr = AREG((Opcode >> 0) & 7) - 2;
31905         AREG((Opcode >> 0) & 7) = adr;
31906         PRE_IO
31907         READ_WORD_F(adr, res)
31908         res ^= src;
31909         flag_C = 0;
31910         flag_V = 0;
31911         flag_NotZ = res;
31912         flag_N = res >> 8;
31913         WRITE_WORD_F(adr, res)
31914         POST_IO
31915 RET(14)
31916 }
31917
31918 // EORDa
31919 OPCODE(0xB168)
31920 {
31921         u32 adr, res;
31922         u32 src, dst;
31923
31924         src = DREGu16((Opcode >> 9) & 7);
31925         FETCH_SWORD(adr);
31926         adr += AREG((Opcode >> 0) & 7);
31927         PRE_IO
31928         READ_WORD_F(adr, res)
31929         res ^= src;
31930         flag_C = 0;
31931         flag_V = 0;
31932         flag_NotZ = res;
31933         flag_N = res >> 8;
31934         WRITE_WORD_F(adr, res)
31935         POST_IO
31936 RET(16)
31937 }
31938
31939 // EORDa
31940 OPCODE(0xB170)
31941 {
31942         u32 adr, res;
31943         u32 src, dst;
31944
31945         src = DREGu16((Opcode >> 9) & 7);
31946         adr = AREG((Opcode >> 0) & 7);
31947         DECODE_EXT_WORD
31948         PRE_IO
31949         READ_WORD_F(adr, res)
31950         res ^= src;
31951         flag_C = 0;
31952         flag_V = 0;
31953         flag_NotZ = res;
31954         flag_N = res >> 8;
31955         WRITE_WORD_F(adr, res)
31956         POST_IO
31957 RET(18)
31958 }
31959
31960 // EORDa
31961 OPCODE(0xB178)
31962 {
31963         u32 adr, res;
31964         u32 src, dst;
31965
31966         src = DREGu16((Opcode >> 9) & 7);
31967         FETCH_SWORD(adr);
31968         PRE_IO
31969         READ_WORD_F(adr, res)
31970         res ^= src;
31971         flag_C = 0;
31972         flag_V = 0;
31973         flag_NotZ = res;
31974         flag_N = res >> 8;
31975         WRITE_WORD_F(adr, res)
31976         POST_IO
31977 RET(16)
31978 }
31979
31980 // EORDa
31981 OPCODE(0xB179)
31982 {
31983         u32 adr, res;
31984         u32 src, dst;
31985
31986         src = DREGu16((Opcode >> 9) & 7);
31987         FETCH_LONG(adr);
31988         PRE_IO
31989         READ_WORD_F(adr, res)
31990         res ^= src;
31991         flag_C = 0;
31992         flag_V = 0;
31993         flag_NotZ = res;
31994         flag_N = res >> 8;
31995         WRITE_WORD_F(adr, res)
31996         POST_IO
31997 RET(20)
31998 }
31999
32000 // EORDa
32001 OPCODE(0xB15F)
32002 {
32003         u32 adr, res;
32004         u32 src, dst;
32005
32006         src = DREGu16((Opcode >> 9) & 7);
32007         adr = AREG(7);
32008         AREG(7) += 2;
32009         PRE_IO
32010         READ_WORD_F(adr, res)
32011         res ^= src;
32012         flag_C = 0;
32013         flag_V = 0;
32014         flag_NotZ = res;
32015         flag_N = res >> 8;
32016         WRITE_WORD_F(adr, res)
32017         POST_IO
32018 RET(12)
32019 }
32020
32021 // EORDa
32022 OPCODE(0xB167)
32023 {
32024         u32 adr, res;
32025         u32 src, dst;
32026
32027         src = DREGu16((Opcode >> 9) & 7);
32028         adr = AREG(7) - 2;
32029         AREG(7) = adr;
32030         PRE_IO
32031         READ_WORD_F(adr, res)
32032         res ^= src;
32033         flag_C = 0;
32034         flag_V = 0;
32035         flag_NotZ = res;
32036         flag_N = res >> 8;
32037         WRITE_WORD_F(adr, res)
32038         POST_IO
32039 RET(14)
32040 }
32041
32042 // EORDa
32043 OPCODE(0xB180)
32044 {
32045         u32 adr, res;
32046         u32 src, dst;
32047
32048         src = DREGu32((Opcode >> 9) & 7);
32049         res = DREGu32((Opcode >> 0) & 7);
32050         res ^= src;
32051         flag_C = 0;
32052         flag_V = 0;
32053         flag_NotZ = res;
32054         flag_N = res >> 24;
32055         DREGu32((Opcode >> 0) & 7) = res;
32056 RET(8)
32057 }
32058
32059 // EORDa
32060 OPCODE(0xB190)
32061 {
32062         u32 adr, res;
32063         u32 src, dst;
32064
32065         src = DREGu32((Opcode >> 9) & 7);
32066         adr = AREG((Opcode >> 0) & 7);
32067         PRE_IO
32068         READ_LONG_F(adr, res)
32069         res ^= src;
32070         flag_C = 0;
32071         flag_V = 0;
32072         flag_NotZ = res;
32073         flag_N = res >> 24;
32074         WRITE_LONG_F(adr, res)
32075         POST_IO
32076 RET(20)
32077 }
32078
32079 // EORDa
32080 OPCODE(0xB198)
32081 {
32082         u32 adr, res;
32083         u32 src, dst;
32084
32085         src = DREGu32((Opcode >> 9) & 7);
32086         adr = AREG((Opcode >> 0) & 7);
32087         AREG((Opcode >> 0) & 7) += 4;
32088         PRE_IO
32089         READ_LONG_F(adr, res)
32090         res ^= src;
32091         flag_C = 0;
32092         flag_V = 0;
32093         flag_NotZ = res;
32094         flag_N = res >> 24;
32095         WRITE_LONG_F(adr, res)
32096         POST_IO
32097 RET(20)
32098 }
32099
32100 // EORDa
32101 OPCODE(0xB1A0)
32102 {
32103         u32 adr, res;
32104         u32 src, dst;
32105
32106         src = DREGu32((Opcode >> 9) & 7);
32107         adr = AREG((Opcode >> 0) & 7) - 4;
32108         AREG((Opcode >> 0) & 7) = adr;
32109         PRE_IO
32110         READ_LONG_F(adr, res)
32111         res ^= src;
32112         flag_C = 0;
32113         flag_V = 0;
32114         flag_NotZ = res;
32115         flag_N = res >> 24;
32116         WRITE_LONG_F(adr, res)
32117         POST_IO
32118 RET(22)
32119 }
32120
32121 // EORDa
32122 OPCODE(0xB1A8)
32123 {
32124         u32 adr, res;
32125         u32 src, dst;
32126
32127         src = DREGu32((Opcode >> 9) & 7);
32128         FETCH_SWORD(adr);
32129         adr += AREG((Opcode >> 0) & 7);
32130         PRE_IO
32131         READ_LONG_F(adr, res)
32132         res ^= src;
32133         flag_C = 0;
32134         flag_V = 0;
32135         flag_NotZ = res;
32136         flag_N = res >> 24;
32137         WRITE_LONG_F(adr, res)
32138         POST_IO
32139 RET(24)
32140 }
32141
32142 // EORDa
32143 OPCODE(0xB1B0)
32144 {
32145         u32 adr, res;
32146         u32 src, dst;
32147
32148         src = DREGu32((Opcode >> 9) & 7);
32149         adr = AREG((Opcode >> 0) & 7);
32150         DECODE_EXT_WORD
32151         PRE_IO
32152         READ_LONG_F(adr, res)
32153         res ^= src;
32154         flag_C = 0;
32155         flag_V = 0;
32156         flag_NotZ = res;
32157         flag_N = res >> 24;
32158         WRITE_LONG_F(adr, res)
32159         POST_IO
32160 RET(26)
32161 }
32162
32163 // EORDa
32164 OPCODE(0xB1B8)
32165 {
32166         u32 adr, res;
32167         u32 src, dst;
32168
32169         src = DREGu32((Opcode >> 9) & 7);
32170         FETCH_SWORD(adr);
32171         PRE_IO
32172         READ_LONG_F(adr, res)
32173         res ^= src;
32174         flag_C = 0;
32175         flag_V = 0;
32176         flag_NotZ = res;
32177         flag_N = res >> 24;
32178         WRITE_LONG_F(adr, res)
32179         POST_IO
32180 RET(24)
32181 }
32182
32183 // EORDa
32184 OPCODE(0xB1B9)
32185 {
32186         u32 adr, res;
32187         u32 src, dst;
32188
32189         src = DREGu32((Opcode >> 9) & 7);
32190         FETCH_LONG(adr);
32191         PRE_IO
32192         READ_LONG_F(adr, res)
32193         res ^= src;
32194         flag_C = 0;
32195         flag_V = 0;
32196         flag_NotZ = res;
32197         flag_N = res >> 24;
32198         WRITE_LONG_F(adr, res)
32199         POST_IO
32200 RET(28)
32201 }
32202
32203 // EORDa
32204 OPCODE(0xB19F)
32205 {
32206         u32 adr, res;
32207         u32 src, dst;
32208
32209         src = DREGu32((Opcode >> 9) & 7);
32210         adr = AREG(7);
32211         AREG(7) += 4;
32212         PRE_IO
32213         READ_LONG_F(adr, res)
32214         res ^= src;
32215         flag_C = 0;
32216         flag_V = 0;
32217         flag_NotZ = res;
32218         flag_N = res >> 24;
32219         WRITE_LONG_F(adr, res)
32220         POST_IO
32221 RET(20)
32222 }
32223
32224 // EORDa
32225 OPCODE(0xB1A7)
32226 {
32227         u32 adr, res;
32228         u32 src, dst;
32229
32230         src = DREGu32((Opcode >> 9) & 7);
32231         adr = AREG(7) - 4;
32232         AREG(7) = adr;
32233         PRE_IO
32234         READ_LONG_F(adr, res)
32235         res ^= src;
32236         flag_C = 0;
32237         flag_V = 0;
32238         flag_NotZ = res;
32239         flag_N = res >> 24;
32240         WRITE_LONG_F(adr, res)
32241         POST_IO
32242 RET(22)
32243 }
32244
32245 // CMPA
32246 OPCODE(0xB0C0)
32247 {
32248         u32 adr, res;
32249         u32 src, dst;
32250
32251         src = (s32)DREGs16((Opcode >> 0) & 7);
32252         dst = AREGu32((Opcode >> 9) & 7);
32253         res = dst - src;
32254         flag_NotZ = res;
32255         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32256         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32257         flag_N = res >> 24;
32258 RET(6)
32259 }
32260
32261 // CMPA
32262 OPCODE(0xB0C8)
32263 {
32264         u32 adr, res;
32265         u32 src, dst;
32266
32267         src = (s32)AREGs16((Opcode >> 0) & 7);
32268         dst = AREGu32((Opcode >> 9) & 7);
32269         res = dst - src;
32270         flag_NotZ = res;
32271         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32272         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32273         flag_N = res >> 24;
32274 RET(6)
32275 }
32276
32277 // CMPA
32278 OPCODE(0xB0D0)
32279 {
32280         u32 adr, res;
32281         u32 src, dst;
32282
32283         adr = AREG((Opcode >> 0) & 7);
32284         PRE_IO
32285         READSX_WORD_F(adr, src)
32286         dst = AREGu32((Opcode >> 9) & 7);
32287         res = dst - src;
32288         flag_NotZ = res;
32289         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32290         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32291         flag_N = res >> 24;
32292         POST_IO
32293 RET(10)
32294 }
32295
32296 // CMPA
32297 OPCODE(0xB0D8)
32298 {
32299         u32 adr, res;
32300         u32 src, dst;
32301
32302         adr = AREG((Opcode >> 0) & 7);
32303         AREG((Opcode >> 0) & 7) += 2;
32304         PRE_IO
32305         READSX_WORD_F(adr, src)
32306         dst = AREGu32((Opcode >> 9) & 7);
32307         res = dst - src;
32308         flag_NotZ = res;
32309         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32310         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32311         flag_N = res >> 24;
32312         POST_IO
32313 RET(10)
32314 }
32315
32316 // CMPA
32317 OPCODE(0xB0E0)
32318 {
32319         u32 adr, res;
32320         u32 src, dst;
32321
32322         adr = AREG((Opcode >> 0) & 7) - 2;
32323         AREG((Opcode >> 0) & 7) = adr;
32324         PRE_IO
32325         READSX_WORD_F(adr, src)
32326         dst = AREGu32((Opcode >> 9) & 7);
32327         res = dst - src;
32328         flag_NotZ = res;
32329         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32330         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32331         flag_N = res >> 24;
32332         POST_IO
32333 RET(12)
32334 }
32335
32336 // CMPA
32337 OPCODE(0xB0E8)
32338 {
32339         u32 adr, res;
32340         u32 src, dst;
32341
32342         FETCH_SWORD(adr);
32343         adr += AREG((Opcode >> 0) & 7);
32344         PRE_IO
32345         READSX_WORD_F(adr, src)
32346         dst = AREGu32((Opcode >> 9) & 7);
32347         res = dst - src;
32348         flag_NotZ = res;
32349         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32350         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32351         flag_N = res >> 24;
32352         POST_IO
32353 RET(14)
32354 }
32355
32356 // CMPA
32357 OPCODE(0xB0F0)
32358 {
32359         u32 adr, res;
32360         u32 src, dst;
32361
32362         adr = AREG((Opcode >> 0) & 7);
32363         DECODE_EXT_WORD
32364         PRE_IO
32365         READSX_WORD_F(adr, src)
32366         dst = AREGu32((Opcode >> 9) & 7);
32367         res = dst - src;
32368         flag_NotZ = res;
32369         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32370         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32371         flag_N = res >> 24;
32372         POST_IO
32373 RET(16)
32374 }
32375
32376 // CMPA
32377 OPCODE(0xB0F8)
32378 {
32379         u32 adr, res;
32380         u32 src, dst;
32381
32382         FETCH_SWORD(adr);
32383         PRE_IO
32384         READSX_WORD_F(adr, src)
32385         dst = AREGu32((Opcode >> 9) & 7);
32386         res = dst - src;
32387         flag_NotZ = res;
32388         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32389         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32390         flag_N = res >> 24;
32391         POST_IO
32392 RET(14)
32393 }
32394
32395 // CMPA
32396 OPCODE(0xB0F9)
32397 {
32398         u32 adr, res;
32399         u32 src, dst;
32400
32401         FETCH_LONG(adr);
32402         PRE_IO
32403         READSX_WORD_F(adr, src)
32404         dst = AREGu32((Opcode >> 9) & 7);
32405         res = dst - src;
32406         flag_NotZ = res;
32407         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32408         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32409         flag_N = res >> 24;
32410         POST_IO
32411 RET(18)
32412 }
32413
32414 // CMPA
32415 OPCODE(0xB0FA)
32416 {
32417         u32 adr, res;
32418         u32 src, dst;
32419
32420         adr = GET_SWORD + GET_PC;
32421         PC++;
32422         PRE_IO
32423         READSX_WORD_F(adr, src)
32424         dst = AREGu32((Opcode >> 9) & 7);
32425         res = dst - src;
32426         flag_NotZ = res;
32427         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32428         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32429         flag_N = res >> 24;
32430         POST_IO
32431 RET(14)
32432 }
32433
32434 // CMPA
32435 OPCODE(0xB0FB)
32436 {
32437         u32 adr, res;
32438         u32 src, dst;
32439
32440         adr = GET_PC;
32441         DECODE_EXT_WORD
32442         PRE_IO
32443         READSX_WORD_F(adr, src)
32444         dst = AREGu32((Opcode >> 9) & 7);
32445         res = dst - src;
32446         flag_NotZ = res;
32447         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32448         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32449         flag_N = res >> 24;
32450         POST_IO
32451 RET(16)
32452 }
32453
32454 // CMPA
32455 OPCODE(0xB0FC)
32456 {
32457         u32 adr, res;
32458         u32 src, dst;
32459
32460         FETCH_SWORD(src);
32461         dst = AREGu32((Opcode >> 9) & 7);
32462         res = dst - src;
32463         flag_NotZ = res;
32464         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32465         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32466         flag_N = res >> 24;
32467 RET(10)
32468 }
32469
32470 // CMPA
32471 OPCODE(0xB0DF)
32472 {
32473         u32 adr, res;
32474         u32 src, dst;
32475
32476         adr = AREG(7);
32477         AREG(7) += 2;
32478         PRE_IO
32479         READSX_WORD_F(adr, src)
32480         dst = AREGu32((Opcode >> 9) & 7);
32481         res = dst - src;
32482         flag_NotZ = res;
32483         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32484         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32485         flag_N = res >> 24;
32486         POST_IO
32487 RET(10)
32488 }
32489
32490 // CMPA
32491 OPCODE(0xB0E7)
32492 {
32493         u32 adr, res;
32494         u32 src, dst;
32495
32496         adr = AREG(7) - 2;
32497         AREG(7) = adr;
32498         PRE_IO
32499         READSX_WORD_F(adr, src)
32500         dst = AREGu32((Opcode >> 9) & 7);
32501         res = dst - src;
32502         flag_NotZ = res;
32503         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32504         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32505         flag_N = res >> 24;
32506         POST_IO
32507 RET(12)
32508 }
32509
32510 // CMPA
32511 OPCODE(0xB1C0)
32512 {
32513         u32 adr, res;
32514         u32 src, dst;
32515
32516         src = (s32)DREGs32((Opcode >> 0) & 7);
32517         dst = AREGu32((Opcode >> 9) & 7);
32518         res = dst - src;
32519         flag_NotZ = res;
32520         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32521         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32522         flag_N = res >> 24;
32523 RET(6)
32524 }
32525
32526 // CMPA
32527 OPCODE(0xB1C8)
32528 {
32529         u32 adr, res;
32530         u32 src, dst;
32531
32532         src = (s32)AREGs32((Opcode >> 0) & 7);
32533         dst = AREGu32((Opcode >> 9) & 7);
32534         res = dst - src;
32535         flag_NotZ = res;
32536         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32537         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32538         flag_N = res >> 24;
32539 RET(6)
32540 }
32541
32542 // CMPA
32543 OPCODE(0xB1D0)
32544 {
32545         u32 adr, res;
32546         u32 src, dst;
32547
32548         adr = AREG((Opcode >> 0) & 7);
32549         PRE_IO
32550         READSX_LONG_F(adr, src)
32551         dst = AREGu32((Opcode >> 9) & 7);
32552         res = dst - src;
32553         flag_NotZ = res;
32554         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32555         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32556         flag_N = res >> 24;
32557         POST_IO
32558 RET(14)
32559 }
32560
32561 // CMPA
32562 OPCODE(0xB1D8)
32563 {
32564         u32 adr, res;
32565         u32 src, dst;
32566
32567         adr = AREG((Opcode >> 0) & 7);
32568         AREG((Opcode >> 0) & 7) += 4;
32569         PRE_IO
32570         READSX_LONG_F(adr, src)
32571         dst = AREGu32((Opcode >> 9) & 7);
32572         res = dst - src;
32573         flag_NotZ = res;
32574         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32575         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32576         flag_N = res >> 24;
32577         POST_IO
32578 RET(14)
32579 }
32580
32581 // CMPA
32582 OPCODE(0xB1E0)
32583 {
32584         u32 adr, res;
32585         u32 src, dst;
32586
32587         adr = AREG((Opcode >> 0) & 7) - 4;
32588         AREG((Opcode >> 0) & 7) = adr;
32589         PRE_IO
32590         READSX_LONG_F(adr, src)
32591         dst = AREGu32((Opcode >> 9) & 7);
32592         res = dst - src;
32593         flag_NotZ = res;
32594         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32595         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32596         flag_N = res >> 24;
32597         POST_IO
32598 RET(16)
32599 }
32600
32601 // CMPA
32602 OPCODE(0xB1E8)
32603 {
32604         u32 adr, res;
32605         u32 src, dst;
32606
32607         FETCH_SWORD(adr);
32608         adr += AREG((Opcode >> 0) & 7);
32609         PRE_IO
32610         READSX_LONG_F(adr, src)
32611         dst = AREGu32((Opcode >> 9) & 7);
32612         res = dst - src;
32613         flag_NotZ = res;
32614         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32615         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32616         flag_N = res >> 24;
32617         POST_IO
32618 RET(18)
32619 }
32620
32621 // CMPA
32622 OPCODE(0xB1F0)
32623 {
32624         u32 adr, res;
32625         u32 src, dst;
32626
32627         adr = AREG((Opcode >> 0) & 7);
32628         DECODE_EXT_WORD
32629         PRE_IO
32630         READSX_LONG_F(adr, src)
32631         dst = AREGu32((Opcode >> 9) & 7);
32632         res = dst - src;
32633         flag_NotZ = res;
32634         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32635         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32636         flag_N = res >> 24;
32637         POST_IO
32638 RET(20)
32639 }
32640
32641 // CMPA
32642 OPCODE(0xB1F8)
32643 {
32644         u32 adr, res;
32645         u32 src, dst;
32646
32647         FETCH_SWORD(adr);
32648         PRE_IO
32649         READSX_LONG_F(adr, src)
32650         dst = AREGu32((Opcode >> 9) & 7);
32651         res = dst - src;
32652         flag_NotZ = res;
32653         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32654         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32655         flag_N = res >> 24;
32656         POST_IO
32657 RET(18)
32658 }
32659
32660 // CMPA
32661 OPCODE(0xB1F9)
32662 {
32663         u32 adr, res;
32664         u32 src, dst;
32665
32666         FETCH_LONG(adr);
32667         PRE_IO
32668         READSX_LONG_F(adr, src)
32669         dst = AREGu32((Opcode >> 9) & 7);
32670         res = dst - src;
32671         flag_NotZ = res;
32672         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32673         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32674         flag_N = res >> 24;
32675         POST_IO
32676 RET(22)
32677 }
32678
32679 // CMPA
32680 OPCODE(0xB1FA)
32681 {
32682         u32 adr, res;
32683         u32 src, dst;
32684
32685         adr = GET_SWORD + GET_PC;
32686         PC++;
32687         PRE_IO
32688         READSX_LONG_F(adr, src)
32689         dst = AREGu32((Opcode >> 9) & 7);
32690         res = dst - src;
32691         flag_NotZ = res;
32692         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32693         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32694         flag_N = res >> 24;
32695         POST_IO
32696 RET(18)
32697 }
32698
32699 // CMPA
32700 OPCODE(0xB1FB)
32701 {
32702         u32 adr, res;
32703         u32 src, dst;
32704
32705         adr = GET_PC;
32706         DECODE_EXT_WORD
32707         PRE_IO
32708         READSX_LONG_F(adr, src)
32709         dst = AREGu32((Opcode >> 9) & 7);
32710         res = dst - src;
32711         flag_NotZ = res;
32712         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32713         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32714         flag_N = res >> 24;
32715         POST_IO
32716 RET(20)
32717 }
32718
32719 // CMPA
32720 OPCODE(0xB1FC)
32721 {
32722         u32 adr, res;
32723         u32 src, dst;
32724
32725         FETCH_LONG(src);
32726         dst = AREGu32((Opcode >> 9) & 7);
32727         res = dst - src;
32728         flag_NotZ = res;
32729         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32730         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32731         flag_N = res >> 24;
32732 RET(14)
32733 }
32734
32735 // CMPA
32736 OPCODE(0xB1DF)
32737 {
32738         u32 adr, res;
32739         u32 src, dst;
32740
32741         adr = AREG(7);
32742         AREG(7) += 4;
32743         PRE_IO
32744         READSX_LONG_F(adr, src)
32745         dst = AREGu32((Opcode >> 9) & 7);
32746         res = dst - src;
32747         flag_NotZ = res;
32748         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32749         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32750         flag_N = res >> 24;
32751         POST_IO
32752 RET(14)
32753 }
32754
32755 // CMPA
32756 OPCODE(0xB1E7)
32757 {
32758         u32 adr, res;
32759         u32 src, dst;
32760
32761         adr = AREG(7) - 4;
32762         AREG(7) = adr;
32763         PRE_IO
32764         READSX_LONG_F(adr, src)
32765         dst = AREGu32((Opcode >> 9) & 7);
32766         res = dst - src;
32767         flag_NotZ = res;
32768         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32769         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32770         flag_N = res >> 24;
32771         POST_IO
32772 RET(16)
32773 }
32774
32775 // ANDaD
32776 OPCODE(0xC000)
32777 {
32778         u32 adr, res;
32779         u32 src, dst;
32780
32781         src = DREGu8((Opcode >> 0) & 7);
32782         res = DREGu8((Opcode >> 9) & 7);
32783         res &= src;
32784         flag_C = 0;
32785         flag_V = 0;
32786         flag_NotZ = res;
32787         flag_N = res;
32788         DREGu8((Opcode >> 9) & 7) = res;
32789 RET(4)
32790 }
32791
32792 // ANDaD
32793 OPCODE(0xC010)
32794 {
32795         u32 adr, res;
32796         u32 src, dst;
32797
32798         adr = AREG((Opcode >> 0) & 7);
32799         PRE_IO
32800         READ_BYTE_F(adr, src)
32801         res = DREGu8((Opcode >> 9) & 7);
32802         res &= src;
32803         flag_C = 0;
32804         flag_V = 0;
32805         flag_NotZ = res;
32806         flag_N = res;
32807         DREGu8((Opcode >> 9) & 7) = res;
32808         POST_IO
32809 RET(8)
32810 }
32811
32812 // ANDaD
32813 OPCODE(0xC018)
32814 {
32815         u32 adr, res;
32816         u32 src, dst;
32817
32818         adr = AREG((Opcode >> 0) & 7);
32819         AREG((Opcode >> 0) & 7) += 1;
32820         PRE_IO
32821         READ_BYTE_F(adr, src)
32822         res = DREGu8((Opcode >> 9) & 7);
32823         res &= src;
32824         flag_C = 0;
32825         flag_V = 0;
32826         flag_NotZ = res;
32827         flag_N = res;
32828         DREGu8((Opcode >> 9) & 7) = res;
32829         POST_IO
32830 RET(8)
32831 }
32832
32833 // ANDaD
32834 OPCODE(0xC020)
32835 {
32836         u32 adr, res;
32837         u32 src, dst;
32838
32839         adr = AREG((Opcode >> 0) & 7) - 1;
32840         AREG((Opcode >> 0) & 7) = adr;
32841         PRE_IO
32842         READ_BYTE_F(adr, src)
32843         res = DREGu8((Opcode >> 9) & 7);
32844         res &= src;
32845         flag_C = 0;
32846         flag_V = 0;
32847         flag_NotZ = res;
32848         flag_N = res;
32849         DREGu8((Opcode >> 9) & 7) = res;
32850         POST_IO
32851 RET(10)
32852 }
32853
32854 // ANDaD
32855 OPCODE(0xC028)
32856 {
32857         u32 adr, res;
32858         u32 src, dst;
32859
32860         FETCH_SWORD(adr);
32861         adr += AREG((Opcode >> 0) & 7);
32862         PRE_IO
32863         READ_BYTE_F(adr, src)
32864         res = DREGu8((Opcode >> 9) & 7);
32865         res &= src;
32866         flag_C = 0;
32867         flag_V = 0;
32868         flag_NotZ = res;
32869         flag_N = res;
32870         DREGu8((Opcode >> 9) & 7) = res;
32871         POST_IO
32872 RET(12)
32873 }
32874
32875 // ANDaD
32876 OPCODE(0xC030)
32877 {
32878         u32 adr, res;
32879         u32 src, dst;
32880
32881         adr = AREG((Opcode >> 0) & 7);
32882         DECODE_EXT_WORD
32883         PRE_IO
32884         READ_BYTE_F(adr, src)
32885         res = DREGu8((Opcode >> 9) & 7);
32886         res &= src;
32887         flag_C = 0;
32888         flag_V = 0;
32889         flag_NotZ = res;
32890         flag_N = res;
32891         DREGu8((Opcode >> 9) & 7) = res;
32892         POST_IO
32893 RET(14)
32894 }
32895
32896 // ANDaD
32897 OPCODE(0xC038)
32898 {
32899         u32 adr, res;
32900         u32 src, dst;
32901
32902         FETCH_SWORD(adr);
32903         PRE_IO
32904         READ_BYTE_F(adr, src)
32905         res = DREGu8((Opcode >> 9) & 7);
32906         res &= src;
32907         flag_C = 0;
32908         flag_V = 0;
32909         flag_NotZ = res;
32910         flag_N = res;
32911         DREGu8((Opcode >> 9) & 7) = res;
32912         POST_IO
32913 RET(12)
32914 }
32915
32916 // ANDaD
32917 OPCODE(0xC039)
32918 {
32919         u32 adr, res;
32920         u32 src, dst;
32921
32922         FETCH_LONG(adr);
32923         PRE_IO
32924         READ_BYTE_F(adr, src)
32925         res = DREGu8((Opcode >> 9) & 7);
32926         res &= src;
32927         flag_C = 0;
32928         flag_V = 0;
32929         flag_NotZ = res;
32930         flag_N = res;
32931         DREGu8((Opcode >> 9) & 7) = res;
32932         POST_IO
32933 RET(16)
32934 }
32935
32936 // ANDaD
32937 OPCODE(0xC03A)
32938 {
32939         u32 adr, res;
32940         u32 src, dst;
32941
32942         adr = GET_SWORD + GET_PC;
32943         PC++;
32944         PRE_IO
32945         READ_BYTE_F(adr, src)
32946         res = DREGu8((Opcode >> 9) & 7);
32947         res &= src;
32948         flag_C = 0;
32949         flag_V = 0;
32950         flag_NotZ = res;
32951         flag_N = res;
32952         DREGu8((Opcode >> 9) & 7) = res;
32953         POST_IO
32954 RET(12)
32955 }
32956
32957 // ANDaD
32958 OPCODE(0xC03B)
32959 {
32960         u32 adr, res;
32961         u32 src, dst;
32962
32963         adr = GET_PC;
32964         DECODE_EXT_WORD
32965         PRE_IO
32966         READ_BYTE_F(adr, src)
32967         res = DREGu8((Opcode >> 9) & 7);
32968         res &= src;
32969         flag_C = 0;
32970         flag_V = 0;
32971         flag_NotZ = res;
32972         flag_N = res;
32973         DREGu8((Opcode >> 9) & 7) = res;
32974         POST_IO
32975 RET(14)
32976 }
32977
32978 // ANDaD
32979 OPCODE(0xC03C)
32980 {
32981         u32 adr, res;
32982         u32 src, dst;
32983
32984         FETCH_BYTE(src);
32985         res = DREGu8((Opcode >> 9) & 7);
32986         res &= src;
32987         flag_C = 0;
32988         flag_V = 0;
32989         flag_NotZ = res;
32990         flag_N = res;
32991         DREGu8((Opcode >> 9) & 7) = res;
32992 RET(8)
32993 }
32994
32995 // ANDaD
32996 OPCODE(0xC01F)
32997 {
32998         u32 adr, res;
32999         u32 src, dst;
33000
33001         adr = AREG(7);
33002         AREG(7) += 2;
33003         PRE_IO
33004         READ_BYTE_F(adr, src)
33005         res = DREGu8((Opcode >> 9) & 7);
33006         res &= src;
33007         flag_C = 0;
33008         flag_V = 0;
33009         flag_NotZ = res;
33010         flag_N = res;
33011         DREGu8((Opcode >> 9) & 7) = res;
33012         POST_IO
33013 RET(8)
33014 }
33015
33016 // ANDaD
33017 OPCODE(0xC027)
33018 {
33019         u32 adr, res;
33020         u32 src, dst;
33021
33022         adr = AREG(7) - 2;
33023         AREG(7) = adr;
33024         PRE_IO
33025         READ_BYTE_F(adr, src)
33026         res = DREGu8((Opcode >> 9) & 7);
33027         res &= src;
33028         flag_C = 0;
33029         flag_V = 0;
33030         flag_NotZ = res;
33031         flag_N = res;
33032         DREGu8((Opcode >> 9) & 7) = res;
33033         POST_IO
33034 RET(10)
33035 }
33036
33037 // ANDaD
33038 OPCODE(0xC040)
33039 {
33040         u32 adr, res;
33041         u32 src, dst;
33042
33043         src = DREGu16((Opcode >> 0) & 7);
33044         res = DREGu16((Opcode >> 9) & 7);
33045         res &= src;
33046         flag_C = 0;
33047         flag_V = 0;
33048         flag_NotZ = res;
33049         flag_N = res >> 8;
33050         DREGu16((Opcode >> 9) & 7) = res;
33051 RET(4)
33052 }
33053
33054 // ANDaD
33055 OPCODE(0xC050)
33056 {
33057         u32 adr, res;
33058         u32 src, dst;
33059
33060         adr = AREG((Opcode >> 0) & 7);
33061         PRE_IO
33062         READ_WORD_F(adr, src)
33063         res = DREGu16((Opcode >> 9) & 7);
33064         res &= src;
33065         flag_C = 0;
33066         flag_V = 0;
33067         flag_NotZ = res;
33068         flag_N = res >> 8;
33069         DREGu16((Opcode >> 9) & 7) = res;
33070         POST_IO
33071 RET(8)
33072 }
33073
33074 // ANDaD
33075 OPCODE(0xC058)
33076 {
33077         u32 adr, res;
33078         u32 src, dst;
33079
33080         adr = AREG((Opcode >> 0) & 7);
33081         AREG((Opcode >> 0) & 7) += 2;
33082         PRE_IO
33083         READ_WORD_F(adr, src)
33084         res = DREGu16((Opcode >> 9) & 7);
33085         res &= src;
33086         flag_C = 0;
33087         flag_V = 0;
33088         flag_NotZ = res;
33089         flag_N = res >> 8;
33090         DREGu16((Opcode >> 9) & 7) = res;
33091         POST_IO
33092 RET(8)
33093 }
33094
33095 // ANDaD
33096 OPCODE(0xC060)
33097 {
33098         u32 adr, res;
33099         u32 src, dst;
33100
33101         adr = AREG((Opcode >> 0) & 7) - 2;
33102         AREG((Opcode >> 0) & 7) = adr;
33103         PRE_IO
33104         READ_WORD_F(adr, src)
33105         res = DREGu16((Opcode >> 9) & 7);
33106         res &= src;
33107         flag_C = 0;
33108         flag_V = 0;
33109         flag_NotZ = res;
33110         flag_N = res >> 8;
33111         DREGu16((Opcode >> 9) & 7) = res;
33112         POST_IO
33113 RET(10)
33114 }
33115
33116 // ANDaD
33117 OPCODE(0xC068)
33118 {
33119         u32 adr, res;
33120         u32 src, dst;
33121
33122         FETCH_SWORD(adr);
33123         adr += AREG((Opcode >> 0) & 7);
33124         PRE_IO
33125         READ_WORD_F(adr, src)
33126         res = DREGu16((Opcode >> 9) & 7);
33127         res &= src;
33128         flag_C = 0;
33129         flag_V = 0;
33130         flag_NotZ = res;
33131         flag_N = res >> 8;
33132         DREGu16((Opcode >> 9) & 7) = res;
33133         POST_IO
33134 RET(12)
33135 }
33136
33137 // ANDaD
33138 OPCODE(0xC070)
33139 {
33140         u32 adr, res;
33141         u32 src, dst;
33142
33143         adr = AREG((Opcode >> 0) & 7);
33144         DECODE_EXT_WORD
33145         PRE_IO
33146         READ_WORD_F(adr, src)
33147         res = DREGu16((Opcode >> 9) & 7);
33148         res &= src;
33149         flag_C = 0;
33150         flag_V = 0;
33151         flag_NotZ = res;
33152         flag_N = res >> 8;
33153         DREGu16((Opcode >> 9) & 7) = res;
33154         POST_IO
33155 RET(14)
33156 }
33157
33158 // ANDaD
33159 OPCODE(0xC078)
33160 {
33161         u32 adr, res;
33162         u32 src, dst;
33163
33164         FETCH_SWORD(adr);
33165         PRE_IO
33166         READ_WORD_F(adr, src)
33167         res = DREGu16((Opcode >> 9) & 7);
33168         res &= src;
33169         flag_C = 0;
33170         flag_V = 0;
33171         flag_NotZ = res;
33172         flag_N = res >> 8;
33173         DREGu16((Opcode >> 9) & 7) = res;
33174         POST_IO
33175 RET(12)
33176 }
33177
33178 // ANDaD
33179 OPCODE(0xC079)
33180 {
33181         u32 adr, res;
33182         u32 src, dst;
33183
33184         FETCH_LONG(adr);
33185         PRE_IO
33186         READ_WORD_F(adr, src)
33187         res = DREGu16((Opcode >> 9) & 7);
33188         res &= src;
33189         flag_C = 0;
33190         flag_V = 0;
33191         flag_NotZ = res;
33192         flag_N = res >> 8;
33193         DREGu16((Opcode >> 9) & 7) = res;
33194         POST_IO
33195 RET(16)
33196 }
33197
33198 // ANDaD
33199 OPCODE(0xC07A)
33200 {
33201         u32 adr, res;
33202         u32 src, dst;
33203
33204         adr = GET_SWORD + GET_PC;
33205         PC++;
33206         PRE_IO
33207         READ_WORD_F(adr, src)
33208         res = DREGu16((Opcode >> 9) & 7);
33209         res &= src;
33210         flag_C = 0;
33211         flag_V = 0;
33212         flag_NotZ = res;
33213         flag_N = res >> 8;
33214         DREGu16((Opcode >> 9) & 7) = res;
33215         POST_IO
33216 RET(12)
33217 }
33218
33219 // ANDaD
33220 OPCODE(0xC07B)
33221 {
33222         u32 adr, res;
33223         u32 src, dst;
33224
33225         adr = GET_PC;
33226         DECODE_EXT_WORD
33227         PRE_IO
33228         READ_WORD_F(adr, src)
33229         res = DREGu16((Opcode >> 9) & 7);
33230         res &= src;
33231         flag_C = 0;
33232         flag_V = 0;
33233         flag_NotZ = res;
33234         flag_N = res >> 8;
33235         DREGu16((Opcode >> 9) & 7) = res;
33236         POST_IO
33237 RET(14)
33238 }
33239
33240 // ANDaD
33241 OPCODE(0xC07C)
33242 {
33243         u32 adr, res;
33244         u32 src, dst;
33245
33246         FETCH_WORD(src);
33247         res = DREGu16((Opcode >> 9) & 7);
33248         res &= src;
33249         flag_C = 0;
33250         flag_V = 0;
33251         flag_NotZ = res;
33252         flag_N = res >> 8;
33253         DREGu16((Opcode >> 9) & 7) = res;
33254 RET(8)
33255 }
33256
33257 // ANDaD
33258 OPCODE(0xC05F)
33259 {
33260         u32 adr, res;
33261         u32 src, dst;
33262
33263         adr = AREG(7);
33264         AREG(7) += 2;
33265         PRE_IO
33266         READ_WORD_F(adr, src)
33267         res = DREGu16((Opcode >> 9) & 7);
33268         res &= src;
33269         flag_C = 0;
33270         flag_V = 0;
33271         flag_NotZ = res;
33272         flag_N = res >> 8;
33273         DREGu16((Opcode >> 9) & 7) = res;
33274         POST_IO
33275 RET(8)
33276 }
33277
33278 // ANDaD
33279 OPCODE(0xC067)
33280 {
33281         u32 adr, res;
33282         u32 src, dst;
33283
33284         adr = AREG(7) - 2;
33285         AREG(7) = adr;
33286         PRE_IO
33287         READ_WORD_F(adr, src)
33288         res = DREGu16((Opcode >> 9) & 7);
33289         res &= src;
33290         flag_C = 0;
33291         flag_V = 0;
33292         flag_NotZ = res;
33293         flag_N = res >> 8;
33294         DREGu16((Opcode >> 9) & 7) = res;
33295         POST_IO
33296 RET(10)
33297 }
33298
33299 // ANDaD
33300 OPCODE(0xC080)
33301 {
33302         u32 adr, res;
33303         u32 src, dst;
33304
33305         src = DREGu32((Opcode >> 0) & 7);
33306         res = DREGu32((Opcode >> 9) & 7);
33307         res &= src;
33308         flag_C = 0;
33309         flag_V = 0;
33310         flag_NotZ = res;
33311         flag_N = res >> 24;
33312         DREGu32((Opcode >> 9) & 7) = res;
33313 RET(8)
33314 }
33315
33316 // ANDaD
33317 OPCODE(0xC090)
33318 {
33319         u32 adr, res;
33320         u32 src, dst;
33321
33322         adr = AREG((Opcode >> 0) & 7);
33323         PRE_IO
33324         READ_LONG_F(adr, src)
33325         res = DREGu32((Opcode >> 9) & 7);
33326         res &= src;
33327         flag_C = 0;
33328         flag_V = 0;
33329         flag_NotZ = res;
33330         flag_N = res >> 24;
33331         DREGu32((Opcode >> 9) & 7) = res;
33332         POST_IO
33333 RET(14)
33334 }
33335
33336 // ANDaD
33337 OPCODE(0xC098)
33338 {
33339         u32 adr, res;
33340         u32 src, dst;
33341
33342         adr = AREG((Opcode >> 0) & 7);
33343         AREG((Opcode >> 0) & 7) += 4;
33344         PRE_IO
33345         READ_LONG_F(adr, src)
33346         res = DREGu32((Opcode >> 9) & 7);
33347         res &= src;
33348         flag_C = 0;
33349         flag_V = 0;
33350         flag_NotZ = res;
33351         flag_N = res >> 24;
33352         DREGu32((Opcode >> 9) & 7) = res;
33353         POST_IO
33354 RET(14)
33355 }
33356
33357 // ANDaD
33358 OPCODE(0xC0A0)
33359 {
33360         u32 adr, res;
33361         u32 src, dst;
33362
33363         adr = AREG((Opcode >> 0) & 7) - 4;
33364         AREG((Opcode >> 0) & 7) = adr;
33365         PRE_IO
33366         READ_LONG_F(adr, src)
33367         res = DREGu32((Opcode >> 9) & 7);
33368         res &= src;
33369         flag_C = 0;
33370         flag_V = 0;
33371         flag_NotZ = res;
33372         flag_N = res >> 24;
33373         DREGu32((Opcode >> 9) & 7) = res;
33374         POST_IO
33375 RET(16)
33376 }
33377
33378 // ANDaD
33379 OPCODE(0xC0A8)
33380 {
33381         u32 adr, res;
33382         u32 src, dst;
33383
33384         FETCH_SWORD(adr);
33385         adr += AREG((Opcode >> 0) & 7);
33386         PRE_IO
33387         READ_LONG_F(adr, src)
33388         res = DREGu32((Opcode >> 9) & 7);
33389         res &= src;
33390         flag_C = 0;
33391         flag_V = 0;
33392         flag_NotZ = res;
33393         flag_N = res >> 24;
33394         DREGu32((Opcode >> 9) & 7) = res;
33395         POST_IO
33396 RET(18)
33397 }
33398
33399 // ANDaD
33400 OPCODE(0xC0B0)
33401 {
33402         u32 adr, res;
33403         u32 src, dst;
33404
33405         adr = AREG((Opcode >> 0) & 7);
33406         DECODE_EXT_WORD
33407         PRE_IO
33408         READ_LONG_F(adr, src)
33409         res = DREGu32((Opcode >> 9) & 7);
33410         res &= src;
33411         flag_C = 0;
33412         flag_V = 0;
33413         flag_NotZ = res;
33414         flag_N = res >> 24;
33415         DREGu32((Opcode >> 9) & 7) = res;
33416         POST_IO
33417 RET(20)
33418 }
33419
33420 // ANDaD
33421 OPCODE(0xC0B8)
33422 {
33423         u32 adr, res;
33424         u32 src, dst;
33425
33426         FETCH_SWORD(adr);
33427         PRE_IO
33428         READ_LONG_F(adr, src)
33429         res = DREGu32((Opcode >> 9) & 7);
33430         res &= src;
33431         flag_C = 0;
33432         flag_V = 0;
33433         flag_NotZ = res;
33434         flag_N = res >> 24;
33435         DREGu32((Opcode >> 9) & 7) = res;
33436         POST_IO
33437 RET(18)
33438 }
33439
33440 // ANDaD
33441 OPCODE(0xC0B9)
33442 {
33443         u32 adr, res;
33444         u32 src, dst;
33445
33446         FETCH_LONG(adr);
33447         PRE_IO
33448         READ_LONG_F(adr, src)
33449         res = DREGu32((Opcode >> 9) & 7);
33450         res &= src;
33451         flag_C = 0;
33452         flag_V = 0;
33453         flag_NotZ = res;
33454         flag_N = res >> 24;
33455         DREGu32((Opcode >> 9) & 7) = res;
33456         POST_IO
33457 RET(22)
33458 }
33459
33460 // ANDaD
33461 OPCODE(0xC0BA)
33462 {
33463         u32 adr, res;
33464         u32 src, dst;
33465
33466         adr = GET_SWORD + GET_PC;
33467         PC++;
33468         PRE_IO
33469         READ_LONG_F(adr, src)
33470         res = DREGu32((Opcode >> 9) & 7);
33471         res &= src;
33472         flag_C = 0;
33473         flag_V = 0;
33474         flag_NotZ = res;
33475         flag_N = res >> 24;
33476         DREGu32((Opcode >> 9) & 7) = res;
33477         POST_IO
33478 RET(18)
33479 }
33480
33481 // ANDaD
33482 OPCODE(0xC0BB)
33483 {
33484         u32 adr, res;
33485         u32 src, dst;
33486
33487         adr = GET_PC;
33488         DECODE_EXT_WORD
33489         PRE_IO
33490         READ_LONG_F(adr, src)
33491         res = DREGu32((Opcode >> 9) & 7);
33492         res &= src;
33493         flag_C = 0;
33494         flag_V = 0;
33495         flag_NotZ = res;
33496         flag_N = res >> 24;
33497         DREGu32((Opcode >> 9) & 7) = res;
33498         POST_IO
33499 RET(20)
33500 }
33501
33502 // ANDaD
33503 OPCODE(0xC0BC)
33504 {
33505         u32 adr, res;
33506         u32 src, dst;
33507
33508         FETCH_LONG(src);
33509         res = DREGu32((Opcode >> 9) & 7);
33510         res &= src;
33511         flag_C = 0;
33512         flag_V = 0;
33513         flag_NotZ = res;
33514         flag_N = res >> 24;
33515         DREGu32((Opcode >> 9) & 7) = res;
33516 RET(16)
33517 }
33518
33519 // ANDaD
33520 OPCODE(0xC09F)
33521 {
33522         u32 adr, res;
33523         u32 src, dst;
33524
33525         adr = AREG(7);
33526         AREG(7) += 4;
33527         PRE_IO
33528         READ_LONG_F(adr, src)
33529         res = DREGu32((Opcode >> 9) & 7);
33530         res &= src;
33531         flag_C = 0;
33532         flag_V = 0;
33533         flag_NotZ = res;
33534         flag_N = res >> 24;
33535         DREGu32((Opcode >> 9) & 7) = res;
33536         POST_IO
33537 RET(14)
33538 }
33539
33540 // ANDaD
33541 OPCODE(0xC0A7)
33542 {
33543         u32 adr, res;
33544         u32 src, dst;
33545
33546         adr = AREG(7) - 4;
33547         AREG(7) = adr;
33548         PRE_IO
33549         READ_LONG_F(adr, src)
33550         res = DREGu32((Opcode >> 9) & 7);
33551         res &= src;
33552         flag_C = 0;
33553         flag_V = 0;
33554         flag_NotZ = res;
33555         flag_N = res >> 24;
33556         DREGu32((Opcode >> 9) & 7) = res;
33557         POST_IO
33558 RET(16)
33559 }
33560
33561 // ANDDa
33562 OPCODE(0xC110)
33563 {
33564         u32 adr, res;
33565         u32 src, dst;
33566
33567         src = DREGu8((Opcode >> 9) & 7);
33568         adr = AREG((Opcode >> 0) & 7);
33569         PRE_IO
33570         READ_BYTE_F(adr, res)
33571         res &= src;
33572         flag_C = 0;
33573         flag_V = 0;
33574         flag_NotZ = res;
33575         flag_N = res;
33576         WRITE_BYTE_F(adr, res)
33577         POST_IO
33578 RET(12)
33579 }
33580
33581 // ANDDa
33582 OPCODE(0xC118)
33583 {
33584         u32 adr, res;
33585         u32 src, dst;
33586
33587         src = DREGu8((Opcode >> 9) & 7);
33588         adr = AREG((Opcode >> 0) & 7);
33589         AREG((Opcode >> 0) & 7) += 1;
33590         PRE_IO
33591         READ_BYTE_F(adr, res)
33592         res &= src;
33593         flag_C = 0;
33594         flag_V = 0;
33595         flag_NotZ = res;
33596         flag_N = res;
33597         WRITE_BYTE_F(adr, res)
33598         POST_IO
33599 RET(12)
33600 }
33601
33602 // ANDDa
33603 OPCODE(0xC120)
33604 {
33605         u32 adr, res;
33606         u32 src, dst;
33607
33608         src = DREGu8((Opcode >> 9) & 7);
33609         adr = AREG((Opcode >> 0) & 7) - 1;
33610         AREG((Opcode >> 0) & 7) = adr;
33611         PRE_IO
33612         READ_BYTE_F(adr, res)
33613         res &= src;
33614         flag_C = 0;
33615         flag_V = 0;
33616         flag_NotZ = res;
33617         flag_N = res;
33618         WRITE_BYTE_F(adr, res)
33619         POST_IO
33620 RET(14)
33621 }
33622
33623 // ANDDa
33624 OPCODE(0xC128)
33625 {
33626         u32 adr, res;
33627         u32 src, dst;
33628
33629         src = DREGu8((Opcode >> 9) & 7);
33630         FETCH_SWORD(adr);
33631         adr += AREG((Opcode >> 0) & 7);
33632         PRE_IO
33633         READ_BYTE_F(adr, res)
33634         res &= src;
33635         flag_C = 0;
33636         flag_V = 0;
33637         flag_NotZ = res;
33638         flag_N = res;
33639         WRITE_BYTE_F(adr, res)
33640         POST_IO
33641 RET(16)
33642 }
33643
33644 // ANDDa
33645 OPCODE(0xC130)
33646 {
33647         u32 adr, res;
33648         u32 src, dst;
33649
33650         src = DREGu8((Opcode >> 9) & 7);
33651         adr = AREG((Opcode >> 0) & 7);
33652         DECODE_EXT_WORD
33653         PRE_IO
33654         READ_BYTE_F(adr, res)
33655         res &= src;
33656         flag_C = 0;
33657         flag_V = 0;
33658         flag_NotZ = res;
33659         flag_N = res;
33660         WRITE_BYTE_F(adr, res)
33661         POST_IO
33662 RET(18)
33663 }
33664
33665 // ANDDa
33666 OPCODE(0xC138)
33667 {
33668         u32 adr, res;
33669         u32 src, dst;
33670
33671         src = DREGu8((Opcode >> 9) & 7);
33672         FETCH_SWORD(adr);
33673         PRE_IO
33674         READ_BYTE_F(adr, res)
33675         res &= src;
33676         flag_C = 0;
33677         flag_V = 0;
33678         flag_NotZ = res;
33679         flag_N = res;
33680         WRITE_BYTE_F(adr, res)
33681         POST_IO
33682 RET(16)
33683 }
33684
33685 // ANDDa
33686 OPCODE(0xC139)
33687 {
33688         u32 adr, res;
33689         u32 src, dst;
33690
33691         src = DREGu8((Opcode >> 9) & 7);
33692         FETCH_LONG(adr);
33693         PRE_IO
33694         READ_BYTE_F(adr, res)
33695         res &= src;
33696         flag_C = 0;
33697         flag_V = 0;
33698         flag_NotZ = res;
33699         flag_N = res;
33700         WRITE_BYTE_F(adr, res)
33701         POST_IO
33702 RET(20)
33703 }
33704
33705 // ANDDa
33706 OPCODE(0xC11F)
33707 {
33708         u32 adr, res;
33709         u32 src, dst;
33710
33711         src = DREGu8((Opcode >> 9) & 7);
33712         adr = AREG(7);
33713         AREG(7) += 2;
33714         PRE_IO
33715         READ_BYTE_F(adr, res)
33716         res &= src;
33717         flag_C = 0;
33718         flag_V = 0;
33719         flag_NotZ = res;
33720         flag_N = res;
33721         WRITE_BYTE_F(adr, res)
33722         POST_IO
33723 RET(12)
33724 }
33725
33726 // ANDDa
33727 OPCODE(0xC127)
33728 {
33729         u32 adr, res;
33730         u32 src, dst;
33731
33732         src = DREGu8((Opcode >> 9) & 7);
33733         adr = AREG(7) - 2;
33734         AREG(7) = adr;
33735         PRE_IO
33736         READ_BYTE_F(adr, res)
33737         res &= src;
33738         flag_C = 0;
33739         flag_V = 0;
33740         flag_NotZ = res;
33741         flag_N = res;
33742         WRITE_BYTE_F(adr, res)
33743         POST_IO
33744 RET(14)
33745 }
33746
33747 // ANDDa
33748 OPCODE(0xC150)
33749 {
33750         u32 adr, res;
33751         u32 src, dst;
33752
33753         src = DREGu16((Opcode >> 9) & 7);
33754         adr = AREG((Opcode >> 0) & 7);
33755         PRE_IO
33756         READ_WORD_F(adr, res)
33757         res &= src;
33758         flag_C = 0;
33759         flag_V = 0;
33760         flag_NotZ = res;
33761         flag_N = res >> 8;
33762         WRITE_WORD_F(adr, res)
33763         POST_IO
33764 RET(12)
33765 }
33766
33767 // ANDDa
33768 OPCODE(0xC158)
33769 {
33770         u32 adr, res;
33771         u32 src, dst;
33772
33773         src = DREGu16((Opcode >> 9) & 7);
33774         adr = AREG((Opcode >> 0) & 7);
33775         AREG((Opcode >> 0) & 7) += 2;
33776         PRE_IO
33777         READ_WORD_F(adr, res)
33778         res &= src;
33779         flag_C = 0;
33780         flag_V = 0;
33781         flag_NotZ = res;
33782         flag_N = res >> 8;
33783         WRITE_WORD_F(adr, res)
33784         POST_IO
33785 RET(12)
33786 }
33787
33788 // ANDDa
33789 OPCODE(0xC160)
33790 {
33791         u32 adr, res;
33792         u32 src, dst;
33793
33794         src = DREGu16((Opcode >> 9) & 7);
33795         adr = AREG((Opcode >> 0) & 7) - 2;
33796         AREG((Opcode >> 0) & 7) = adr;
33797         PRE_IO
33798         READ_WORD_F(adr, res)
33799         res &= src;
33800         flag_C = 0;
33801         flag_V = 0;
33802         flag_NotZ = res;
33803         flag_N = res >> 8;
33804         WRITE_WORD_F(adr, res)
33805         POST_IO
33806 RET(14)
33807 }
33808
33809 // ANDDa
33810 OPCODE(0xC168)
33811 {
33812         u32 adr, res;
33813         u32 src, dst;
33814
33815         src = DREGu16((Opcode >> 9) & 7);
33816         FETCH_SWORD(adr);
33817         adr += AREG((Opcode >> 0) & 7);
33818         PRE_IO
33819         READ_WORD_F(adr, res)
33820         res &= src;
33821         flag_C = 0;
33822         flag_V = 0;
33823         flag_NotZ = res;
33824         flag_N = res >> 8;
33825         WRITE_WORD_F(adr, res)
33826         POST_IO
33827 RET(16)
33828 }
33829
33830 // ANDDa
33831 OPCODE(0xC170)
33832 {
33833         u32 adr, res;
33834         u32 src, dst;
33835
33836         src = DREGu16((Opcode >> 9) & 7);
33837         adr = AREG((Opcode >> 0) & 7);
33838         DECODE_EXT_WORD
33839         PRE_IO
33840         READ_WORD_F(adr, res)
33841         res &= src;
33842         flag_C = 0;
33843         flag_V = 0;
33844         flag_NotZ = res;
33845         flag_N = res >> 8;
33846         WRITE_WORD_F(adr, res)
33847         POST_IO
33848 RET(18)
33849 }
33850
33851 // ANDDa
33852 OPCODE(0xC178)
33853 {
33854         u32 adr, res;
33855         u32 src, dst;
33856
33857         src = DREGu16((Opcode >> 9) & 7);
33858         FETCH_SWORD(adr);
33859         PRE_IO
33860         READ_WORD_F(adr, res)
33861         res &= src;
33862         flag_C = 0;
33863         flag_V = 0;
33864         flag_NotZ = res;
33865         flag_N = res >> 8;
33866         WRITE_WORD_F(adr, res)
33867         POST_IO
33868 RET(16)
33869 }
33870
33871 // ANDDa
33872 OPCODE(0xC179)
33873 {
33874         u32 adr, res;
33875         u32 src, dst;
33876
33877         src = DREGu16((Opcode >> 9) & 7);
33878         FETCH_LONG(adr);
33879         PRE_IO
33880         READ_WORD_F(adr, res)
33881         res &= src;
33882         flag_C = 0;
33883         flag_V = 0;
33884         flag_NotZ = res;
33885         flag_N = res >> 8;
33886         WRITE_WORD_F(adr, res)
33887         POST_IO
33888 RET(20)
33889 }
33890
33891 // ANDDa
33892 OPCODE(0xC15F)
33893 {
33894         u32 adr, res;
33895         u32 src, dst;
33896
33897         src = DREGu16((Opcode >> 9) & 7);
33898         adr = AREG(7);
33899         AREG(7) += 2;
33900         PRE_IO
33901         READ_WORD_F(adr, res)
33902         res &= src;
33903         flag_C = 0;
33904         flag_V = 0;
33905         flag_NotZ = res;
33906         flag_N = res >> 8;
33907         WRITE_WORD_F(adr, res)
33908         POST_IO
33909 RET(12)
33910 }
33911
33912 // ANDDa
33913 OPCODE(0xC167)
33914 {
33915         u32 adr, res;
33916         u32 src, dst;
33917
33918         src = DREGu16((Opcode >> 9) & 7);
33919         adr = AREG(7) - 2;
33920         AREG(7) = adr;
33921         PRE_IO
33922         READ_WORD_F(adr, res)
33923         res &= src;
33924         flag_C = 0;
33925         flag_V = 0;
33926         flag_NotZ = res;
33927         flag_N = res >> 8;
33928         WRITE_WORD_F(adr, res)
33929         POST_IO
33930 RET(14)
33931 }
33932
33933 // ANDDa
33934 OPCODE(0xC190)
33935 {
33936         u32 adr, res;
33937         u32 src, dst;
33938
33939         src = DREGu32((Opcode >> 9) & 7);
33940         adr = AREG((Opcode >> 0) & 7);
33941         PRE_IO
33942         READ_LONG_F(adr, res)
33943         res &= src;
33944         flag_C = 0;
33945         flag_V = 0;
33946         flag_NotZ = res;
33947         flag_N = res >> 24;
33948         WRITE_LONG_F(adr, res)
33949         POST_IO
33950 RET(20)
33951 }
33952
33953 // ANDDa
33954 OPCODE(0xC198)
33955 {
33956         u32 adr, res;
33957         u32 src, dst;
33958
33959         src = DREGu32((Opcode >> 9) & 7);
33960         adr = AREG((Opcode >> 0) & 7);
33961         AREG((Opcode >> 0) & 7) += 4;
33962         PRE_IO
33963         READ_LONG_F(adr, res)
33964         res &= src;
33965         flag_C = 0;
33966         flag_V = 0;
33967         flag_NotZ = res;
33968         flag_N = res >> 24;
33969         WRITE_LONG_F(adr, res)
33970         POST_IO
33971 RET(20)
33972 }
33973
33974 // ANDDa
33975 OPCODE(0xC1A0)
33976 {
33977         u32 adr, res;
33978         u32 src, dst;
33979
33980         src = DREGu32((Opcode >> 9) & 7);
33981         adr = AREG((Opcode >> 0) & 7) - 4;
33982         AREG((Opcode >> 0) & 7) = adr;
33983         PRE_IO
33984         READ_LONG_F(adr, res)
33985         res &= src;
33986         flag_C = 0;
33987         flag_V = 0;
33988         flag_NotZ = res;
33989         flag_N = res >> 24;
33990         WRITE_LONG_F(adr, res)
33991         POST_IO
33992 RET(22)
33993 }
33994
33995 // ANDDa
33996 OPCODE(0xC1A8)
33997 {
33998         u32 adr, res;
33999         u32 src, dst;
34000
34001         src = DREGu32((Opcode >> 9) & 7);
34002         FETCH_SWORD(adr);
34003         adr += AREG((Opcode >> 0) & 7);
34004         PRE_IO
34005         READ_LONG_F(adr, res)
34006         res &= src;
34007         flag_C = 0;
34008         flag_V = 0;
34009         flag_NotZ = res;
34010         flag_N = res >> 24;
34011         WRITE_LONG_F(adr, res)
34012         POST_IO
34013 RET(24)
34014 }
34015
34016 // ANDDa
34017 OPCODE(0xC1B0)
34018 {
34019         u32 adr, res;
34020         u32 src, dst;
34021
34022         src = DREGu32((Opcode >> 9) & 7);
34023         adr = AREG((Opcode >> 0) & 7);
34024         DECODE_EXT_WORD
34025         PRE_IO
34026         READ_LONG_F(adr, res)
34027         res &= src;
34028         flag_C = 0;
34029         flag_V = 0;
34030         flag_NotZ = res;
34031         flag_N = res >> 24;
34032         WRITE_LONG_F(adr, res)
34033         POST_IO
34034 RET(26)
34035 }
34036
34037 // ANDDa
34038 OPCODE(0xC1B8)
34039 {
34040         u32 adr, res;
34041         u32 src, dst;
34042
34043         src = DREGu32((Opcode >> 9) & 7);
34044         FETCH_SWORD(adr);
34045         PRE_IO
34046         READ_LONG_F(adr, res)
34047         res &= src;
34048         flag_C = 0;
34049         flag_V = 0;
34050         flag_NotZ = res;
34051         flag_N = res >> 24;
34052         WRITE_LONG_F(adr, res)
34053         POST_IO
34054 RET(24)
34055 }
34056
34057 // ANDDa
34058 OPCODE(0xC1B9)
34059 {
34060         u32 adr, res;
34061         u32 src, dst;
34062
34063         src = DREGu32((Opcode >> 9) & 7);
34064         FETCH_LONG(adr);
34065         PRE_IO
34066         READ_LONG_F(adr, res)
34067         res &= src;
34068         flag_C = 0;
34069         flag_V = 0;
34070         flag_NotZ = res;
34071         flag_N = res >> 24;
34072         WRITE_LONG_F(adr, res)
34073         POST_IO
34074 RET(28)
34075 }
34076
34077 // ANDDa
34078 OPCODE(0xC19F)
34079 {
34080         u32 adr, res;
34081         u32 src, dst;
34082
34083         src = DREGu32((Opcode >> 9) & 7);
34084         adr = AREG(7);
34085         AREG(7) += 4;
34086         PRE_IO
34087         READ_LONG_F(adr, res)
34088         res &= src;
34089         flag_C = 0;
34090         flag_V = 0;
34091         flag_NotZ = res;
34092         flag_N = res >> 24;
34093         WRITE_LONG_F(adr, res)
34094         POST_IO
34095 RET(20)
34096 }
34097
34098 // ANDDa
34099 OPCODE(0xC1A7)
34100 {
34101         u32 adr, res;
34102         u32 src, dst;
34103
34104         src = DREGu32((Opcode >> 9) & 7);
34105         adr = AREG(7) - 4;
34106         AREG(7) = adr;
34107         PRE_IO
34108         READ_LONG_F(adr, res)
34109         res &= src;
34110         flag_C = 0;
34111         flag_V = 0;
34112         flag_NotZ = res;
34113         flag_N = res >> 24;
34114         WRITE_LONG_F(adr, res)
34115         POST_IO
34116 RET(22)
34117 }
34118
34119 // ABCD
34120 OPCODE(0xC100)
34121 {
34122         u32 adr, res;
34123         u32 src, dst;
34124
34125         src = DREGu8((Opcode >> 0) & 7);
34126         dst = DREGu8((Opcode >> 9) & 7);
34127         res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34128         if (res > 9) res += 6;
34129         res += (dst & 0xF0) + (src & 0xF0);
34130         if (res > 0x99)
34131         {
34132                 res -= 0xA0;
34133                 flag_X = flag_C = M68K_SR_C;
34134         }
34135         else flag_X = flag_C = 0;
34136         flag_NotZ |= res & 0xFF;
34137         flag_N = res;
34138         DREGu8((Opcode >> 9) & 7) = res;
34139 RET(6)
34140 }
34141
34142 // ABCDM
34143 OPCODE(0xC108)
34144 {
34145         u32 adr, res;
34146         u32 src, dst;
34147
34148         adr = AREG((Opcode >> 0) & 7) - 1;
34149         AREG((Opcode >> 0) & 7) = adr;
34150         PRE_IO
34151         READ_BYTE_F(adr, src)
34152         adr = AREG((Opcode >> 9) & 7) - 1;
34153         AREG((Opcode >> 9) & 7) = adr;
34154         READ_BYTE_F(adr, dst)
34155         res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34156         if (res > 9) res += 6;
34157         res += (dst & 0xF0) + (src & 0xF0);
34158         if (res > 0x99)
34159         {
34160                 res -= 0xA0;
34161                 flag_X = flag_C = M68K_SR_C;
34162         }
34163         else flag_X = flag_C = 0;
34164         flag_NotZ |= res & 0xFF;
34165         flag_N = res;
34166         WRITE_BYTE_F(adr, res)
34167         POST_IO
34168 RET(18)
34169 }
34170
34171 // ABCD7M
34172 OPCODE(0xC10F)
34173 {
34174         u32 adr, res;
34175         u32 src, dst;
34176
34177         adr = AREG(7) - 2;
34178         AREG(7) = adr;
34179         PRE_IO
34180         READ_BYTE_F(adr, src)
34181         adr = AREG((Opcode >> 9) & 7) - 1;
34182         AREG((Opcode >> 9) & 7) = adr;
34183         READ_BYTE_F(adr, dst)
34184         res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34185         if (res > 9) res += 6;
34186         res += (dst & 0xF0) + (src & 0xF0);
34187         if (res > 0x99)
34188         {
34189                 res -= 0xA0;
34190                 flag_X = flag_C = M68K_SR_C;
34191         }
34192         else flag_X = flag_C = 0;
34193         flag_NotZ |= res & 0xFF;
34194         flag_N = res;
34195         WRITE_BYTE_F(adr, res)
34196         POST_IO
34197 RET(18)
34198 }
34199
34200 // ABCDM7
34201 OPCODE(0xCF08)
34202 {
34203         u32 adr, res;
34204         u32 src, dst;
34205
34206         adr = AREG((Opcode >> 0) & 7) - 1;
34207         AREG((Opcode >> 0) & 7) = adr;
34208         PRE_IO
34209         READ_BYTE_F(adr, src)
34210         adr = AREG(7) - 2;
34211         AREG(7) = adr;
34212         READ_BYTE_F(adr, dst)
34213         res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34214         if (res > 9) res += 6;
34215         res += (dst & 0xF0) + (src & 0xF0);
34216         if (res > 0x99)
34217         {
34218                 res -= 0xA0;
34219                 flag_X = flag_C = M68K_SR_C;
34220         }
34221         else flag_X = flag_C = 0;
34222         flag_NotZ |= res & 0xFF;
34223         flag_N = res;
34224         WRITE_BYTE_F(adr, res)
34225         POST_IO
34226 RET(18)
34227 }
34228
34229 // ABCD7M7
34230 OPCODE(0xCF0F)
34231 {
34232         u32 adr, res;
34233         u32 src, dst;
34234
34235         adr = AREG(7) - 2;
34236         AREG(7) = adr;
34237         PRE_IO
34238         READ_BYTE_F(adr, src)
34239         adr = AREG(7) - 2;
34240         AREG(7) = adr;
34241         READ_BYTE_F(adr, dst)
34242         res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34243         if (res > 9) res += 6;
34244         res += (dst & 0xF0) + (src & 0xF0);
34245         if (res > 0x99)
34246         {
34247                 res -= 0xA0;
34248                 flag_X = flag_C = M68K_SR_C;
34249         }
34250         else flag_X = flag_C = 0;
34251         flag_NotZ |= res & 0xFF;
34252         flag_N = res;
34253         WRITE_BYTE_F(adr, res)
34254         POST_IO
34255 RET(18)
34256 }
34257
34258 // MULU
34259 OPCODE(0xC0C0)
34260 {
34261         u32 adr, res;
34262         u32 src, dst;
34263
34264         src = DREGu16((Opcode >> 0) & 7);
34265         res = DREGu16((Opcode >> 9) & 7);
34266         res *= src;
34267         flag_N = res >> 24;
34268         flag_NotZ = res;
34269         flag_V = flag_C = 0;
34270         DREGu32((Opcode >> 9) & 7) = res;
34271 #ifdef USE_CYCLONE_TIMING
34272 RET(54)
34273 #else
34274 RET(50)
34275 #endif
34276 }
34277
34278 // MULU
34279 OPCODE(0xC0D0)
34280 {
34281         u32 adr, res;
34282         u32 src, dst;
34283
34284         adr = AREG((Opcode >> 0) & 7);
34285         PRE_IO
34286         READ_WORD_F(adr, src)
34287         res = DREGu16((Opcode >> 9) & 7);
34288         res *= src;
34289         flag_N = res >> 24;
34290         flag_NotZ = res;
34291         flag_V = flag_C = 0;
34292         DREGu32((Opcode >> 9) & 7) = res;
34293         POST_IO
34294 #ifdef USE_CYCLONE_TIMING
34295 RET(58)
34296 #else
34297 RET(54)
34298 #endif
34299 }
34300
34301 // MULU
34302 OPCODE(0xC0D8)
34303 {
34304         u32 adr, res;
34305         u32 src, dst;
34306
34307         adr = AREG((Opcode >> 0) & 7);
34308         AREG((Opcode >> 0) & 7) += 2;
34309         PRE_IO
34310         READ_WORD_F(adr, src)
34311         res = DREGu16((Opcode >> 9) & 7);
34312         res *= src;
34313         flag_N = res >> 24;
34314         flag_NotZ = res;
34315         flag_V = flag_C = 0;
34316         DREGu32((Opcode >> 9) & 7) = res;
34317         POST_IO
34318 #ifdef USE_CYCLONE_TIMING
34319 RET(58)
34320 #else
34321 RET(54)
34322 #endif
34323 }
34324
34325 // MULU
34326 OPCODE(0xC0E0)
34327 {
34328         u32 adr, res;
34329         u32 src, dst;
34330
34331         adr = AREG((Opcode >> 0) & 7) - 2;
34332         AREG((Opcode >> 0) & 7) = adr;
34333         PRE_IO
34334         READ_WORD_F(adr, src)
34335         res = DREGu16((Opcode >> 9) & 7);
34336         res *= src;
34337         flag_N = res >> 24;
34338         flag_NotZ = res;
34339         flag_V = flag_C = 0;
34340         DREGu32((Opcode >> 9) & 7) = res;
34341         POST_IO
34342 #ifdef USE_CYCLONE_TIMING
34343 RET(60)
34344 #else
34345 RET(56)
34346 #endif
34347 }
34348
34349 // MULU
34350 OPCODE(0xC0E8)
34351 {
34352         u32 adr, res;
34353         u32 src, dst;
34354
34355         FETCH_SWORD(adr);
34356         adr += AREG((Opcode >> 0) & 7);
34357         PRE_IO
34358         READ_WORD_F(adr, src)
34359         res = DREGu16((Opcode >> 9) & 7);
34360         res *= src;
34361         flag_N = res >> 24;
34362         flag_NotZ = res;
34363         flag_V = flag_C = 0;
34364         DREGu32((Opcode >> 9) & 7) = res;
34365         POST_IO
34366 #ifdef USE_CYCLONE_TIMING
34367 RET(62)
34368 #else
34369 RET(58)
34370 #endif
34371 }
34372
34373 // MULU
34374 OPCODE(0xC0F0)
34375 {
34376         u32 adr, res;
34377         u32 src, dst;
34378
34379         adr = AREG((Opcode >> 0) & 7);
34380         DECODE_EXT_WORD
34381         PRE_IO
34382         READ_WORD_F(adr, src)
34383         res = DREGu16((Opcode >> 9) & 7);
34384         res *= src;
34385         flag_N = res >> 24;
34386         flag_NotZ = res;
34387         flag_V = flag_C = 0;
34388         DREGu32((Opcode >> 9) & 7) = res;
34389         POST_IO
34390 #ifdef USE_CYCLONE_TIMING
34391 RET(64)
34392 #else
34393 RET(60)
34394 #endif
34395 }
34396
34397 // MULU
34398 OPCODE(0xC0F8)
34399 {
34400         u32 adr, res;
34401         u32 src, dst;
34402
34403         FETCH_SWORD(adr);
34404         PRE_IO
34405         READ_WORD_F(adr, src)
34406         res = DREGu16((Opcode >> 9) & 7);
34407         res *= src;
34408         flag_N = res >> 24;
34409         flag_NotZ = res;
34410         flag_V = flag_C = 0;
34411         DREGu32((Opcode >> 9) & 7) = res;
34412         POST_IO
34413 #ifdef USE_CYCLONE_TIMING
34414 RET(62)
34415 #else
34416 RET(58)
34417 #endif
34418 }
34419
34420 // MULU
34421 OPCODE(0xC0F9)
34422 {
34423         u32 adr, res;
34424         u32 src, dst;
34425
34426         FETCH_LONG(adr);
34427         PRE_IO
34428         READ_WORD_F(adr, src)
34429         res = DREGu16((Opcode >> 9) & 7);
34430         res *= src;
34431         flag_N = res >> 24;
34432         flag_NotZ = res;
34433         flag_V = flag_C = 0;
34434         DREGu32((Opcode >> 9) & 7) = res;
34435         POST_IO
34436 #ifdef USE_CYCLONE_TIMING
34437 RET(66)
34438 #else
34439 RET(62)
34440 #endif
34441 }
34442
34443 // MULU
34444 OPCODE(0xC0FA)
34445 {
34446         u32 adr, res;
34447         u32 src, dst;
34448
34449         adr = GET_SWORD + GET_PC;
34450         PC++;
34451         PRE_IO
34452         READ_WORD_F(adr, src)
34453         res = DREGu16((Opcode >> 9) & 7);
34454         res *= src;
34455         flag_N = res >> 24;
34456         flag_NotZ = res;
34457         flag_V = flag_C = 0;
34458         DREGu32((Opcode >> 9) & 7) = res;
34459         POST_IO
34460 #ifdef USE_CYCLONE_TIMING
34461 RET(62)
34462 #else
34463 RET(58)
34464 #endif
34465 }
34466
34467 // MULU
34468 OPCODE(0xC0FB)
34469 {
34470         u32 adr, res;
34471         u32 src, dst;
34472
34473         adr = GET_PC;
34474         DECODE_EXT_WORD
34475         PRE_IO
34476         READ_WORD_F(adr, src)
34477         res = DREGu16((Opcode >> 9) & 7);
34478         res *= src;
34479         flag_N = res >> 24;
34480         flag_NotZ = res;
34481         flag_V = flag_C = 0;
34482         DREGu32((Opcode >> 9) & 7) = res;
34483         POST_IO
34484 #ifdef USE_CYCLONE_TIMING
34485 RET(64)
34486 #else
34487 RET(60)
34488 #endif
34489 }
34490
34491 // MULU
34492 OPCODE(0xC0FC)
34493 {
34494         u32 adr, res;
34495         u32 src, dst;
34496
34497         FETCH_WORD(src);
34498         res = DREGu16((Opcode >> 9) & 7);
34499         res *= src;
34500         flag_N = res >> 24;
34501         flag_NotZ = res;
34502         flag_V = flag_C = 0;
34503         DREGu32((Opcode >> 9) & 7) = res;
34504 #ifdef USE_CYCLONE_TIMING
34505 RET(58)
34506 #else
34507 RET(54)
34508 #endif
34509 }
34510
34511 // MULU
34512 OPCODE(0xC0DF)
34513 {
34514         u32 adr, res;
34515         u32 src, dst;
34516
34517         adr = AREG(7);
34518         AREG(7) += 2;
34519         PRE_IO
34520         READ_WORD_F(adr, src)
34521         res = DREGu16((Opcode >> 9) & 7);
34522         res *= src;
34523         flag_N = res >> 24;
34524         flag_NotZ = res;
34525         flag_V = flag_C = 0;
34526         DREGu32((Opcode >> 9) & 7) = res;
34527         POST_IO
34528 #ifdef USE_CYCLONE_TIMING
34529 RET(58)
34530 #else
34531 RET(54)
34532 #endif
34533 }
34534
34535 // MULU
34536 OPCODE(0xC0E7)
34537 {
34538         u32 adr, res;
34539         u32 src, dst;
34540
34541         adr = AREG(7) - 2;
34542         AREG(7) = adr;
34543         PRE_IO
34544         READ_WORD_F(adr, src)
34545         res = DREGu16((Opcode >> 9) & 7);
34546         res *= src;
34547         flag_N = res >> 24;
34548         flag_NotZ = res;
34549         flag_V = flag_C = 0;
34550         DREGu32((Opcode >> 9) & 7) = res;
34551         POST_IO
34552 #ifdef USE_CYCLONE_TIMING
34553 RET(60)
34554 #else
34555 RET(56)
34556 #endif
34557 }
34558
34559 // MULS
34560 OPCODE(0xC1C0)
34561 {
34562         u32 adr, res;
34563         u32 src, dst;
34564
34565         src = (s32)DREGs16((Opcode >> 0) & 7);
34566         res = (s32)DREGs16((Opcode >> 9) & 7);
34567         res = ((s32)res) * ((s32)src);
34568         flag_N = res >> 24;
34569         flag_NotZ = res;
34570         flag_V = flag_C = 0;
34571         DREGu32((Opcode >> 9) & 7) = res;
34572 #ifdef USE_CYCLONE_TIMING
34573 RET(54)
34574 #else
34575 RET(50)
34576 #endif
34577 }
34578
34579 // MULS
34580 OPCODE(0xC1D0)
34581 {
34582         u32 adr, res;
34583         u32 src, dst;
34584
34585         adr = AREG((Opcode >> 0) & 7);
34586         PRE_IO
34587         READSX_WORD_F(adr, src)
34588         res = (s32)DREGs16((Opcode >> 9) & 7);
34589         res = ((s32)res) * ((s32)src);
34590         flag_N = res >> 24;
34591         flag_NotZ = res;
34592         flag_V = flag_C = 0;
34593         DREGu32((Opcode >> 9) & 7) = res;
34594         POST_IO
34595 #ifdef USE_CYCLONE_TIMING
34596 RET(58)
34597 #else
34598 RET(54)
34599 #endif
34600 }
34601
34602 // MULS
34603 OPCODE(0xC1D8)
34604 {
34605         u32 adr, res;
34606         u32 src, dst;
34607
34608         adr = AREG((Opcode >> 0) & 7);
34609         AREG((Opcode >> 0) & 7) += 2;
34610         PRE_IO
34611         READSX_WORD_F(adr, src)
34612         res = (s32)DREGs16((Opcode >> 9) & 7);
34613         res = ((s32)res) * ((s32)src);
34614         flag_N = res >> 24;
34615         flag_NotZ = res;
34616         flag_V = flag_C = 0;
34617         DREGu32((Opcode >> 9) & 7) = res;
34618         POST_IO
34619 #ifdef USE_CYCLONE_TIMING
34620 RET(58)
34621 #else
34622 RET(54)
34623 #endif
34624 }
34625
34626 // MULS
34627 OPCODE(0xC1E0)
34628 {
34629         u32 adr, res;
34630         u32 src, dst;
34631
34632         adr = AREG((Opcode >> 0) & 7) - 2;
34633         AREG((Opcode >> 0) & 7) = adr;
34634         PRE_IO
34635         READSX_WORD_F(adr, src)
34636         res = (s32)DREGs16((Opcode >> 9) & 7);
34637         res = ((s32)res) * ((s32)src);
34638         flag_N = res >> 24;
34639         flag_NotZ = res;
34640         flag_V = flag_C = 0;
34641         DREGu32((Opcode >> 9) & 7) = res;
34642         POST_IO
34643 #ifdef USE_CYCLONE_TIMING
34644 RET(60)
34645 #else
34646 RET(56)
34647 #endif
34648 }
34649
34650 // MULS
34651 OPCODE(0xC1E8)
34652 {
34653         u32 adr, res;
34654         u32 src, dst;
34655
34656         FETCH_SWORD(adr);
34657         adr += AREG((Opcode >> 0) & 7);
34658         PRE_IO
34659         READSX_WORD_F(adr, src)
34660         res = (s32)DREGs16((Opcode >> 9) & 7);
34661         res = ((s32)res) * ((s32)src);
34662         flag_N = res >> 24;
34663         flag_NotZ = res;
34664         flag_V = flag_C = 0;
34665         DREGu32((Opcode >> 9) & 7) = res;
34666         POST_IO
34667 #ifdef USE_CYCLONE_TIMING
34668 RET(62)
34669 #else
34670 RET(58)
34671 #endif
34672 }
34673
34674 // MULS
34675 OPCODE(0xC1F0)
34676 {
34677         u32 adr, res;
34678         u32 src, dst;
34679
34680         adr = AREG((Opcode >> 0) & 7);
34681         DECODE_EXT_WORD
34682         PRE_IO
34683         READSX_WORD_F(adr, src)
34684         res = (s32)DREGs16((Opcode >> 9) & 7);
34685         res = ((s32)res) * ((s32)src);
34686         flag_N = res >> 24;
34687         flag_NotZ = res;
34688         flag_V = flag_C = 0;
34689         DREGu32((Opcode >> 9) & 7) = res;
34690         POST_IO
34691 #ifdef USE_CYCLONE_TIMING
34692 RET(64)
34693 #else
34694 RET(60)
34695 #endif
34696 }
34697
34698 // MULS
34699 OPCODE(0xC1F8)
34700 {
34701         u32 adr, res;
34702         u32 src, dst;
34703
34704         FETCH_SWORD(adr);
34705         PRE_IO
34706         READSX_WORD_F(adr, src)
34707         res = (s32)DREGs16((Opcode >> 9) & 7);
34708         res = ((s32)res) * ((s32)src);
34709         flag_N = res >> 24;
34710         flag_NotZ = res;
34711         flag_V = flag_C = 0;
34712         DREGu32((Opcode >> 9) & 7) = res;
34713         POST_IO
34714 #ifdef USE_CYCLONE_TIMING
34715 RET(62)
34716 #else
34717 RET(58)
34718 #endif
34719 }
34720
34721 // MULS
34722 OPCODE(0xC1F9)
34723 {
34724         u32 adr, res;
34725         u32 src, dst;
34726
34727         FETCH_LONG(adr);
34728         PRE_IO
34729         READSX_WORD_F(adr, src)
34730         res = (s32)DREGs16((Opcode >> 9) & 7);
34731         res = ((s32)res) * ((s32)src);
34732         flag_N = res >> 24;
34733         flag_NotZ = res;
34734         flag_V = flag_C = 0;
34735         DREGu32((Opcode >> 9) & 7) = res;
34736         POST_IO
34737 #ifdef USE_CYCLONE_TIMING
34738 RET(66)
34739 #else
34740 RET(62)
34741 #endif
34742 }
34743
34744 // MULS
34745 OPCODE(0xC1FA)
34746 {
34747         u32 adr, res;
34748         u32 src, dst;
34749
34750         adr = GET_SWORD + GET_PC;
34751         PC++;
34752         PRE_IO
34753         READSX_WORD_F(adr, src)
34754         res = (s32)DREGs16((Opcode >> 9) & 7);
34755         res = ((s32)res) * ((s32)src);
34756         flag_N = res >> 24;
34757         flag_NotZ = res;
34758         flag_V = flag_C = 0;
34759         DREGu32((Opcode >> 9) & 7) = res;
34760         POST_IO
34761 #ifdef USE_CYCLONE_TIMING
34762 RET(62)
34763 #else
34764 RET(58)
34765 #endif
34766 }
34767
34768 // MULS
34769 OPCODE(0xC1FB)
34770 {
34771         u32 adr, res;
34772         u32 src, dst;
34773
34774         adr = GET_PC;
34775         DECODE_EXT_WORD
34776         PRE_IO
34777         READSX_WORD_F(adr, src)
34778         res = (s32)DREGs16((Opcode >> 9) & 7);
34779         res = ((s32)res) * ((s32)src);
34780         flag_N = res >> 24;
34781         flag_NotZ = res;
34782         flag_V = flag_C = 0;
34783         DREGu32((Opcode >> 9) & 7) = res;
34784         POST_IO
34785 #ifdef USE_CYCLONE_TIMING
34786 RET(64)
34787 #else
34788 RET(60)
34789 #endif
34790 }
34791
34792 // MULS
34793 OPCODE(0xC1FC)
34794 {
34795         u32 adr, res;
34796         u32 src, dst;
34797
34798         FETCH_SWORD(src);
34799         res = (s32)DREGs16((Opcode >> 9) & 7);
34800         res = ((s32)res) * ((s32)src);
34801         flag_N = res >> 24;
34802         flag_NotZ = res;
34803         flag_V = flag_C = 0;
34804         DREGu32((Opcode >> 9) & 7) = res;
34805 #ifdef USE_CYCLONE_TIMING
34806 RET(58)
34807 #else
34808 RET(54)
34809 #endif
34810 }
34811
34812 // MULS
34813 OPCODE(0xC1DF)
34814 {
34815         u32 adr, res;
34816         u32 src, dst;
34817
34818         adr = AREG(7);
34819         AREG(7) += 2;
34820         PRE_IO
34821         READSX_WORD_F(adr, src)
34822         res = (s32)DREGs16((Opcode >> 9) & 7);
34823         res = ((s32)res) * ((s32)src);
34824         flag_N = res >> 24;
34825         flag_NotZ = res;
34826         flag_V = flag_C = 0;
34827         DREGu32((Opcode >> 9) & 7) = res;
34828         POST_IO
34829 #ifdef USE_CYCLONE_TIMING
34830 RET(58)
34831 #else
34832 RET(54)
34833 #endif
34834 }
34835
34836 // MULS
34837 OPCODE(0xC1E7)
34838 {
34839         u32 adr, res;
34840         u32 src, dst;
34841
34842         adr = AREG(7) - 2;
34843         AREG(7) = adr;
34844         PRE_IO
34845         READSX_WORD_F(adr, src)
34846         res = (s32)DREGs16((Opcode >> 9) & 7);
34847         res = ((s32)res) * ((s32)src);
34848         flag_N = res >> 24;
34849         flag_NotZ = res;
34850         flag_V = flag_C = 0;
34851         DREGu32((Opcode >> 9) & 7) = res;
34852         POST_IO
34853 #ifdef USE_CYCLONE_TIMING
34854 RET(60)
34855 #else
34856 RET(56)
34857 #endif
34858 }
34859
34860 // EXGDD
34861 OPCODE(0xC140)
34862 {
34863         u32 adr, res;
34864         u32 src, dst;
34865
34866         res = DREGu32((Opcode >> 0) & 7);
34867         src = DREGu32((Opcode >> 9) & 7);
34868         DREGu32((Opcode >> 9) & 7) = res;
34869         res = src;
34870         DREGu32((Opcode >> 0) & 7) = res;
34871 RET(6)
34872 }
34873
34874 // EXGAA
34875 OPCODE(0xC148)
34876 {
34877         u32 adr, res;
34878         u32 src, dst;
34879
34880         res = AREGu32((Opcode >> 0) & 7);
34881         src = AREGu32((Opcode >> 9) & 7);
34882         AREG((Opcode >> 9) & 7) = res;
34883         res = src;
34884         AREG((Opcode >> 0) & 7) = res;
34885 RET(6)
34886 }
34887
34888 // EXGAD
34889 OPCODE(0xC188)
34890 {
34891         u32 adr, res;
34892         u32 src, dst;
34893
34894         res = AREGu32((Opcode >> 0) & 7);
34895         src = DREGu32((Opcode >> 9) & 7);
34896         DREGu32((Opcode >> 9) & 7) = res;
34897         res = src;
34898         AREG((Opcode >> 0) & 7) = res;
34899 RET(6)
34900 }
34901
34902 // ADDaD
34903 OPCODE(0xD000)
34904 {
34905         u32 adr, res;
34906         u32 src, dst;
34907
34908         src = DREGu8((Opcode >> 0) & 7);
34909         dst = DREGu8((Opcode >> 9) & 7);
34910         res = dst + src;
34911         flag_N = flag_X = flag_C = res;
34912         flag_V = (src ^ res) & (dst ^ res);
34913         flag_NotZ = res & 0xFF;
34914         DREGu8((Opcode >> 9) & 7) = res;
34915 RET(4)
34916 }
34917
34918 // ADDaD
34919 #if 0
34920 OPCODE(0xD008)
34921 {
34922         u32 adr, res;
34923         u32 src, dst;
34924
34925         // can't read byte from Ax registers !
34926         m68kcontext.execinfo |= M68K_FAULTED;
34927         m68kcontext.io_cycle_counter = 0;
34928 /*
34929         goto famec_Exec_End;
34930         dst = DREGu8((Opcode >> 9) & 7);
34931         res = dst + src;
34932         flag_N = flag_X = flag_C = res;
34933         flag_V = (src ^ res) & (dst ^ res);
34934         flag_NotZ = res & 0xFF;
34935         DREGu8((Opcode >> 9) & 7) = res;
34936 */
34937 RET(4)
34938 }
34939 #endif
34940
34941 // ADDaD
34942 OPCODE(0xD010)
34943 {
34944         u32 adr, res;
34945         u32 src, dst;
34946
34947         adr = AREG((Opcode >> 0) & 7);
34948         PRE_IO
34949         READ_BYTE_F(adr, src)
34950         dst = DREGu8((Opcode >> 9) & 7);
34951         res = dst + src;
34952         flag_N = flag_X = flag_C = res;
34953         flag_V = (src ^ res) & (dst ^ res);
34954         flag_NotZ = res & 0xFF;
34955         DREGu8((Opcode >> 9) & 7) = res;
34956         POST_IO
34957 RET(8)
34958 }
34959
34960 // ADDaD
34961 OPCODE(0xD018)
34962 {
34963         u32 adr, res;
34964         u32 src, dst;
34965
34966         adr = AREG((Opcode >> 0) & 7);
34967         AREG((Opcode >> 0) & 7) += 1;
34968         PRE_IO
34969         READ_BYTE_F(adr, src)
34970         dst = DREGu8((Opcode >> 9) & 7);
34971         res = dst + src;
34972         flag_N = flag_X = flag_C = res;
34973         flag_V = (src ^ res) & (dst ^ res);
34974         flag_NotZ = res & 0xFF;
34975         DREGu8((Opcode >> 9) & 7) = res;
34976         POST_IO
34977 RET(8)
34978 }
34979
34980 // ADDaD
34981 OPCODE(0xD020)
34982 {
34983         u32 adr, res;
34984         u32 src, dst;
34985
34986         adr = AREG((Opcode >> 0) & 7) - 1;
34987         AREG((Opcode >> 0) & 7) = adr;
34988         PRE_IO
34989         READ_BYTE_F(adr, src)
34990         dst = DREGu8((Opcode >> 9) & 7);
34991         res = dst + src;
34992         flag_N = flag_X = flag_C = res;
34993         flag_V = (src ^ res) & (dst ^ res);
34994         flag_NotZ = res & 0xFF;
34995         DREGu8((Opcode >> 9) & 7) = res;
34996         POST_IO
34997 RET(10)
34998 }
34999
35000 // ADDaD
35001 OPCODE(0xD028)
35002 {
35003         u32 adr, res;
35004         u32 src, dst;
35005
35006         FETCH_SWORD(adr);
35007         adr += AREG((Opcode >> 0) & 7);
35008         PRE_IO
35009         READ_BYTE_F(adr, src)
35010         dst = DREGu8((Opcode >> 9) & 7);
35011         res = dst + src;
35012         flag_N = flag_X = flag_C = res;
35013         flag_V = (src ^ res) & (dst ^ res);
35014         flag_NotZ = res & 0xFF;
35015         DREGu8((Opcode >> 9) & 7) = res;
35016         POST_IO
35017 RET(12)
35018 }
35019
35020 // ADDaD
35021 OPCODE(0xD030)
35022 {
35023         u32 adr, res;
35024         u32 src, dst;
35025
35026         adr = AREG((Opcode >> 0) & 7);
35027         DECODE_EXT_WORD
35028         PRE_IO
35029         READ_BYTE_F(adr, src)
35030         dst = DREGu8((Opcode >> 9) & 7);
35031         res = dst + src;
35032         flag_N = flag_X = flag_C = res;
35033         flag_V = (src ^ res) & (dst ^ res);
35034         flag_NotZ = res & 0xFF;
35035         DREGu8((Opcode >> 9) & 7) = res;
35036         POST_IO
35037 RET(14)
35038 }
35039
35040 // ADDaD
35041 OPCODE(0xD038)
35042 {
35043         u32 adr, res;
35044         u32 src, dst;
35045
35046         FETCH_SWORD(adr);
35047         PRE_IO
35048         READ_BYTE_F(adr, src)
35049         dst = DREGu8((Opcode >> 9) & 7);
35050         res = dst + src;
35051         flag_N = flag_X = flag_C = res;
35052         flag_V = (src ^ res) & (dst ^ res);
35053         flag_NotZ = res & 0xFF;
35054         DREGu8((Opcode >> 9) & 7) = res;
35055         POST_IO
35056 RET(12)
35057 }
35058
35059 // ADDaD
35060 OPCODE(0xD039)
35061 {
35062         u32 adr, res;
35063         u32 src, dst;
35064
35065         FETCH_LONG(adr);
35066         PRE_IO
35067         READ_BYTE_F(adr, src)
35068         dst = DREGu8((Opcode >> 9) & 7);
35069         res = dst + src;
35070         flag_N = flag_X = flag_C = res;
35071         flag_V = (src ^ res) & (dst ^ res);
35072         flag_NotZ = res & 0xFF;
35073         DREGu8((Opcode >> 9) & 7) = res;
35074         POST_IO
35075 RET(16)
35076 }
35077
35078 // ADDaD
35079 OPCODE(0xD03A)
35080 {
35081         u32 adr, res;
35082         u32 src, dst;
35083
35084         adr = GET_SWORD + GET_PC;
35085         PC++;
35086         PRE_IO
35087         READ_BYTE_F(adr, src)
35088         dst = DREGu8((Opcode >> 9) & 7);
35089         res = dst + src;
35090         flag_N = flag_X = flag_C = res;
35091         flag_V = (src ^ res) & (dst ^ res);
35092         flag_NotZ = res & 0xFF;
35093         DREGu8((Opcode >> 9) & 7) = res;
35094         POST_IO
35095 RET(12)
35096 }
35097
35098 // ADDaD
35099 OPCODE(0xD03B)
35100 {
35101         u32 adr, res;
35102         u32 src, dst;
35103
35104         adr = GET_PC;
35105         DECODE_EXT_WORD
35106         PRE_IO
35107         READ_BYTE_F(adr, src)
35108         dst = DREGu8((Opcode >> 9) & 7);
35109         res = dst + src;
35110         flag_N = flag_X = flag_C = res;
35111         flag_V = (src ^ res) & (dst ^ res);
35112         flag_NotZ = res & 0xFF;
35113         DREGu8((Opcode >> 9) & 7) = res;
35114         POST_IO
35115 RET(14)
35116 }
35117
35118 // ADDaD
35119 OPCODE(0xD03C)
35120 {
35121         u32 adr, res;
35122         u32 src, dst;
35123
35124         FETCH_BYTE(src);
35125         dst = DREGu8((Opcode >> 9) & 7);
35126         res = dst + src;
35127         flag_N = flag_X = flag_C = res;
35128         flag_V = (src ^ res) & (dst ^ res);
35129         flag_NotZ = res & 0xFF;
35130         DREGu8((Opcode >> 9) & 7) = res;
35131 RET(8)
35132 }
35133
35134 // ADDaD
35135 OPCODE(0xD01F)
35136 {
35137         u32 adr, res;
35138         u32 src, dst;
35139
35140         adr = AREG(7);
35141         AREG(7) += 2;
35142         PRE_IO
35143         READ_BYTE_F(adr, src)
35144         dst = DREGu8((Opcode >> 9) & 7);
35145         res = dst + src;
35146         flag_N = flag_X = flag_C = res;
35147         flag_V = (src ^ res) & (dst ^ res);
35148         flag_NotZ = res & 0xFF;
35149         DREGu8((Opcode >> 9) & 7) = res;
35150         POST_IO
35151 RET(8)
35152 }
35153
35154 // ADDaD
35155 OPCODE(0xD027)
35156 {
35157         u32 adr, res;
35158         u32 src, dst;
35159
35160         adr = AREG(7) - 2;
35161         AREG(7) = adr;
35162         PRE_IO
35163         READ_BYTE_F(adr, src)
35164         dst = DREGu8((Opcode >> 9) & 7);
35165         res = dst + src;
35166         flag_N = flag_X = flag_C = res;
35167         flag_V = (src ^ res) & (dst ^ res);
35168         flag_NotZ = res & 0xFF;
35169         DREGu8((Opcode >> 9) & 7) = res;
35170         POST_IO
35171 RET(10)
35172 }
35173
35174 // ADDaD
35175 OPCODE(0xD040)
35176 {
35177         u32 adr, res;
35178         u32 src, dst;
35179
35180         src = DREGu16((Opcode >> 0) & 7);
35181         dst = DREGu16((Opcode >> 9) & 7);
35182         res = dst + src;
35183         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35184         flag_N = flag_X = flag_C = res >> 8;
35185         flag_NotZ = res & 0xFFFF;
35186         DREGu16((Opcode >> 9) & 7) = res;
35187 RET(4)
35188 }
35189
35190 // ADDaD
35191 OPCODE(0xD048)
35192 {
35193         u32 adr, res;
35194         u32 src, dst;
35195
35196         src = AREGu16((Opcode >> 0) & 7);
35197         dst = DREGu16((Opcode >> 9) & 7);
35198         res = dst + src;
35199         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35200         flag_N = flag_X = flag_C = res >> 8;
35201         flag_NotZ = res & 0xFFFF;
35202         DREGu16((Opcode >> 9) & 7) = res;
35203 RET(4)
35204 }
35205
35206 // ADDaD
35207 OPCODE(0xD050)
35208 {
35209         u32 adr, res;
35210         u32 src, dst;
35211
35212         adr = AREG((Opcode >> 0) & 7);
35213         PRE_IO
35214         READ_WORD_F(adr, src)
35215         dst = DREGu16((Opcode >> 9) & 7);
35216         res = dst + src;
35217         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35218         flag_N = flag_X = flag_C = res >> 8;
35219         flag_NotZ = res & 0xFFFF;
35220         DREGu16((Opcode >> 9) & 7) = res;
35221         POST_IO
35222 RET(8)
35223 }
35224
35225 // ADDaD
35226 OPCODE(0xD058)
35227 {
35228         u32 adr, res;
35229         u32 src, dst;
35230
35231         adr = AREG((Opcode >> 0) & 7);
35232         AREG((Opcode >> 0) & 7) += 2;
35233         PRE_IO
35234         READ_WORD_F(adr, src)
35235         dst = DREGu16((Opcode >> 9) & 7);
35236         res = dst + src;
35237         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35238         flag_N = flag_X = flag_C = res >> 8;
35239         flag_NotZ = res & 0xFFFF;
35240         DREGu16((Opcode >> 9) & 7) = res;
35241         POST_IO
35242 RET(8)
35243 }
35244
35245 // ADDaD
35246 OPCODE(0xD060)
35247 {
35248         u32 adr, res;
35249         u32 src, dst;
35250
35251         adr = AREG((Opcode >> 0) & 7) - 2;
35252         AREG((Opcode >> 0) & 7) = adr;
35253         PRE_IO
35254         READ_WORD_F(adr, src)
35255         dst = DREGu16((Opcode >> 9) & 7);
35256         res = dst + src;
35257         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35258         flag_N = flag_X = flag_C = res >> 8;
35259         flag_NotZ = res & 0xFFFF;
35260         DREGu16((Opcode >> 9) & 7) = res;
35261         POST_IO
35262 RET(10)
35263 }
35264
35265 // ADDaD
35266 OPCODE(0xD068)
35267 {
35268         u32 adr, res;
35269         u32 src, dst;
35270
35271         FETCH_SWORD(adr);
35272         adr += AREG((Opcode >> 0) & 7);
35273         PRE_IO
35274         READ_WORD_F(adr, src)
35275         dst = DREGu16((Opcode >> 9) & 7);
35276         res = dst + src;
35277         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35278         flag_N = flag_X = flag_C = res >> 8;
35279         flag_NotZ = res & 0xFFFF;
35280         DREGu16((Opcode >> 9) & 7) = res;
35281         POST_IO
35282 RET(12)
35283 }
35284
35285 // ADDaD
35286 OPCODE(0xD070)
35287 {
35288         u32 adr, res;
35289         u32 src, dst;
35290
35291         adr = AREG((Opcode >> 0) & 7);
35292         DECODE_EXT_WORD
35293         PRE_IO
35294         READ_WORD_F(adr, src)
35295         dst = DREGu16((Opcode >> 9) & 7);
35296         res = dst + src;
35297         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35298         flag_N = flag_X = flag_C = res >> 8;
35299         flag_NotZ = res & 0xFFFF;
35300         DREGu16((Opcode >> 9) & 7) = res;
35301         POST_IO
35302 RET(14)
35303 }
35304
35305 // ADDaD
35306 OPCODE(0xD078)
35307 {
35308         u32 adr, res;
35309         u32 src, dst;
35310
35311         FETCH_SWORD(adr);
35312         PRE_IO
35313         READ_WORD_F(adr, src)
35314         dst = DREGu16((Opcode >> 9) & 7);
35315         res = dst + src;
35316         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35317         flag_N = flag_X = flag_C = res >> 8;
35318         flag_NotZ = res & 0xFFFF;
35319         DREGu16((Opcode >> 9) & 7) = res;
35320         POST_IO
35321 RET(12)
35322 }
35323
35324 // ADDaD
35325 OPCODE(0xD079)
35326 {
35327         u32 adr, res;
35328         u32 src, dst;
35329
35330         FETCH_LONG(adr);
35331         PRE_IO
35332         READ_WORD_F(adr, src)
35333         dst = DREGu16((Opcode >> 9) & 7);
35334         res = dst + src;
35335         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35336         flag_N = flag_X = flag_C = res >> 8;
35337         flag_NotZ = res & 0xFFFF;
35338         DREGu16((Opcode >> 9) & 7) = res;
35339         POST_IO
35340 RET(16)
35341 }
35342
35343 // ADDaD
35344 OPCODE(0xD07A)
35345 {
35346         u32 adr, res;
35347         u32 src, dst;
35348
35349         adr = GET_SWORD + GET_PC;
35350         PC++;
35351         PRE_IO
35352         READ_WORD_F(adr, src)
35353         dst = DREGu16((Opcode >> 9) & 7);
35354         res = dst + src;
35355         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35356         flag_N = flag_X = flag_C = res >> 8;
35357         flag_NotZ = res & 0xFFFF;
35358         DREGu16((Opcode >> 9) & 7) = res;
35359         POST_IO
35360 RET(12)
35361 }
35362
35363 // ADDaD
35364 OPCODE(0xD07B)
35365 {
35366         u32 adr, res;
35367         u32 src, dst;
35368
35369         adr = GET_PC;
35370         DECODE_EXT_WORD
35371         PRE_IO
35372         READ_WORD_F(adr, src)
35373         dst = DREGu16((Opcode >> 9) & 7);
35374         res = dst + src;
35375         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35376         flag_N = flag_X = flag_C = res >> 8;
35377         flag_NotZ = res & 0xFFFF;
35378         DREGu16((Opcode >> 9) & 7) = res;
35379         POST_IO
35380 RET(14)
35381 }
35382
35383 // ADDaD
35384 OPCODE(0xD07C)
35385 {
35386         u32 adr, res;
35387         u32 src, dst;
35388
35389         FETCH_WORD(src);
35390         dst = DREGu16((Opcode >> 9) & 7);
35391         res = dst + src;
35392         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35393         flag_N = flag_X = flag_C = res >> 8;
35394         flag_NotZ = res & 0xFFFF;
35395         DREGu16((Opcode >> 9) & 7) = res;
35396 RET(8)
35397 }
35398
35399 // ADDaD
35400 OPCODE(0xD05F)
35401 {
35402         u32 adr, res;
35403         u32 src, dst;
35404
35405         adr = AREG(7);
35406         AREG(7) += 2;
35407         PRE_IO
35408         READ_WORD_F(adr, src)
35409         dst = DREGu16((Opcode >> 9) & 7);
35410         res = dst + src;
35411         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35412         flag_N = flag_X = flag_C = res >> 8;
35413         flag_NotZ = res & 0xFFFF;
35414         DREGu16((Opcode >> 9) & 7) = res;
35415         POST_IO
35416 RET(8)
35417 }
35418
35419 // ADDaD
35420 OPCODE(0xD067)
35421 {
35422         u32 adr, res;
35423         u32 src, dst;
35424
35425         adr = AREG(7) - 2;
35426         AREG(7) = adr;
35427         PRE_IO
35428         READ_WORD_F(adr, src)
35429         dst = DREGu16((Opcode >> 9) & 7);
35430         res = dst + src;
35431         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35432         flag_N = flag_X = flag_C = res >> 8;
35433         flag_NotZ = res & 0xFFFF;
35434         DREGu16((Opcode >> 9) & 7) = res;
35435         POST_IO
35436 RET(10)
35437 }
35438
35439 // ADDaD
35440 OPCODE(0xD080)
35441 {
35442         u32 adr, res;
35443         u32 src, dst;
35444
35445         src = DREGu32((Opcode >> 0) & 7);
35446         dst = DREGu32((Opcode >> 9) & 7);
35447         res = dst + src;
35448         flag_NotZ = res;
35449         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35450         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35451         flag_N = res >> 24;
35452         DREGu32((Opcode >> 9) & 7) = res;
35453 RET(8)
35454 }
35455
35456 // ADDaD
35457 OPCODE(0xD088)
35458 {
35459         u32 adr, res;
35460         u32 src, dst;
35461
35462         src = AREGu32((Opcode >> 0) & 7);
35463         dst = DREGu32((Opcode >> 9) & 7);
35464         res = dst + src;
35465         flag_NotZ = res;
35466         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35467         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35468         flag_N = res >> 24;
35469         DREGu32((Opcode >> 9) & 7) = res;
35470 RET(8)
35471 }
35472
35473 // ADDaD
35474 OPCODE(0xD090)
35475 {
35476         u32 adr, res;
35477         u32 src, dst;
35478
35479         adr = AREG((Opcode >> 0) & 7);
35480         PRE_IO
35481         READ_LONG_F(adr, src)
35482         dst = DREGu32((Opcode >> 9) & 7);
35483         res = dst + src;
35484         flag_NotZ = res;
35485         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35486         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35487         flag_N = res >> 24;
35488         DREGu32((Opcode >> 9) & 7) = res;
35489         POST_IO
35490 RET(14)
35491 }
35492
35493 // ADDaD
35494 OPCODE(0xD098)
35495 {
35496         u32 adr, res;
35497         u32 src, dst;
35498
35499         adr = AREG((Opcode >> 0) & 7);
35500         AREG((Opcode >> 0) & 7) += 4;
35501         PRE_IO
35502         READ_LONG_F(adr, src)
35503         dst = DREGu32((Opcode >> 9) & 7);
35504         res = dst + src;
35505         flag_NotZ = res;
35506         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35507         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35508         flag_N = res >> 24;
35509         DREGu32((Opcode >> 9) & 7) = res;
35510         POST_IO
35511 RET(14)
35512 }
35513
35514 // ADDaD
35515 OPCODE(0xD0A0)
35516 {
35517         u32 adr, res;
35518         u32 src, dst;
35519
35520         adr = AREG((Opcode >> 0) & 7) - 4;
35521         AREG((Opcode >> 0) & 7) = adr;
35522         PRE_IO
35523         READ_LONG_F(adr, src)
35524         dst = DREGu32((Opcode >> 9) & 7);
35525         res = dst + src;
35526         flag_NotZ = res;
35527         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35528         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35529         flag_N = res >> 24;
35530         DREGu32((Opcode >> 9) & 7) = res;
35531         POST_IO
35532 RET(16)
35533 }
35534
35535 // ADDaD
35536 OPCODE(0xD0A8)
35537 {
35538         u32 adr, res;
35539         u32 src, dst;
35540
35541         FETCH_SWORD(adr);
35542         adr += AREG((Opcode >> 0) & 7);
35543         PRE_IO
35544         READ_LONG_F(adr, src)
35545         dst = DREGu32((Opcode >> 9) & 7);
35546         res = dst + src;
35547         flag_NotZ = res;
35548         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35549         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35550         flag_N = res >> 24;
35551         DREGu32((Opcode >> 9) & 7) = res;
35552         POST_IO
35553 RET(18)
35554 }
35555
35556 // ADDaD
35557 OPCODE(0xD0B0)
35558 {
35559         u32 adr, res;
35560         u32 src, dst;
35561
35562         adr = AREG((Opcode >> 0) & 7);
35563         DECODE_EXT_WORD
35564         PRE_IO
35565         READ_LONG_F(adr, src)
35566         dst = DREGu32((Opcode >> 9) & 7);
35567         res = dst + src;
35568         flag_NotZ = res;
35569         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35570         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35571         flag_N = res >> 24;
35572         DREGu32((Opcode >> 9) & 7) = res;
35573         POST_IO
35574 RET(20)
35575 }
35576
35577 // ADDaD
35578 OPCODE(0xD0B8)
35579 {
35580         u32 adr, res;
35581         u32 src, dst;
35582
35583         FETCH_SWORD(adr);
35584         PRE_IO
35585         READ_LONG_F(adr, src)
35586         dst = DREGu32((Opcode >> 9) & 7);
35587         res = dst + src;
35588         flag_NotZ = res;
35589         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35590         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35591         flag_N = res >> 24;
35592         DREGu32((Opcode >> 9) & 7) = res;
35593         POST_IO
35594 RET(18)
35595 }
35596
35597 // ADDaD
35598 OPCODE(0xD0B9)
35599 {
35600         u32 adr, res;
35601         u32 src, dst;
35602
35603         FETCH_LONG(adr);
35604         PRE_IO
35605         READ_LONG_F(adr, src)
35606         dst = DREGu32((Opcode >> 9) & 7);
35607         res = dst + src;
35608         flag_NotZ = res;
35609         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35610         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35611         flag_N = res >> 24;
35612         DREGu32((Opcode >> 9) & 7) = res;
35613         POST_IO
35614 RET(22)
35615 }
35616
35617 // ADDaD
35618 OPCODE(0xD0BA)
35619 {
35620         u32 adr, res;
35621         u32 src, dst;
35622
35623         adr = GET_SWORD + GET_PC;
35624         PC++;
35625         PRE_IO
35626         READ_LONG_F(adr, src)
35627         dst = DREGu32((Opcode >> 9) & 7);
35628         res = dst + src;
35629         flag_NotZ = res;
35630         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35631         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35632         flag_N = res >> 24;
35633         DREGu32((Opcode >> 9) & 7) = res;
35634         POST_IO
35635 RET(18)
35636 }
35637
35638 // ADDaD
35639 OPCODE(0xD0BB)
35640 {
35641         u32 adr, res;
35642         u32 src, dst;
35643
35644         adr = GET_PC;
35645         DECODE_EXT_WORD
35646         PRE_IO
35647         READ_LONG_F(adr, src)
35648         dst = DREGu32((Opcode >> 9) & 7);
35649         res = dst + src;
35650         flag_NotZ = res;
35651         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35652         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35653         flag_N = res >> 24;
35654         DREGu32((Opcode >> 9) & 7) = res;
35655         POST_IO
35656 RET(20)
35657 }
35658
35659 // ADDaD
35660 OPCODE(0xD0BC)
35661 {
35662         u32 adr, res;
35663         u32 src, dst;
35664
35665         FETCH_LONG(src);
35666         dst = DREGu32((Opcode >> 9) & 7);
35667         res = dst + src;
35668         flag_NotZ = res;
35669         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35670         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35671         flag_N = res >> 24;
35672         DREGu32((Opcode >> 9) & 7) = res;
35673 RET(16)
35674 }
35675
35676 // ADDaD
35677 OPCODE(0xD09F)
35678 {
35679         u32 adr, res;
35680         u32 src, dst;
35681
35682         adr = AREG(7);
35683         AREG(7) += 4;
35684         PRE_IO
35685         READ_LONG_F(adr, src)
35686         dst = DREGu32((Opcode >> 9) & 7);
35687         res = dst + src;
35688         flag_NotZ = res;
35689         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35690         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35691         flag_N = res >> 24;
35692         DREGu32((Opcode >> 9) & 7) = res;
35693         POST_IO
35694 RET(14)
35695 }
35696
35697 // ADDaD
35698 OPCODE(0xD0A7)
35699 {
35700         u32 adr, res;
35701         u32 src, dst;
35702
35703         adr = AREG(7) - 4;
35704         AREG(7) = adr;
35705         PRE_IO
35706         READ_LONG_F(adr, src)
35707         dst = DREGu32((Opcode >> 9) & 7);
35708         res = dst + src;
35709         flag_NotZ = res;
35710         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35711         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35712         flag_N = res >> 24;
35713         DREGu32((Opcode >> 9) & 7) = res;
35714         POST_IO
35715 RET(16)
35716 }
35717
35718 // ADDDa
35719 OPCODE(0xD110)
35720 {
35721         u32 adr, res;
35722         u32 src, dst;
35723
35724         src = DREGu8((Opcode >> 9) & 7);
35725         adr = AREG((Opcode >> 0) & 7);
35726         PRE_IO
35727         READ_BYTE_F(adr, dst)
35728         res = dst + src;
35729         flag_N = flag_X = flag_C = res;
35730         flag_V = (src ^ res) & (dst ^ res);
35731         flag_NotZ = res & 0xFF;
35732         WRITE_BYTE_F(adr, res)
35733         POST_IO
35734 RET(12)
35735 }
35736
35737 // ADDDa
35738 OPCODE(0xD118)
35739 {
35740         u32 adr, res;
35741         u32 src, dst;
35742
35743         src = DREGu8((Opcode >> 9) & 7);
35744         adr = AREG((Opcode >> 0) & 7);
35745         AREG((Opcode >> 0) & 7) += 1;
35746         PRE_IO
35747         READ_BYTE_F(adr, dst)
35748         res = dst + src;
35749         flag_N = flag_X = flag_C = res;
35750         flag_V = (src ^ res) & (dst ^ res);
35751         flag_NotZ = res & 0xFF;
35752         WRITE_BYTE_F(adr, res)
35753         POST_IO
35754 RET(12)
35755 }
35756
35757 // ADDDa
35758 OPCODE(0xD120)
35759 {
35760         u32 adr, res;
35761         u32 src, dst;
35762
35763         src = DREGu8((Opcode >> 9) & 7);
35764         adr = AREG((Opcode >> 0) & 7) - 1;
35765         AREG((Opcode >> 0) & 7) = adr;
35766         PRE_IO
35767         READ_BYTE_F(adr, dst)
35768         res = dst + src;
35769         flag_N = flag_X = flag_C = res;
35770         flag_V = (src ^ res) & (dst ^ res);
35771         flag_NotZ = res & 0xFF;
35772         WRITE_BYTE_F(adr, res)
35773         POST_IO
35774 RET(14)
35775 }
35776
35777 // ADDDa
35778 OPCODE(0xD128)
35779 {
35780         u32 adr, res;
35781         u32 src, dst;
35782
35783         src = DREGu8((Opcode >> 9) & 7);
35784         FETCH_SWORD(adr);
35785         adr += AREG((Opcode >> 0) & 7);
35786         PRE_IO
35787         READ_BYTE_F(adr, dst)
35788         res = dst + src;
35789         flag_N = flag_X = flag_C = res;
35790         flag_V = (src ^ res) & (dst ^ res);
35791         flag_NotZ = res & 0xFF;
35792         WRITE_BYTE_F(adr, res)
35793         POST_IO
35794 RET(16)
35795 }
35796
35797 // ADDDa
35798 OPCODE(0xD130)
35799 {
35800         u32 adr, res;
35801         u32 src, dst;
35802
35803         src = DREGu8((Opcode >> 9) & 7);
35804         adr = AREG((Opcode >> 0) & 7);
35805         DECODE_EXT_WORD
35806         PRE_IO
35807         READ_BYTE_F(adr, dst)
35808         res = dst + src;
35809         flag_N = flag_X = flag_C = res;
35810         flag_V = (src ^ res) & (dst ^ res);
35811         flag_NotZ = res & 0xFF;
35812         WRITE_BYTE_F(adr, res)
35813         POST_IO
35814 RET(18)
35815 }
35816
35817 // ADDDa
35818 OPCODE(0xD138)
35819 {
35820         u32 adr, res;
35821         u32 src, dst;
35822
35823         src = DREGu8((Opcode >> 9) & 7);
35824         FETCH_SWORD(adr);
35825         PRE_IO
35826         READ_BYTE_F(adr, dst)
35827         res = dst + src;
35828         flag_N = flag_X = flag_C = res;
35829         flag_V = (src ^ res) & (dst ^ res);
35830         flag_NotZ = res & 0xFF;
35831         WRITE_BYTE_F(adr, res)
35832         POST_IO
35833 RET(16)
35834 }
35835
35836 // ADDDa
35837 OPCODE(0xD139)
35838 {
35839         u32 adr, res;
35840         u32 src, dst;
35841
35842         src = DREGu8((Opcode >> 9) & 7);
35843         FETCH_LONG(adr);
35844         PRE_IO
35845         READ_BYTE_F(adr, dst)
35846         res = dst + src;
35847         flag_N = flag_X = flag_C = res;
35848         flag_V = (src ^ res) & (dst ^ res);
35849         flag_NotZ = res & 0xFF;
35850         WRITE_BYTE_F(adr, res)
35851         POST_IO
35852 RET(20)
35853 }
35854
35855 // ADDDa
35856 OPCODE(0xD11F)
35857 {
35858         u32 adr, res;
35859         u32 src, dst;
35860
35861         src = DREGu8((Opcode >> 9) & 7);
35862         adr = AREG(7);
35863         AREG(7) += 2;
35864         PRE_IO
35865         READ_BYTE_F(adr, dst)
35866         res = dst + src;
35867         flag_N = flag_X = flag_C = res;
35868         flag_V = (src ^ res) & (dst ^ res);
35869         flag_NotZ = res & 0xFF;
35870         WRITE_BYTE_F(adr, res)
35871         POST_IO
35872 RET(12)
35873 }
35874
35875 // ADDDa
35876 OPCODE(0xD127)
35877 {
35878         u32 adr, res;
35879         u32 src, dst;
35880
35881         src = DREGu8((Opcode >> 9) & 7);
35882         adr = AREG(7) - 2;
35883         AREG(7) = adr;
35884         PRE_IO
35885         READ_BYTE_F(adr, dst)
35886         res = dst + src;
35887         flag_N = flag_X = flag_C = res;
35888         flag_V = (src ^ res) & (dst ^ res);
35889         flag_NotZ = res & 0xFF;
35890         WRITE_BYTE_F(adr, res)
35891         POST_IO
35892 RET(14)
35893 }
35894
35895 // ADDDa
35896 OPCODE(0xD150)
35897 {
35898         u32 adr, res;
35899         u32 src, dst;
35900
35901         src = DREGu16((Opcode >> 9) & 7);
35902         adr = AREG((Opcode >> 0) & 7);
35903         PRE_IO
35904         READ_WORD_F(adr, dst)
35905         res = dst + src;
35906         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35907         flag_N = flag_X = flag_C = res >> 8;
35908         flag_NotZ = res & 0xFFFF;
35909         WRITE_WORD_F(adr, res)
35910         POST_IO
35911 RET(12)
35912 }
35913
35914 // ADDDa
35915 OPCODE(0xD158)
35916 {
35917         u32 adr, res;
35918         u32 src, dst;
35919
35920         src = DREGu16((Opcode >> 9) & 7);
35921         adr = AREG((Opcode >> 0) & 7);
35922         AREG((Opcode >> 0) & 7) += 2;
35923         PRE_IO
35924         READ_WORD_F(adr, dst)
35925         res = dst + src;
35926         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35927         flag_N = flag_X = flag_C = res >> 8;
35928         flag_NotZ = res & 0xFFFF;
35929         WRITE_WORD_F(adr, res)
35930         POST_IO
35931 RET(12)
35932 }
35933
35934 // ADDDa
35935 OPCODE(0xD160)
35936 {
35937         u32 adr, res;
35938         u32 src, dst;
35939
35940         src = DREGu16((Opcode >> 9) & 7);
35941         adr = AREG((Opcode >> 0) & 7) - 2;
35942         AREG((Opcode >> 0) & 7) = adr;
35943         PRE_IO
35944         READ_WORD_F(adr, dst)
35945         res = dst + src;
35946         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35947         flag_N = flag_X = flag_C = res >> 8;
35948         flag_NotZ = res & 0xFFFF;
35949         WRITE_WORD_F(adr, res)
35950         POST_IO
35951 RET(14)
35952 }
35953
35954 // ADDDa
35955 OPCODE(0xD168)
35956 {
35957         u32 adr, res;
35958         u32 src, dst;
35959
35960         src = DREGu16((Opcode >> 9) & 7);
35961         FETCH_SWORD(adr);
35962         adr += AREG((Opcode >> 0) & 7);
35963         PRE_IO
35964         READ_WORD_F(adr, dst)
35965         res = dst + src;
35966         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35967         flag_N = flag_X = flag_C = res >> 8;
35968         flag_NotZ = res & 0xFFFF;
35969         WRITE_WORD_F(adr, res)
35970         POST_IO
35971 RET(16)
35972 }
35973
35974 // ADDDa
35975 OPCODE(0xD170)
35976 {
35977         u32 adr, res;
35978         u32 src, dst;
35979
35980         src = DREGu16((Opcode >> 9) & 7);
35981         adr = AREG((Opcode >> 0) & 7);
35982         DECODE_EXT_WORD
35983         PRE_IO
35984         READ_WORD_F(adr, dst)
35985         res = dst + src;
35986         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35987         flag_N = flag_X = flag_C = res >> 8;
35988         flag_NotZ = res & 0xFFFF;
35989         WRITE_WORD_F(adr, res)
35990         POST_IO
35991 RET(18)
35992 }
35993
35994 // ADDDa
35995 OPCODE(0xD178)
35996 {
35997         u32 adr, res;
35998         u32 src, dst;
35999
36000         src = DREGu16((Opcode >> 9) & 7);
36001         FETCH_SWORD(adr);
36002         PRE_IO
36003         READ_WORD_F(adr, dst)
36004         res = dst + src;
36005         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36006         flag_N = flag_X = flag_C = res >> 8;
36007         flag_NotZ = res & 0xFFFF;
36008         WRITE_WORD_F(adr, res)
36009         POST_IO
36010 RET(16)
36011 }
36012
36013 // ADDDa
36014 OPCODE(0xD179)
36015 {
36016         u32 adr, res;
36017         u32 src, dst;
36018
36019         src = DREGu16((Opcode >> 9) & 7);
36020         FETCH_LONG(adr);
36021         PRE_IO
36022         READ_WORD_F(adr, dst)
36023         res = dst + src;
36024         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36025         flag_N = flag_X = flag_C = res >> 8;
36026         flag_NotZ = res & 0xFFFF;
36027         WRITE_WORD_F(adr, res)
36028         POST_IO
36029 RET(20)
36030 }
36031
36032 // ADDDa
36033 OPCODE(0xD15F)
36034 {
36035         u32 adr, res;
36036         u32 src, dst;
36037
36038         src = DREGu16((Opcode >> 9) & 7);
36039         adr = AREG(7);
36040         AREG(7) += 2;
36041         PRE_IO
36042         READ_WORD_F(adr, dst)
36043         res = dst + src;
36044         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36045         flag_N = flag_X = flag_C = res >> 8;
36046         flag_NotZ = res & 0xFFFF;
36047         WRITE_WORD_F(adr, res)
36048         POST_IO
36049 RET(12)
36050 }
36051
36052 // ADDDa
36053 OPCODE(0xD167)
36054 {
36055         u32 adr, res;
36056         u32 src, dst;
36057
36058         src = DREGu16((Opcode >> 9) & 7);
36059         adr = AREG(7) - 2;
36060         AREG(7) = adr;
36061         PRE_IO
36062         READ_WORD_F(adr, dst)
36063         res = dst + src;
36064         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36065         flag_N = flag_X = flag_C = res >> 8;
36066         flag_NotZ = res & 0xFFFF;
36067         WRITE_WORD_F(adr, res)
36068         POST_IO
36069 RET(14)
36070 }
36071
36072 // ADDDa
36073 OPCODE(0xD190)
36074 {
36075         u32 adr, res;
36076         u32 src, dst;
36077
36078         src = DREGu32((Opcode >> 9) & 7);
36079         adr = AREG((Opcode >> 0) & 7);
36080         PRE_IO
36081         READ_LONG_F(adr, dst)
36082         res = dst + src;
36083         flag_NotZ = res;
36084         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36085         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36086         flag_N = res >> 24;
36087         WRITE_LONG_F(adr, res)
36088         POST_IO
36089 RET(20)
36090 }
36091
36092 // ADDDa
36093 OPCODE(0xD198)
36094 {
36095         u32 adr, res;
36096         u32 src, dst;
36097
36098         src = DREGu32((Opcode >> 9) & 7);
36099         adr = AREG((Opcode >> 0) & 7);
36100         AREG((Opcode >> 0) & 7) += 4;
36101         PRE_IO
36102         READ_LONG_F(adr, dst)
36103         res = dst + src;
36104         flag_NotZ = res;
36105         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36106         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36107         flag_N = res >> 24;
36108         WRITE_LONG_F(adr, res)
36109         POST_IO
36110 RET(20)
36111 }
36112
36113 // ADDDa
36114 OPCODE(0xD1A0)
36115 {
36116         u32 adr, res;
36117         u32 src, dst;
36118
36119         src = DREGu32((Opcode >> 9) & 7);
36120         adr = AREG((Opcode >> 0) & 7) - 4;
36121         AREG((Opcode >> 0) & 7) = adr;
36122         PRE_IO
36123         READ_LONG_F(adr, dst)
36124         res = dst + src;
36125         flag_NotZ = res;
36126         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36127         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36128         flag_N = res >> 24;
36129         WRITE_LONG_F(adr, res)
36130         POST_IO
36131 RET(22)
36132 }
36133
36134 // ADDDa
36135 OPCODE(0xD1A8)
36136 {
36137         u32 adr, res;
36138         u32 src, dst;
36139
36140         src = DREGu32((Opcode >> 9) & 7);
36141         FETCH_SWORD(adr);
36142         adr += AREG((Opcode >> 0) & 7);
36143         PRE_IO
36144         READ_LONG_F(adr, dst)
36145         res = dst + src;
36146         flag_NotZ = res;
36147         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36148         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36149         flag_N = res >> 24;
36150         WRITE_LONG_F(adr, res)
36151         POST_IO
36152 RET(24)
36153 }
36154
36155 // ADDDa
36156 OPCODE(0xD1B0)
36157 {
36158         u32 adr, res;
36159         u32 src, dst;
36160
36161         src = DREGu32((Opcode >> 9) & 7);
36162         adr = AREG((Opcode >> 0) & 7);
36163         DECODE_EXT_WORD
36164         PRE_IO
36165         READ_LONG_F(adr, dst)
36166         res = dst + src;
36167         flag_NotZ = res;
36168         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36169         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36170         flag_N = res >> 24;
36171         WRITE_LONG_F(adr, res)
36172         POST_IO
36173 RET(26)
36174 }
36175
36176 // ADDDa
36177 OPCODE(0xD1B8)
36178 {
36179         u32 adr, res;
36180         u32 src, dst;
36181
36182         src = DREGu32((Opcode >> 9) & 7);
36183         FETCH_SWORD(adr);
36184         PRE_IO
36185         READ_LONG_F(adr, dst)
36186         res = dst + src;
36187         flag_NotZ = res;
36188         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36189         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36190         flag_N = res >> 24;
36191         WRITE_LONG_F(adr, res)
36192         POST_IO
36193 RET(24)
36194 }
36195
36196 // ADDDa
36197 OPCODE(0xD1B9)
36198 {
36199         u32 adr, res;
36200         u32 src, dst;
36201
36202         src = DREGu32((Opcode >> 9) & 7);
36203         FETCH_LONG(adr);
36204         PRE_IO
36205         READ_LONG_F(adr, dst)
36206         res = dst + src;
36207         flag_NotZ = res;
36208         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36209         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36210         flag_N = res >> 24;
36211         WRITE_LONG_F(adr, res)
36212         POST_IO
36213 RET(28)
36214 }
36215
36216 // ADDDa
36217 OPCODE(0xD19F)
36218 {
36219         u32 adr, res;
36220         u32 src, dst;
36221
36222         src = DREGu32((Opcode >> 9) & 7);
36223         adr = AREG(7);
36224         AREG(7) += 4;
36225         PRE_IO
36226         READ_LONG_F(adr, dst)
36227         res = dst + src;
36228         flag_NotZ = res;
36229         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36230         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36231         flag_N = res >> 24;
36232         WRITE_LONG_F(adr, res)
36233         POST_IO
36234 RET(20)
36235 }
36236
36237 // ADDDa
36238 OPCODE(0xD1A7)
36239 {
36240         u32 adr, res;
36241         u32 src, dst;
36242
36243         src = DREGu32((Opcode >> 9) & 7);
36244         adr = AREG(7) - 4;
36245         AREG(7) = adr;
36246         PRE_IO
36247         READ_LONG_F(adr, dst)
36248         res = dst + src;
36249         flag_NotZ = res;
36250         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36251         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36252         flag_N = res >> 24;
36253         WRITE_LONG_F(adr, res)
36254         POST_IO
36255 RET(22)
36256 }
36257
36258 // ADDX
36259 OPCODE(0xD100)
36260 {
36261         u32 adr, res;
36262         u32 src, dst;
36263
36264         src = DREGu8((Opcode >> 0) & 7);
36265         dst = DREGu8((Opcode >> 9) & 7);
36266         res = dst + src + ((flag_X >> 8) & 1);
36267         flag_N = flag_X = flag_C = res;
36268         flag_V = (src ^ res) & (dst ^ res);
36269         flag_NotZ |= res & 0xFF;
36270         DREGu8((Opcode >> 9) & 7) = res;
36271 RET(4)
36272 }
36273
36274 // ADDX
36275 OPCODE(0xD140)
36276 {
36277         u32 adr, res;
36278         u32 src, dst;
36279
36280         src = DREGu16((Opcode >> 0) & 7);
36281         dst = DREGu16((Opcode >> 9) & 7);
36282         res = dst + src + ((flag_X >> 8) & 1);
36283         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36284         flag_N = flag_X = flag_C = res >> 8;
36285         flag_NotZ |= res & 0xFFFF;
36286         DREGu16((Opcode >> 9) & 7) = res;
36287 RET(4)
36288 }
36289
36290 // ADDX
36291 OPCODE(0xD180)
36292 {
36293         u32 adr, res;
36294         u32 src, dst;
36295
36296         src = DREGu32((Opcode >> 0) & 7);
36297         dst = DREGu32((Opcode >> 9) & 7);
36298         res = dst + src + ((flag_X >> 8) & 1);
36299         flag_NotZ |= res;
36300         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36301         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36302         flag_N = res >> 24;
36303         DREGu32((Opcode >> 9) & 7) = res;
36304 RET(8)
36305 }
36306
36307 // ADDXM
36308 OPCODE(0xD108)
36309 {
36310         u32 adr, res;
36311         u32 src, dst;
36312
36313         adr = AREG((Opcode >> 0) & 7) - 1;
36314         AREG((Opcode >> 0) & 7) = adr;
36315         PRE_IO
36316         READ_BYTE_F(adr, src)
36317         adr = AREG((Opcode >> 9) & 7) - 1;
36318         AREG((Opcode >> 9) & 7) = adr;
36319         READ_BYTE_F(adr, dst)
36320         res = dst + src + ((flag_X >> 8) & 1);
36321         flag_N = flag_X = flag_C = res;
36322         flag_V = (src ^ res) & (dst ^ res);
36323         flag_NotZ |= res & 0xFF;
36324         WRITE_BYTE_F(adr, res)
36325         POST_IO
36326 RET(18)
36327 }
36328
36329 // ADDXM
36330 OPCODE(0xD148)
36331 {
36332         u32 adr, res;
36333         u32 src, dst;
36334
36335         adr = AREG((Opcode >> 0) & 7) - 2;
36336         AREG((Opcode >> 0) & 7) = adr;
36337         PRE_IO
36338         READ_WORD_F(adr, src)
36339         adr = AREG((Opcode >> 9) & 7) - 2;
36340         AREG((Opcode >> 9) & 7) = adr;
36341         READ_WORD_F(adr, dst)
36342         res = dst + src + ((flag_X >> 8) & 1);
36343         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36344         flag_N = flag_X = flag_C = res >> 8;
36345         flag_NotZ |= res & 0xFFFF;
36346         WRITE_WORD_F(adr, res)
36347         POST_IO
36348 RET(18)
36349 }
36350
36351 // ADDXM
36352 OPCODE(0xD188)
36353 {
36354         u32 adr, res;
36355         u32 src, dst;
36356
36357         adr = AREG((Opcode >> 0) & 7) - 4;
36358         AREG((Opcode >> 0) & 7) = adr;
36359         PRE_IO
36360         READ_LONG_F(adr, src)
36361         adr = AREG((Opcode >> 9) & 7) - 4;
36362         AREG((Opcode >> 9) & 7) = adr;
36363         READ_LONG_F(adr, dst)
36364         res = dst + src + ((flag_X >> 8) & 1);
36365         flag_NotZ |= res;
36366         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36367         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36368         flag_N = res >> 24;
36369         WRITE_LONG_F(adr, res)
36370         POST_IO
36371 RET(30)
36372 }
36373
36374 // ADDX7M
36375 OPCODE(0xD10F)
36376 {
36377         u32 adr, res;
36378         u32 src, dst;
36379
36380         adr = AREG(7) - 2;
36381         AREG(7) = adr;
36382         PRE_IO
36383         READ_BYTE_F(adr, src)
36384         adr = AREG((Opcode >> 9) & 7) - 1;
36385         AREG((Opcode >> 9) & 7) = adr;
36386         READ_BYTE_F(adr, dst)
36387         res = dst + src + ((flag_X >> 8) & 1);
36388         flag_N = flag_X = flag_C = res;
36389         flag_V = (src ^ res) & (dst ^ res);
36390         flag_NotZ |= res & 0xFF;
36391         WRITE_BYTE_F(adr, res)
36392         POST_IO
36393 RET(18)
36394 }
36395
36396 // ADDX7M
36397 OPCODE(0xD14F)
36398 {
36399         u32 adr, res;
36400         u32 src, dst;
36401
36402         adr = AREG(7) - 2;
36403         AREG(7) = adr;
36404         PRE_IO
36405         READ_WORD_F(adr, src)
36406         adr = AREG((Opcode >> 9) & 7) - 2;
36407         AREG((Opcode >> 9) & 7) = adr;
36408         READ_WORD_F(adr, dst)
36409         res = dst + src + ((flag_X >> 8) & 1);
36410         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36411         flag_N = flag_X = flag_C = res >> 8;
36412         flag_NotZ |= res & 0xFFFF;
36413         WRITE_WORD_F(adr, res)
36414         POST_IO
36415 RET(18)
36416 }
36417
36418 // ADDX7M
36419 OPCODE(0xD18F)
36420 {
36421         u32 adr, res;
36422         u32 src, dst;
36423
36424         adr = AREG(7) - 4;
36425         AREG(7) = adr;
36426         PRE_IO
36427         READ_LONG_F(adr, src)
36428         adr = AREG((Opcode >> 9) & 7) - 4;
36429         AREG((Opcode >> 9) & 7) = adr;
36430         READ_LONG_F(adr, dst)
36431         res = dst + src + ((flag_X >> 8) & 1);
36432         flag_NotZ |= res;
36433         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36434         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36435         flag_N = res >> 24;
36436         WRITE_LONG_F(adr, res)
36437         POST_IO
36438 RET(30)
36439 }
36440
36441 // ADDXM7
36442 OPCODE(0xDF08)
36443 {
36444         u32 adr, res;
36445         u32 src, dst;
36446
36447         adr = AREG((Opcode >> 0) & 7) - 1;
36448         AREG((Opcode >> 0) & 7) = adr;
36449         PRE_IO
36450         READ_BYTE_F(adr, src)
36451         adr = AREG(7) - 2;
36452         AREG(7) = adr;
36453         READ_BYTE_F(adr, dst)
36454         res = dst + src + ((flag_X >> 8) & 1);
36455         flag_N = flag_X = flag_C = res;
36456         flag_V = (src ^ res) & (dst ^ res);
36457         flag_NotZ |= res & 0xFF;
36458         WRITE_BYTE_F(adr, res)
36459         POST_IO
36460 RET(18)
36461 }
36462
36463 // ADDXM7
36464 OPCODE(0xDF48)
36465 {
36466         u32 adr, res;
36467         u32 src, dst;
36468
36469         adr = AREG((Opcode >> 0) & 7) - 2;
36470         AREG((Opcode >> 0) & 7) = adr;
36471         PRE_IO
36472         READ_WORD_F(adr, src)
36473         adr = AREG(7) - 2;
36474         AREG(7) = adr;
36475         READ_WORD_F(adr, dst)
36476         res = dst + src + ((flag_X >> 8) & 1);
36477         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36478         flag_N = flag_X = flag_C = res >> 8;
36479         flag_NotZ |= res & 0xFFFF;
36480         WRITE_WORD_F(adr, res)
36481         POST_IO
36482 RET(18)
36483 }
36484
36485 // ADDXM7
36486 OPCODE(0xDF88)
36487 {
36488         u32 adr, res;
36489         u32 src, dst;
36490
36491         adr = AREG((Opcode >> 0) & 7) - 4;
36492         AREG((Opcode >> 0) & 7) = adr;
36493         PRE_IO
36494         READ_LONG_F(adr, src)
36495         adr = AREG(7) - 4;
36496         AREG(7) = adr;
36497         READ_LONG_F(adr, dst)
36498         res = dst + src + ((flag_X >> 8) & 1);
36499         flag_NotZ |= res;
36500         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36501         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36502         flag_N = res >> 24;
36503         WRITE_LONG_F(adr, res)
36504         POST_IO
36505 RET(30)
36506 }
36507
36508 // ADDX7M7
36509 OPCODE(0xDF0F)
36510 {
36511         u32 adr, res;
36512         u32 src, dst;
36513
36514         adr = AREG(7) - 2;
36515         AREG(7) = adr;
36516         PRE_IO
36517         READ_BYTE_F(adr, src)
36518         adr = AREG(7) - 2;
36519         AREG(7) = adr;
36520         READ_BYTE_F(adr, dst)
36521         res = dst + src + ((flag_X >> 8) & 1);
36522         flag_N = flag_X = flag_C = res;
36523         flag_V = (src ^ res) & (dst ^ res);
36524         flag_NotZ |= res & 0xFF;
36525         WRITE_BYTE_F(adr, res)
36526         POST_IO
36527 RET(18)
36528 }
36529
36530 // ADDX7M7
36531 OPCODE(0xDF4F)
36532 {
36533         u32 adr, res;
36534         u32 src, dst;
36535
36536         adr = AREG(7) - 2;
36537         AREG(7) = adr;
36538         PRE_IO
36539         READ_WORD_F(adr, src)
36540         adr = AREG(7) - 2;
36541         AREG(7) = adr;
36542         READ_WORD_F(adr, dst)
36543         res = dst + src + ((flag_X >> 8) & 1);
36544         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36545         flag_N = flag_X = flag_C = res >> 8;
36546         flag_NotZ |= res & 0xFFFF;
36547         WRITE_WORD_F(adr, res)
36548         POST_IO
36549 RET(18)
36550 }
36551
36552 // ADDX7M7
36553 OPCODE(0xDF8F)
36554 {
36555         u32 adr, res;
36556         u32 src, dst;
36557
36558         adr = AREG(7) - 4;
36559         AREG(7) = adr;
36560         PRE_IO
36561         READ_LONG_F(adr, src)
36562         adr = AREG(7) - 4;
36563         AREG(7) = adr;
36564         READ_LONG_F(adr, dst)
36565         res = dst + src + ((flag_X >> 8) & 1);
36566         flag_NotZ |= res;
36567         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36568         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36569         flag_N = res >> 24;
36570         WRITE_LONG_F(adr, res)
36571         POST_IO
36572 RET(30)
36573 }
36574
36575 // ADDA
36576 OPCODE(0xD0C0)
36577 {
36578         u32 adr, res;
36579         u32 src, dst;
36580
36581         src = (s32)DREGs16((Opcode >> 0) & 7);
36582         dst = AREGu32((Opcode >> 9) & 7);
36583         res = dst + src;
36584         AREG((Opcode >> 9) & 7) = res;
36585 RET(8)
36586 }
36587
36588 // ADDA
36589 OPCODE(0xD0C8)
36590 {
36591         u32 adr, res;
36592         u32 src, dst;
36593
36594         src = (s32)AREGs16((Opcode >> 0) & 7);
36595         dst = AREGu32((Opcode >> 9) & 7);
36596         res = dst + src;
36597         AREG((Opcode >> 9) & 7) = res;
36598 RET(8)
36599 }
36600
36601 // ADDA
36602 OPCODE(0xD0D0)
36603 {
36604         u32 adr, res;
36605         u32 src, dst;
36606
36607         adr = AREG((Opcode >> 0) & 7);
36608         PRE_IO
36609         READSX_WORD_F(adr, src)
36610         dst = AREGu32((Opcode >> 9) & 7);
36611         res = dst + src;
36612         AREG((Opcode >> 9) & 7) = res;
36613         POST_IO
36614 #ifdef USE_CYCLONE_TIMING
36615 RET(12)
36616 #else
36617 RET(10)
36618 #endif
36619 }
36620
36621 // ADDA
36622 OPCODE(0xD0D8)
36623 {
36624         u32 adr, res;
36625         u32 src, dst;
36626
36627         adr = AREG((Opcode >> 0) & 7);
36628         AREG((Opcode >> 0) & 7) += 2;
36629         PRE_IO
36630         READSX_WORD_F(adr, src)
36631         dst = AREGu32((Opcode >> 9) & 7);
36632         res = dst + src;
36633         AREG((Opcode >> 9) & 7) = res;
36634         POST_IO
36635 #ifdef USE_CYCLONE_TIMING
36636 RET(12)
36637 #else
36638 RET(10)
36639 #endif
36640 }
36641
36642 // ADDA
36643 OPCODE(0xD0E0)
36644 {
36645         u32 adr, res;
36646         u32 src, dst;
36647
36648         adr = AREG((Opcode >> 0) & 7) - 2;
36649         AREG((Opcode >> 0) & 7) = adr;
36650         PRE_IO
36651         READSX_WORD_F(adr, src)
36652         dst = AREGu32((Opcode >> 9) & 7);
36653         res = dst + src;
36654         AREG((Opcode >> 9) & 7) = res;
36655         POST_IO
36656 #ifdef USE_CYCLONE_TIMING
36657 RET(14)
36658 #else
36659 RET(12)
36660 #endif
36661 }
36662
36663 // ADDA
36664 OPCODE(0xD0E8)
36665 {
36666         u32 adr, res;
36667         u32 src, dst;
36668
36669         FETCH_SWORD(adr);
36670         adr += AREG((Opcode >> 0) & 7);
36671         PRE_IO
36672         READSX_WORD_F(adr, src)
36673         dst = AREGu32((Opcode >> 9) & 7);
36674         res = dst + src;
36675         AREG((Opcode >> 9) & 7) = res;
36676         POST_IO
36677 #ifdef USE_CYCLONE_TIMING
36678 RET(16)
36679 #else
36680 RET(14)
36681 #endif
36682 }
36683
36684 // ADDA
36685 OPCODE(0xD0F0)
36686 {
36687         u32 adr, res;
36688         u32 src, dst;
36689
36690         adr = AREG((Opcode >> 0) & 7);
36691         DECODE_EXT_WORD
36692         PRE_IO
36693         READSX_WORD_F(adr, src)
36694         dst = AREGu32((Opcode >> 9) & 7);
36695         res = dst + src;
36696         AREG((Opcode >> 9) & 7) = res;
36697         POST_IO
36698 #ifdef USE_CYCLONE_TIMING
36699 RET(18)
36700 #else
36701 RET(16)
36702 #endif
36703 }
36704
36705 // ADDA
36706 OPCODE(0xD0F8)
36707 {
36708         u32 adr, res;
36709         u32 src, dst;
36710
36711         FETCH_SWORD(adr);
36712         PRE_IO
36713         READSX_WORD_F(adr, src)
36714         dst = AREGu32((Opcode >> 9) & 7);
36715         res = dst + src;
36716         AREG((Opcode >> 9) & 7) = res;
36717         POST_IO
36718 #ifdef USE_CYCLONE_TIMING
36719 RET(16)
36720 #else
36721 RET(14)
36722 #endif
36723 }
36724
36725 // ADDA
36726 OPCODE(0xD0F9)
36727 {
36728         u32 adr, res;
36729         u32 src, dst;
36730
36731         FETCH_LONG(adr);
36732         PRE_IO
36733         READSX_WORD_F(adr, src)
36734         dst = AREGu32((Opcode >> 9) & 7);
36735         res = dst + src;
36736         AREG((Opcode >> 9) & 7) = res;
36737         POST_IO
36738 #ifdef USE_CYCLONE_TIMING
36739 RET(20)
36740 #else
36741 RET(18)
36742 #endif
36743 }
36744
36745 // ADDA
36746 OPCODE(0xD0FA)
36747 {
36748         u32 adr, res;
36749         u32 src, dst;
36750
36751         adr = GET_SWORD + GET_PC;
36752         PC++;
36753         PRE_IO
36754         READSX_WORD_F(adr, src)
36755         dst = AREGu32((Opcode >> 9) & 7);
36756         res = dst + src;
36757         AREG((Opcode >> 9) & 7) = res;
36758         POST_IO
36759 #ifdef USE_CYCLONE_TIMING
36760 RET(16)
36761 #else
36762 RET(14)
36763 #endif
36764 }
36765
36766 // ADDA
36767 OPCODE(0xD0FB)
36768 {
36769         u32 adr, res;
36770         u32 src, dst;
36771
36772         adr = GET_PC;
36773         DECODE_EXT_WORD
36774         PRE_IO
36775         READSX_WORD_F(adr, src)
36776         dst = AREGu32((Opcode >> 9) & 7);
36777         res = dst + src;
36778         AREG((Opcode >> 9) & 7) = res;
36779         POST_IO
36780 #ifdef USE_CYCLONE_TIMING
36781 RET(18)
36782 #else
36783 RET(16)
36784 #endif
36785 }
36786
36787 // ADDA
36788 OPCODE(0xD0FC)
36789 {
36790         u32 adr, res;
36791         u32 src, dst;
36792
36793         FETCH_SWORD(src);
36794         dst = AREGu32((Opcode >> 9) & 7);
36795         res = dst + src;
36796         AREG((Opcode >> 9) & 7) = res;
36797 RET(12)
36798 }
36799
36800 // ADDA
36801 OPCODE(0xD0DF)
36802 {
36803         u32 adr, res;
36804         u32 src, dst;
36805
36806         adr = AREG(7);
36807         AREG(7) += 2;
36808         PRE_IO
36809         READSX_WORD_F(adr, src)
36810         dst = AREGu32((Opcode >> 9) & 7);
36811         res = dst + src;
36812         AREG((Opcode >> 9) & 7) = res;
36813         POST_IO
36814 #ifdef USE_CYCLONE_TIMING
36815 RET(12)
36816 #else
36817 RET(10)
36818 #endif
36819 }
36820
36821 // ADDA
36822 OPCODE(0xD0E7)
36823 {
36824         u32 adr, res;
36825         u32 src, dst;
36826
36827         adr = AREG(7) - 2;
36828         AREG(7) = adr;
36829         PRE_IO
36830         READSX_WORD_F(adr, src)
36831         dst = AREGu32((Opcode >> 9) & 7);
36832         res = dst + src;
36833         AREG((Opcode >> 9) & 7) = res;
36834         POST_IO
36835 #ifdef USE_CYCLONE_TIMING
36836 RET(14)
36837 #else
36838 RET(12)
36839 #endif
36840 }
36841
36842 // ADDA
36843 OPCODE(0xD1C0)
36844 {
36845         u32 adr, res;
36846         u32 src, dst;
36847
36848         src = (s32)DREGs32((Opcode >> 0) & 7);
36849         dst = AREGu32((Opcode >> 9) & 7);
36850         res = dst + src;
36851         AREG((Opcode >> 9) & 7) = res;
36852 #ifdef USE_CYCLONE_TIMING
36853 RET(8)
36854 #else
36855 RET(6)
36856 #endif
36857 }
36858
36859 // ADDA
36860 OPCODE(0xD1C8)
36861 {
36862         u32 adr, res;
36863         u32 src, dst;
36864
36865         src = (s32)AREGs32((Opcode >> 0) & 7);
36866         dst = AREGu32((Opcode >> 9) & 7);
36867         res = dst + src;
36868         AREG((Opcode >> 9) & 7) = res;
36869 #ifdef USE_CYCLONE_TIMING
36870 RET(8)
36871 #else
36872 RET(6)
36873 #endif
36874 }
36875
36876 // ADDA
36877 OPCODE(0xD1D0)
36878 {
36879         u32 adr, res;
36880         u32 src, dst;
36881
36882         adr = AREG((Opcode >> 0) & 7);
36883         PRE_IO
36884         READSX_LONG_F(adr, src)
36885         dst = AREGu32((Opcode >> 9) & 7);
36886         res = dst + src;
36887         AREG((Opcode >> 9) & 7) = res;
36888         POST_IO
36889 RET(14)
36890 }
36891
36892 // ADDA
36893 OPCODE(0xD1D8)
36894 {
36895         u32 adr, res;
36896         u32 src, dst;
36897
36898         adr = AREG((Opcode >> 0) & 7);
36899         AREG((Opcode >> 0) & 7) += 4;
36900         PRE_IO
36901         READSX_LONG_F(adr, src)
36902         dst = AREGu32((Opcode >> 9) & 7);
36903         res = dst + src;
36904         AREG((Opcode >> 9) & 7) = res;
36905         POST_IO
36906 RET(14)
36907 }
36908
36909 // ADDA
36910 OPCODE(0xD1E0)
36911 {
36912         u32 adr, res;
36913         u32 src, dst;
36914
36915         adr = AREG((Opcode >> 0) & 7) - 4;
36916         AREG((Opcode >> 0) & 7) = adr;
36917         PRE_IO
36918         READSX_LONG_F(adr, src)
36919         dst = AREGu32((Opcode >> 9) & 7);
36920         res = dst + src;
36921         AREG((Opcode >> 9) & 7) = res;
36922         POST_IO
36923 RET(16)
36924 }
36925
36926 // ADDA
36927 OPCODE(0xD1E8)
36928 {
36929         u32 adr, res;
36930         u32 src, dst;
36931
36932         FETCH_SWORD(adr);
36933         adr += AREG((Opcode >> 0) & 7);
36934         PRE_IO
36935         READSX_LONG_F(adr, src)
36936         dst = AREGu32((Opcode >> 9) & 7);
36937         res = dst + src;
36938         AREG((Opcode >> 9) & 7) = res;
36939         POST_IO
36940 RET(18)
36941 }
36942
36943 // ADDA
36944 OPCODE(0xD1F0)
36945 {
36946         u32 adr, res;
36947         u32 src, dst;
36948
36949         adr = AREG((Opcode >> 0) & 7);
36950         DECODE_EXT_WORD
36951         PRE_IO
36952         READSX_LONG_F(adr, src)
36953         dst = AREGu32((Opcode >> 9) & 7);
36954         res = dst + src;
36955         AREG((Opcode >> 9) & 7) = res;
36956         POST_IO
36957 RET(20)
36958 }
36959
36960 // ADDA
36961 OPCODE(0xD1F8)
36962 {
36963         u32 adr, res;
36964         u32 src, dst;
36965
36966         FETCH_SWORD(adr);
36967         PRE_IO
36968         READSX_LONG_F(adr, src)
36969         dst = AREGu32((Opcode >> 9) & 7);
36970         res = dst + src;
36971         AREG((Opcode >> 9) & 7) = res;
36972         POST_IO
36973 RET(18)
36974 }
36975
36976 // ADDA
36977 OPCODE(0xD1F9)
36978 {
36979         u32 adr, res;
36980         u32 src, dst;
36981
36982         FETCH_LONG(adr);
36983         PRE_IO
36984         READSX_LONG_F(adr, src)
36985         dst = AREGu32((Opcode >> 9) & 7);
36986         res = dst + src;
36987         AREG((Opcode >> 9) & 7) = res;
36988         POST_IO
36989 RET(22)
36990 }
36991
36992 // ADDA
36993 OPCODE(0xD1FA)
36994 {
36995         u32 adr, res;
36996         u32 src, dst;
36997
36998         adr = GET_SWORD + GET_PC;
36999         PC++;
37000         PRE_IO
37001         READSX_LONG_F(adr, src)
37002         dst = AREGu32((Opcode >> 9) & 7);
37003         res = dst + src;
37004         AREG((Opcode >> 9) & 7) = res;
37005         POST_IO
37006 RET(18)
37007 }
37008
37009 // ADDA
37010 OPCODE(0xD1FB)
37011 {
37012         u32 adr, res;
37013         u32 src, dst;
37014
37015         adr = GET_PC;
37016         DECODE_EXT_WORD
37017         PRE_IO
37018         READSX_LONG_F(adr, src)
37019         dst = AREGu32((Opcode >> 9) & 7);
37020         res = dst + src;
37021         AREG((Opcode >> 9) & 7) = res;
37022         POST_IO
37023 RET(20)
37024 }
37025
37026 // ADDA
37027 OPCODE(0xD1FC)
37028 {
37029         u32 adr, res;
37030         u32 src, dst;
37031
37032         FETCH_LONG(src);
37033         dst = AREGu32((Opcode >> 9) & 7);
37034         res = dst + src;
37035         AREG((Opcode >> 9) & 7) = res;
37036 #ifdef USE_CYCLONE_TIMING
37037 RET(16)
37038 #else
37039 RET(14)
37040 #endif
37041 }
37042
37043 // ADDA
37044 OPCODE(0xD1DF)
37045 {
37046         u32 adr, res;
37047         u32 src, dst;
37048
37049         adr = AREG(7);
37050         AREG(7) += 4;
37051         PRE_IO
37052         READSX_LONG_F(adr, src)
37053         dst = AREGu32((Opcode >> 9) & 7);
37054         res = dst + src;
37055         AREG((Opcode >> 9) & 7) = res;
37056         POST_IO
37057 RET(14)
37058 }
37059
37060 // ADDA
37061 OPCODE(0xD1E7)
37062 {
37063         u32 adr, res;
37064         u32 src, dst;
37065
37066         adr = AREG(7) - 4;
37067         AREG(7) = adr;
37068         PRE_IO
37069         READSX_LONG_F(adr, src)
37070         dst = AREGu32((Opcode >> 9) & 7);
37071         res = dst + src;
37072         AREG((Opcode >> 9) & 7) = res;
37073         POST_IO
37074 RET(16)
37075 }
37076
37077 // ASRk
37078 OPCODE(0xE000)
37079 {
37080         u32 adr, res;
37081         u32 src, dst;
37082
37083         u32 sft;
37084
37085         sft = (((Opcode >> 9) - 1) & 7) + 1;
37086         m68kcontext.io_cycle_counter -= sft * 2;
37087         src = (s32)DREGs8((Opcode >> 0) & 7);
37088         flag_V = 0;
37089         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37090         res = ((s32)src) >> sft;
37091         flag_N = res >> 0;
37092         flag_NotZ = res;
37093         DREGu8((Opcode >> 0) & 7) = res;
37094 RET(6)
37095 }
37096
37097 // ASRk
37098 OPCODE(0xE040)
37099 {
37100         u32 adr, res;
37101         u32 src, dst;
37102
37103         u32 sft;
37104
37105         sft = (((Opcode >> 9) - 1) & 7) + 1;
37106         m68kcontext.io_cycle_counter -= sft * 2;
37107         src = (s32)DREGs16((Opcode >> 0) & 7);
37108         flag_V = 0;
37109         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37110         res = ((s32)src) >> sft;
37111         flag_N = res >> 8;
37112         flag_NotZ = res;
37113         DREGu16((Opcode >> 0) & 7) = res;
37114 RET(6)
37115 }
37116
37117 // ASRk
37118 OPCODE(0xE080)
37119 {
37120         u32 adr, res;
37121         u32 src, dst;
37122
37123         u32 sft;
37124
37125         sft = (((Opcode >> 9) - 1) & 7) + 1;
37126         m68kcontext.io_cycle_counter -= sft * 2;
37127         src = (s32)DREGs32((Opcode >> 0) & 7);
37128         flag_V = 0;
37129         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37130         res = ((s32)src) >> sft;
37131         flag_N = res >> 24;
37132         flag_NotZ = res;
37133         DREGu32((Opcode >> 0) & 7) = res;
37134 RET(8)
37135 }
37136
37137 // LSRk
37138 OPCODE(0xE008)
37139 {
37140         u32 adr, res;
37141         u32 src, dst;
37142
37143         u32 sft;
37144
37145         sft = (((Opcode >> 9) - 1) & 7) + 1;
37146         m68kcontext.io_cycle_counter -= sft * 2;
37147         src = DREGu8((Opcode >> 0) & 7);
37148         flag_N = flag_V = 0;
37149         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37150         res = src >> sft;
37151         flag_NotZ = res;
37152         DREGu8((Opcode >> 0) & 7) = res;
37153 RET(6)
37154 }
37155
37156 // LSRk
37157 OPCODE(0xE048)
37158 {
37159         u32 adr, res;
37160         u32 src, dst;
37161
37162         u32 sft;
37163
37164         sft = (((Opcode >> 9) - 1) & 7) + 1;
37165         m68kcontext.io_cycle_counter -= sft * 2;
37166         src = DREGu16((Opcode >> 0) & 7);
37167         flag_N = flag_V = 0;
37168         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37169         res = src >> sft;
37170         flag_NotZ = res;
37171         DREGu16((Opcode >> 0) & 7) = res;
37172 RET(6)
37173 }
37174
37175 // LSRk
37176 OPCODE(0xE088)
37177 {
37178         u32 adr, res;
37179         u32 src, dst;
37180
37181         u32 sft;
37182
37183         sft = (((Opcode >> 9) - 1) & 7) + 1;
37184         m68kcontext.io_cycle_counter -= sft * 2;
37185         src = DREGu32((Opcode >> 0) & 7);
37186         flag_N = flag_V = 0;
37187         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37188         res = src >> sft;
37189         flag_NotZ = res;
37190         DREGu32((Opcode >> 0) & 7) = res;
37191 RET(8)
37192 }
37193
37194 // ROXRk
37195 OPCODE(0xE010)
37196 {
37197         u32 adr, res;
37198         u32 src, dst;
37199
37200         u32 sft;
37201
37202         sft = (((Opcode >> 9) - 1) & 7) + 1;
37203         m68kcontext.io_cycle_counter -= sft * 2;
37204         src = DREGu8((Opcode >> 0) & 7);
37205         src |= (flag_X & M68K_SR_X) << 0;
37206         res = (src >> sft) | (src << (9 - sft));
37207         flag_X = flag_C = res >> 0;
37208         flag_V = 0;
37209         flag_N = res >> 0;
37210         flag_NotZ = res & 0x000000FF;
37211         DREGu8((Opcode >> 0) & 7) = res;
37212 RET(6)
37213 }
37214
37215 // ROXRk
37216 OPCODE(0xE050)
37217 {
37218         u32 adr, res;
37219         u32 src, dst;
37220
37221         u32 sft;
37222
37223         sft = (((Opcode >> 9) - 1) & 7) + 1;
37224         m68kcontext.io_cycle_counter -= sft * 2;
37225         src = DREGu16((Opcode >> 0) & 7);
37226         src |= (flag_X & M68K_SR_X) << 8;
37227         res = (src >> sft) | (src << (17 - sft));
37228         flag_X = flag_C = res >> 8;
37229         flag_V = 0;
37230         flag_N = res >> 8;
37231         flag_NotZ = res & 0x0000FFFF;
37232         DREGu16((Opcode >> 0) & 7) = res;
37233 RET(6)
37234 }
37235
37236 // ROXRk
37237 OPCODE(0xE090)
37238 {
37239         u32 adr, res;
37240         u32 src, dst;
37241
37242         u32 sft;
37243
37244         sft = (((Opcode >> 9) - 1) & 7) + 1;
37245         m68kcontext.io_cycle_counter -= sft * 2;
37246         src = DREGu32((Opcode >> 0) & 7);
37247         flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37248         if (sft == 1) res = (src >> 1) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1)));
37249         else res = (src >> sft) | (src << (33 - sft)) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + sft)));
37250         flag_X = flag_C;
37251         flag_V = 0;
37252         flag_N = res >> 24;
37253         flag_NotZ = res;
37254         DREGu32((Opcode >> 0) & 7) = res;
37255 RET(8)
37256 }
37257
37258 // RORk
37259 OPCODE(0xE018)
37260 {
37261         u32 adr, res;
37262         u32 src, dst;
37263
37264         u32 sft;
37265
37266         sft = (((Opcode >> 9) - 1) & 7) + 1;
37267         m68kcontext.io_cycle_counter -= sft * 2;
37268         src = DREGu8((Opcode >> 0) & 7);
37269         flag_V = 0;
37270         flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37271         res = (src >> sft) | (src << (8 - sft));
37272         flag_N = res >> 0;
37273         flag_NotZ = res & 0x000000FF;
37274         DREGu8((Opcode >> 0) & 7) = res;
37275 RET(6)
37276 }
37277
37278 // RORk
37279 OPCODE(0xE058)
37280 {
37281         u32 adr, res;
37282         u32 src, dst;
37283
37284         u32 sft;
37285
37286         sft = (((Opcode >> 9) - 1) & 7) + 1;
37287         m68kcontext.io_cycle_counter -= sft * 2;
37288         src = DREGu16((Opcode >> 0) & 7);
37289         flag_V = 0;
37290         flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37291         res = (src >> sft) | (src << (16 - sft));
37292         flag_N = res >> 8;
37293         flag_NotZ = res & 0x0000FFFF;
37294         DREGu16((Opcode >> 0) & 7) = res;
37295 RET(6)
37296 }
37297
37298 // RORk
37299 OPCODE(0xE098)
37300 {
37301         u32 adr, res;
37302         u32 src, dst;
37303
37304         u32 sft;
37305
37306         sft = (((Opcode >> 9) - 1) & 7) + 1;
37307         m68kcontext.io_cycle_counter -= sft * 2;
37308         src = DREGu32((Opcode >> 0) & 7);
37309         flag_V = 0;
37310         flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37311         res = (src >> sft) | (src << (32 - sft));
37312         flag_N = res >> 24;
37313         flag_NotZ = res;
37314         DREGu32((Opcode >> 0) & 7) = res;
37315 RET(8)
37316 }
37317
37318 // ASLk
37319 OPCODE(0xE100)
37320 {
37321         u32 adr, res;
37322         u32 src, dst;
37323
37324         u32 sft;
37325
37326         sft = (((Opcode >> 9) - 1) & 7) + 1;
37327         m68kcontext.io_cycle_counter -= sft * 2;
37328         src = DREGu8((Opcode >> 0) & 7);
37329         if (sft < 8)
37330         {
37331                 flag_X = flag_C = src << (0 + sft);
37332                 res = src << sft;
37333                 flag_N = res >> 0;
37334                 flag_NotZ = res & 0x000000FF;
37335         DREGu8((Opcode >> 0) & 7) = res;
37336                 flag_V = 0;
37337                 if ((sft > 7) && (src)) flag_V = M68K_SR_V;
37338                 else
37339                 {
37340                         u32 msk = (((s32)0x80000000) >> (sft + 24)) & 0x000000FF;
37341                         src &= msk;
37342                         if ((src) && (src != msk)) flag_V = M68K_SR_V;
37343                 }
37344         RET(6)
37345         }
37346
37347         if (src) flag_V = M68K_SR_V;
37348         else flag_V = 0;
37349         flag_X = flag_C = src << M68K_SR_C_SFT;
37350         res = 0;
37351         DREGu8((Opcode >> 0) & 7) = res;
37352         flag_N = 0;
37353         flag_NotZ = 0;
37354 RET(6)
37355 }
37356
37357 // ASLk
37358 OPCODE(0xE140)
37359 {
37360         u32 adr, res;
37361         u32 src, dst;
37362
37363         u32 sft;
37364
37365         sft = (((Opcode >> 9) - 1) & 7) + 1;
37366         m68kcontext.io_cycle_counter -= sft * 2;
37367         src = DREGu16((Opcode >> 0) & 7);
37368                 flag_X = flag_C = src >> (8 - sft);
37369                 res = src << sft;
37370                 flag_N = res >> 8;
37371                 flag_NotZ = res & 0x0000FFFF;
37372         DREGu16((Opcode >> 0) & 7) = res;
37373                 flag_V = 0;
37374                 {
37375                         u32 msk = (((s32)0x80000000) >> (sft + 16)) & 0x0000FFFF;
37376                         src &= msk;
37377                         if ((src) && (src != msk)) flag_V = M68K_SR_V;
37378                 }
37379 RET(6)
37380 }
37381
37382 // ASLk
37383 OPCODE(0xE180)
37384 {
37385         u32 adr, res;
37386         u32 src, dst;
37387
37388         u32 sft;
37389
37390         sft = (((Opcode >> 9) - 1) & 7) + 1;
37391         m68kcontext.io_cycle_counter -= sft * 2;
37392         src = DREGu32((Opcode >> 0) & 7);
37393                 flag_X = flag_C = src >> (24 - sft);
37394                 res = src << sft;
37395                 flag_N = res >> 24;
37396                 flag_NotZ = res & 0xFFFFFFFF;
37397         DREGu32((Opcode >> 0) & 7) = res;
37398                 flag_V = 0;
37399                 {
37400                         u32 msk = (((s32)0x80000000) >> (sft + 0)) & 0xFFFFFFFF;
37401                         src &= msk;
37402                         if ((src) && (src != msk)) flag_V = M68K_SR_V;
37403                 }
37404 RET(8)
37405 }
37406
37407 // LSLk
37408 OPCODE(0xE108)
37409 {
37410         u32 adr, res;
37411         u32 src, dst;
37412
37413         u32 sft;
37414
37415         sft = (((Opcode >> 9) - 1) & 7) + 1;
37416         m68kcontext.io_cycle_counter -= sft * 2;
37417         src = DREGu8((Opcode >> 0) & 7);
37418         flag_V = 0;
37419         flag_X = flag_C = src << (0 + sft);
37420         res = src << sft;
37421         flag_N = res >> 0;
37422         flag_NotZ = res & 0x000000FF;
37423         DREGu8((Opcode >> 0) & 7) = res;
37424 RET(6)
37425 }
37426
37427 // LSLk
37428 OPCODE(0xE148)
37429 {
37430         u32 adr, res;
37431         u32 src, dst;
37432
37433         u32 sft;
37434
37435         sft = (((Opcode >> 9) - 1) & 7) + 1;
37436         m68kcontext.io_cycle_counter -= sft * 2;
37437         src = DREGu16((Opcode >> 0) & 7);
37438         flag_V = 0;
37439         flag_X = flag_C = src >> (8 - sft);
37440         res = src << sft;
37441         flag_N = res >> 8;
37442         flag_NotZ = res & 0x0000FFFF;
37443         DREGu16((Opcode >> 0) & 7) = res;
37444 RET(6)
37445 }
37446
37447 // LSLk
37448 OPCODE(0xE188)
37449 {
37450         u32 adr, res;
37451         u32 src, dst;
37452
37453         u32 sft;
37454
37455         sft = (((Opcode >> 9) - 1) & 7) + 1;
37456         m68kcontext.io_cycle_counter -= sft * 2;
37457         src = DREGu32((Opcode >> 0) & 7);
37458         flag_V = 0;
37459         flag_X = flag_C = src >> (24 - sft);
37460         res = src << sft;
37461         flag_N = res >> 24;
37462         flag_NotZ = res & 0xFFFFFFFF;
37463         DREGu32((Opcode >> 0) & 7) = res;
37464 RET(8)
37465 }
37466
37467 // ROXLk
37468 OPCODE(0xE110)
37469 {
37470         u32 adr, res;
37471         u32 src, dst;
37472
37473         u32 sft;
37474
37475         sft = (((Opcode >> 9) - 1) & 7) + 1;
37476         m68kcontext.io_cycle_counter -= sft * 2;
37477         src = DREGu8((Opcode >> 0) & 7);
37478         src |= (flag_X & M68K_SR_X) << 0;
37479         res = (src << sft) | (src >> (9 - sft));
37480         flag_X = flag_C = res >> 0;
37481         flag_V = 0;
37482         flag_N = res >> 0;
37483         flag_NotZ = res & 0x000000FF;
37484         DREGu8((Opcode >> 0) & 7) = res;
37485 RET(6)
37486 }
37487
37488 // ROXLk
37489 OPCODE(0xE150)
37490 {
37491         u32 adr, res;
37492         u32 src, dst;
37493
37494         u32 sft;
37495
37496         sft = (((Opcode >> 9) - 1) & 7) + 1;
37497         m68kcontext.io_cycle_counter -= sft * 2;
37498         src = DREGu16((Opcode >> 0) & 7);
37499         src |= (flag_X & M68K_SR_X) << 8;
37500         res = (src << sft) | (src >> (17 - sft));
37501         flag_X = flag_C = res >> 8;
37502         flag_V = 0;
37503         flag_N = res >> 8;
37504         flag_NotZ = res & 0x0000FFFF;
37505         DREGu16((Opcode >> 0) & 7) = res;
37506 RET(6)
37507 }
37508
37509 // ROXLk
37510 OPCODE(0xE190)
37511 {
37512         u32 adr, res;
37513         u32 src, dst;
37514
37515         u32 sft;
37516
37517         sft = (((Opcode >> 9) - 1) & 7) + 1;
37518         m68kcontext.io_cycle_counter -= sft * 2;
37519         src = DREGu32((Opcode >> 0) & 7);
37520         flag_C = src >> ((32 - M68K_SR_C_SFT) - sft);
37521         if (sft == 1) res = (src << 1) | ((flag_X & M68K_SR_X) >> ((M68K_SR_X_SFT + 1) - 1));
37522         else res = (src << sft) | (src >> (33 - sft)) | ((flag_X & M68K_SR_X) >> ((M68K_SR_X_SFT + 1) - sft));
37523         flag_X = flag_C;
37524         flag_V = 0;
37525         flag_N = res >> 24;
37526         flag_NotZ = res;
37527         DREGu32((Opcode >> 0) & 7) = res;
37528 RET(8)
37529 }
37530
37531 // ROLk
37532 OPCODE(0xE118)
37533 {
37534         u32 adr, res;
37535         u32 src, dst;
37536
37537         u32 sft;
37538
37539         sft = (((Opcode >> 9) - 1) & 7) + 1;
37540         m68kcontext.io_cycle_counter -= sft * 2;
37541         src = DREGu8((Opcode >> 0) & 7);
37542         flag_V = 0;
37543         flag_C = src << (0 + sft);
37544         res = (src << sft) | (src >> (8 - sft));
37545         flag_N = res >> 0;
37546         flag_NotZ = res & 0x000000FF;
37547         DREGu8((Opcode >> 0) & 7) = res;
37548 RET(6)
37549 }
37550
37551 // ROLk
37552 OPCODE(0xE158)
37553 {
37554         u32 adr, res;
37555         u32 src, dst;
37556
37557         u32 sft;
37558
37559         sft = (((Opcode >> 9) - 1) & 7) + 1;
37560         m68kcontext.io_cycle_counter -= sft * 2;
37561         src = DREGu16((Opcode >> 0) & 7);
37562         flag_V = 0;
37563         flag_C = src >> (8 - sft);
37564         res = (src << sft) | (src >> (16 - sft));
37565         flag_N = res >> 8;
37566         flag_NotZ = res & 0x0000FFFF;
37567         DREGu16((Opcode >> 0) & 7) = res;
37568 RET(6)
37569 }
37570
37571 // ROLk
37572 OPCODE(0xE198)
37573 {
37574         u32 adr, res;
37575         u32 src, dst;
37576
37577         u32 sft;
37578
37579         sft = (((Opcode >> 9) - 1) & 7) + 1;
37580         m68kcontext.io_cycle_counter -= sft * 2;
37581         src = DREGu32((Opcode >> 0) & 7);
37582         flag_V = 0;
37583         flag_C = src >> (24 - sft);
37584         res = (src << sft) | (src >> (32 - sft));
37585         flag_N = res >> 24;
37586         flag_NotZ = res;
37587         DREGu32((Opcode >> 0) & 7) = res;
37588 RET(8)
37589 }
37590
37591 // ASRD
37592 OPCODE(0xE020)
37593 {
37594         u32 adr, res;
37595         u32 src, dst;
37596
37597         u32 sft;
37598
37599         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37600         src = (s32)DREGs8((Opcode >> 0) & 7);
37601         if (sft)
37602         {
37603         m68kcontext.io_cycle_counter -= sft * 2;
37604                 if (sft < 8)
37605                 {
37606                         flag_V = 0;
37607                         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37608                         res = ((s32)src) >> sft;
37609                         flag_N = res >> 0;
37610                         flag_NotZ = res;
37611         DREGu8((Opcode >> 0) & 7) = res;
37612         RET(6)
37613                 }
37614
37615                 if (src & (1 << 7))
37616                 {
37617                         flag_N = M68K_SR_N;
37618                         flag_NotZ = 1;
37619                         flag_V = 0;
37620                         flag_C = M68K_SR_C;
37621                         flag_X = M68K_SR_X;
37622                         res = 0x000000FF;
37623         DREGu8((Opcode >> 0) & 7) = res;
37624         RET(6)
37625                 }
37626
37627                 flag_N = 0;
37628                 flag_NotZ = 0;
37629                 flag_V = 0;
37630                 flag_C = 0;
37631                 flag_X = 0;
37632                 res = 0;
37633         DREGu8((Opcode >> 0) & 7) = res;
37634         RET(6)
37635         }
37636
37637         flag_V = 0;
37638         flag_C = 0;
37639         flag_N = src >> 0;
37640         flag_NotZ = src;
37641 RET(6)
37642 }
37643
37644 // ASRD
37645 OPCODE(0xE060)
37646 {
37647         u32 adr, res;
37648         u32 src, dst;
37649
37650         u32 sft;
37651
37652         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37653         src = (s32)DREGs16((Opcode >> 0) & 7);
37654         if (sft)
37655         {
37656         m68kcontext.io_cycle_counter -= sft * 2;
37657                 if (sft < 16)
37658                 {
37659                         flag_V = 0;
37660                         flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37661                         res = ((s32)src) >> sft;
37662                         flag_N = res >> 8;
37663                         flag_NotZ = res;
37664         DREGu16((Opcode >> 0) & 7) = res;
37665         RET(6)
37666                 }
37667
37668                 if (src & (1 << 15))
37669                 {
37670                         flag_N = M68K_SR_N;
37671                         flag_NotZ = 1;
37672                         flag_V = 0;
37673                         flag_C = M68K_SR_C;
37674                         flag_X = M68K_SR_X;
37675                         res = 0x0000FFFF;
37676         DREGu16((Opcode >> 0) & 7) = res;
37677         RET(6)
37678                 }
37679
37680                 flag_N = 0;
37681                 flag_NotZ = 0;
37682                 flag_V = 0;
37683                 flag_C = 0;
37684                 flag_X = 0;
37685                 res = 0;
37686         DREGu16((Opcode >> 0) & 7) = res;
37687         RET(6)
37688         }
37689
37690         flag_V = 0;
37691         flag_C = 0;
37692         flag_N = src >> 8;
37693         flag_NotZ = src;
37694 RET(6)
37695 }
37696
37697 // ASRD
37698 OPCODE(0xE0A0)
37699 {
37700 #ifdef USE_CYCLONE_TIMING
37701 #define CYC 8
37702 #else
37703 #define CYC 6
37704 #endif
37705         u32 adr, res;
37706         u32 src, dst;
37707
37708         u32 sft;
37709
37710         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37711         src = (s32)DREGs32((Opcode >> 0) & 7);
37712         if (sft)
37713         {
37714         m68kcontext.io_cycle_counter -= sft * 2;
37715                 if (sft < 32)
37716                 {
37717                         flag_V = 0;
37718                         flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37719                         res = ((s32)src) >> sft;
37720                         flag_N = res >> 24;
37721                         flag_NotZ = res;
37722         DREGu32((Opcode >> 0) & 7) = res;
37723         RET(CYC)
37724                 }
37725
37726                 if (src & (1 << 31))
37727                 {
37728                         flag_N = M68K_SR_N;
37729                         flag_NotZ = 1;
37730                         flag_V = 0;
37731                         flag_C = M68K_SR_C;
37732                         flag_X = M68K_SR_X;
37733                         res = 0xFFFFFFFF;
37734         DREGu32((Opcode >> 0) & 7) = res;
37735         RET(CYC)
37736                 }
37737
37738                 flag_N = 0;
37739                 flag_NotZ = 0;
37740                 flag_V = 0;
37741                 flag_C = 0;
37742                 flag_X = 0;
37743                 res = 0;
37744         DREGu32((Opcode >> 0) & 7) = res;
37745         RET(CYC)
37746         }
37747
37748         flag_V = 0;
37749         flag_C = 0;
37750         flag_N = src >> 24;
37751         flag_NotZ = src;
37752 RET(CYC)
37753 #undef CYC
37754 }
37755
37756 // LSRD
37757 OPCODE(0xE028)
37758 {
37759         u32 adr, res;
37760         u32 src, dst;
37761
37762         u32 sft;
37763
37764         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37765         src = DREGu8((Opcode >> 0) & 7);
37766         if (sft)
37767         {
37768         m68kcontext.io_cycle_counter -= sft * 2;
37769                 if (sft <= 8)
37770                 {
37771                         flag_N = flag_V = 0;
37772                         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37773                         res = src >> sft;
37774                         flag_NotZ = res;
37775         DREGu8((Opcode >> 0) & 7) = res;
37776         RET(6)
37777                 }
37778
37779                 flag_X = flag_C = 0;
37780                 flag_N = 0;
37781                 flag_NotZ = 0;
37782                 flag_V = 0;
37783                 res = 0;
37784         DREGu8((Opcode >> 0) & 7) = res;
37785         RET(6)
37786         }
37787
37788         flag_V = 0;
37789         flag_C = 0;
37790         flag_N = src >> 0;
37791         flag_NotZ = src;
37792 RET(6)
37793 }
37794
37795 // LSRD
37796 OPCODE(0xE068)
37797 {
37798         u32 adr, res;
37799         u32 src, dst;
37800
37801         u32 sft;
37802
37803         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37804         src = DREGu16((Opcode >> 0) & 7);
37805         if (sft)
37806         {
37807         m68kcontext.io_cycle_counter -= sft * 2;
37808                 if (sft <= 16)
37809                 {
37810                         flag_N = flag_V = 0;
37811                         flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37812                         res = src >> sft;
37813                         flag_NotZ = res;
37814         DREGu16((Opcode >> 0) & 7) = res;
37815         RET(6)
37816                 }
37817
37818                 flag_X = flag_C = 0;
37819                 flag_N = 0;
37820                 flag_NotZ = 0;
37821                 flag_V = 0;
37822                 res = 0;
37823         DREGu16((Opcode >> 0) & 7) = res;
37824         RET(6)
37825         }
37826
37827         flag_V = 0;
37828         flag_C = 0;
37829         flag_N = src >> 8;
37830         flag_NotZ = src;
37831 RET(6)
37832 }
37833
37834 // LSRD
37835 OPCODE(0xE0A8)
37836 {
37837 #ifdef USE_CYCLONE_TIMING
37838 #define CYC 8
37839 #else
37840 #define CYC 6
37841 #endif
37842         u32 adr, res;
37843         u32 src, dst;
37844
37845         u32 sft;
37846
37847         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37848         src = DREGu32((Opcode >> 0) & 7);
37849         if (sft)
37850         {
37851         m68kcontext.io_cycle_counter -= sft * 2;
37852                 if (sft < 32)
37853                 {
37854                         flag_N = flag_V = 0;
37855                         flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37856                         res = src >> sft;
37857                         flag_NotZ = res;
37858         DREGu32((Opcode >> 0) & 7) = res;
37859         RET(CYC)
37860                 }
37861
37862                 if (sft == 32) flag_C = src >> (31 - M68K_SR_C_SFT);
37863                 else flag_C = 0;
37864                 flag_X = flag_C;
37865                 flag_N = 0;
37866                 flag_NotZ = 0;
37867                 flag_V = 0;
37868                 res = 0;
37869         DREGu32((Opcode >> 0) & 7) = res;
37870         RET(CYC)
37871         }
37872
37873         flag_V = 0;
37874         flag_C = 0;
37875         flag_N = src >> 24;
37876         flag_NotZ = src;
37877 RET(CYC)
37878 #undef CYC
37879 }
37880
37881 // ROXRD
37882 OPCODE(0xE030)
37883 {
37884         u32 adr, res;
37885         u32 src, dst;
37886
37887         u32 sft;
37888
37889         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37890         src = DREGu8((Opcode >> 0) & 7);
37891         if (sft)
37892         {
37893         m68kcontext.io_cycle_counter -= sft * 2;
37894                 sft %= 9;
37895
37896                 src |= (flag_X & M68K_SR_X) << 0;
37897                 res = (src >> sft) | (src << (9 - sft));
37898                 flag_X = flag_C = res >> 0;
37899                 flag_V = 0;
37900                 flag_N = res >> 0;
37901                 flag_NotZ = res & 0x000000FF;
37902         DREGu8((Opcode >> 0) & 7) = res;
37903         RET(6)
37904         }
37905
37906         flag_V = 0;
37907         flag_C = flag_X;
37908         flag_N = src >> 0;
37909         flag_NotZ = src;
37910 RET(6)
37911 }
37912
37913 // ROXRD
37914 OPCODE(0xE070)
37915 {
37916         u32 adr, res;
37917         u32 src, dst;
37918
37919         u32 sft;
37920
37921         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37922         src = DREGu16((Opcode >> 0) & 7);
37923         if (sft)
37924         {
37925         m68kcontext.io_cycle_counter -= sft * 2;
37926                 sft %= 17;
37927
37928                 src |= (flag_X & M68K_SR_X) << 8;
37929                 res = (src >> sft) | (src << (17 - sft));
37930                 flag_X = flag_C = res >> 8;
37931                 flag_V = 0;
37932                 flag_N = res >> 8;
37933                 flag_NotZ = res & 0x0000FFFF;
37934         DREGu16((Opcode >> 0) & 7) = res;
37935         RET(6)
37936         }
37937
37938         flag_V = 0;
37939         flag_C = flag_X;
37940         flag_N = src >> 8;
37941         flag_NotZ = src;
37942 RET(6)
37943 }
37944
37945 // ROXRD
37946 OPCODE(0xE0B0)
37947 {
37948 #ifdef USE_CYCLONE_TIMING
37949 #define CYC 8
37950 #else
37951 #define CYC 6
37952 #endif
37953         u32 adr, res;
37954         u32 src, dst;
37955
37956         u32 sft;
37957
37958         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37959         src = DREGu32((Opcode >> 0) & 7);
37960         if (sft)
37961         {
37962         m68kcontext.io_cycle_counter -= sft * 2;
37963                 sft %= 33;
37964
37965                 if (sft != 0)
37966                 {
37967                         if (sft == 1) res = (src >> 1) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1)));
37968                         else res = (src >> sft) | (src << (33 - sft)) | (((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1))) >> (sft - 1));
37969                         flag_X = (src >> (32 - sft)) << M68K_SR_X_SFT;
37970                 }
37971                 else res = src;
37972                 flag_C = flag_X;
37973                 flag_V = 0;
37974                 flag_N = res >> 24;
37975                 flag_NotZ = res;
37976         DREGu32((Opcode >> 0) & 7) = res;
37977         RET(CYC)
37978         }
37979
37980         flag_V = 0;
37981         flag_C = flag_X;
37982         flag_N = src >> 24;
37983         flag_NotZ = src;
37984 RET(CYC)
37985 #undef CYC
37986 }
37987
37988 // RORD
37989 OPCODE(0xE038)
37990 {
37991         u32 adr, res;
37992         u32 src, dst;
37993
37994         u32 sft;
37995
37996         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37997         src = DREGu8((Opcode >> 0) & 7);
37998         if (sft)
37999         {
38000         m68kcontext.io_cycle_counter -= sft * 2;
38001                 sft &= 0x07;
38002
38003                 flag_C = src << (M68K_SR_C_SFT - ((sft - 1) & 7));
38004                 res = (src >> sft) | (src << (8 - sft));
38005                 flag_V = 0;
38006                 flag_N = res >> 0;
38007                 flag_NotZ = res & 0x000000FF;
38008         DREGu8((Opcode >> 0) & 7) = res;
38009         RET(6)
38010         }
38011
38012         flag_V = 0;
38013         flag_C = 0;
38014         flag_N = src >> 0;
38015         flag_NotZ = src;
38016 RET(6)
38017 }
38018
38019 // RORD
38020 OPCODE(0xE078)
38021 {
38022         u32 adr, res;
38023         u32 src, dst;
38024
38025         u32 sft;
38026
38027         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38028         src = DREGu16((Opcode >> 0) & 7);
38029         if (sft)
38030         {
38031         m68kcontext.io_cycle_counter -= sft * 2;
38032                 sft &= 0x0F;
38033
38034                 flag_C = (src >> ((sft - 1) & 15)) << M68K_SR_C_SFT;
38035                 res = (src >> sft) | (src << (16 - sft));
38036                 flag_V = 0;
38037                 flag_N = res >> 8;
38038                 flag_NotZ = res & 0x0000FFFF;
38039         DREGu16((Opcode >> 0) & 7) = res;
38040         RET(6)
38041         }
38042
38043         flag_V = 0;
38044         flag_C = 0;
38045         flag_N = src >> 8;
38046         flag_NotZ = src;
38047 RET(6)
38048 }
38049
38050 // RORD
38051 OPCODE(0xE0B8)
38052 {
38053 #ifdef USE_CYCLONE_TIMING
38054 #define CYC 8
38055 #else
38056 #define CYC 6
38057 #endif
38058         u32 adr, res;
38059         u32 src, dst;
38060
38061         u32 sft;
38062
38063         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38064         src = DREGu32((Opcode >> 0) & 7);
38065         if (sft)
38066         {
38067         m68kcontext.io_cycle_counter -= sft * 2;
38068                 sft &= 0x1F;
38069
38070                 flag_C = (src >> ((sft - 1) & 31)) << M68K_SR_C_SFT;
38071                 res = (src >> sft) | (src << (32 - sft));
38072                 flag_V = 0;
38073                 flag_N = res >> 24;
38074                 flag_NotZ = res;
38075         DREGu32((Opcode >> 0) & 7) = res;
38076         RET(CYC)
38077         }
38078
38079         flag_V = 0;
38080         flag_C = 0;
38081         flag_N = src >> 24;
38082         flag_NotZ = src;
38083 RET(CYC)
38084 #undef CYC
38085 }
38086
38087 // ASLD
38088 OPCODE(0xE120)
38089 {
38090         u32 adr, res;
38091         u32 src, dst;
38092
38093         u32 sft;
38094
38095         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38096         src = DREGu8((Opcode >> 0) & 7);
38097         if (sft)
38098         {
38099         m68kcontext.io_cycle_counter -= sft * 2;
38100                 if (sft < 8)
38101                 {
38102                         flag_X = flag_C = (src << sft) >> 0;
38103                         res = (src << sft) & 0x000000FF;
38104                         flag_N = res >> 0;
38105                         flag_NotZ = res;
38106         DREGu8((Opcode >> 0) & 7) = res;
38107                         flag_V = 0;
38108                         {
38109                                 u32 msk = (((s32)0x80000000) >> (sft + 24)) & 0x000000FF;
38110                                 src &= msk;
38111                                 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38112                         }
38113         RET(6)
38114                 }
38115
38116                 if (sft == 256) flag_C = src << M68K_SR_C_SFT;
38117                 else flag_C = 0;
38118                 flag_X = flag_C;
38119                 if (src) flag_V = M68K_SR_V;
38120                 else flag_V = 0;
38121                 res = 0;
38122         DREGu8((Opcode >> 0) & 7) = res;
38123                 flag_N = 0;
38124                 flag_NotZ = 0;
38125         RET(6)
38126         }
38127
38128         flag_V = 0;
38129         flag_C = 0;
38130         flag_N = src >> 0;
38131         flag_NotZ = src;
38132 RET(6)
38133 }
38134
38135 // ASLD
38136 OPCODE(0xE160)
38137 {
38138         u32 adr, res;
38139         u32 src, dst;
38140
38141         u32 sft;
38142
38143         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38144         src = DREGu16((Opcode >> 0) & 7);
38145         if (sft)
38146         {
38147         m68kcontext.io_cycle_counter -= sft * 2;
38148                 if (sft < 16)
38149                 {
38150                         flag_X = flag_C = (src << sft) >> 8;
38151                         res = (src << sft) & 0x0000FFFF;
38152                         flag_N = res >> 8;
38153                         flag_NotZ = res;
38154         DREGu16((Opcode >> 0) & 7) = res;
38155                         flag_V = 0;
38156                         {
38157                                 u32 msk = (((s32)0x80000000) >> (sft + 16)) & 0x0000FFFF;
38158                                 src &= msk;
38159                                 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38160                         }
38161         RET(6)
38162                 }
38163
38164                 if (sft == 65536) flag_C = src << M68K_SR_C_SFT;
38165                 else flag_C = 0;
38166                 flag_X = flag_C;
38167                 if (src) flag_V = M68K_SR_V;
38168                 else flag_V = 0;
38169                 res = 0;
38170         DREGu16((Opcode >> 0) & 7) = res;
38171                 flag_N = 0;
38172                 flag_NotZ = 0;
38173         RET(6)
38174         }
38175
38176         flag_V = 0;
38177         flag_C = 0;
38178         flag_N = src >> 8;
38179         flag_NotZ = src;
38180 RET(6)
38181 }
38182
38183 // ASLD
38184 OPCODE(0xE1A0)
38185 {
38186 #ifdef USE_CYCLONE_TIMING
38187 #define CYC 8
38188 #else
38189 #define CYC 6
38190 #endif
38191         u32 adr, res;
38192         u32 src, dst;
38193
38194         u32 sft;
38195
38196         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38197         src = DREGu32((Opcode >> 0) & 7);
38198         if (sft)
38199         {
38200         m68kcontext.io_cycle_counter -= sft * 2;
38201                 if (sft < 32)
38202                 {
38203                         flag_X = flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38204                         res = src << sft;
38205                         flag_N = res >> 24;
38206                         flag_NotZ = res;
38207         DREGu32((Opcode >> 0) & 7) = res;
38208                         flag_V = 0;
38209                         {
38210                                 u32 msk = (((s32)0x80000000) >> (sft + 0)) & 0xFFFFFFFF;
38211                                 src &= msk;
38212                                 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38213                         }
38214         RET(CYC)
38215                 }
38216
38217                 if (sft == 0) flag_C = src << M68K_SR_C_SFT;
38218                 else flag_C = 0;
38219                 flag_X = flag_C;
38220                 if (src) flag_V = M68K_SR_V;
38221                 else flag_V = 0;
38222                 res = 0;
38223         DREGu32((Opcode >> 0) & 7) = res;
38224                 flag_N = 0;
38225                 flag_NotZ = 0;
38226         RET(CYC)
38227         }
38228
38229         flag_V = 0;
38230         flag_C = 0;
38231         flag_N = src >> 24;
38232         flag_NotZ = src;
38233 RET(CYC)
38234 #undef CYC
38235 }
38236
38237 // LSLD
38238 OPCODE(0xE128)
38239 {
38240         u32 adr, res;
38241         u32 src, dst;
38242
38243         u32 sft;
38244
38245         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38246         src = DREGu8((Opcode >> 0) & 7);
38247         if (sft)
38248         {
38249         m68kcontext.io_cycle_counter -= sft * 2;
38250                 if (sft <= 8)
38251                 {
38252                         flag_X = flag_C = (src << sft) >> 0;
38253                         res = (src << sft) & 0x000000FF;
38254                         flag_V = 0;
38255                         flag_N = res >> 0;
38256                         flag_NotZ = res;
38257         DREGu8((Opcode >> 0) & 7) = res;
38258         RET(6)
38259                 }
38260
38261                 flag_X = flag_C = 0;
38262                 flag_N = 0;
38263                 flag_NotZ = 0;
38264                 flag_V = 0;
38265                 res = 0;
38266         DREGu8((Opcode >> 0) & 7) = res;
38267         RET(6)
38268         }
38269
38270         flag_V = 0;
38271         flag_C = 0;
38272         flag_N = src >> 0;
38273         flag_NotZ = src;
38274 RET(6)
38275 }
38276
38277 // LSLD
38278 OPCODE(0xE168)
38279 {
38280         u32 adr, res;
38281         u32 src, dst;
38282
38283         u32 sft;
38284
38285         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38286         src = DREGu16((Opcode >> 0) & 7);
38287         if (sft)
38288         {
38289         m68kcontext.io_cycle_counter -= sft * 2;
38290                 if (sft <= 16)
38291                 {
38292                         flag_X = flag_C = (src << sft) >> 8;
38293                         res = (src << sft) & 0x0000FFFF;
38294                         flag_V = 0;
38295                         flag_N = res >> 8;
38296                         flag_NotZ = res;
38297         DREGu16((Opcode >> 0) & 7) = res;
38298         RET(6)
38299                 }
38300
38301                 flag_X = flag_C = 0;
38302                 flag_N = 0;
38303                 flag_NotZ = 0;
38304                 flag_V = 0;
38305                 res = 0;
38306         DREGu16((Opcode >> 0) & 7) = res;
38307         RET(6)
38308         }
38309
38310         flag_V = 0;
38311         flag_C = 0;
38312         flag_N = src >> 8;
38313         flag_NotZ = src;
38314 RET(6)
38315 }
38316
38317 // LSLD
38318 OPCODE(0xE1A8)
38319 {
38320 #ifdef USE_CYCLONE_TIMING
38321 #define CYC 8
38322 #else
38323 #define CYC 6
38324 #endif
38325         u32 adr, res;
38326         u32 src, dst;
38327
38328         u32 sft;
38329
38330         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38331         src = DREGu32((Opcode >> 0) & 7);
38332         if (sft)
38333         {
38334         m68kcontext.io_cycle_counter -= sft * 2;
38335                 if (sft < 32)
38336                 {
38337                         flag_X = flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38338                         res = src << sft;
38339                         flag_V = 0;
38340                         flag_N = res >> 24;
38341                         flag_NotZ = res;
38342         DREGu32((Opcode >> 0) & 7) = res;
38343         RET(CYC)
38344                 }
38345
38346                 if (sft == 32) flag_C = src << M68K_SR_C_SFT;
38347                 else flag_C = 0;
38348                 flag_X = flag_C;
38349                 flag_N = 0;
38350                 flag_NotZ = 0;
38351                 flag_V = 0;
38352                 res = 0;
38353         DREGu32((Opcode >> 0) & 7) = res;
38354         RET(CYC)
38355         }
38356
38357         flag_V = 0;
38358         flag_C = 0;
38359         flag_N = src >> 24;
38360         flag_NotZ = src;
38361 RET(CYC)
38362 #undef CYC
38363 }
38364
38365 // ROXLD
38366 OPCODE(0xE130)
38367 {
38368         u32 adr, res;
38369         u32 src, dst;
38370
38371         u32 sft;
38372
38373         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38374         src = DREGu8((Opcode >> 0) & 7);
38375         if (sft)
38376         {
38377         m68kcontext.io_cycle_counter -= sft * 2;
38378                 sft %= 9;
38379
38380                 src |= (flag_X & M68K_SR_X) << 0;
38381                 res = (src << sft) | (src >> (9 - sft));
38382                 flag_X = flag_C = res >> 0;
38383                 flag_V = 0;
38384                 flag_N = res >> 0;
38385                 flag_NotZ = res & 0x000000FF;
38386         DREGu8((Opcode >> 0) & 7) = res;
38387         RET(6)
38388         }
38389
38390         flag_V = 0;
38391         flag_C = flag_X;
38392         flag_N = src >> 0;
38393         flag_NotZ = src;
38394 RET(6)
38395 }
38396
38397 // ROXLD
38398 OPCODE(0xE170)
38399 {
38400         u32 adr, res;
38401         u32 src, dst;
38402
38403         u32 sft;
38404
38405         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38406         src = DREGu16((Opcode >> 0) & 7);
38407         if (sft)
38408         {
38409         m68kcontext.io_cycle_counter -= sft * 2;
38410                 sft %= 17;
38411
38412                 src |= (flag_X & M68K_SR_X) << 8;
38413                 res = (src << sft) | (src >> (17 - sft));
38414                 flag_X = flag_C = res >> 8;
38415                 flag_V = 0;
38416                 flag_N = res >> 8;
38417                 flag_NotZ = res & 0x0000FFFF;
38418         DREGu16((Opcode >> 0) & 7) = res;
38419         RET(6)
38420         }
38421
38422         flag_V = 0;
38423         flag_C = flag_X;
38424         flag_N = src >> 8;
38425         flag_NotZ = src;
38426 RET(6)
38427 }
38428
38429 // ROXLD
38430 OPCODE(0xE1B0)
38431 {
38432 #ifdef USE_CYCLONE_TIMING
38433 #define CYC 8
38434 #else
38435 #define CYC 6
38436 #endif
38437         u32 adr, res;
38438         u32 src, dst;
38439
38440         u32 sft;
38441
38442         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38443         src = DREGu32((Opcode >> 0) & 7);
38444         if (sft)
38445         {
38446         m68kcontext.io_cycle_counter -= sft * 2;
38447                 sft %= 33;
38448
38449                 if (sft != 0)
38450                 {
38451                         if (sft == 1) res = (src << 1) | ((flag_X >> ((M68K_SR_X_SFT + 1) - 1)) & 1);
38452                         else res = (src << sft) | (src >> (33 - sft)) | (((flag_X >> ((M68K_SR_X_SFT + 1) - 1)) & 1) << (sft - 1));
38453                         flag_X = (src >> (32 - sft)) << M68K_SR_X_SFT;
38454                 }
38455                 else res = src;
38456                 flag_C = flag_X;
38457                 flag_V = 0;
38458                 flag_N = res >> 24;
38459                 flag_NotZ = res;
38460         DREGu32((Opcode >> 0) & 7) = res;
38461         RET(CYC)
38462         }
38463
38464         flag_V = 0;
38465         flag_C = flag_X;
38466         flag_N = src >> 24;
38467         flag_NotZ = src;
38468 RET(CYC)
38469 #undef CYC
38470 }
38471
38472 // ROLD
38473 OPCODE(0xE138)
38474 {
38475         u32 adr, res;
38476         u32 src, dst;
38477
38478         u32 sft;
38479
38480         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38481         src = DREGu8((Opcode >> 0) & 7);
38482         if (sft)
38483         {
38484         m68kcontext.io_cycle_counter -= sft * 2;
38485                 if (sft &= 0x07)
38486                 {
38487                         flag_C = (src << sft) >> 0;
38488                         res = ((src << sft) | (src >> (8 - sft))) & 0x000000FF;
38489                         flag_V = 0;
38490                         flag_N = res >> 0;
38491                         flag_NotZ = res;
38492         DREGu8((Opcode >> 0) & 7) = res;
38493         RET(6)
38494                 }
38495
38496                 flag_V = 0;
38497                 flag_C = src << M68K_SR_C_SFT;
38498                 flag_N = src >> 0;
38499                 flag_NotZ = src;
38500         RET(6)
38501         }
38502
38503         flag_V = 0;
38504         flag_C = 0;
38505         flag_N = src >> 0;
38506         flag_NotZ = src;
38507 RET(6)
38508 }
38509
38510 // ROLD
38511 OPCODE(0xE178)
38512 {
38513         u32 adr, res;
38514         u32 src, dst;
38515
38516         u32 sft;
38517
38518         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38519         src = DREGu16((Opcode >> 0) & 7);
38520         if (sft)
38521         {
38522         m68kcontext.io_cycle_counter -= sft * 2;
38523                 if (sft &= 0x0F)
38524                 {
38525                         flag_C = (src << sft) >> 8;
38526                         res = ((src << sft) | (src >> (16 - sft))) & 0x0000FFFF;
38527                         flag_V = 0;
38528                         flag_N = res >> 8;
38529                         flag_NotZ = res;
38530         DREGu16((Opcode >> 0) & 7) = res;
38531         RET(6)
38532                 }
38533
38534                 flag_V = 0;
38535                 flag_C = src << M68K_SR_C_SFT;
38536                 flag_N = src >> 8;
38537                 flag_NotZ = src;
38538         RET(6)
38539         }
38540
38541         flag_V = 0;
38542         flag_C = 0;
38543         flag_N = src >> 8;
38544         flag_NotZ = src;
38545 RET(6)
38546 }
38547
38548 // ROLD
38549 OPCODE(0xE1B8)
38550 {
38551 #ifdef USE_CYCLONE_TIMING
38552 #define CYC 8
38553 #else
38554 #define CYC 6
38555 #endif
38556         u32 adr, res;
38557         u32 src, dst;
38558
38559         u32 sft;
38560
38561         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38562         src = DREGu32((Opcode >> 0) & 7);
38563         if (sft)
38564         {
38565         m68kcontext.io_cycle_counter -= sft * 2;
38566                 if (sft &= 0x1F)
38567                 {
38568                         flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38569                         res = (src << sft) | (src >> (32 - sft));
38570                         flag_V = 0;
38571                         flag_N = res >> 24;
38572                         flag_NotZ = res;
38573         DREGu32((Opcode >> 0) & 7) = res;
38574         RET(CYC)
38575                 }
38576
38577                 flag_V = 0;
38578                 flag_C = src << M68K_SR_C_SFT;
38579                 flag_N = src >> 24;
38580                 flag_NotZ = src;
38581         RET(CYC)
38582         }
38583
38584         flag_V = 0;
38585         flag_C = 0;
38586         flag_N = src >> 24;
38587         flag_NotZ = src;
38588 RET(CYC)
38589 #undef CYC
38590 }
38591
38592 // ASR
38593 OPCODE(0xE0D0)
38594 {
38595         u32 adr, res;
38596         u32 src, dst;
38597
38598         adr = AREG((Opcode >> 0) & 7);
38599         PRE_IO
38600         READ_WORD_F(adr, src)
38601         flag_V = 0;
38602         flag_X = flag_C = src << M68K_SR_C_SFT;
38603         res = (src >> 1) | (src & (1 << 15));
38604         flag_N = res >> 8;
38605         flag_NotZ = res;
38606         WRITE_WORD_F(adr, res)
38607         POST_IO
38608 RET(12)
38609 }
38610
38611 // ASR
38612 OPCODE(0xE0D8)
38613 {
38614         u32 adr, res;
38615         u32 src, dst;
38616
38617         adr = AREG((Opcode >> 0) & 7);
38618         AREG((Opcode >> 0) & 7) += 2;
38619         PRE_IO
38620         READ_WORD_F(adr, src)
38621         flag_V = 0;
38622         flag_X = flag_C = src << M68K_SR_C_SFT;
38623         res = (src >> 1) | (src & (1 << 15));
38624         flag_N = res >> 8;
38625         flag_NotZ = res;
38626         WRITE_WORD_F(adr, res)
38627         POST_IO
38628 RET(12)
38629 }
38630
38631 // ASR
38632 OPCODE(0xE0E0)
38633 {
38634         u32 adr, res;
38635         u32 src, dst;
38636
38637         adr = AREG((Opcode >> 0) & 7) - 2;
38638         AREG((Opcode >> 0) & 7) = adr;
38639         PRE_IO
38640         READ_WORD_F(adr, src)
38641         flag_V = 0;
38642         flag_X = flag_C = src << M68K_SR_C_SFT;
38643         res = (src >> 1) | (src & (1 << 15));
38644         flag_N = res >> 8;
38645         flag_NotZ = res;
38646         WRITE_WORD_F(adr, res)
38647         POST_IO
38648 RET(14)
38649 }
38650
38651 // ASR
38652 OPCODE(0xE0E8)
38653 {
38654         u32 adr, res;
38655         u32 src, dst;
38656
38657         FETCH_SWORD(adr);
38658         adr += AREG((Opcode >> 0) & 7);
38659         PRE_IO
38660         READ_WORD_F(adr, src)
38661         flag_V = 0;
38662         flag_X = flag_C = src << M68K_SR_C_SFT;
38663         res = (src >> 1) | (src & (1 << 15));
38664         flag_N = res >> 8;
38665         flag_NotZ = res;
38666         WRITE_WORD_F(adr, res)
38667         POST_IO
38668 RET(16)
38669 }
38670
38671 // ASR
38672 OPCODE(0xE0F0)
38673 {
38674         u32 adr, res;
38675         u32 src, dst;
38676
38677         adr = AREG((Opcode >> 0) & 7);
38678         DECODE_EXT_WORD
38679         PRE_IO
38680         READ_WORD_F(adr, src)
38681         flag_V = 0;
38682         flag_X = flag_C = src << M68K_SR_C_SFT;
38683         res = (src >> 1) | (src & (1 << 15));
38684         flag_N = res >> 8;
38685         flag_NotZ = res;
38686         WRITE_WORD_F(adr, res)
38687         POST_IO
38688 RET(18)
38689 }
38690
38691 // ASR
38692 OPCODE(0xE0F8)
38693 {
38694         u32 adr, res;
38695         u32 src, dst;
38696
38697         FETCH_SWORD(adr);
38698         PRE_IO
38699         READ_WORD_F(adr, src)
38700         flag_V = 0;
38701         flag_X = flag_C = src << M68K_SR_C_SFT;
38702         res = (src >> 1) | (src & (1 << 15));
38703         flag_N = res >> 8;
38704         flag_NotZ = res;
38705         WRITE_WORD_F(adr, res)
38706         POST_IO
38707 RET(16)
38708 }
38709
38710 // ASR
38711 OPCODE(0xE0F9)
38712 {
38713         u32 adr, res;
38714         u32 src, dst;
38715
38716         FETCH_LONG(adr);
38717         PRE_IO
38718         READ_WORD_F(adr, src)
38719         flag_V = 0;
38720         flag_X = flag_C = src << M68K_SR_C_SFT;
38721         res = (src >> 1) | (src & (1 << 15));
38722         flag_N = res >> 8;
38723         flag_NotZ = res;
38724         WRITE_WORD_F(adr, res)
38725         POST_IO
38726 RET(20)
38727 }
38728
38729 // ASR
38730 OPCODE(0xE0DF)
38731 {
38732         u32 adr, res;
38733         u32 src, dst;
38734
38735         adr = AREG(7);
38736         AREG(7) += 2;
38737         PRE_IO
38738         READ_WORD_F(adr, src)
38739         flag_V = 0;
38740         flag_X = flag_C = src << M68K_SR_C_SFT;
38741         res = (src >> 1) | (src & (1 << 15));
38742         flag_N = res >> 8;
38743         flag_NotZ = res;
38744         WRITE_WORD_F(adr, res)
38745         POST_IO
38746 RET(12)
38747 }
38748
38749 // ASR
38750 OPCODE(0xE0E7)
38751 {
38752         u32 adr, res;
38753         u32 src, dst;
38754
38755         adr = AREG(7) - 2;
38756         AREG(7) = adr;
38757         PRE_IO
38758         READ_WORD_F(adr, src)
38759         flag_V = 0;
38760         flag_X = flag_C = src << M68K_SR_C_SFT;
38761         res = (src >> 1) | (src & (1 << 15));
38762         flag_N = res >> 8;
38763         flag_NotZ = res;
38764         WRITE_WORD_F(adr, res)
38765         POST_IO
38766 RET(14)
38767 }
38768
38769 // LSR
38770 OPCODE(0xE2D0)
38771 {
38772         u32 adr, res;
38773         u32 src, dst;
38774
38775         adr = AREG((Opcode >> 0) & 7);
38776         PRE_IO
38777         READ_WORD_F(adr, src)
38778         flag_N = flag_V = 0;
38779         flag_X = flag_C = src << M68K_SR_C_SFT;
38780         res = src >> 1;
38781         flag_NotZ = res;
38782         WRITE_WORD_F(adr, res)
38783         POST_IO
38784 RET(12)
38785 }
38786
38787 // LSR
38788 OPCODE(0xE2D8)
38789 {
38790         u32 adr, res;
38791         u32 src, dst;
38792
38793         adr = AREG((Opcode >> 0) & 7);
38794         AREG((Opcode >> 0) & 7) += 2;
38795         PRE_IO
38796         READ_WORD_F(adr, src)
38797         flag_N = flag_V = 0;
38798         flag_X = flag_C = src << M68K_SR_C_SFT;
38799         res = src >> 1;
38800         flag_NotZ = res;
38801         WRITE_WORD_F(adr, res)
38802         POST_IO
38803 RET(12)
38804 }
38805
38806 // LSR
38807 OPCODE(0xE2E0)
38808 {
38809         u32 adr, res;
38810         u32 src, dst;
38811
38812         adr = AREG((Opcode >> 0) & 7) - 2;
38813         AREG((Opcode >> 0) & 7) = adr;
38814         PRE_IO
38815         READ_WORD_F(adr, src)
38816         flag_N = flag_V = 0;
38817         flag_X = flag_C = src << M68K_SR_C_SFT;
38818         res = src >> 1;
38819         flag_NotZ = res;
38820         WRITE_WORD_F(adr, res)
38821         POST_IO
38822 RET(14)
38823 }
38824
38825 // LSR
38826 OPCODE(0xE2E8)
38827 {
38828         u32 adr, res;
38829         u32 src, dst;
38830
38831         FETCH_SWORD(adr);
38832         adr += AREG((Opcode >> 0) & 7);
38833         PRE_IO
38834         READ_WORD_F(adr, src)
38835         flag_N = flag_V = 0;
38836         flag_X = flag_C = src << M68K_SR_C_SFT;
38837         res = src >> 1;
38838         flag_NotZ = res;
38839         WRITE_WORD_F(adr, res)
38840         POST_IO
38841 RET(16)
38842 }
38843
38844 // LSR
38845 OPCODE(0xE2F0)
38846 {
38847         u32 adr, res;
38848         u32 src, dst;
38849
38850         adr = AREG((Opcode >> 0) & 7);
38851         DECODE_EXT_WORD
38852         PRE_IO
38853         READ_WORD_F(adr, src)
38854         flag_N = flag_V = 0;
38855         flag_X = flag_C = src << M68K_SR_C_SFT;
38856         res = src >> 1;
38857         flag_NotZ = res;
38858         WRITE_WORD_F(adr, res)
38859         POST_IO
38860 RET(18)
38861 }
38862
38863 // LSR
38864 OPCODE(0xE2F8)
38865 {
38866         u32 adr, res;
38867         u32 src, dst;
38868
38869         FETCH_SWORD(adr);
38870         PRE_IO
38871         READ_WORD_F(adr, src)
38872         flag_N = flag_V = 0;
38873         flag_X = flag_C = src << M68K_SR_C_SFT;
38874         res = src >> 1;
38875         flag_NotZ = res;
38876         WRITE_WORD_F(adr, res)
38877         POST_IO
38878 RET(16)
38879 }
38880
38881 // LSR
38882 OPCODE(0xE2F9)
38883 {
38884         u32 adr, res;
38885         u32 src, dst;
38886
38887         FETCH_LONG(adr);
38888         PRE_IO
38889         READ_WORD_F(adr, src)
38890         flag_N = flag_V = 0;
38891         flag_X = flag_C = src << M68K_SR_C_SFT;
38892         res = src >> 1;
38893         flag_NotZ = res;
38894         WRITE_WORD_F(adr, res)
38895         POST_IO
38896 RET(20)
38897 }
38898
38899 // LSR
38900 OPCODE(0xE2DF)
38901 {
38902         u32 adr, res;
38903         u32 src, dst;
38904
38905         adr = AREG(7);
38906         AREG(7) += 2;
38907         PRE_IO
38908         READ_WORD_F(adr, src)
38909         flag_N = flag_V = 0;
38910         flag_X = flag_C = src << M68K_SR_C_SFT;
38911         res = src >> 1;
38912         flag_NotZ = res;
38913         WRITE_WORD_F(adr, res)
38914         POST_IO
38915 RET(12)
38916 }
38917
38918 // LSR
38919 OPCODE(0xE2E7)
38920 {
38921         u32 adr, res;
38922         u32 src, dst;
38923
38924         adr = AREG(7) - 2;
38925         AREG(7) = adr;
38926         PRE_IO
38927         READ_WORD_F(adr, src)
38928         flag_N = flag_V = 0;
38929         flag_X = flag_C = src << M68K_SR_C_SFT;
38930         res = src >> 1;
38931         flag_NotZ = res;
38932         WRITE_WORD_F(adr, res)
38933         POST_IO
38934 RET(14)
38935 }
38936
38937 // ROXR
38938 OPCODE(0xE4D0)
38939 {
38940         u32 adr, res;
38941         u32 src, dst;
38942
38943         adr = AREG((Opcode >> 0) & 7);
38944         PRE_IO
38945         READ_WORD_F(adr, src)
38946         flag_V = 0;
38947         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
38948         flag_C = flag_X = src << M68K_SR_C_SFT;
38949         flag_N = res >> 8;
38950         flag_NotZ = res;
38951         WRITE_WORD_F(adr, res)
38952         POST_IO
38953 RET(12)
38954 }
38955
38956 // ROXR
38957 OPCODE(0xE4D8)
38958 {
38959         u32 adr, res;
38960         u32 src, dst;
38961
38962         adr = AREG((Opcode >> 0) & 7);
38963         AREG((Opcode >> 0) & 7) += 2;
38964         PRE_IO
38965         READ_WORD_F(adr, src)
38966         flag_V = 0;
38967         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
38968         flag_C = flag_X = src << M68K_SR_C_SFT;
38969         flag_N = res >> 8;
38970         flag_NotZ = res;
38971         WRITE_WORD_F(adr, res)
38972         POST_IO
38973 RET(12)
38974 }
38975
38976 // ROXR
38977 OPCODE(0xE4E0)
38978 {
38979         u32 adr, res;
38980         u32 src, dst;
38981
38982         adr = AREG((Opcode >> 0) & 7) - 2;
38983         AREG((Opcode >> 0) & 7) = adr;
38984         PRE_IO
38985         READ_WORD_F(adr, src)
38986         flag_V = 0;
38987         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
38988         flag_C = flag_X = src << M68K_SR_C_SFT;
38989         flag_N = res >> 8;
38990         flag_NotZ = res;
38991         WRITE_WORD_F(adr, res)
38992         POST_IO
38993 RET(14)
38994 }
38995
38996 // ROXR
38997 OPCODE(0xE4E8)
38998 {
38999         u32 adr, res;
39000         u32 src, dst;
39001
39002         FETCH_SWORD(adr);
39003         adr += AREG((Opcode >> 0) & 7);
39004         PRE_IO
39005         READ_WORD_F(adr, src)
39006         flag_V = 0;
39007         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39008         flag_C = flag_X = src << M68K_SR_C_SFT;
39009         flag_N = res >> 8;
39010         flag_NotZ = res;
39011         WRITE_WORD_F(adr, res)
39012         POST_IO
39013 RET(16)
39014 }
39015
39016 // ROXR
39017 OPCODE(0xE4F0)
39018 {
39019         u32 adr, res;
39020         u32 src, dst;
39021
39022         adr = AREG((Opcode >> 0) & 7);
39023         DECODE_EXT_WORD
39024         PRE_IO
39025         READ_WORD_F(adr, src)
39026         flag_V = 0;
39027         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39028         flag_C = flag_X = src << M68K_SR_C_SFT;
39029         flag_N = res >> 8;
39030         flag_NotZ = res;
39031         WRITE_WORD_F(adr, res)
39032         POST_IO
39033 RET(18)
39034 }
39035
39036 // ROXR
39037 OPCODE(0xE4F8)
39038 {
39039         u32 adr, res;
39040         u32 src, dst;
39041
39042         FETCH_SWORD(adr);
39043         PRE_IO
39044         READ_WORD_F(adr, src)
39045         flag_V = 0;
39046         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39047         flag_C = flag_X = src << M68K_SR_C_SFT;
39048         flag_N = res >> 8;
39049         flag_NotZ = res;
39050         WRITE_WORD_F(adr, res)
39051         POST_IO
39052 RET(16)
39053 }
39054
39055 // ROXR
39056 OPCODE(0xE4F9)
39057 {
39058         u32 adr, res;
39059         u32 src, dst;
39060
39061         FETCH_LONG(adr);
39062         PRE_IO
39063         READ_WORD_F(adr, src)
39064         flag_V = 0;
39065         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39066         flag_C = flag_X = src << M68K_SR_C_SFT;
39067         flag_N = res >> 8;
39068         flag_NotZ = res;
39069         WRITE_WORD_F(adr, res)
39070         POST_IO
39071 RET(20)
39072 }
39073
39074 // ROXR
39075 OPCODE(0xE4DF)
39076 {
39077         u32 adr, res;
39078         u32 src, dst;
39079
39080         adr = AREG(7);
39081         AREG(7) += 2;
39082         PRE_IO
39083         READ_WORD_F(adr, src)
39084         flag_V = 0;
39085         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39086         flag_C = flag_X = src << M68K_SR_C_SFT;
39087         flag_N = res >> 8;
39088         flag_NotZ = res;
39089         WRITE_WORD_F(adr, res)
39090         POST_IO
39091 RET(12)
39092 }
39093
39094 // ROXR
39095 OPCODE(0xE4E7)
39096 {
39097         u32 adr, res;
39098         u32 src, dst;
39099
39100         adr = AREG(7) - 2;
39101         AREG(7) = adr;
39102         PRE_IO
39103         READ_WORD_F(adr, src)
39104         flag_V = 0;
39105         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39106         flag_C = flag_X = src << M68K_SR_C_SFT;
39107         flag_N = res >> 8;
39108         flag_NotZ = res;
39109         WRITE_WORD_F(adr, res)
39110         POST_IO
39111 RET(14)
39112 }
39113
39114 // ROR
39115 OPCODE(0xE6D0)
39116 {
39117         u32 adr, res;
39118         u32 src, dst;
39119
39120         adr = AREG((Opcode >> 0) & 7);
39121         PRE_IO
39122         READ_WORD_F(adr, src)
39123         flag_V = 0;
39124         flag_C = src << M68K_SR_C_SFT;
39125         res = (src >> 1) | (src << 15);
39126         flag_N = res >> 8;
39127         flag_NotZ = res & 0x0000FFFF;
39128         WRITE_WORD_F(adr, res)
39129         POST_IO
39130 RET(12)
39131 }
39132
39133 // ROR
39134 OPCODE(0xE6D8)
39135 {
39136         u32 adr, res;
39137         u32 src, dst;
39138
39139         adr = AREG((Opcode >> 0) & 7);
39140         AREG((Opcode >> 0) & 7) += 2;
39141         PRE_IO
39142         READ_WORD_F(adr, src)
39143         flag_V = 0;
39144         flag_C = src << M68K_SR_C_SFT;
39145         res = (src >> 1) | (src << 15);
39146         flag_N = res >> 8;
39147         flag_NotZ = res & 0x0000FFFF;
39148         WRITE_WORD_F(adr, res)
39149         POST_IO
39150 RET(12)
39151 }
39152
39153 // ROR
39154 OPCODE(0xE6E0)
39155 {
39156         u32 adr, res;
39157         u32 src, dst;
39158
39159         adr = AREG((Opcode >> 0) & 7) - 2;
39160         AREG((Opcode >> 0) & 7) = adr;
39161         PRE_IO
39162         READ_WORD_F(adr, src)
39163         flag_V = 0;
39164         flag_C = src << M68K_SR_C_SFT;
39165         res = (src >> 1) | (src << 15);
39166         flag_N = res >> 8;
39167         flag_NotZ = res & 0x0000FFFF;
39168         WRITE_WORD_F(adr, res)
39169         POST_IO
39170 RET(14)
39171 }
39172
39173 // ROR
39174 OPCODE(0xE6E8)
39175 {
39176         u32 adr, res;
39177         u32 src, dst;
39178
39179         FETCH_SWORD(adr);
39180         adr += AREG((Opcode >> 0) & 7);
39181         PRE_IO
39182         READ_WORD_F(adr, src)
39183         flag_V = 0;
39184         flag_C = src << M68K_SR_C_SFT;
39185         res = (src >> 1) | (src << 15);
39186         flag_N = res >> 8;
39187         flag_NotZ = res & 0x0000FFFF;
39188         WRITE_WORD_F(adr, res)
39189         POST_IO
39190 RET(16)
39191 }
39192
39193 // ROR
39194 OPCODE(0xE6F0)
39195 {
39196         u32 adr, res;
39197         u32 src, dst;
39198
39199         adr = AREG((Opcode >> 0) & 7);
39200         DECODE_EXT_WORD
39201         PRE_IO
39202         READ_WORD_F(adr, src)
39203         flag_V = 0;
39204         flag_C = src << M68K_SR_C_SFT;
39205         res = (src >> 1) | (src << 15);
39206         flag_N = res >> 8;
39207         flag_NotZ = res & 0x0000FFFF;
39208         WRITE_WORD_F(adr, res)
39209         POST_IO
39210 RET(18)
39211 }
39212
39213 // ROR
39214 OPCODE(0xE6F8)
39215 {
39216         u32 adr, res;
39217         u32 src, dst;
39218
39219         FETCH_SWORD(adr);
39220         PRE_IO
39221         READ_WORD_F(adr, src)
39222         flag_V = 0;
39223         flag_C = src << M68K_SR_C_SFT;
39224         res = (src >> 1) | (src << 15);
39225         flag_N = res >> 8;
39226         flag_NotZ = res & 0x0000FFFF;
39227         WRITE_WORD_F(adr, res)
39228         POST_IO
39229 RET(16)
39230 }
39231
39232 // ROR
39233 OPCODE(0xE6F9)
39234 {
39235         u32 adr, res;
39236         u32 src, dst;
39237
39238         FETCH_LONG(adr);
39239         PRE_IO
39240         READ_WORD_F(adr, src)
39241         flag_V = 0;
39242         flag_C = src << M68K_SR_C_SFT;
39243         res = (src >> 1) | (src << 15);
39244         flag_N = res >> 8;
39245         flag_NotZ = res & 0x0000FFFF;
39246         WRITE_WORD_F(adr, res)
39247         POST_IO
39248 RET(20)
39249 }
39250
39251 // ROR
39252 OPCODE(0xE6DF)
39253 {
39254         u32 adr, res;
39255         u32 src, dst;
39256
39257         adr = AREG(7);
39258         AREG(7) += 2;
39259         PRE_IO
39260         READ_WORD_F(adr, src)
39261         flag_V = 0;
39262         flag_C = src << M68K_SR_C_SFT;
39263         res = (src >> 1) | (src << 15);
39264         flag_N = res >> 8;
39265         flag_NotZ = res & 0x0000FFFF;
39266         WRITE_WORD_F(adr, res)
39267         POST_IO
39268 RET(12)
39269 }
39270
39271 // ROR
39272 OPCODE(0xE6E7)
39273 {
39274         u32 adr, res;
39275         u32 src, dst;
39276
39277         adr = AREG(7) - 2;
39278         AREG(7) = adr;
39279         PRE_IO
39280         READ_WORD_F(adr, src)
39281         flag_V = 0;
39282         flag_C = src << M68K_SR_C_SFT;
39283         res = (src >> 1) | (src << 15);
39284         flag_N = res >> 8;
39285         flag_NotZ = res & 0x0000FFFF;
39286         WRITE_WORD_F(adr, res)
39287         POST_IO
39288 RET(14)
39289 }
39290
39291 // ASL
39292 OPCODE(0xE1D0)
39293 {
39294         u32 adr, res;
39295         u32 src, dst;
39296
39297         adr = AREG((Opcode >> 0) & 7);
39298         PRE_IO
39299         READ_WORD_F(adr, src)
39300         flag_X = flag_C = src >> 7;
39301         res = src << 1;
39302         flag_V = (src ^ res) >> 8;
39303         flag_N = res >> 8;
39304         flag_NotZ = res & 0x0000FFFF;
39305         WRITE_WORD_F(adr, res)
39306         POST_IO
39307 RET(12)
39308 }
39309
39310 // ASL
39311 OPCODE(0xE1D8)
39312 {
39313         u32 adr, res;
39314         u32 src, dst;
39315
39316         adr = AREG((Opcode >> 0) & 7);
39317         AREG((Opcode >> 0) & 7) += 2;
39318         PRE_IO
39319         READ_WORD_F(adr, src)
39320         flag_X = flag_C = src >> 7;
39321         res = src << 1;
39322         flag_V = (src ^ res) >> 8;
39323         flag_N = res >> 8;
39324         flag_NotZ = res & 0x0000FFFF;
39325         WRITE_WORD_F(adr, res)
39326         POST_IO
39327 RET(12)
39328 }
39329
39330 // ASL
39331 OPCODE(0xE1E0)
39332 {
39333         u32 adr, res;
39334         u32 src, dst;
39335
39336         adr = AREG((Opcode >> 0) & 7) - 2;
39337         AREG((Opcode >> 0) & 7) = adr;
39338         PRE_IO
39339         READ_WORD_F(adr, src)
39340         flag_X = flag_C = src >> 7;
39341         res = src << 1;
39342         flag_V = (src ^ res) >> 8;
39343         flag_N = res >> 8;
39344         flag_NotZ = res & 0x0000FFFF;
39345         WRITE_WORD_F(adr, res)
39346         POST_IO
39347 RET(14)
39348 }
39349
39350 // ASL
39351 OPCODE(0xE1E8)
39352 {
39353         u32 adr, res;
39354         u32 src, dst;
39355
39356         FETCH_SWORD(adr);
39357         adr += AREG((Opcode >> 0) & 7);
39358         PRE_IO
39359         READ_WORD_F(adr, src)
39360         flag_X = flag_C = src >> 7;
39361         res = src << 1;
39362         flag_V = (src ^ res) >> 8;
39363         flag_N = res >> 8;
39364         flag_NotZ = res & 0x0000FFFF;
39365         WRITE_WORD_F(adr, res)
39366         POST_IO
39367 RET(16)
39368 }
39369
39370 // ASL
39371 OPCODE(0xE1F0)
39372 {
39373         u32 adr, res;
39374         u32 src, dst;
39375
39376         adr = AREG((Opcode >> 0) & 7);
39377         DECODE_EXT_WORD
39378         PRE_IO
39379         READ_WORD_F(adr, src)
39380         flag_X = flag_C = src >> 7;
39381         res = src << 1;
39382         flag_V = (src ^ res) >> 8;
39383         flag_N = res >> 8;
39384         flag_NotZ = res & 0x0000FFFF;
39385         WRITE_WORD_F(adr, res)
39386         POST_IO
39387 RET(18)
39388 }
39389
39390 // ASL
39391 OPCODE(0xE1F8)
39392 {
39393         u32 adr, res;
39394         u32 src, dst;
39395
39396         FETCH_SWORD(adr);
39397         PRE_IO
39398         READ_WORD_F(adr, src)
39399         flag_X = flag_C = src >> 7;
39400         res = src << 1;
39401         flag_V = (src ^ res) >> 8;
39402         flag_N = res >> 8;
39403         flag_NotZ = res & 0x0000FFFF;
39404         WRITE_WORD_F(adr, res)
39405         POST_IO
39406 RET(16)
39407 }
39408
39409 // ASL
39410 OPCODE(0xE1F9)
39411 {
39412         u32 adr, res;
39413         u32 src, dst;
39414
39415         FETCH_LONG(adr);
39416         PRE_IO
39417         READ_WORD_F(adr, src)
39418         flag_X = flag_C = src >> 7;
39419         res = src << 1;
39420         flag_V = (src ^ res) >> 8;
39421         flag_N = res >> 8;
39422         flag_NotZ = res & 0x0000FFFF;
39423         WRITE_WORD_F(adr, res)
39424         POST_IO
39425 RET(20)
39426 }
39427
39428 // ASL
39429 OPCODE(0xE1DF)
39430 {
39431         u32 adr, res;
39432         u32 src, dst;
39433
39434         adr = AREG(7);
39435         AREG(7) += 2;
39436         PRE_IO
39437         READ_WORD_F(adr, src)
39438         flag_X = flag_C = src >> 7;
39439         res = src << 1;
39440         flag_V = (src ^ res) >> 8;
39441         flag_N = res >> 8;
39442         flag_NotZ = res & 0x0000FFFF;
39443         WRITE_WORD_F(adr, res)
39444         POST_IO
39445 RET(12)
39446 }
39447
39448 // ASL
39449 OPCODE(0xE1E7)
39450 {
39451         u32 adr, res;
39452         u32 src, dst;
39453
39454         adr = AREG(7) - 2;
39455         AREG(7) = adr;
39456         PRE_IO
39457         READ_WORD_F(adr, src)
39458         flag_X = flag_C = src >> 7;
39459         res = src << 1;
39460         flag_V = (src ^ res) >> 8;
39461         flag_N = res >> 8;
39462         flag_NotZ = res & 0x0000FFFF;
39463         WRITE_WORD_F(adr, res)
39464         POST_IO
39465 RET(14)
39466 }
39467
39468 // LSL
39469 OPCODE(0xE3D0)
39470 {
39471         u32 adr, res;
39472         u32 src, dst;
39473
39474         adr = AREG((Opcode >> 0) & 7);
39475         PRE_IO
39476         READ_WORD_F(adr, src)
39477         flag_V = 0;
39478         flag_X = flag_C = src >> 7;
39479         res = src << 1;
39480         flag_N = res >> 8;
39481         flag_NotZ = res & 0x0000FFFF;
39482         WRITE_WORD_F(adr, res)
39483         POST_IO
39484 RET(12)
39485 }
39486
39487 // LSL
39488 OPCODE(0xE3D8)
39489 {
39490         u32 adr, res;
39491         u32 src, dst;
39492
39493         adr = AREG((Opcode >> 0) & 7);
39494         AREG((Opcode >> 0) & 7) += 2;
39495         PRE_IO
39496         READ_WORD_F(adr, src)
39497         flag_V = 0;
39498         flag_X = flag_C = src >> 7;
39499         res = src << 1;
39500         flag_N = res >> 8;
39501         flag_NotZ = res & 0x0000FFFF;
39502         WRITE_WORD_F(adr, res)
39503         POST_IO
39504 RET(12)
39505 }
39506
39507 // LSL
39508 OPCODE(0xE3E0)
39509 {
39510         u32 adr, res;
39511         u32 src, dst;
39512
39513         adr = AREG((Opcode >> 0) & 7) - 2;
39514         AREG((Opcode >> 0) & 7) = adr;
39515         PRE_IO
39516         READ_WORD_F(adr, src)
39517         flag_V = 0;
39518         flag_X = flag_C = src >> 7;
39519         res = src << 1;
39520         flag_N = res >> 8;
39521         flag_NotZ = res & 0x0000FFFF;
39522         WRITE_WORD_F(adr, res)
39523         POST_IO
39524 RET(14)
39525 }
39526
39527 // LSL
39528 OPCODE(0xE3E8)
39529 {
39530         u32 adr, res;
39531         u32 src, dst;
39532
39533         FETCH_SWORD(adr);
39534         adr += AREG((Opcode >> 0) & 7);
39535         PRE_IO
39536         READ_WORD_F(adr, src)
39537         flag_V = 0;
39538         flag_X = flag_C = src >> 7;
39539         res = src << 1;
39540         flag_N = res >> 8;
39541         flag_NotZ = res & 0x0000FFFF;
39542         WRITE_WORD_F(adr, res)
39543         POST_IO
39544 RET(16)
39545 }
39546
39547 // LSL
39548 OPCODE(0xE3F0)
39549 {
39550         u32 adr, res;
39551         u32 src, dst;
39552
39553         adr = AREG((Opcode >> 0) & 7);
39554         DECODE_EXT_WORD
39555         PRE_IO
39556         READ_WORD_F(adr, src)
39557         flag_V = 0;
39558         flag_X = flag_C = src >> 7;
39559         res = src << 1;
39560         flag_N = res >> 8;
39561         flag_NotZ = res & 0x0000FFFF;
39562         WRITE_WORD_F(adr, res)
39563         POST_IO
39564 RET(18)
39565 }
39566
39567 // LSL
39568 OPCODE(0xE3F8)
39569 {
39570         u32 adr, res;
39571         u32 src, dst;
39572
39573         FETCH_SWORD(adr);
39574         PRE_IO
39575         READ_WORD_F(adr, src)
39576         flag_V = 0;
39577         flag_X = flag_C = src >> 7;
39578         res = src << 1;
39579         flag_N = res >> 8;
39580         flag_NotZ = res & 0x0000FFFF;
39581         WRITE_WORD_F(adr, res)
39582         POST_IO
39583 RET(16)
39584 }
39585
39586 // LSL
39587 OPCODE(0xE3F9)
39588 {
39589         u32 adr, res;
39590         u32 src, dst;
39591
39592         FETCH_LONG(adr);
39593         PRE_IO
39594         READ_WORD_F(adr, src)
39595         flag_V = 0;
39596         flag_X = flag_C = src >> 7;
39597         res = src << 1;
39598         flag_N = res >> 8;
39599         flag_NotZ = res & 0x0000FFFF;
39600         WRITE_WORD_F(adr, res)
39601         POST_IO
39602 RET(20)
39603 }
39604
39605 // LSL
39606 OPCODE(0xE3DF)
39607 {
39608         u32 adr, res;
39609         u32 src, dst;
39610
39611         adr = AREG(7);
39612         AREG(7) += 2;
39613         PRE_IO
39614         READ_WORD_F(adr, src)
39615         flag_V = 0;
39616         flag_X = flag_C = src >> 7;
39617         res = src << 1;
39618         flag_N = res >> 8;
39619         flag_NotZ = res & 0x0000FFFF;
39620         WRITE_WORD_F(adr, res)
39621         POST_IO
39622 RET(12)
39623 }
39624
39625 // LSL
39626 OPCODE(0xE3E7)
39627 {
39628         u32 adr, res;
39629         u32 src, dst;
39630
39631         adr = AREG(7) - 2;
39632         AREG(7) = adr;
39633         PRE_IO
39634         READ_WORD_F(adr, src)
39635         flag_V = 0;
39636         flag_X = flag_C = src >> 7;
39637         res = src << 1;
39638         flag_N = res >> 8;
39639         flag_NotZ = res & 0x0000FFFF;
39640         WRITE_WORD_F(adr, res)
39641         POST_IO
39642 RET(14)
39643 }
39644
39645 // ROXL
39646 OPCODE(0xE5D0)
39647 {
39648         u32 adr, res;
39649         u32 src, dst;
39650
39651         adr = AREG((Opcode >> 0) & 7);
39652         PRE_IO
39653         READ_WORD_F(adr, src)
39654         flag_V = 0;
39655         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39656         flag_X = flag_C = src >> 7;
39657         flag_N = res >> 8;
39658         flag_NotZ = res & 0x0000FFFF;
39659         WRITE_WORD_F(adr, res)
39660         POST_IO
39661 RET(12)
39662 }
39663
39664 // ROXL
39665 OPCODE(0xE5D8)
39666 {
39667         u32 adr, res;
39668         u32 src, dst;
39669
39670         adr = AREG((Opcode >> 0) & 7);
39671         AREG((Opcode >> 0) & 7) += 2;
39672         PRE_IO
39673         READ_WORD_F(adr, src)
39674         flag_V = 0;
39675         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39676         flag_X = flag_C = src >> 7;
39677         flag_N = res >> 8;
39678         flag_NotZ = res & 0x0000FFFF;
39679         WRITE_WORD_F(adr, res)
39680         POST_IO
39681 RET(12)
39682 }
39683
39684 // ROXL
39685 OPCODE(0xE5E0)
39686 {
39687         u32 adr, res;
39688         u32 src, dst;
39689
39690         adr = AREG((Opcode >> 0) & 7) - 2;
39691         AREG((Opcode >> 0) & 7) = adr;
39692         PRE_IO
39693         READ_WORD_F(adr, src)
39694         flag_V = 0;
39695         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39696         flag_X = flag_C = src >> 7;
39697         flag_N = res >> 8;
39698         flag_NotZ = res & 0x0000FFFF;
39699         WRITE_WORD_F(adr, res)
39700         POST_IO
39701 RET(14)
39702 }
39703
39704 // ROXL
39705 OPCODE(0xE5E8)
39706 {
39707         u32 adr, res;
39708         u32 src, dst;
39709
39710         FETCH_SWORD(adr);
39711         adr += AREG((Opcode >> 0) & 7);
39712         PRE_IO
39713         READ_WORD_F(adr, src)
39714         flag_V = 0;
39715         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39716         flag_X = flag_C = src >> 7;
39717         flag_N = res >> 8;
39718         flag_NotZ = res & 0x0000FFFF;
39719         WRITE_WORD_F(adr, res)
39720         POST_IO
39721 RET(16)
39722 }
39723
39724 // ROXL
39725 OPCODE(0xE5F0)
39726 {
39727         u32 adr, res;
39728         u32 src, dst;
39729
39730         adr = AREG((Opcode >> 0) & 7);
39731         DECODE_EXT_WORD
39732         PRE_IO
39733         READ_WORD_F(adr, src)
39734         flag_V = 0;
39735         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39736         flag_X = flag_C = src >> 7;
39737         flag_N = res >> 8;
39738         flag_NotZ = res & 0x0000FFFF;
39739         WRITE_WORD_F(adr, res)
39740         POST_IO
39741 RET(18)
39742 }
39743
39744 // ROXL
39745 OPCODE(0xE5F8)
39746 {
39747         u32 adr, res;
39748         u32 src, dst;
39749
39750         FETCH_SWORD(adr);
39751         PRE_IO
39752         READ_WORD_F(adr, src)
39753         flag_V = 0;
39754         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39755         flag_X = flag_C = src >> 7;
39756         flag_N = res >> 8;
39757         flag_NotZ = res & 0x0000FFFF;
39758         WRITE_WORD_F(adr, res)
39759         POST_IO
39760 RET(16)
39761 }
39762
39763 // ROXL
39764 OPCODE(0xE5F9)
39765 {
39766         u32 adr, res;
39767         u32 src, dst;
39768
39769         FETCH_LONG(adr);
39770         PRE_IO
39771         READ_WORD_F(adr, src)
39772         flag_V = 0;
39773         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39774         flag_X = flag_C = src >> 7;
39775         flag_N = res >> 8;
39776         flag_NotZ = res & 0x0000FFFF;
39777         WRITE_WORD_F(adr, res)
39778         POST_IO
39779 RET(20)
39780 }
39781
39782 // ROXL
39783 OPCODE(0xE5DF)
39784 {
39785         u32 adr, res;
39786         u32 src, dst;
39787
39788         adr = AREG(7);
39789         AREG(7) += 2;
39790         PRE_IO
39791         READ_WORD_F(adr, src)
39792         flag_V = 0;
39793         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39794         flag_X = flag_C = src >> 7;
39795         flag_N = res >> 8;
39796         flag_NotZ = res & 0x0000FFFF;
39797         WRITE_WORD_F(adr, res)
39798         POST_IO
39799 RET(12)
39800 }
39801
39802 // ROXL
39803 OPCODE(0xE5E7)
39804 {
39805         u32 adr, res;
39806         u32 src, dst;
39807
39808         adr = AREG(7) - 2;
39809         AREG(7) = adr;
39810         PRE_IO
39811         READ_WORD_F(adr, src)
39812         flag_V = 0;
39813         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39814         flag_X = flag_C = src >> 7;
39815         flag_N = res >> 8;
39816         flag_NotZ = res & 0x0000FFFF;
39817         WRITE_WORD_F(adr, res)
39818         POST_IO
39819 RET(14)
39820 }
39821
39822 // ROL
39823 OPCODE(0xE7D0)
39824 {
39825         u32 adr, res;
39826         u32 src, dst;
39827
39828         adr = AREG((Opcode >> 0) & 7);
39829         PRE_IO
39830         READ_WORD_F(adr, src)
39831         flag_V = 0;
39832         flag_C = src >> 7;
39833         res = (src << 1) | (src >> 15);
39834         flag_N = res >> 8;
39835         flag_NotZ = res & 0x0000FFFF;
39836         WRITE_WORD_F(adr, res)
39837         POST_IO
39838 RET(12)
39839 }
39840
39841 // ROL
39842 OPCODE(0xE7D8)
39843 {
39844         u32 adr, res;
39845         u32 src, dst;
39846
39847         adr = AREG((Opcode >> 0) & 7);
39848         AREG((Opcode >> 0) & 7) += 2;
39849         PRE_IO
39850         READ_WORD_F(adr, src)
39851         flag_V = 0;
39852         flag_C = src >> 7;
39853         res = (src << 1) | (src >> 15);
39854         flag_N = res >> 8;
39855         flag_NotZ = res & 0x0000FFFF;
39856         WRITE_WORD_F(adr, res)
39857         POST_IO
39858 RET(12)
39859 }
39860
39861 // ROL
39862 OPCODE(0xE7E0)
39863 {
39864         u32 adr, res;
39865         u32 src, dst;
39866
39867         adr = AREG((Opcode >> 0) & 7) - 2;
39868         AREG((Opcode >> 0) & 7) = adr;
39869         PRE_IO
39870         READ_WORD_F(adr, src)
39871         flag_V = 0;
39872         flag_C = src >> 7;
39873         res = (src << 1) | (src >> 15);
39874         flag_N = res >> 8;
39875         flag_NotZ = res & 0x0000FFFF;
39876         WRITE_WORD_F(adr, res)
39877         POST_IO
39878 RET(14)
39879 }
39880
39881 // ROL
39882 OPCODE(0xE7E8)
39883 {
39884         u32 adr, res;
39885         u32 src, dst;
39886
39887         FETCH_SWORD(adr);
39888         adr += AREG((Opcode >> 0) & 7);
39889         PRE_IO
39890         READ_WORD_F(adr, src)
39891         flag_V = 0;
39892         flag_C = src >> 7;
39893         res = (src << 1) | (src >> 15);
39894         flag_N = res >> 8;
39895         flag_NotZ = res & 0x0000FFFF;
39896         WRITE_WORD_F(adr, res)
39897         POST_IO
39898 RET(16)
39899 }
39900
39901 // ROL
39902 OPCODE(0xE7F0)
39903 {
39904         u32 adr, res;
39905         u32 src, dst;
39906
39907         adr = AREG((Opcode >> 0) & 7);
39908         DECODE_EXT_WORD
39909         PRE_IO
39910         READ_WORD_F(adr, src)
39911         flag_V = 0;
39912         flag_C = src >> 7;
39913         res = (src << 1) | (src >> 15);
39914         flag_N = res >> 8;
39915         flag_NotZ = res & 0x0000FFFF;
39916         WRITE_WORD_F(adr, res)
39917         POST_IO
39918 RET(18)
39919 }
39920
39921 // ROL
39922 OPCODE(0xE7F8)
39923 {
39924         u32 adr, res;
39925         u32 src, dst;
39926
39927         FETCH_SWORD(adr);
39928         PRE_IO
39929         READ_WORD_F(adr, src)
39930         flag_V = 0;
39931         flag_C = src >> 7;
39932         res = (src << 1) | (src >> 15);
39933         flag_N = res >> 8;
39934         flag_NotZ = res & 0x0000FFFF;
39935         WRITE_WORD_F(adr, res)
39936         POST_IO
39937 RET(16)
39938 }
39939
39940 // ROL
39941 OPCODE(0xE7F9)
39942 {
39943         u32 adr, res;
39944         u32 src, dst;
39945
39946         FETCH_LONG(adr);
39947         PRE_IO
39948         READ_WORD_F(adr, src)
39949         flag_V = 0;
39950         flag_C = src >> 7;
39951         res = (src << 1) | (src >> 15);
39952         flag_N = res >> 8;
39953         flag_NotZ = res & 0x0000FFFF;
39954         WRITE_WORD_F(adr, res)
39955         POST_IO
39956 RET(20)
39957 }
39958
39959 // ROL
39960 OPCODE(0xE7DF)
39961 {
39962         u32 adr, res;
39963         u32 src, dst;
39964
39965         adr = AREG(7);
39966         AREG(7) += 2;
39967         PRE_IO
39968         READ_WORD_F(adr, src)
39969         flag_V = 0;
39970         flag_C = src >> 7;
39971         res = (src << 1) | (src >> 15);
39972         flag_N = res >> 8;
39973         flag_NotZ = res & 0x0000FFFF;
39974         WRITE_WORD_F(adr, res)
39975         POST_IO
39976 RET(12)
39977 }
39978
39979 // ROL
39980 OPCODE(0xE7E7)
39981 {
39982         u32 adr, res;
39983         u32 src, dst;
39984
39985         adr = AREG(7) - 2;
39986         AREG(7) = adr;
39987         PRE_IO
39988         READ_WORD_F(adr, src)
39989         flag_V = 0;
39990         flag_C = src >> 7;
39991         res = (src << 1) | (src >> 15);
39992         flag_N = res >> 8;
39993         flag_NotZ = res & 0x0000FFFF;
39994         WRITE_WORD_F(adr, res)
39995         POST_IO
39996 RET(14)
39997 }
39998
39999 #ifdef PICODRIVE_HACK
40000 #if 0
40001 #define UPDATE_IDLE_COUNT { \
40002         extern int idle_hit_counter; \
40003         idle_hit_counter++; \
40004 }
40005 #else
40006 #define UPDATE_IDLE_COUNT
40007 #endif
40008
40009 // BRA
40010 OPCODE(0x6001_idle)
40011 {
40012 #ifdef FAMEC_CHECK_BRANCHES
40013         u32 newPC = GET_PC;
40014         s8 offs=Opcode;
40015         newPC += offs;
40016         SET_PC(newPC);
40017         CHECK_BRANCH_EXCEPTION(offs)
40018 #else
40019         PC += ((s8)(Opcode & 0xFE)) >> 1;
40020 #endif
40021         UPDATE_IDLE_COUNT
40022 RET0()
40023 }
40024
40025 // BCC
40026 OPCODE(0x6601_idle)
40027 {
40028         if (flag_NotZ)
40029         {
40030                 UPDATE_IDLE_COUNT
40031                 PC += ((s8)(Opcode & 0xFE)) >> 1;
40032                 //if (idle_hit)
40033                 RET0()
40034         }
40035 RET(8)
40036 }
40037
40038 OPCODE(0x6701_idle)
40039 {
40040         if (!flag_NotZ)
40041         {
40042                 UPDATE_IDLE_COUNT
40043                 PC += ((s8)(Opcode & 0xFE)) >> 1;
40044                 //if (idle_hit)
40045                 RET0()
40046         }
40047 RET(8)
40048 }
40049
40050
40051 extern int SekIsIdleReady(void);
40052 extern int SekIsIdleCode(unsigned short *dst, int bytes);
40053 extern int SekRegisterIdlePatch(unsigned int pc, int oldop, int newop, void *ctx);
40054
40055 OPCODE(idle_detector_bcc8)
40056 {
40057         int frame_count, cond_true, bytes, ret, newop;
40058         u16 *dest_pc;
40059
40060         dest_pc = PC + (((s8)(Opcode & 0xFE)) >> 1);
40061
40062         if (!SekIsIdleReady())
40063                 goto end;
40064
40065         bytes = 0 - (s8)(Opcode & 0xFE) - 2;
40066         ret = SekIsIdleCode(dest_pc, bytes);
40067         newop = (Opcode & 0xfe) | 0x7100;
40068         if (!ret) newop |= 0x200;
40069         if (  Opcode & 0x0100)  newop |= 0x400; // beq
40070         if (!(Opcode & 0x0f00)) newop |= 0xc00; // bra
40071
40072         ret = SekRegisterIdlePatch(GET_PC - 2, Opcode, newop, &m68kcontext);
40073         switch (ret)
40074         {
40075                 case 0: PC[-1] = newop; break;
40076                 case 1: break;
40077                 case 2: JumpTable[Opcode] = (Opcode & 0x0f00) ?
40078                                 ((Opcode & 0x0100) ? CAST_OP(0x6701) : CAST_OP(0x6601)) :
40079                                 CAST_OP(0x6001); break;
40080         }
40081
40082 end:
40083         if ((Opcode & 0xff00) == 0x6000) cond_true = 1;
40084         else cond_true = (Opcode & 0x0100) ? !flag_NotZ : flag_NotZ; // beq?
40085         if (cond_true)
40086         {
40087                 PC = dest_pc;
40088                 m68kcontext.io_cycle_counter -= 2;
40089         }
40090 RET(8)
40091 }
40092
40093 #endif // PICODRIVE_HACK