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         dst = DREGu8((Opcode >> 0) & 7);
16940         res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
16941
16942         if (res != 0)
16943         {
16944                 flag_V = res;
16945                 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
16946                 res = (res + 0x9a) & 0xFF;
16947                 DREGu8((Opcode >> 0) & 7) = res;
16948                 flag_V &= ~res;
16949                 flag_NotZ |= res;
16950                 flag_X = flag_C = M68K_SR_C;
16951         }
16952         else flag_V = flag_X = flag_C = 0;
16953         flag_N = res;
16954 RET(6)
16955 }
16956
16957 // NBCD
16958 OPCODE(0x4810)
16959 {
16960         u32 adr, res;
16961         u32 src, dst;
16962
16963         adr = AREG((Opcode >> 0) & 7);
16964         PRE_IO
16965         READ_BYTE_F(adr, dst)
16966         res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
16967
16968         if (res != 0)
16969         {
16970                 flag_V = res;
16971                 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
16972                 res = (res + 0x9a) & 0xFF;
16973                 WRITE_BYTE_F(adr, res)
16974                 flag_V &= ~res;
16975                 flag_NotZ |= res;
16976                 flag_X = flag_C = M68K_SR_C;
16977         }
16978         else flag_V = flag_X = flag_C = 0;
16979         flag_N = res;
16980         POST_IO
16981 RET(12)
16982 }
16983
16984 // NBCD
16985 OPCODE(0x4818)
16986 {
16987         u32 adr, res;
16988         u32 src, dst;
16989
16990         adr = AREG((Opcode >> 0) & 7);
16991         AREG((Opcode >> 0) & 7) += 1;
16992         PRE_IO
16993         READ_BYTE_F(adr, dst)
16994         res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
16995
16996         if (res != 0)
16997         {
16998                 flag_V = res;
16999                 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17000                 res = (res + 0x9a) & 0xFF;
17001                 WRITE_BYTE_F(adr, res)
17002                 flag_V &= ~res;
17003                 flag_NotZ |= res;
17004                 flag_X = flag_C = M68K_SR_C;
17005         }
17006         else flag_V = flag_X = flag_C = 0;
17007         flag_N = res;
17008         POST_IO
17009 RET(12)
17010 }
17011
17012 // NBCD
17013 OPCODE(0x4820)
17014 {
17015         u32 adr, res;
17016         u32 src, dst;
17017
17018         adr = AREG((Opcode >> 0) & 7) - 1;
17019         AREG((Opcode >> 0) & 7) = adr;
17020         PRE_IO
17021         READ_BYTE_F(adr, dst)
17022         res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17023
17024         if (res != 0)
17025         {
17026                 flag_V = res;
17027                 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17028                 res = (res + 0x9a) & 0xFF;
17029                 WRITE_BYTE_F(adr, res)
17030                 flag_V &= ~res;
17031                 flag_NotZ |= res;
17032                 flag_X = flag_C = M68K_SR_C;
17033         }
17034         else flag_V = flag_X = flag_C = 0;
17035         flag_N = res;
17036         POST_IO
17037 RET(14)
17038 }
17039
17040 // NBCD
17041 OPCODE(0x4828)
17042 {
17043         u32 adr, res;
17044         u32 src, dst;
17045
17046         FETCH_SWORD(adr);
17047         adr += AREG((Opcode >> 0) & 7);
17048         PRE_IO
17049         READ_BYTE_F(adr, dst)
17050         res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17051
17052         if (res != 0)
17053         {
17054                 flag_V = res;
17055                 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17056                 res = (res + 0x9a) & 0xFF;
17057                 WRITE_BYTE_F(adr, res)
17058                 flag_V &= ~res;
17059                 flag_NotZ |= res;
17060                 flag_X = flag_C = M68K_SR_C;
17061         }
17062         else flag_V = flag_X = flag_C = 0;
17063         flag_N = res;
17064         POST_IO
17065 RET(16)
17066 }
17067
17068 // NBCD
17069 OPCODE(0x4830)
17070 {
17071         u32 adr, res;
17072         u32 src, dst;
17073
17074         adr = AREG((Opcode >> 0) & 7);
17075         DECODE_EXT_WORD
17076         PRE_IO
17077         READ_BYTE_F(adr, dst)
17078         res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17079
17080         if (res != 0)
17081         {
17082                 flag_V = res;
17083                 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17084                 res = (res + 0x9a) & 0xFF;
17085                 WRITE_BYTE_F(adr, res)
17086                 flag_V &= ~res;
17087                 flag_NotZ |= res;
17088                 flag_X = flag_C = M68K_SR_C;
17089         }
17090         else flag_V = flag_X = flag_C = 0;
17091         flag_N = res;
17092         POST_IO
17093 RET(18)
17094 }
17095
17096 // NBCD
17097 OPCODE(0x4838)
17098 {
17099         u32 adr, res;
17100         u32 src, dst;
17101
17102         FETCH_SWORD(adr);
17103         PRE_IO
17104         READ_BYTE_F(adr, dst)
17105         res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17106
17107         if (res != 0)
17108         {
17109                 flag_V = res;
17110                 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17111                 res = (res + 0x9a) & 0xFF;
17112                 WRITE_BYTE_F(adr, res)
17113                 flag_V &= ~res;
17114                 flag_NotZ |= res;
17115                 flag_X = flag_C = M68K_SR_C;
17116         }
17117         else flag_V = flag_X = flag_C = 0;
17118         flag_N = res;
17119         POST_IO
17120 RET(16)
17121 }
17122
17123 // NBCD
17124 OPCODE(0x4839)
17125 {
17126         u32 adr, res;
17127         u32 src, dst;
17128
17129         FETCH_LONG(adr);
17130         PRE_IO
17131         READ_BYTE_F(adr, dst)
17132         res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17133
17134         if (res != 0)
17135         {
17136                 flag_V = res;
17137                 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17138                 res = (res + 0x9a) & 0xFF;
17139                 WRITE_BYTE_F(adr, res)
17140                 flag_V &= ~res;
17141                 flag_NotZ |= res;
17142                 flag_X = flag_C = M68K_SR_C;
17143         }
17144         else flag_V = flag_X = flag_C = 0;
17145         flag_N = res;
17146         POST_IO
17147 RET(20)
17148 }
17149
17150 // NBCD
17151 OPCODE(0x481F)
17152 {
17153         u32 adr, res;
17154         u32 src, dst;
17155
17156         adr = AREG(7);
17157         AREG(7) += 2;
17158         PRE_IO
17159         READ_BYTE_F(adr, dst)
17160         res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17161
17162         if (res != 0)
17163         {
17164                 flag_V = res;
17165                 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17166                 res = (res + 0x9a) & 0xFF;
17167                 WRITE_BYTE_F(adr, res)
17168                 flag_V &= ~res;
17169                 flag_NotZ |= res;
17170                 flag_X = flag_C = M68K_SR_C;
17171         }
17172         else flag_V = flag_X = flag_C = 0;
17173         flag_N = res;
17174         POST_IO
17175 RET(12)
17176 }
17177
17178 // NBCD
17179 OPCODE(0x4827)
17180 {
17181         u32 adr, res;
17182         u32 src, dst;
17183
17184         adr = AREG(7) - 2;
17185         AREG(7) = adr;
17186         PRE_IO
17187         READ_BYTE_F(adr, dst)
17188         res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17189
17190         if (res != 0)
17191         {
17192                 flag_V = res;
17193                 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17194                 res = (res + 0x9a) & 0xFF;
17195                 WRITE_BYTE_F(adr, res)
17196                 flag_V &= ~res;
17197                 flag_NotZ |= res;
17198                 flag_X = flag_C = M68K_SR_C;
17199         }
17200         else flag_V = flag_X = flag_C = 0;
17201         flag_N = res;
17202         POST_IO
17203 RET(14)
17204 }
17205
17206 // PEA
17207 OPCODE(0x4850)
17208 {
17209         u32 adr, res;
17210         u32 src, dst;
17211
17212         adr = AREG((Opcode >> 0) & 7);
17213         PRE_IO
17214         PUSH_32_F(adr)
17215         POST_IO
17216 RET(12)
17217 }
17218
17219 // PEA
17220 OPCODE(0x4868)
17221 {
17222         u32 adr, res;
17223         u32 src, dst;
17224
17225         FETCH_SWORD(adr);
17226         adr += AREG((Opcode >> 0) & 7);
17227         PRE_IO
17228         PUSH_32_F(adr)
17229         POST_IO
17230 RET(16)
17231 }
17232
17233 // PEA
17234 OPCODE(0x4870)
17235 {
17236         u32 adr, res;
17237         u32 src, dst;
17238
17239         adr = AREG((Opcode >> 0) & 7);
17240         DECODE_EXT_WORD
17241         PRE_IO
17242         PUSH_32_F(adr)
17243         POST_IO
17244 RET(20)
17245 }
17246
17247 // PEA
17248 OPCODE(0x4878)
17249 {
17250         u32 adr, res;
17251         u32 src, dst;
17252
17253         FETCH_SWORD(adr);
17254         PRE_IO
17255         PUSH_32_F(adr)
17256         POST_IO
17257 RET(16)
17258 }
17259
17260 // PEA
17261 OPCODE(0x4879)
17262 {
17263         u32 adr, res;
17264         u32 src, dst;
17265
17266         FETCH_LONG(adr);
17267         PRE_IO
17268         PUSH_32_F(adr)
17269         POST_IO
17270 RET(20)
17271 }
17272
17273 // PEA
17274 OPCODE(0x487A)
17275 {
17276         u32 adr, res;
17277         u32 src, dst;
17278
17279         adr = GET_SWORD + GET_PC;
17280         PC++;
17281         PRE_IO
17282         PUSH_32_F(adr)
17283         POST_IO
17284 RET(16)
17285 }
17286
17287 // PEA
17288 OPCODE(0x487B)
17289 {
17290         u32 adr, res;
17291         u32 src, dst;
17292
17293         adr = GET_PC;
17294         DECODE_EXT_WORD
17295         PRE_IO
17296         PUSH_32_F(adr)
17297         POST_IO
17298 RET(20)
17299 }
17300
17301 // SWAP
17302 OPCODE(0x4840)
17303 {
17304         u32 adr, res;
17305         u32 src, dst;
17306
17307         res = DREGu32((Opcode >> 0) & 7);
17308         res = (res >> 16) | (res << 16);
17309         flag_C = 0;
17310         flag_V = 0;
17311         flag_NotZ = res;
17312         flag_N = res >> 24;
17313         DREGu32((Opcode >> 0) & 7) = res;
17314 RET(4)
17315 }
17316
17317 // MOVEMRa
17318 OPCODE(0x4890)
17319 {
17320         u32 adr, res;
17321         u32 src, dst;
17322
17323         u32 *psrc;
17324
17325         FETCH_WORD(res);
17326         adr = AREG((Opcode >> 0) & 7);
17327         psrc = &DREGu32(0);
17328         dst = adr;
17329         PRE_IO
17330         do
17331         {
17332                 if (res & 1)
17333                 {
17334                         WRITE_WORD_F(adr, *psrc)
17335                         adr += 2;
17336                 }
17337                 psrc++;
17338         } while (res >>= 1);
17339         POST_IO
17340         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17341 #ifdef USE_CYCLONE_TIMING
17342 RET(8)
17343 #else
17344 RET(12)
17345 #endif
17346 }
17347
17348 // MOVEMRa
17349 OPCODE(0x48A0)
17350 {
17351         u32 adr, res;
17352         u32 src, dst;
17353
17354         u32 *psrc;
17355
17356         FETCH_WORD(res);
17357         adr = AREG((Opcode >> 0) & 7);
17358         psrc = &AREGu32(7);
17359         dst = adr;
17360         PRE_IO
17361         do
17362         {
17363                 if (res & 1)
17364                 {
17365                         adr -= 2;
17366                         WRITE_WORD_F(adr, *psrc)
17367                 }
17368                 psrc--;
17369         } while (res >>= 1);
17370         AREG((Opcode >> 0) & 7) = adr;
17371         POST_IO
17372         m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17373 RET(8)
17374 }
17375
17376 // MOVEMRa
17377 OPCODE(0x48A8)
17378 {
17379         u32 adr, res;
17380         u32 src, dst;
17381
17382         u32 *psrc;
17383
17384         FETCH_WORD(res);
17385         FETCH_SWORD(adr);
17386         adr += AREG((Opcode >> 0) & 7);
17387         psrc = &DREGu32(0);
17388         dst = adr;
17389         PRE_IO
17390         do
17391         {
17392                 if (res & 1)
17393                 {
17394                         WRITE_WORD_F(adr, *psrc)
17395                         adr += 2;
17396                 }
17397                 psrc++;
17398         } while (res >>= 1);
17399         POST_IO
17400         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17401 #ifdef USE_CYCLONE_TIMING
17402 RET(12)
17403 #else
17404 RET(20)
17405 #endif
17406 }
17407
17408 // MOVEMRa
17409 OPCODE(0x48B0)
17410 {
17411         u32 adr, res;
17412         u32 src, dst;
17413
17414         u32 *psrc;
17415
17416         FETCH_WORD(res);
17417         adr = AREG((Opcode >> 0) & 7);
17418         DECODE_EXT_WORD
17419         psrc = &DREGu32(0);
17420         dst = adr;
17421         PRE_IO
17422         do
17423         {
17424                 if (res & 1)
17425                 {
17426                         WRITE_WORD_F(adr, *psrc)
17427                         adr += 2;
17428                 }
17429                 psrc++;
17430         } while (res >>= 1);
17431         POST_IO
17432         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17433 #ifdef USE_CYCLONE_TIMING
17434 RET(14)
17435 #else
17436 RET(24)
17437 #endif
17438 }
17439
17440 // MOVEMRa
17441 OPCODE(0x48B8)
17442 {
17443         u32 adr, res;
17444         u32 src, dst;
17445
17446         u32 *psrc;
17447
17448         FETCH_WORD(res);
17449         FETCH_SWORD(adr);
17450         psrc = &DREGu32(0);
17451         dst = adr;
17452         PRE_IO
17453         do
17454         {
17455                 if (res & 1)
17456                 {
17457                         WRITE_WORD_F(adr, *psrc)
17458                         adr += 2;
17459                 }
17460                 psrc++;
17461         } while (res >>= 1);
17462         POST_IO
17463         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17464 #ifdef USE_CYCLONE_TIMING
17465 RET(12)
17466 #else
17467 RET(20)
17468 #endif
17469 }
17470
17471 // MOVEMRa
17472 OPCODE(0x48B9)
17473 {
17474         u32 adr, res;
17475         u32 src, dst;
17476
17477         u32 *psrc;
17478
17479         FETCH_WORD(res);
17480         FETCH_LONG(adr);
17481         psrc = &DREGu32(0);
17482         dst = adr;
17483         PRE_IO
17484         do
17485         {
17486                 if (res & 1)
17487                 {
17488                         WRITE_WORD_F(adr, *psrc)
17489                         adr += 2;
17490                 }
17491                 psrc++;
17492         } while (res >>= 1);
17493         POST_IO
17494         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17495 #ifdef USE_CYCLONE_TIMING
17496 RET(16)
17497 #else
17498 RET(28)
17499 #endif
17500 }
17501
17502 // MOVEMRa
17503 OPCODE(0x48A7)
17504 {
17505         u32 adr, res;
17506         u32 src, dst;
17507
17508         u32 *psrc;
17509
17510         FETCH_WORD(res);
17511         adr = AREG(7);
17512         psrc = &AREGu32(7);
17513         dst = adr;
17514         PRE_IO
17515         do
17516         {
17517                 if (res & 1)
17518                 {
17519                         adr -= 2;
17520                         WRITE_WORD_F(adr, *psrc)
17521                 }
17522                 psrc--;
17523         } while (res >>= 1);
17524         AREG(7) = adr;
17525         POST_IO
17526         m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17527 RET(8)
17528 }
17529
17530 // MOVEMRa
17531 OPCODE(0x48D0)
17532 {
17533         u32 adr, res;
17534         u32 src, dst;
17535
17536         u32 *psrc;
17537
17538         FETCH_WORD(res);
17539         adr = AREG((Opcode >> 0) & 7);
17540         psrc = &DREGu32(0);
17541         dst = adr;
17542         PRE_IO
17543         do
17544         {
17545                 if (res & 1)
17546                 {
17547                         WRITE_LONG_F(adr, *psrc)
17548                         adr += 4;
17549                 }
17550                 psrc++;
17551         } while (res >>= 1);
17552         POST_IO
17553         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17554 #ifdef USE_CYCLONE_TIMING
17555 RET(8)
17556 #else
17557 RET(16)
17558 #endif
17559 }
17560
17561 // MOVEMRa
17562 OPCODE(0x48E0)
17563 {
17564         u32 adr, res;
17565         u32 src, dst;
17566
17567         u32 *psrc;
17568
17569         FETCH_WORD(res);
17570         adr = AREG((Opcode >> 0) & 7);
17571         psrc = &AREGu32(7);
17572         dst = adr;
17573         PRE_IO
17574         do
17575         {
17576                 if (res & 1)
17577                 {
17578                         adr -= 4;
17579                         WRITE_LONG_DEC_F(adr, *psrc)
17580                 }
17581                 psrc--;
17582         } while (res >>= 1);
17583         AREG((Opcode >> 0) & 7) = adr;
17584         POST_IO
17585         m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17586 RET(8)
17587 }
17588
17589 // MOVEMRa
17590 OPCODE(0x48E8)
17591 {
17592         u32 adr, res;
17593         u32 src, dst;
17594
17595         u32 *psrc;
17596
17597         FETCH_WORD(res);
17598         FETCH_SWORD(adr);
17599         adr += AREG((Opcode >> 0) & 7);
17600         psrc = &DREGu32(0);
17601         dst = adr;
17602         PRE_IO
17603         do
17604         {
17605                 if (res & 1)
17606                 {
17607                         WRITE_LONG_F(adr, *psrc)
17608                         adr += 4;
17609                 }
17610                 psrc++;
17611         } while (res >>= 1);
17612         POST_IO
17613         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17614 #ifdef USE_CYCLONE_TIMING
17615 RET(12)
17616 #else
17617 RET(24)
17618 #endif
17619 }
17620
17621 // MOVEMRa
17622 OPCODE(0x48F0)
17623 {
17624         u32 adr, res;
17625         u32 src, dst;
17626
17627         u32 *psrc;
17628
17629         FETCH_WORD(res);
17630         adr = AREG((Opcode >> 0) & 7);
17631         DECODE_EXT_WORD
17632         psrc = &DREGu32(0);
17633         dst = adr;
17634         PRE_IO
17635         do
17636         {
17637                 if (res & 1)
17638                 {
17639                         WRITE_LONG_F(adr, *psrc)
17640                         adr += 4;
17641                 }
17642                 psrc++;
17643         } while (res >>= 1);
17644         POST_IO
17645         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17646 #ifdef USE_CYCLONE_TIMING
17647 RET(14)
17648 #else
17649 RET(28)
17650 #endif
17651 }
17652
17653 // MOVEMRa
17654 OPCODE(0x48F8)
17655 {
17656         u32 adr, res;
17657         u32 src, dst;
17658
17659         u32 *psrc;
17660
17661         FETCH_WORD(res);
17662         FETCH_SWORD(adr);
17663         psrc = &DREGu32(0);
17664         dst = adr;
17665         PRE_IO
17666         do
17667         {
17668                 if (res & 1)
17669                 {
17670                         WRITE_LONG_F(adr, *psrc)
17671                         adr += 4;
17672                 }
17673                 psrc++;
17674         } while (res >>= 1);
17675         POST_IO
17676         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17677 #ifdef USE_CYCLONE_TIMING
17678 RET(12)
17679 #else
17680 RET(24)
17681 #endif
17682 }
17683
17684 // MOVEMRa
17685 OPCODE(0x48F9)
17686 {
17687         u32 adr, res;
17688         u32 src, dst;
17689
17690         u32 *psrc;
17691
17692         FETCH_WORD(res);
17693         FETCH_LONG(adr);
17694         psrc = &DREGu32(0);
17695         dst = adr;
17696         PRE_IO
17697         do
17698         {
17699                 if (res & 1)
17700                 {
17701                         WRITE_LONG_F(adr, *psrc)
17702                         adr += 4;
17703                 }
17704                 psrc++;
17705         } while (res >>= 1);
17706         POST_IO
17707         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17708 #ifdef USE_CYCLONE_TIMING
17709 RET(16)
17710 #else
17711 RET(32)
17712 #endif
17713 }
17714
17715 // MOVEMRa
17716 OPCODE(0x48E7)
17717 {
17718         u32 adr, res;
17719         u32 src, dst;
17720
17721         u32 *psrc;
17722
17723         FETCH_WORD(res);
17724         adr = AREG(7);
17725         psrc = &AREGu32(7);
17726         dst = adr;
17727         PRE_IO
17728         do
17729         {
17730                 if (res & 1)
17731                 {
17732                         adr -= 4;
17733                         WRITE_LONG_DEC_F(adr, *psrc)
17734                 }
17735                 psrc--;
17736         } while (res >>= 1);
17737         AREG(7) = adr;
17738         POST_IO
17739         m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17740 RET(8)
17741 }
17742
17743 // EXT
17744 OPCODE(0x4880)
17745 {
17746         u32 adr, res;
17747         u32 src, dst;
17748
17749         res = (s32)DREGs8((Opcode >> 0) & 7);
17750         flag_C = 0;
17751         flag_V = 0;
17752         flag_NotZ = res;
17753         flag_N = res;
17754         DREGu16((Opcode >> 0) & 7) = res;
17755 RET(4)
17756 }
17757
17758 // EXT
17759 OPCODE(0x48C0)
17760 {
17761         u32 adr, res;
17762         u32 src, dst;
17763
17764         res = (s32)DREGs16((Opcode >> 0) & 7);
17765         flag_C = 0;
17766         flag_V = 0;
17767         flag_NotZ = res;
17768         flag_N = res >> 8;
17769         DREGu32((Opcode >> 0) & 7) = res;
17770 RET(4)
17771 }
17772
17773 // TST
17774 OPCODE(0x4A00)
17775 {
17776         u32 adr, res;
17777         u32 src, dst;
17778
17779         res = DREGu8((Opcode >> 0) & 7);
17780         flag_C = 0;
17781         flag_V = 0;
17782         flag_NotZ = res;
17783         flag_N = res;
17784 RET(4)
17785 }
17786
17787 // TST
17788 OPCODE(0x4A10)
17789 {
17790         u32 adr, res;
17791         u32 src, dst;
17792
17793         adr = AREG((Opcode >> 0) & 7);
17794         PRE_IO
17795         READ_BYTE_F(adr, res)
17796         flag_C = 0;
17797         flag_V = 0;
17798         flag_NotZ = res;
17799         flag_N = res;
17800         POST_IO
17801 RET(8)
17802 }
17803
17804 // TST
17805 OPCODE(0x4A18)
17806 {
17807         u32 adr, res;
17808         u32 src, dst;
17809
17810         adr = AREG((Opcode >> 0) & 7);
17811         AREG((Opcode >> 0) & 7) += 1;
17812         PRE_IO
17813         READ_BYTE_F(adr, res)
17814         flag_C = 0;
17815         flag_V = 0;
17816         flag_NotZ = res;
17817         flag_N = res;
17818         POST_IO
17819 RET(8)
17820 }
17821
17822 // TST
17823 OPCODE(0x4A20)
17824 {
17825         u32 adr, res;
17826         u32 src, dst;
17827
17828         adr = AREG((Opcode >> 0) & 7) - 1;
17829         AREG((Opcode >> 0) & 7) = adr;
17830         PRE_IO
17831         READ_BYTE_F(adr, res)
17832         flag_C = 0;
17833         flag_V = 0;
17834         flag_NotZ = res;
17835         flag_N = res;
17836         POST_IO
17837 RET(10)
17838 }
17839
17840 // TST
17841 OPCODE(0x4A28)
17842 {
17843         u32 adr, res;
17844         u32 src, dst;
17845
17846         FETCH_SWORD(adr);
17847         adr += AREG((Opcode >> 0) & 7);
17848         PRE_IO
17849         READ_BYTE_F(adr, res)
17850         flag_C = 0;
17851         flag_V = 0;
17852         flag_NotZ = res;
17853         flag_N = res;
17854         POST_IO
17855 RET(12)
17856 }
17857
17858 // TST
17859 OPCODE(0x4A30)
17860 {
17861         u32 adr, res;
17862         u32 src, dst;
17863
17864         adr = AREG((Opcode >> 0) & 7);
17865         DECODE_EXT_WORD
17866         PRE_IO
17867         READ_BYTE_F(adr, res)
17868         flag_C = 0;
17869         flag_V = 0;
17870         flag_NotZ = res;
17871         flag_N = res;
17872         POST_IO
17873 RET(14)
17874 }
17875
17876 // TST
17877 OPCODE(0x4A38)
17878 {
17879         u32 adr, res;
17880         u32 src, dst;
17881
17882         FETCH_SWORD(adr);
17883         PRE_IO
17884         READ_BYTE_F(adr, res)
17885         flag_C = 0;
17886         flag_V = 0;
17887         flag_NotZ = res;
17888         flag_N = res;
17889         POST_IO
17890 RET(12)
17891 }
17892
17893 // TST
17894 OPCODE(0x4A39)
17895 {
17896         u32 adr, res;
17897         u32 src, dst;
17898
17899         FETCH_LONG(adr);
17900         PRE_IO
17901         READ_BYTE_F(adr, res)
17902         flag_C = 0;
17903         flag_V = 0;
17904         flag_NotZ = res;
17905         flag_N = res;
17906         POST_IO
17907 RET(16)
17908 }
17909
17910 // TST
17911 OPCODE(0x4A1F)
17912 {
17913         u32 adr, res;
17914         u32 src, dst;
17915
17916         adr = AREG(7);
17917         AREG(7) += 2;
17918         PRE_IO
17919         READ_BYTE_F(adr, res)
17920         flag_C = 0;
17921         flag_V = 0;
17922         flag_NotZ = res;
17923         flag_N = res;
17924         POST_IO
17925 RET(8)
17926 }
17927
17928 // TST
17929 OPCODE(0x4A27)
17930 {
17931         u32 adr, res;
17932         u32 src, dst;
17933
17934         adr = AREG(7) - 2;
17935         AREG(7) = adr;
17936         PRE_IO
17937         READ_BYTE_F(adr, res)
17938         flag_C = 0;
17939         flag_V = 0;
17940         flag_NotZ = res;
17941         flag_N = res;
17942         POST_IO
17943 RET(10)
17944 }
17945
17946 // TST
17947 OPCODE(0x4A40)
17948 {
17949         u32 adr, res;
17950         u32 src, dst;
17951
17952         res = DREGu16((Opcode >> 0) & 7);
17953         flag_C = 0;
17954         flag_V = 0;
17955         flag_NotZ = res;
17956         flag_N = res >> 8;
17957 RET(4)
17958 }
17959
17960 // TST
17961 OPCODE(0x4A50)
17962 {
17963         u32 adr, res;
17964         u32 src, dst;
17965
17966         adr = AREG((Opcode >> 0) & 7);
17967         PRE_IO
17968         READ_WORD_F(adr, res)
17969         flag_C = 0;
17970         flag_V = 0;
17971         flag_NotZ = res;
17972         flag_N = res >> 8;
17973         POST_IO
17974 RET(8)
17975 }
17976
17977 // TST
17978 OPCODE(0x4A58)
17979 {
17980         u32 adr, res;
17981         u32 src, dst;
17982
17983         adr = AREG((Opcode >> 0) & 7);
17984         AREG((Opcode >> 0) & 7) += 2;
17985         PRE_IO
17986         READ_WORD_F(adr, res)
17987         flag_C = 0;
17988         flag_V = 0;
17989         flag_NotZ = res;
17990         flag_N = res >> 8;
17991         POST_IO
17992 RET(8)
17993 }
17994
17995 // TST
17996 OPCODE(0x4A60)
17997 {
17998         u32 adr, res;
17999         u32 src, dst;
18000
18001         adr = AREG((Opcode >> 0) & 7) - 2;
18002         AREG((Opcode >> 0) & 7) = adr;
18003         PRE_IO
18004         READ_WORD_F(adr, res)
18005         flag_C = 0;
18006         flag_V = 0;
18007         flag_NotZ = res;
18008         flag_N = res >> 8;
18009         POST_IO
18010 RET(10)
18011 }
18012
18013 // TST
18014 OPCODE(0x4A68)
18015 {
18016         u32 adr, res;
18017         u32 src, dst;
18018
18019         FETCH_SWORD(adr);
18020         adr += AREG((Opcode >> 0) & 7);
18021         PRE_IO
18022         READ_WORD_F(adr, res)
18023         flag_C = 0;
18024         flag_V = 0;
18025         flag_NotZ = res;
18026         flag_N = res >> 8;
18027         POST_IO
18028 RET(12)
18029 }
18030
18031 // TST
18032 OPCODE(0x4A70)
18033 {
18034         u32 adr, res;
18035         u32 src, dst;
18036
18037         adr = AREG((Opcode >> 0) & 7);
18038         DECODE_EXT_WORD
18039         PRE_IO
18040         READ_WORD_F(adr, res)
18041         flag_C = 0;
18042         flag_V = 0;
18043         flag_NotZ = res;
18044         flag_N = res >> 8;
18045         POST_IO
18046 RET(14)
18047 }
18048
18049 // TST
18050 OPCODE(0x4A78)
18051 {
18052         u32 adr, res;
18053         u32 src, dst;
18054
18055         FETCH_SWORD(adr);
18056         PRE_IO
18057         READ_WORD_F(adr, res)
18058         flag_C = 0;
18059         flag_V = 0;
18060         flag_NotZ = res;
18061         flag_N = res >> 8;
18062         POST_IO
18063 RET(12)
18064 }
18065
18066 // TST
18067 OPCODE(0x4A79)
18068 {
18069         u32 adr, res;
18070         u32 src, dst;
18071
18072         FETCH_LONG(adr);
18073         PRE_IO
18074         READ_WORD_F(adr, res)
18075         flag_C = 0;
18076         flag_V = 0;
18077         flag_NotZ = res;
18078         flag_N = res >> 8;
18079         POST_IO
18080 RET(16)
18081 }
18082
18083 // TST
18084 OPCODE(0x4A5F)
18085 {
18086         u32 adr, res;
18087         u32 src, dst;
18088
18089         adr = AREG(7);
18090         AREG(7) += 2;
18091         PRE_IO
18092         READ_WORD_F(adr, res)
18093         flag_C = 0;
18094         flag_V = 0;
18095         flag_NotZ = res;
18096         flag_N = res >> 8;
18097         POST_IO
18098 RET(8)
18099 }
18100
18101 // TST
18102 OPCODE(0x4A67)
18103 {
18104         u32 adr, res;
18105         u32 src, dst;
18106
18107         adr = AREG(7) - 2;
18108         AREG(7) = adr;
18109         PRE_IO
18110         READ_WORD_F(adr, res)
18111         flag_C = 0;
18112         flag_V = 0;
18113         flag_NotZ = res;
18114         flag_N = res >> 8;
18115         POST_IO
18116 RET(10)
18117 }
18118
18119 // TST
18120 OPCODE(0x4A80)
18121 {
18122         u32 adr, res;
18123         u32 src, dst;
18124
18125         res = DREGu32((Opcode >> 0) & 7);
18126         flag_C = 0;
18127         flag_V = 0;
18128         flag_NotZ = res;
18129         flag_N = res >> 24;
18130 RET(4)
18131 }
18132
18133 // TST
18134 OPCODE(0x4A90)
18135 {
18136         u32 adr, res;
18137         u32 src, dst;
18138
18139         adr = AREG((Opcode >> 0) & 7);
18140         PRE_IO
18141         READ_LONG_F(adr, res)
18142         flag_C = 0;
18143         flag_V = 0;
18144         flag_NotZ = res;
18145         flag_N = res >> 24;
18146         POST_IO
18147 RET(12)
18148 }
18149
18150 // TST
18151 OPCODE(0x4A98)
18152 {
18153         u32 adr, res;
18154         u32 src, dst;
18155
18156         adr = AREG((Opcode >> 0) & 7);
18157         AREG((Opcode >> 0) & 7) += 4;
18158         PRE_IO
18159         READ_LONG_F(adr, res)
18160         flag_C = 0;
18161         flag_V = 0;
18162         flag_NotZ = res;
18163         flag_N = res >> 24;
18164         POST_IO
18165 RET(12)
18166 }
18167
18168 // TST
18169 OPCODE(0x4AA0)
18170 {
18171         u32 adr, res;
18172         u32 src, dst;
18173
18174         adr = AREG((Opcode >> 0) & 7) - 4;
18175         AREG((Opcode >> 0) & 7) = adr;
18176         PRE_IO
18177         READ_LONG_F(adr, res)
18178         flag_C = 0;
18179         flag_V = 0;
18180         flag_NotZ = res;
18181         flag_N = res >> 24;
18182         POST_IO
18183 RET(14)
18184 }
18185
18186 // TST
18187 OPCODE(0x4AA8)
18188 {
18189         u32 adr, res;
18190         u32 src, dst;
18191
18192         FETCH_SWORD(adr);
18193         adr += AREG((Opcode >> 0) & 7);
18194         PRE_IO
18195         READ_LONG_F(adr, res)
18196         flag_C = 0;
18197         flag_V = 0;
18198         flag_NotZ = res;
18199         flag_N = res >> 24;
18200         POST_IO
18201 RET(16)
18202 }
18203
18204 // TST
18205 OPCODE(0x4AB0)
18206 {
18207         u32 adr, res;
18208         u32 src, dst;
18209
18210         adr = AREG((Opcode >> 0) & 7);
18211         DECODE_EXT_WORD
18212         PRE_IO
18213         READ_LONG_F(adr, res)
18214         flag_C = 0;
18215         flag_V = 0;
18216         flag_NotZ = res;
18217         flag_N = res >> 24;
18218         POST_IO
18219 RET(18)
18220 }
18221
18222 // TST
18223 OPCODE(0x4AB8)
18224 {
18225         u32 adr, res;
18226         u32 src, dst;
18227
18228         FETCH_SWORD(adr);
18229         PRE_IO
18230         READ_LONG_F(adr, res)
18231         flag_C = 0;
18232         flag_V = 0;
18233         flag_NotZ = res;
18234         flag_N = res >> 24;
18235         POST_IO
18236 RET(16)
18237 }
18238
18239 // TST
18240 OPCODE(0x4AB9)
18241 {
18242         u32 adr, res;
18243         u32 src, dst;
18244
18245         FETCH_LONG(adr);
18246         PRE_IO
18247         READ_LONG_F(adr, res)
18248         flag_C = 0;
18249         flag_V = 0;
18250         flag_NotZ = res;
18251         flag_N = res >> 24;
18252         POST_IO
18253 RET(20)
18254 }
18255
18256 // TST
18257 OPCODE(0x4A9F)
18258 {
18259         u32 adr, res;
18260         u32 src, dst;
18261
18262         adr = AREG(7);
18263         AREG(7) += 4;
18264         PRE_IO
18265         READ_LONG_F(adr, res)
18266         flag_C = 0;
18267         flag_V = 0;
18268         flag_NotZ = res;
18269         flag_N = res >> 24;
18270         POST_IO
18271 RET(12)
18272 }
18273
18274 // TST
18275 OPCODE(0x4AA7)
18276 {
18277         u32 adr, res;
18278         u32 src, dst;
18279
18280         adr = AREG(7) - 4;
18281         AREG(7) = adr;
18282         PRE_IO
18283         READ_LONG_F(adr, res)
18284         flag_C = 0;
18285         flag_V = 0;
18286         flag_NotZ = res;
18287         flag_N = res >> 24;
18288         POST_IO
18289 RET(14)
18290 }
18291
18292 // TAS
18293 OPCODE(0x4AC0)
18294 {
18295         u32 adr, res;
18296         u32 src, dst;
18297
18298         res = DREGu8((Opcode >> 0) & 7);
18299         flag_C = 0;
18300         flag_V = 0;
18301         flag_NotZ = res;
18302         flag_N = res;
18303         res |= 0x80;
18304         DREGu8((Opcode >> 0) & 7) = res;
18305 RET(4)
18306 }
18307
18308 // TAS
18309 OPCODE(0x4AD0)
18310 {
18311         u32 adr, res;
18312         u32 src, dst;
18313
18314         adr = AREG((Opcode >> 0) & 7);
18315         PRE_IO
18316         READ_BYTE_F(adr, res)
18317         flag_C = 0;
18318         flag_V = 0;
18319         flag_NotZ = res;
18320         flag_N = res;
18321 #ifdef PICODRIVE_HACK
18322         if (g_m68kcontext == &PicoCpuFS68k) {
18323                 res |= 0x80;
18324                 WRITE_BYTE_F(adr, res);
18325         }
18326 #endif
18327
18328         POST_IO
18329 #ifdef USE_CYCLONE_TIMING
18330 RET(18)
18331 #else
18332 RET(8)
18333 #endif
18334 }
18335
18336 // TAS
18337 OPCODE(0x4AD8)
18338 {
18339         u32 adr, res;
18340         u32 src, dst;
18341
18342         adr = AREG((Opcode >> 0) & 7);
18343         AREG((Opcode >> 0) & 7) += 1;
18344         PRE_IO
18345         READ_BYTE_F(adr, res)
18346         flag_C = 0;
18347         flag_V = 0;
18348         flag_NotZ = res;
18349         flag_N = res;
18350
18351 #ifdef PICODRIVE_HACK
18352         if (g_m68kcontext == &PicoCpuFS68k) {
18353                 res |= 0x80;
18354                 WRITE_BYTE_F(adr, res);
18355         }
18356 #endif
18357
18358         POST_IO
18359 #ifdef USE_CYCLONE_TIMING
18360 RET(18)
18361 #else
18362 RET(8)
18363 #endif
18364 }
18365
18366 // TAS
18367 OPCODE(0x4AE0)
18368 {
18369         u32 adr, res;
18370         u32 src, dst;
18371
18372         adr = AREG((Opcode >> 0) & 7) - 1;
18373         AREG((Opcode >> 0) & 7) = adr;
18374         PRE_IO
18375         READ_BYTE_F(adr, res)
18376         flag_C = 0;
18377         flag_V = 0;
18378         flag_NotZ = res;
18379         flag_N = res;
18380
18381 #ifdef PICODRIVE_HACK
18382         if (g_m68kcontext == &PicoCpuFS68k) {
18383                 res |= 0x80;
18384                 WRITE_BYTE_F(adr, res);
18385         }
18386 #endif
18387
18388         POST_IO
18389 #ifdef USE_CYCLONE_TIMING
18390 RET(20)
18391 #else
18392 RET(10)
18393 #endif
18394 }
18395
18396 // TAS
18397 OPCODE(0x4AE8)
18398 {
18399         u32 adr, res;
18400         u32 src, dst;
18401
18402         FETCH_SWORD(adr);
18403         adr += AREG((Opcode >> 0) & 7);
18404         PRE_IO
18405         READ_BYTE_F(adr, res)
18406         flag_C = 0;
18407         flag_V = 0;
18408         flag_NotZ = res;
18409         flag_N = res;
18410
18411 #ifdef PICODRIVE_HACK
18412         if (g_m68kcontext == &PicoCpuFS68k) {
18413                 res |= 0x80;
18414                 WRITE_BYTE_F(adr, res);
18415         }
18416 #endif
18417
18418         POST_IO
18419 #ifdef USE_CYCLONE_TIMING
18420 RET(22)
18421 #else
18422 RET(12)
18423 #endif
18424 }
18425
18426 // TAS
18427 OPCODE(0x4AF0)
18428 {
18429         u32 adr, res;
18430         u32 src, dst;
18431
18432         adr = AREG((Opcode >> 0) & 7);
18433         DECODE_EXT_WORD
18434         PRE_IO
18435         READ_BYTE_F(adr, res)
18436         flag_C = 0;
18437         flag_V = 0;
18438         flag_NotZ = res;
18439         flag_N = res;
18440
18441 #ifdef PICODRIVE_HACK
18442         if (g_m68kcontext == &PicoCpuFS68k) {
18443                 res |= 0x80;
18444                 WRITE_BYTE_F(adr, res);
18445         }
18446 #endif
18447
18448         POST_IO
18449 #ifdef USE_CYCLONE_TIMING
18450 RET(24)
18451 #else
18452 RET(14)
18453 #endif
18454 }
18455
18456 // TAS
18457 OPCODE(0x4AF8)
18458 {
18459         u32 adr, res;
18460         u32 src, dst;
18461
18462         FETCH_SWORD(adr);
18463         PRE_IO
18464         READ_BYTE_F(adr, res)
18465         flag_C = 0;
18466         flag_V = 0;
18467         flag_NotZ = res;
18468         flag_N = res;
18469
18470 #ifdef PICODRIVE_HACK
18471         if (g_m68kcontext == &PicoCpuFS68k) {
18472                 res |= 0x80;
18473                 WRITE_BYTE_F(adr, res);
18474         }
18475 #endif
18476
18477         POST_IO
18478 #ifdef USE_CYCLONE_TIMING
18479 RET(22)
18480 #else
18481 RET(12)
18482 #endif
18483 }
18484
18485 // TAS
18486 OPCODE(0x4AF9)
18487 {
18488         u32 adr, res;
18489         u32 src, dst;
18490
18491         FETCH_LONG(adr);
18492         PRE_IO
18493         READ_BYTE_F(adr, res)
18494         flag_C = 0;
18495         flag_V = 0;
18496         flag_NotZ = res;
18497         flag_N = res;
18498
18499 #ifdef PICODRIVE_HACK
18500         if (g_m68kcontext == &PicoCpuFS68k) {
18501                 res |= 0x80;
18502                 WRITE_BYTE_F(adr, res);
18503         }
18504 #endif
18505
18506         POST_IO
18507 #ifdef USE_CYCLONE_TIMING
18508 RET(26)
18509 #else
18510 RET(16)
18511 #endif
18512 }
18513
18514 // TAS
18515 OPCODE(0x4ADF)
18516 {
18517         u32 adr, res;
18518         u32 src, dst;
18519
18520         adr = AREG(7);
18521         AREG(7) += 2;
18522         PRE_IO
18523         READ_BYTE_F(adr, res)
18524         flag_C = 0;
18525         flag_V = 0;
18526         flag_NotZ = res;
18527         flag_N = res;
18528
18529 #ifdef PICODRIVE_HACK
18530         if (g_m68kcontext == &PicoCpuFS68k) {
18531                 res |= 0x80;
18532                 WRITE_BYTE_F(adr, res);
18533         }
18534 #endif
18535
18536         POST_IO
18537 #ifdef USE_CYCLONE_TIMING
18538 RET(18)
18539 #else
18540 RET(8)
18541 #endif
18542 }
18543
18544 // TAS
18545 OPCODE(0x4AE7)
18546 {
18547         u32 adr, res;
18548         u32 src, dst;
18549
18550         adr = AREG(7) - 2;
18551         AREG(7) = adr;
18552         PRE_IO
18553         READ_BYTE_F(adr, res)
18554         flag_C = 0;
18555         flag_V = 0;
18556         flag_NotZ = res;
18557         flag_N = res;
18558
18559 #ifdef PICODRIVE_HACK
18560         if (g_m68kcontext == &PicoCpuFS68k) {
18561                 res |= 0x80;
18562                 WRITE_BYTE_F(adr, res);
18563         }
18564 #endif
18565
18566         POST_IO
18567 #ifdef USE_CYCLONE_TIMING
18568 RET(20)
18569 #else
18570 RET(8)
18571 #endif
18572 }
18573
18574 // ILLEGAL
18575 OPCODE(0x4AFC)
18576 {
18577         SET_PC(execute_exception(M68K_ILLEGAL_INSTRUCTION_EX, GET_PC-2, GET_SR));
18578 RET(0)
18579 }
18580
18581 // ILLEGAL A000-AFFF
18582 OPCODE(0xA000)
18583 {
18584         SET_PC(execute_exception(M68K_1010_EX, GET_PC-2, GET_SR));
18585 RET(0)
18586 }
18587
18588 // ILLEGAL F000-FFFF
18589 OPCODE(0xF000)
18590 {
18591         SET_PC(execute_exception(M68K_1111_EX, GET_PC-2, GET_SR));
18592 RET(0) // 4 already taken by exc. handler
18593 }
18594
18595 // MOVEMaR
18596 OPCODE(0x4C90)
18597 {
18598         u32 adr, res;
18599         u32 src, dst;
18600
18601         s32 *psrc;
18602
18603         FETCH_WORD(res);
18604         adr = AREG((Opcode >> 0) & 7);
18605         psrc = &DREGs32(0);
18606         dst = adr;
18607         PRE_IO
18608         do
18609         {
18610                 if (res & 1)
18611                 {
18612                         READSX_WORD_F(adr, *psrc)
18613                         adr += 2;
18614                 }
18615                 psrc++;
18616         } while (res >>= 1);
18617         POST_IO
18618         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18619 #ifdef USE_CYCLONE_TIMING
18620 RET(12)
18621 #else
18622 RET(16)
18623 #endif
18624 }
18625
18626 // MOVEMaR
18627 OPCODE(0x4C98)
18628 {
18629         u32 adr, res;
18630         u32 src, dst;
18631
18632         s32 *psrc;
18633
18634         FETCH_WORD(res);
18635         adr = AREG((Opcode >> 0) & 7);
18636         psrc = &DREGs32(0);
18637         dst = adr;
18638         PRE_IO
18639         do
18640         {
18641                 if (res & 1)
18642                 {
18643                         READSX_WORD_F(adr, *psrc)
18644                         adr += 2;
18645                 }
18646                 psrc++;
18647         } while (res >>= 1);
18648         AREG((Opcode >> 0) & 7) = adr;
18649         POST_IO
18650         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18651 RET(12)
18652 }
18653
18654 // MOVEMaR
18655 OPCODE(0x4CA8)
18656 {
18657         u32 adr, res;
18658         u32 src, dst;
18659
18660         s32 *psrc;
18661
18662         FETCH_WORD(res);
18663         FETCH_SWORD(adr);
18664         adr += AREG((Opcode >> 0) & 7);
18665         psrc = &DREGs32(0);
18666         dst = adr;
18667         PRE_IO
18668         do
18669         {
18670                 if (res & 1)
18671                 {
18672                         READSX_WORD_F(adr, *psrc)
18673                         adr += 2;
18674                 }
18675                 psrc++;
18676         } while (res >>= 1);
18677         POST_IO
18678         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18679 #ifdef USE_CYCLONE_TIMING
18680 RET(16)
18681 #else
18682 RET(24)
18683 #endif
18684 }
18685
18686 // MOVEMaR
18687 OPCODE(0x4CB0)
18688 {
18689         u32 adr, res;
18690         u32 src, dst;
18691
18692         s32 *psrc;
18693
18694         FETCH_WORD(res);
18695         adr = AREG((Opcode >> 0) & 7);
18696         DECODE_EXT_WORD
18697         psrc = &DREGs32(0);
18698         dst = adr;
18699         PRE_IO
18700         do
18701         {
18702                 if (res & 1)
18703                 {
18704                         READSX_WORD_F(adr, *psrc)
18705                         adr += 2;
18706                 }
18707                 psrc++;
18708         } while (res >>= 1);
18709         POST_IO
18710         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18711 #ifdef USE_CYCLONE_TIMING
18712 RET(18)
18713 #else
18714 RET(28)
18715 #endif
18716 }
18717
18718 // MOVEMaR
18719 OPCODE(0x4CB8)
18720 {
18721         u32 adr, res;
18722         u32 src, dst;
18723
18724         s32 *psrc;
18725
18726         FETCH_WORD(res);
18727         FETCH_SWORD(adr);
18728         psrc = &DREGs32(0);
18729         dst = adr;
18730         PRE_IO
18731         do
18732         {
18733                 if (res & 1)
18734                 {
18735                         READSX_WORD_F(adr, *psrc)
18736                         adr += 2;
18737                 }
18738                 psrc++;
18739         } while (res >>= 1);
18740         POST_IO
18741         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18742 #ifdef USE_CYCLONE_TIMING
18743 RET(16)
18744 #else
18745 RET(24)
18746 #endif
18747 }
18748
18749 // MOVEMaR
18750 OPCODE(0x4CB9)
18751 {
18752         u32 adr, res;
18753         u32 src, dst;
18754
18755         s32 *psrc;
18756
18757         FETCH_WORD(res);
18758         FETCH_LONG(adr);
18759         psrc = &DREGs32(0);
18760         dst = adr;
18761         PRE_IO
18762         do
18763         {
18764                 if (res & 1)
18765                 {
18766                         READSX_WORD_F(adr, *psrc)
18767                         adr += 2;
18768                 }
18769                 psrc++;
18770         } while (res >>= 1);
18771         POST_IO
18772         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18773 #ifdef USE_CYCLONE_TIMING
18774 RET(20)
18775 #else
18776 RET(32)
18777 #endif
18778 }
18779
18780 // MOVEMaR
18781 OPCODE(0x4CBA)
18782 {
18783         u32 adr, res;
18784         u32 src, dst;
18785
18786         s32 *psrc;
18787
18788         FETCH_WORD(res);
18789         adr = GET_SWORD + GET_PC;
18790         PC++;
18791         psrc = &DREGs32(0);
18792         dst = adr;
18793         PRE_IO
18794         do
18795         {
18796                 if (res & 1)
18797                 {
18798                         READSX_WORD_F(adr, *psrc)
18799                         adr += 2;
18800                 }
18801                 psrc++;
18802         } while (res >>= 1);
18803         POST_IO
18804         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18805 #ifdef USE_CYCLONE_TIMING
18806 RET(16)
18807 #else
18808 RET(24)
18809 #endif
18810 }
18811
18812 // MOVEMaR
18813 OPCODE(0x4CBB)
18814 {
18815         u32 adr, res;
18816         u32 src, dst;
18817
18818         s32 *psrc;
18819
18820         FETCH_WORD(res);
18821         adr = GET_PC;
18822         DECODE_EXT_WORD
18823         psrc = &DREGs32(0);
18824         dst = adr;
18825         PRE_IO
18826         do
18827         {
18828                 if (res & 1)
18829                 {
18830                         READSX_WORD_F(adr, *psrc)
18831                         adr += 2;
18832                 }
18833                 psrc++;
18834         } while (res >>= 1);
18835         POST_IO
18836         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18837 #ifdef USE_CYCLONE_TIMING
18838 RET(18)
18839 #else
18840 RET(28)
18841 #endif
18842 }
18843
18844 // MOVEMaR
18845 OPCODE(0x4C9F)
18846 {
18847         u32 adr, res;
18848         u32 src, dst;
18849
18850         s32 *psrc;
18851
18852         FETCH_WORD(res);
18853         adr = AREG(7);
18854         psrc = &DREGs32(0);
18855         dst = adr;
18856         PRE_IO
18857         do
18858         {
18859                 if (res & 1)
18860                 {
18861                         READSX_WORD_F(adr, *psrc)
18862                         adr += 2;
18863                 }
18864                 psrc++;
18865         } while (res >>= 1);
18866         AREG(7) = adr;
18867         POST_IO
18868         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18869 RET(12)
18870 }
18871
18872 // MOVEMaR
18873 OPCODE(0x4CD0)
18874 {
18875         u32 adr, res;
18876         u32 src, dst;
18877
18878         u32 *psrc;
18879
18880         FETCH_WORD(res);
18881         adr = AREG((Opcode >> 0) & 7);
18882         psrc = &DREGu32(0);
18883         dst = adr;
18884         PRE_IO
18885         do
18886         {
18887                 if (res & 1)
18888                 {
18889                         READ_LONG_F(adr, *psrc)
18890                         adr += 4;
18891                 }
18892                 psrc++;
18893         } while (res >>= 1);
18894         POST_IO
18895         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18896 #ifdef USE_CYCLONE_TIMING
18897 RET(12)
18898 #else
18899 RET(20)
18900 #endif
18901 }
18902
18903 // MOVEMaR
18904 OPCODE(0x4CD8)
18905 {
18906         u32 adr, res;
18907         u32 src, dst;
18908
18909         u32 *psrc;
18910
18911         FETCH_WORD(res);
18912         adr = AREG((Opcode >> 0) & 7);
18913         psrc = &DREGu32(0);
18914         dst = adr;
18915         PRE_IO
18916         do
18917         {
18918                 if (res & 1)
18919                 {
18920                         READ_LONG_F(adr, *psrc)
18921                         adr += 4;
18922                 }
18923                 psrc++;
18924         } while (res >>= 1);
18925         AREG((Opcode >> 0) & 7) = adr;
18926         POST_IO
18927         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18928 RET(12)
18929 }
18930
18931 // MOVEMaR
18932 OPCODE(0x4CE8)
18933 {
18934         u32 adr, res;
18935         u32 src, dst;
18936
18937         u32 *psrc;
18938
18939         FETCH_WORD(res);
18940         FETCH_SWORD(adr);
18941         adr += AREG((Opcode >> 0) & 7);
18942         psrc = &DREGu32(0);
18943         dst = adr;
18944         PRE_IO
18945         do
18946         {
18947                 if (res & 1)
18948                 {
18949                         READ_LONG_F(adr, *psrc)
18950                         adr += 4;
18951                 }
18952                 psrc++;
18953         } while (res >>= 1);
18954         POST_IO
18955         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18956 #ifdef USE_CYCLONE_TIMING
18957 RET(16)
18958 #else
18959 RET(28)
18960 #endif
18961 }
18962
18963 // MOVEMaR
18964 OPCODE(0x4CF0)
18965 {
18966         u32 adr, res;
18967         u32 src, dst;
18968
18969         u32 *psrc;
18970
18971         FETCH_WORD(res);
18972         adr = AREG((Opcode >> 0) & 7);
18973         DECODE_EXT_WORD
18974         psrc = &DREGu32(0);
18975         dst = adr;
18976         PRE_IO
18977         do
18978         {
18979                 if (res & 1)
18980                 {
18981                         READ_LONG_F(adr, *psrc)
18982                         adr += 4;
18983                 }
18984                 psrc++;
18985         } while (res >>= 1);
18986         POST_IO
18987         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18988 #ifdef USE_CYCLONE_TIMING
18989 RET(18)
18990 #else
18991 RET(32)
18992 #endif
18993 }
18994
18995 // MOVEMaR
18996 OPCODE(0x4CF8)
18997 {
18998         u32 adr, res;
18999         u32 src, dst;
19000
19001         u32 *psrc;
19002
19003         FETCH_WORD(res);
19004         FETCH_SWORD(adr);
19005         psrc = &DREGu32(0);
19006         dst = adr;
19007         PRE_IO
19008         do
19009         {
19010                 if (res & 1)
19011                 {
19012                         READ_LONG_F(adr, *psrc)
19013                         adr += 4;
19014                 }
19015                 psrc++;
19016         } while (res >>= 1);
19017         POST_IO
19018         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19019 #ifdef USE_CYCLONE_TIMING
19020 RET(16)
19021 #else
19022 RET(28)
19023 #endif
19024 }
19025
19026 // MOVEMaR
19027 OPCODE(0x4CF9)
19028 {
19029         u32 adr, res;
19030         u32 src, dst;
19031
19032         u32 *psrc;
19033
19034         FETCH_WORD(res);
19035         FETCH_LONG(adr);
19036         psrc = &DREGu32(0);
19037         dst = adr;
19038         PRE_IO
19039         do
19040         {
19041                 if (res & 1)
19042                 {
19043                         READ_LONG_F(adr, *psrc)
19044                         adr += 4;
19045                 }
19046                 psrc++;
19047         } while (res >>= 1);
19048         POST_IO
19049         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19050 #ifdef USE_CYCLONE_TIMING
19051 RET(20)
19052 #else
19053 RET(36)
19054 #endif
19055 }
19056
19057 // MOVEMaR
19058 OPCODE(0x4CFA)
19059 {
19060         u32 adr, res;
19061         u32 src, dst;
19062
19063         u32 *psrc;
19064
19065         FETCH_WORD(res);
19066         adr = GET_SWORD + GET_PC;
19067         PC++;
19068         psrc = &DREGu32(0);
19069         dst = adr;
19070         PRE_IO
19071         do
19072         {
19073                 if (res & 1)
19074                 {
19075                         READ_LONG_F(adr, *psrc)
19076                         adr += 4;
19077                 }
19078                 psrc++;
19079         } while (res >>= 1);
19080         POST_IO
19081         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19082 #ifdef USE_CYCLONE_TIMING
19083 RET(16)
19084 #else
19085 RET(28)
19086 #endif
19087 }
19088
19089 // MOVEMaR
19090 OPCODE(0x4CFB)
19091 {
19092         u32 adr, res;
19093         u32 src, dst;
19094
19095         u32 *psrc;
19096
19097         FETCH_WORD(res);
19098         adr = GET_PC;
19099         DECODE_EXT_WORD
19100         psrc = &DREGu32(0);
19101         dst = adr;
19102         PRE_IO
19103         do
19104         {
19105                 if (res & 1)
19106                 {
19107                         READ_LONG_F(adr, *psrc)
19108                         adr += 4;
19109                 }
19110                 psrc++;
19111         } while (res >>= 1);
19112         POST_IO
19113         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19114 #ifdef USE_CYCLONE_TIMING
19115 RET(18)
19116 #else
19117 RET(32)
19118 #endif
19119 }
19120
19121 // MOVEMaR
19122 OPCODE(0x4CDF)
19123 {
19124         u32 adr, res;
19125         u32 src, dst;
19126
19127         u32 *psrc;
19128
19129         FETCH_WORD(res);
19130         adr = AREG(7);
19131         psrc = &DREGu32(0);
19132         dst = adr;
19133         PRE_IO
19134         do
19135         {
19136                 if (res & 1)
19137                 {
19138                         READ_LONG_F(adr, *psrc)
19139                         adr += 4;
19140                 }
19141                 psrc++;
19142         } while (res >>= 1);
19143         AREG(7) = adr;
19144         POST_IO
19145         m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19146 RET(12)
19147 }
19148
19149 // TRAP
19150 OPCODE(0x4E40)
19151 {
19152         SET_PC(execute_exception(M68K_TRAP_BASE_EX + (Opcode & 0xF), GET_PC, GET_SR));
19153 RET(4)
19154 }
19155
19156 // LINK
19157 OPCODE(0x4E50)
19158 {
19159         u32 adr, res;
19160         u32 src, dst;
19161
19162         res = AREGu32((Opcode >> 0) & 7);
19163         PRE_IO
19164         PUSH_32_F(res)
19165         res = AREG(7);
19166         AREG((Opcode >> 0) & 7) = res;
19167         FETCH_SWORD(res);
19168         AREG(7) += res;
19169         POST_IO
19170 RET(16)
19171 }
19172
19173 // LINKA7
19174 OPCODE(0x4E57)
19175 {
19176         u32 adr, res;
19177         u32 src, dst;
19178
19179         AREG(7) -= 4;
19180         PRE_IO
19181         WRITE_LONG_DEC_F(AREG(7), AREG(7))
19182         FETCH_SWORD(res);
19183         AREG(7) += res;
19184         POST_IO
19185 RET(16)
19186 }
19187
19188 // ULNK
19189 OPCODE(0x4E58)
19190 {
19191         u32 adr, res;
19192         u32 src, dst;
19193
19194         src = AREGu32((Opcode >> 0) & 7);
19195         AREG(7) = src + 4;
19196         PRE_IO
19197         READ_LONG_F(src, res)
19198         AREG((Opcode >> 0) & 7) = res;
19199         POST_IO
19200 RET(12)
19201 }
19202
19203 // ULNKA7
19204 OPCODE(0x4E5F)
19205 {
19206         u32 adr, res;
19207         u32 src, dst;
19208
19209         PRE_IO
19210         READ_LONG_F(AREG(7), AREG(7))
19211         POST_IO
19212 RET(12)
19213 }
19214
19215 // MOVEAUSP
19216 OPCODE(0x4E60)
19217 {
19218         u32 adr, res;
19219         u32 src, dst;
19220
19221         if (!flag_S)
19222         {
19223                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19224                 RET(4)
19225         }
19226         res = AREGu32((Opcode >> 0) & 7);
19227         ASP = res;
19228 RET(4)
19229 }
19230
19231 // MOVEUSPA
19232 OPCODE(0x4E68)
19233 {
19234         u32 adr, res;
19235         u32 src, dst;
19236
19237         if (!flag_S)
19238         {
19239                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19240                 RET(4)
19241         }
19242         res = ASP;
19243         AREG((Opcode >> 0) & 7) = res;
19244 RET(4)
19245 }
19246
19247 // RESET
19248 OPCODE(0x4E70)
19249 {
19250         u32 adr, res;
19251         u32 src, dst;
19252
19253         if (!flag_S)
19254         {
19255                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19256                 RET(4)
19257         }
19258         PRE_IO
19259         if (m68kcontext.reset_handler) m68kcontext.reset_handler();
19260 //      CPU->Reset_CallBack();
19261         POST_IO
19262 RET(132)
19263 }
19264
19265 // NOP
19266 OPCODE(0x4E71)
19267 {
19268 RET(4)
19269 }
19270
19271 // STOP
19272 OPCODE(0x4E72)
19273 {
19274         u32 adr, res;
19275         u32 src, dst;
19276
19277         if (!flag_S)
19278         {
19279                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19280                 RET(4)
19281         }
19282         FETCH_WORD(res);
19283         res &= M68K_SR_MASK;
19284         SET_SR(res)
19285         if (!flag_S)
19286         {
19287                 res = AREG(7);
19288                 AREG(7) = ASP;
19289                 ASP = res;
19290         }
19291         m68kcontext.execinfo |= FM68K_HALTED;
19292 RET0()
19293 }
19294
19295 // RTE
19296 OPCODE(0x4E73)
19297 {
19298         u32 adr, res;
19299         u32 src, dst;
19300
19301         if (!flag_S)
19302         {
19303                 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19304                 RET(4)
19305         }
19306         PRE_IO
19307         POP_16_F(res)
19308         SET_SR(res)
19309         POP_32_F(res)
19310         SET_PC(res)
19311         if (!flag_S)
19312         {
19313                 res = AREG(7);
19314                 AREG(7) = ASP;
19315                 ASP = res;
19316         }
19317         POST_IO
19318         m68kcontext.execinfo &= ~(FM68K_EMULATE_GROUP_0|FM68K_EMULATE_TRACE|FM68K_DO_TRACE);
19319         CHECK_INT_TO_JUMP(20)
19320 RET(20)
19321 }
19322
19323 // RTS
19324 OPCODE(0x4E75)
19325 {
19326         u32 adr, res;
19327         u32 src, dst;
19328
19329         PRE_IO
19330         POP_32_F(res)
19331         SET_PC(res)
19332         CHECK_BRANCH_EXCEPTION(res)
19333         POST_IO
19334 RET(16)
19335 }
19336
19337 // TRAPV
19338 OPCODE(0x4E76)
19339 {
19340         if (flag_V & 0x80)
19341                 SET_PC(execute_exception(M68K_TRAPV_EX, GET_PC, GET_SR));
19342 RET(4)
19343 }
19344
19345 // RTR
19346 OPCODE(0x4E77)
19347 {
19348         u32 adr, res;
19349         u32 src, dst;
19350
19351         PRE_IO
19352         POP_16_F(res)
19353         SET_CCR(res)
19354         POP_32_F(res)
19355         SET_PC(res)
19356         CHECK_BRANCH_EXCEPTION(res)
19357         POST_IO
19358 RET(20)
19359 }
19360
19361 // JSR
19362 OPCODE(0x4E90)
19363 {
19364         u32 adr, res;
19365         u32 src, dst;
19366
19367         adr = AREG((Opcode >> 0) & 7);
19368         {
19369                 u32 oldPC;
19370
19371                 oldPC = GET_PC;
19372         PRE_IO
19373                 PUSH_32_F(oldPC)
19374         }
19375         SET_PC(adr)
19376         CHECK_BRANCH_EXCEPTION(adr)
19377         POST_IO
19378 RET(16)
19379 }
19380
19381 // JSR
19382 OPCODE(0x4EA8)
19383 {
19384         u32 adr, res;
19385         u32 src, dst;
19386
19387         FETCH_SWORD(adr);
19388         adr += AREG((Opcode >> 0) & 7);
19389         {
19390                 u32 oldPC;
19391
19392                 oldPC = GET_PC;
19393         PRE_IO
19394                 PUSH_32_F(oldPC)
19395         }
19396         SET_PC(adr)
19397         CHECK_BRANCH_EXCEPTION(adr)
19398         POST_IO
19399 RET(18)
19400 }
19401
19402 // JSR
19403 OPCODE(0x4EB0)
19404 {
19405         u32 adr, res;
19406         u32 src, dst;
19407
19408         adr = AREG((Opcode >> 0) & 7);
19409         DECODE_EXT_WORD
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(22)
19421 }
19422
19423 // JSR
19424 OPCODE(0x4EB8)
19425 {
19426         u32 adr, res;
19427         u32 src, dst;
19428
19429         FETCH_SWORD(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(18)
19441 }
19442
19443 // JSR
19444 OPCODE(0x4EB9)
19445 {
19446         u32 adr, res;
19447         u32 src, dst;
19448
19449         FETCH_LONG(adr);
19450         {
19451                 u32 oldPC;
19452
19453                 oldPC = GET_PC;
19454         PRE_IO
19455                 PUSH_32_F(oldPC)
19456         }
19457         SET_PC(adr)
19458         CHECK_BRANCH_EXCEPTION(adr)
19459         POST_IO
19460 RET(20)
19461 }
19462
19463 // JSR
19464 OPCODE(0x4EBA)
19465 {
19466         u32 adr, res;
19467         u32 src, dst;
19468
19469         adr = GET_SWORD + GET_PC;
19470         PC++;
19471         {
19472                 u32 oldPC;
19473
19474                 oldPC = GET_PC;
19475         PRE_IO
19476                 PUSH_32_F(oldPC)
19477         }
19478         SET_PC(adr)
19479         CHECK_BRANCH_EXCEPTION(adr)
19480         POST_IO
19481 RET(18)
19482 }
19483
19484 // JSR
19485 OPCODE(0x4EBB)
19486 {
19487         u32 adr, res;
19488         u32 src, dst;
19489
19490         adr = GET_PC;
19491         DECODE_EXT_WORD
19492         {
19493                 u32 oldPC;
19494
19495                 oldPC = GET_PC;
19496         PRE_IO
19497                 PUSH_32_F(oldPC)
19498         }
19499         SET_PC(adr)
19500         CHECK_BRANCH_EXCEPTION(adr)
19501         POST_IO
19502 RET(22)
19503 }
19504
19505 // JMP
19506 OPCODE(0x4ED0)
19507 {
19508         u32 adr, res;
19509         u32 src, dst;
19510
19511         adr = AREG((Opcode >> 0) & 7);
19512         SET_PC(adr)
19513         CHECK_BRANCH_EXCEPTION(adr)
19514 RET(8)
19515 }
19516
19517 // JMP
19518 OPCODE(0x4EE8)
19519 {
19520         u32 adr, res;
19521         u32 src, dst;
19522
19523         FETCH_SWORD(adr);
19524         adr += AREG((Opcode >> 0) & 7);
19525         SET_PC(adr)
19526         CHECK_BRANCH_EXCEPTION(adr)
19527 RET(10)
19528 }
19529
19530 // JMP
19531 OPCODE(0x4EF0)
19532 {
19533         u32 adr, res;
19534         u32 src, dst;
19535
19536         adr = AREG((Opcode >> 0) & 7);
19537         DECODE_EXT_WORD
19538         SET_PC(adr)
19539         CHECK_BRANCH_EXCEPTION(adr)
19540 RET(14)
19541 }
19542
19543 // JMP
19544 OPCODE(0x4EF8)
19545 {
19546         u32 adr, res;
19547         u32 src, dst;
19548
19549         FETCH_SWORD(adr);
19550         SET_PC(adr)
19551         CHECK_BRANCH_EXCEPTION(adr)
19552 RET(10)
19553 }
19554
19555 // JMP
19556 OPCODE(0x4EF9)
19557 {
19558         u32 adr, res;
19559         u32 src, dst;
19560
19561         FETCH_LONG(adr);
19562         SET_PC(adr)
19563         CHECK_BRANCH_EXCEPTION(adr)
19564 RET(12)
19565 }
19566
19567 // JMP
19568 OPCODE(0x4EFA)
19569 {
19570         u32 adr, res;
19571         u32 src, dst;
19572
19573         adr = GET_SWORD + GET_PC;
19574         PC++;
19575         SET_PC(adr)
19576         CHECK_BRANCH_EXCEPTION(adr)
19577 RET(10)
19578 }
19579
19580 // JMP
19581 OPCODE(0x4EFB)
19582 {
19583         u32 adr, res;
19584         u32 src, dst;
19585
19586         adr = GET_PC;
19587         DECODE_EXT_WORD
19588         SET_PC(adr)
19589         CHECK_BRANCH_EXCEPTION(adr)
19590 RET(14)
19591 }
19592
19593 // CHK
19594 OPCODE(0x4180)
19595 {
19596         s32 src, res;
19597
19598         src = DREGs16((Opcode >> 0) & 7);
19599         res = DREGs16((Opcode >> 9) & 7);
19600         if ((res < 0) || (res > src))
19601         {
19602                 flag_N = res >> 8;
19603                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19604         }
19605 RET(10)
19606 }
19607
19608 // CHK
19609 OPCODE(0x4190)
19610 {
19611         s32 src, res;
19612         u32 adr;
19613
19614         adr = AREG((Opcode >> 0) & 7);
19615         PRE_IO
19616         READSX_WORD_F(adr, src)
19617         res = DREGs16((Opcode >> 9) & 7);
19618         if ((res < 0) || (res > src))
19619         {
19620                 flag_N = res >> 8;
19621                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19622         }
19623         POST_IO
19624 RET(14)
19625 }
19626
19627 // CHK
19628 OPCODE(0x4198)
19629 {
19630         s32 src, res;
19631         u32 adr;
19632
19633         adr = AREG((Opcode >> 0) & 7);
19634         AREG((Opcode >> 0) & 7) += 2;
19635         PRE_IO
19636         READSX_WORD_F(adr, src)
19637         res = DREGs16((Opcode >> 9) & 7);
19638         if ((res < 0) || (res > src))
19639         {
19640                 flag_N = res >> 8;
19641                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19642         }
19643         POST_IO
19644 RET(14)
19645 }
19646
19647 // CHK
19648 OPCODE(0x41A0)
19649 {
19650         s32 src, res;
19651         u32 adr;
19652
19653         adr = AREG((Opcode >> 0) & 7) - 2;
19654         AREG((Opcode >> 0) & 7) = adr;
19655         PRE_IO
19656         READSX_WORD_F(adr, src)
19657         res = DREGs16((Opcode >> 9) & 7);
19658         if ((res < 0) || (res > src))
19659         {
19660                 flag_N = res >> 8;
19661                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19662         }
19663         POST_IO
19664 RET(16)
19665 }
19666
19667 // CHK
19668 OPCODE(0x41A8)
19669 {
19670         s32 src, res;
19671         u32 adr;
19672
19673         FETCH_SWORD(adr);
19674         adr += AREG((Opcode >> 0) & 7);
19675         PRE_IO
19676         READSX_WORD_F(adr, src)
19677         res = DREGs16((Opcode >> 9) & 7);
19678         if ((res < 0) || (res > src))
19679         {
19680                 flag_N = res >> 8;
19681                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19682         }
19683         POST_IO
19684 RET(18)
19685 }
19686
19687 // CHK
19688 OPCODE(0x41B0)
19689 {
19690         s32 src, res;
19691         u32 adr;
19692
19693         adr = AREG((Opcode >> 0) & 7);
19694         DECODE_EXT_WORD
19695         PRE_IO
19696         READSX_WORD_F(adr, src)
19697         res = DREGs16((Opcode >> 9) & 7);
19698         if ((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(20)
19705 }
19706
19707 // CHK
19708 OPCODE(0x41B8)
19709 {
19710         s32 src, res;
19711         u32 adr;
19712
19713         FETCH_SWORD(adr);
19714         PRE_IO
19715         READSX_WORD_F(adr, src)
19716         res = DREGs16((Opcode >> 9) & 7);
19717         if ((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(18)
19724 }
19725
19726 // CHK
19727 OPCODE(0x41B9)
19728 {
19729         s32 src, res;
19730         u32 adr;
19731
19732         FETCH_LONG(adr);
19733         PRE_IO
19734         READSX_WORD_F(adr, src)
19735         res = DREGs16((Opcode >> 9) & 7);
19736         if ((res < 0) || (res > src))
19737         {
19738                 flag_N = res >> 8;
19739                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19740         }
19741         POST_IO
19742 RET(22)
19743 }
19744
19745 // CHK
19746 OPCODE(0x41BA)
19747 {
19748         s32 src, res;
19749         u32 adr;
19750
19751         adr = GET_SWORD + GET_PC;
19752         PC++;
19753         PRE_IO
19754         READSX_WORD_F(adr, src)
19755         res = DREGs16((Opcode >> 9) & 7);
19756         if ((res < 0) || (res > src))
19757         {
19758                 flag_N = res >> 8;
19759                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19760         }
19761         POST_IO
19762 RET(18)
19763 }
19764
19765 // CHK
19766 OPCODE(0x41BB)
19767 {
19768         s32 src, res;
19769         u32 adr;
19770
19771         adr = GET_PC;
19772         DECODE_EXT_WORD
19773         PRE_IO
19774         READSX_WORD_F(adr, src)
19775         res = DREGs16((Opcode >> 9) & 7);
19776         if ((res < 0) || (res > src))
19777         {
19778                 flag_N = res >> 8;
19779                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19780         }
19781         POST_IO
19782 RET(20)
19783 }
19784
19785 // CHK
19786 OPCODE(0x41BC)
19787 {
19788         s32 src, res;
19789         u32 adr;
19790
19791         FETCH_SWORD(src);
19792         res = DREGs16((Opcode >> 9) & 7);
19793         if ((res < 0) || (res > src))
19794         {
19795                 flag_N = res >> 8;
19796                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19797         }
19798         POST_IO
19799 RET(14)
19800 }
19801
19802 // CHK
19803 OPCODE(0x419F)
19804 {
19805         s32 src, res;
19806         u32 adr;
19807
19808         adr = AREG(7);
19809         AREG(7) += 2;
19810         PRE_IO
19811         READSX_WORD_F(adr, src)
19812         res = DREGs16((Opcode >> 9) & 7);
19813         if ((res < 0) || (res > src))
19814         {
19815                 flag_N = res >> 8;
19816                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19817         }
19818         POST_IO
19819 RET(14)
19820 }
19821
19822 // CHK
19823 OPCODE(0x41A7)
19824 {
19825         s32 src, res;
19826         u32 adr;
19827
19828         adr = AREG(7) - 2;
19829         AREG(7) = adr;
19830         PRE_IO
19831         READSX_WORD_F(adr, src)
19832         res = DREGs16((Opcode >> 9) & 7);
19833         if ((res < 0) || (res > src))
19834         {
19835                 flag_N = res >> 8;
19836                 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
19837         }
19838         POST_IO
19839 RET(16)
19840 }
19841
19842 // LEA
19843 OPCODE(0x41D0)
19844 {
19845         u32 adr, res;
19846         u32 src, dst;
19847
19848         adr = AREG((Opcode >> 0) & 7);
19849         res = adr;
19850         AREG((Opcode >> 9) & 7) = res;
19851 RET(4)
19852 }
19853
19854 // LEA
19855 OPCODE(0x41E8)
19856 {
19857         u32 adr, res;
19858         u32 src, dst;
19859
19860         FETCH_SWORD(adr);
19861         adr += AREG((Opcode >> 0) & 7);
19862         res = adr;
19863         AREG((Opcode >> 9) & 7) = res;
19864 RET(8)
19865 }
19866
19867 // LEA
19868 OPCODE(0x41F0)
19869 {
19870         u32 adr, res;
19871         u32 src, dst;
19872
19873         adr = AREG((Opcode >> 0) & 7);
19874         DECODE_EXT_WORD
19875         res = adr;
19876         AREG((Opcode >> 9) & 7) = res;
19877 RET(12)
19878 }
19879
19880 // LEA
19881 OPCODE(0x41F8)
19882 {
19883         u32 adr, res;
19884         u32 src, dst;
19885
19886         FETCH_SWORD(adr);
19887         res = adr;
19888         AREG((Opcode >> 9) & 7) = res;
19889 RET(8)
19890 }
19891
19892 // LEA
19893 OPCODE(0x41F9)
19894 {
19895         u32 adr, res;
19896         u32 src, dst;
19897
19898         FETCH_LONG(adr);
19899         res = adr;
19900         AREG((Opcode >> 9) & 7) = res;
19901 RET(12)
19902 }
19903
19904 // LEA
19905 OPCODE(0x41FA)
19906 {
19907         u32 adr, res;
19908         u32 src, dst;
19909
19910         adr = GET_SWORD + GET_PC;
19911         PC++;
19912         res = adr;
19913         AREG((Opcode >> 9) & 7) = res;
19914 RET(8)
19915 }
19916
19917 // LEA
19918 OPCODE(0x41FB)
19919 {
19920         u32 adr, res;
19921         u32 src, dst;
19922
19923         adr = GET_PC;
19924         DECODE_EXT_WORD
19925         res = adr;
19926         AREG((Opcode >> 9) & 7) = res;
19927 RET(12)
19928 }
19929
19930 // STCC
19931 OPCODE(0x50C0)
19932 {
19933         u32 adr, res;
19934         u32 src, dst;
19935
19936         res = 0xFF;
19937         DREGu8((Opcode >> 0) & 7) = res;
19938         RET(6)
19939 }
19940
19941 // STCC
19942 OPCODE(0x51C0)
19943 {
19944         u32 adr, res;
19945         u32 src, dst;
19946
19947         res = 0;
19948         DREGu8((Opcode >> 0) & 7) = res;
19949         RET(4)
19950 }
19951
19952 // STCC
19953 OPCODE(0x52C0)
19954 {
19955         u32 adr, res;
19956         u32 src, dst;
19957
19958         if (flag_NotZ && (!(flag_C & 0x100)))
19959         {
19960         res = 0xFF;
19961         DREGu8((Opcode >> 0) & 7) = res;
19962         RET(6)
19963         }
19964         res = 0;
19965         DREGu8((Opcode >> 0) & 7) = res;
19966         RET(4)
19967 }
19968
19969 // STCC
19970 OPCODE(0x53C0)
19971 {
19972         u32 adr, res;
19973         u32 src, dst;
19974
19975         if ((!flag_NotZ) || (flag_C & 0x100))
19976         {
19977         res = 0xFF;
19978         DREGu8((Opcode >> 0) & 7) = res;
19979         RET(6)
19980         }
19981         res = 0;
19982         DREGu8((Opcode >> 0) & 7) = res;
19983         RET(4)
19984 }
19985
19986 // STCC
19987 OPCODE(0x54C0)
19988 {
19989         u32 adr, res;
19990         u32 src, dst;
19991
19992         if (!(flag_C & 0x100))
19993         {
19994         res = 0xFF;
19995         DREGu8((Opcode >> 0) & 7) = res;
19996         RET(6)
19997         }
19998         res = 0;
19999         DREGu8((Opcode >> 0) & 7) = res;
20000         RET(4)
20001 }
20002
20003 // STCC
20004 OPCODE(0x55C0)
20005 {
20006         u32 adr, res;
20007         u32 src, dst;
20008
20009         if (flag_C & 0x100)
20010         {
20011         res = 0xFF;
20012         DREGu8((Opcode >> 0) & 7) = res;
20013         RET(6)
20014         }
20015         res = 0;
20016         DREGu8((Opcode >> 0) & 7) = res;
20017         RET(4)
20018 }
20019
20020 // STCC
20021 OPCODE(0x56C0)
20022 {
20023         u32 adr, res;
20024         u32 src, dst;
20025
20026         if (flag_NotZ)
20027         {
20028         res = 0xFF;
20029         DREGu8((Opcode >> 0) & 7) = res;
20030         RET(6)
20031         }
20032         res = 0;
20033         DREGu8((Opcode >> 0) & 7) = res;
20034         RET(4)
20035 }
20036
20037 // STCC
20038 OPCODE(0x57C0)
20039 {
20040         u32 adr, res;
20041         u32 src, dst;
20042
20043         if (!flag_NotZ)
20044         {
20045         res = 0xFF;
20046         DREGu8((Opcode >> 0) & 7) = res;
20047         RET(6)
20048         }
20049         res = 0;
20050         DREGu8((Opcode >> 0) & 7) = res;
20051         RET(4)
20052 }
20053
20054 // STCC
20055 OPCODE(0x58C0)
20056 {
20057         u32 adr, res;
20058         u32 src, dst;
20059
20060         if (!(flag_V & 0x80))
20061         {
20062         res = 0xFF;
20063         DREGu8((Opcode >> 0) & 7) = res;
20064         RET(6)
20065         }
20066         res = 0;
20067         DREGu8((Opcode >> 0) & 7) = res;
20068         RET(4)
20069 }
20070
20071 // STCC
20072 OPCODE(0x59C0)
20073 {
20074         u32 adr, res;
20075         u32 src, dst;
20076
20077         if (flag_V & 0x80)
20078         {
20079         res = 0xFF;
20080         DREGu8((Opcode >> 0) & 7) = res;
20081         RET(6)
20082         }
20083         res = 0;
20084         DREGu8((Opcode >> 0) & 7) = res;
20085         RET(4)
20086 }
20087
20088 // STCC
20089 OPCODE(0x5AC0)
20090 {
20091         u32 adr, res;
20092         u32 src, dst;
20093
20094         if (!(flag_N & 0x80))
20095         {
20096         res = 0xFF;
20097         DREGu8((Opcode >> 0) & 7) = res;
20098         RET(6)
20099         }
20100         res = 0;
20101         DREGu8((Opcode >> 0) & 7) = res;
20102         RET(4)
20103 }
20104
20105 // STCC
20106 OPCODE(0x5BC0)
20107 {
20108         u32 adr, res;
20109         u32 src, dst;
20110
20111         if (flag_N & 0x80)
20112         {
20113         res = 0xFF;
20114         DREGu8((Opcode >> 0) & 7) = res;
20115         RET(6)
20116         }
20117         res = 0;
20118         DREGu8((Opcode >> 0) & 7) = res;
20119         RET(4)
20120 }
20121
20122 // STCC
20123 OPCODE(0x5CC0)
20124 {
20125         u32 adr, res;
20126         u32 src, dst;
20127
20128         if (!((flag_N ^ flag_V) & 0x80))
20129         {
20130         res = 0xFF;
20131         DREGu8((Opcode >> 0) & 7) = res;
20132         RET(6)
20133         }
20134         res = 0;
20135         DREGu8((Opcode >> 0) & 7) = res;
20136         RET(4)
20137 }
20138
20139 // STCC
20140 OPCODE(0x5DC0)
20141 {
20142         u32 adr, res;
20143         u32 src, dst;
20144
20145         if ((flag_N ^ flag_V) & 0x80)
20146         {
20147         res = 0xFF;
20148         DREGu8((Opcode >> 0) & 7) = res;
20149         RET(6)
20150         }
20151         res = 0;
20152         DREGu8((Opcode >> 0) & 7) = res;
20153         RET(4)
20154 }
20155
20156 // STCC
20157 OPCODE(0x5EC0)
20158 {
20159         u32 adr, res;
20160         u32 src, dst;
20161
20162         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20163         {
20164         res = 0xFF;
20165         DREGu8((Opcode >> 0) & 7) = res;
20166         RET(6)
20167         }
20168         res = 0;
20169         DREGu8((Opcode >> 0) & 7) = res;
20170         RET(4)
20171 }
20172
20173 // STCC
20174 OPCODE(0x5FC0)
20175 {
20176         u32 adr, res;
20177         u32 src, dst;
20178
20179         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20180         {
20181         res = 0xFF;
20182         DREGu8((Opcode >> 0) & 7) = res;
20183         RET(6)
20184         }
20185         res = 0;
20186         DREGu8((Opcode >> 0) & 7) = res;
20187         RET(4)
20188 }
20189
20190 // STCC
20191 OPCODE(0x50D0)
20192 {
20193         u32 adr, res;
20194         u32 src, dst;
20195
20196         adr = AREG((Opcode >> 0) & 7);
20197         res = 0xFF;
20198         PRE_IO
20199         WRITE_BYTE_F(adr, res)
20200         POST_IO
20201         RET(12)
20202 }
20203
20204 // STCC
20205 OPCODE(0x51D0)
20206 {
20207         u32 adr, res;
20208         u32 src, dst;
20209
20210         adr = AREG((Opcode >> 0) & 7);
20211         res = 0;
20212         PRE_IO
20213         WRITE_BYTE_F(adr, res)
20214         POST_IO
20215         RET(12)
20216 }
20217
20218 // STCC
20219 OPCODE(0x52D0)
20220 {
20221         u32 adr, res;
20222         u32 src, dst;
20223
20224         adr = AREG((Opcode >> 0) & 7);
20225         if (flag_NotZ && (!(flag_C & 0x100)))
20226         {
20227         res = 0xFF;
20228         PRE_IO
20229         WRITE_BYTE_F(adr, res)
20230         POST_IO
20231         RET(12)
20232         }
20233         res = 0;
20234         PRE_IO
20235         WRITE_BYTE_F(adr, res)
20236         POST_IO
20237         RET(12)
20238 }
20239
20240 // STCC
20241 OPCODE(0x53D0)
20242 {
20243         u32 adr, res;
20244         u32 src, dst;
20245
20246         adr = AREG((Opcode >> 0) & 7);
20247         if ((!flag_NotZ) || (flag_C & 0x100))
20248         {
20249         res = 0xFF;
20250         PRE_IO
20251         WRITE_BYTE_F(adr, res)
20252         POST_IO
20253         RET(12)
20254         }
20255         res = 0;
20256         PRE_IO
20257         WRITE_BYTE_F(adr, res)
20258         POST_IO
20259         RET(12)
20260 }
20261
20262 // STCC
20263 OPCODE(0x54D0)
20264 {
20265         u32 adr, res;
20266         u32 src, dst;
20267
20268         adr = AREG((Opcode >> 0) & 7);
20269         if (!(flag_C & 0x100))
20270         {
20271         res = 0xFF;
20272         PRE_IO
20273         WRITE_BYTE_F(adr, res)
20274         POST_IO
20275         RET(12)
20276         }
20277         res = 0;
20278         PRE_IO
20279         WRITE_BYTE_F(adr, res)
20280         POST_IO
20281         RET(12)
20282 }
20283
20284 // STCC
20285 OPCODE(0x55D0)
20286 {
20287         u32 adr, res;
20288         u32 src, dst;
20289
20290         adr = AREG((Opcode >> 0) & 7);
20291         if (flag_C & 0x100)
20292         {
20293         res = 0xFF;
20294         PRE_IO
20295         WRITE_BYTE_F(adr, res)
20296         POST_IO
20297         RET(12)
20298         }
20299         res = 0;
20300         PRE_IO
20301         WRITE_BYTE_F(adr, res)
20302         POST_IO
20303         RET(12)
20304 }
20305
20306 // STCC
20307 OPCODE(0x56D0)
20308 {
20309         u32 adr, res;
20310         u32 src, dst;
20311
20312         adr = AREG((Opcode >> 0) & 7);
20313         if (flag_NotZ)
20314         {
20315         res = 0xFF;
20316         PRE_IO
20317         WRITE_BYTE_F(adr, res)
20318         POST_IO
20319         RET(12)
20320         }
20321         res = 0;
20322         PRE_IO
20323         WRITE_BYTE_F(adr, res)
20324         POST_IO
20325         RET(12)
20326 }
20327
20328 // STCC
20329 OPCODE(0x57D0)
20330 {
20331         u32 adr, res;
20332         u32 src, dst;
20333
20334         adr = AREG((Opcode >> 0) & 7);
20335         if (!flag_NotZ)
20336         {
20337         res = 0xFF;
20338         PRE_IO
20339         WRITE_BYTE_F(adr, res)
20340         POST_IO
20341         RET(12)
20342         }
20343         res = 0;
20344         PRE_IO
20345         WRITE_BYTE_F(adr, res)
20346         POST_IO
20347         RET(12)
20348 }
20349
20350 // STCC
20351 OPCODE(0x58D0)
20352 {
20353         u32 adr, res;
20354         u32 src, dst;
20355
20356         adr = AREG((Opcode >> 0) & 7);
20357         if (!(flag_V & 0x80))
20358         {
20359         res = 0xFF;
20360         PRE_IO
20361         WRITE_BYTE_F(adr, res)
20362         POST_IO
20363         RET(12)
20364         }
20365         res = 0;
20366         PRE_IO
20367         WRITE_BYTE_F(adr, res)
20368         POST_IO
20369         RET(12)
20370 }
20371
20372 // STCC
20373 OPCODE(0x59D0)
20374 {
20375         u32 adr, res;
20376         u32 src, dst;
20377
20378         adr = AREG((Opcode >> 0) & 7);
20379         if (flag_V & 0x80)
20380         {
20381         res = 0xFF;
20382         PRE_IO
20383         WRITE_BYTE_F(adr, res)
20384         POST_IO
20385         RET(12)
20386         }
20387         res = 0;
20388         PRE_IO
20389         WRITE_BYTE_F(adr, res)
20390         POST_IO
20391         RET(12)
20392 }
20393
20394 // STCC
20395 OPCODE(0x5AD0)
20396 {
20397         u32 adr, res;
20398         u32 src, dst;
20399
20400         adr = AREG((Opcode >> 0) & 7);
20401         if (!(flag_N & 0x80))
20402         {
20403         res = 0xFF;
20404         PRE_IO
20405         WRITE_BYTE_F(adr, res)
20406         POST_IO
20407         RET(12)
20408         }
20409         res = 0;
20410         PRE_IO
20411         WRITE_BYTE_F(adr, res)
20412         POST_IO
20413         RET(12)
20414 }
20415
20416 // STCC
20417 OPCODE(0x5BD0)
20418 {
20419         u32 adr, res;
20420         u32 src, dst;
20421
20422         adr = AREG((Opcode >> 0) & 7);
20423         if (flag_N & 0x80)
20424         {
20425         res = 0xFF;
20426         PRE_IO
20427         WRITE_BYTE_F(adr, res)
20428         POST_IO
20429         RET(12)
20430         }
20431         res = 0;
20432         PRE_IO
20433         WRITE_BYTE_F(adr, res)
20434         POST_IO
20435         RET(12)
20436 }
20437
20438 // STCC
20439 OPCODE(0x5CD0)
20440 {
20441         u32 adr, res;
20442         u32 src, dst;
20443
20444         adr = AREG((Opcode >> 0) & 7);
20445         if (!((flag_N ^ flag_V) & 0x80))
20446         {
20447         res = 0xFF;
20448         PRE_IO
20449         WRITE_BYTE_F(adr, res)
20450         POST_IO
20451         RET(12)
20452         }
20453         res = 0;
20454         PRE_IO
20455         WRITE_BYTE_F(adr, res)
20456         POST_IO
20457         RET(12)
20458 }
20459
20460 // STCC
20461 OPCODE(0x5DD0)
20462 {
20463         u32 adr, res;
20464         u32 src, dst;
20465
20466         adr = AREG((Opcode >> 0) & 7);
20467         if ((flag_N ^ flag_V) & 0x80)
20468         {
20469         res = 0xFF;
20470         PRE_IO
20471         WRITE_BYTE_F(adr, res)
20472         POST_IO
20473         RET(12)
20474         }
20475         res = 0;
20476         PRE_IO
20477         WRITE_BYTE_F(adr, res)
20478         POST_IO
20479         RET(12)
20480 }
20481
20482 // STCC
20483 OPCODE(0x5ED0)
20484 {
20485         u32 adr, res;
20486         u32 src, dst;
20487
20488         adr = AREG((Opcode >> 0) & 7);
20489         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20490         {
20491         res = 0xFF;
20492         PRE_IO
20493         WRITE_BYTE_F(adr, res)
20494         POST_IO
20495         RET(12)
20496         }
20497         res = 0;
20498         PRE_IO
20499         WRITE_BYTE_F(adr, res)
20500         POST_IO
20501         RET(12)
20502 }
20503
20504 // STCC
20505 OPCODE(0x5FD0)
20506 {
20507         u32 adr, res;
20508         u32 src, dst;
20509
20510         adr = AREG((Opcode >> 0) & 7);
20511         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20512         {
20513         res = 0xFF;
20514         PRE_IO
20515         WRITE_BYTE_F(adr, res)
20516         POST_IO
20517         RET(12)
20518         }
20519         res = 0;
20520         PRE_IO
20521         WRITE_BYTE_F(adr, res)
20522         POST_IO
20523         RET(12)
20524 }
20525
20526 // STCC
20527 OPCODE(0x50D8)
20528 {
20529         u32 adr, res;
20530         u32 src, dst;
20531
20532         adr = AREG((Opcode >> 0) & 7);
20533         AREG((Opcode >> 0) & 7) += 1;
20534         res = 0xFF;
20535         PRE_IO
20536         WRITE_BYTE_F(adr, res)
20537         POST_IO
20538         RET(12)
20539 }
20540
20541 // STCC
20542 OPCODE(0x51D8)
20543 {
20544         u32 adr, res;
20545         u32 src, dst;
20546
20547         adr = AREG((Opcode >> 0) & 7);
20548         AREG((Opcode >> 0) & 7) += 1;
20549         res = 0;
20550         PRE_IO
20551         WRITE_BYTE_F(adr, res)
20552         POST_IO
20553         RET(12)
20554 }
20555
20556 // STCC
20557 OPCODE(0x52D8)
20558 {
20559         u32 adr, res;
20560         u32 src, dst;
20561
20562         adr = AREG((Opcode >> 0) & 7);
20563         AREG((Opcode >> 0) & 7) += 1;
20564         if (flag_NotZ && (!(flag_C & 0x100)))
20565         {
20566         res = 0xFF;
20567         PRE_IO
20568         WRITE_BYTE_F(adr, res)
20569         POST_IO
20570         RET(12)
20571         }
20572         res = 0;
20573         PRE_IO
20574         WRITE_BYTE_F(adr, res)
20575         POST_IO
20576         RET(12)
20577 }
20578
20579 // STCC
20580 OPCODE(0x53D8)
20581 {
20582         u32 adr, res;
20583         u32 src, dst;
20584
20585         adr = AREG((Opcode >> 0) & 7);
20586         AREG((Opcode >> 0) & 7) += 1;
20587         if ((!flag_NotZ) || (flag_C & 0x100))
20588         {
20589         res = 0xFF;
20590         PRE_IO
20591         WRITE_BYTE_F(adr, res)
20592         POST_IO
20593         RET(12)
20594         }
20595         res = 0;
20596         PRE_IO
20597         WRITE_BYTE_F(adr, res)
20598         POST_IO
20599         RET(12)
20600 }
20601
20602 // STCC
20603 OPCODE(0x54D8)
20604 {
20605         u32 adr, res;
20606         u32 src, dst;
20607
20608         adr = AREG((Opcode >> 0) & 7);
20609         AREG((Opcode >> 0) & 7) += 1;
20610         if (!(flag_C & 0x100))
20611         {
20612         res = 0xFF;
20613         PRE_IO
20614         WRITE_BYTE_F(adr, res)
20615         POST_IO
20616         RET(12)
20617         }
20618         res = 0;
20619         PRE_IO
20620         WRITE_BYTE_F(adr, res)
20621         POST_IO
20622         RET(12)
20623 }
20624
20625 // STCC
20626 OPCODE(0x55D8)
20627 {
20628         u32 adr, res;
20629         u32 src, dst;
20630
20631         adr = AREG((Opcode >> 0) & 7);
20632         AREG((Opcode >> 0) & 7) += 1;
20633         if (flag_C & 0x100)
20634         {
20635         res = 0xFF;
20636         PRE_IO
20637         WRITE_BYTE_F(adr, res)
20638         POST_IO
20639         RET(12)
20640         }
20641         res = 0;
20642         PRE_IO
20643         WRITE_BYTE_F(adr, res)
20644         POST_IO
20645         RET(12)
20646 }
20647
20648 // STCC
20649 OPCODE(0x56D8)
20650 {
20651         u32 adr, res;
20652         u32 src, dst;
20653
20654         adr = AREG((Opcode >> 0) & 7);
20655         AREG((Opcode >> 0) & 7) += 1;
20656         if (flag_NotZ)
20657         {
20658         res = 0xFF;
20659         PRE_IO
20660         WRITE_BYTE_F(adr, res)
20661         POST_IO
20662         RET(12)
20663         }
20664         res = 0;
20665         PRE_IO
20666         WRITE_BYTE_F(adr, res)
20667         POST_IO
20668         RET(12)
20669 }
20670
20671 // STCC
20672 OPCODE(0x57D8)
20673 {
20674         u32 adr, res;
20675         u32 src, dst;
20676
20677         adr = AREG((Opcode >> 0) & 7);
20678         AREG((Opcode >> 0) & 7) += 1;
20679         if (!flag_NotZ)
20680         {
20681         res = 0xFF;
20682         PRE_IO
20683         WRITE_BYTE_F(adr, res)
20684         POST_IO
20685         RET(12)
20686         }
20687         res = 0;
20688         PRE_IO
20689         WRITE_BYTE_F(adr, res)
20690         POST_IO
20691         RET(12)
20692 }
20693
20694 // STCC
20695 OPCODE(0x58D8)
20696 {
20697         u32 adr, res;
20698         u32 src, dst;
20699
20700         adr = AREG((Opcode >> 0) & 7);
20701         AREG((Opcode >> 0) & 7) += 1;
20702         if (!(flag_V & 0x80))
20703         {
20704         res = 0xFF;
20705         PRE_IO
20706         WRITE_BYTE_F(adr, res)
20707         POST_IO
20708         RET(12)
20709         }
20710         res = 0;
20711         PRE_IO
20712         WRITE_BYTE_F(adr, res)
20713         POST_IO
20714         RET(12)
20715 }
20716
20717 // STCC
20718 OPCODE(0x59D8)
20719 {
20720         u32 adr, res;
20721         u32 src, dst;
20722
20723         adr = AREG((Opcode >> 0) & 7);
20724         AREG((Opcode >> 0) & 7) += 1;
20725         if (flag_V & 0x80)
20726         {
20727         res = 0xFF;
20728         PRE_IO
20729         WRITE_BYTE_F(adr, res)
20730         POST_IO
20731         RET(12)
20732         }
20733         res = 0;
20734         PRE_IO
20735         WRITE_BYTE_F(adr, res)
20736         POST_IO
20737         RET(12)
20738 }
20739
20740 // STCC
20741 OPCODE(0x5AD8)
20742 {
20743         u32 adr, res;
20744         u32 src, dst;
20745
20746         adr = AREG((Opcode >> 0) & 7);
20747         AREG((Opcode >> 0) & 7) += 1;
20748         if (!(flag_N & 0x80))
20749         {
20750         res = 0xFF;
20751         PRE_IO
20752         WRITE_BYTE_F(adr, res)
20753         POST_IO
20754         RET(12)
20755         }
20756         res = 0;
20757         PRE_IO
20758         WRITE_BYTE_F(adr, res)
20759         POST_IO
20760         RET(12)
20761 }
20762
20763 // STCC
20764 OPCODE(0x5BD8)
20765 {
20766         u32 adr, res;
20767         u32 src, dst;
20768
20769         adr = AREG((Opcode >> 0) & 7);
20770         AREG((Opcode >> 0) & 7) += 1;
20771         if (flag_N & 0x80)
20772         {
20773         res = 0xFF;
20774         PRE_IO
20775         WRITE_BYTE_F(adr, res)
20776         POST_IO
20777         RET(12)
20778         }
20779         res = 0;
20780         PRE_IO
20781         WRITE_BYTE_F(adr, res)
20782         POST_IO
20783         RET(12)
20784 }
20785
20786 // STCC
20787 OPCODE(0x5CD8)
20788 {
20789         u32 adr, res;
20790         u32 src, dst;
20791
20792         adr = AREG((Opcode >> 0) & 7);
20793         AREG((Opcode >> 0) & 7) += 1;
20794         if (!((flag_N ^ flag_V) & 0x80))
20795         {
20796         res = 0xFF;
20797         PRE_IO
20798         WRITE_BYTE_F(adr, res)
20799         POST_IO
20800         RET(12)
20801         }
20802         res = 0;
20803         PRE_IO
20804         WRITE_BYTE_F(adr, res)
20805         POST_IO
20806         RET(12)
20807 }
20808
20809 // STCC
20810 OPCODE(0x5DD8)
20811 {
20812         u32 adr, res;
20813         u32 src, dst;
20814
20815         adr = AREG((Opcode >> 0) & 7);
20816         AREG((Opcode >> 0) & 7) += 1;
20817         if ((flag_N ^ flag_V) & 0x80)
20818         {
20819         res = 0xFF;
20820         PRE_IO
20821         WRITE_BYTE_F(adr, res)
20822         POST_IO
20823         RET(12)
20824         }
20825         res = 0;
20826         PRE_IO
20827         WRITE_BYTE_F(adr, res)
20828         POST_IO
20829         RET(12)
20830 }
20831
20832 // STCC
20833 OPCODE(0x5ED8)
20834 {
20835         u32 adr, res;
20836         u32 src, dst;
20837
20838         adr = AREG((Opcode >> 0) & 7);
20839         AREG((Opcode >> 0) & 7) += 1;
20840         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20841         {
20842         res = 0xFF;
20843         PRE_IO
20844         WRITE_BYTE_F(adr, res)
20845         POST_IO
20846         RET(12)
20847         }
20848         res = 0;
20849         PRE_IO
20850         WRITE_BYTE_F(adr, res)
20851         POST_IO
20852         RET(12)
20853 }
20854
20855 // STCC
20856 OPCODE(0x5FD8)
20857 {
20858         u32 adr, res;
20859         u32 src, dst;
20860
20861         adr = AREG((Opcode >> 0) & 7);
20862         AREG((Opcode >> 0) & 7) += 1;
20863         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20864         {
20865         res = 0xFF;
20866         PRE_IO
20867         WRITE_BYTE_F(adr, res)
20868         POST_IO
20869         RET(12)
20870         }
20871         res = 0;
20872         PRE_IO
20873         WRITE_BYTE_F(adr, res)
20874         POST_IO
20875         RET(12)
20876 }
20877
20878 // STCC
20879 OPCODE(0x50E0)
20880 {
20881         u32 adr, res;
20882         u32 src, dst;
20883
20884         adr = AREG((Opcode >> 0) & 7) - 1;
20885         AREG((Opcode >> 0) & 7) = adr;
20886         res = 0xFF;
20887         PRE_IO
20888         WRITE_BYTE_F(adr, res)
20889         POST_IO
20890         RET(14)
20891 }
20892
20893 // STCC
20894 OPCODE(0x51E0)
20895 {
20896         u32 adr, res;
20897         u32 src, dst;
20898
20899         adr = AREG((Opcode >> 0) & 7) - 1;
20900         AREG((Opcode >> 0) & 7) = adr;
20901         res = 0;
20902         PRE_IO
20903         WRITE_BYTE_F(adr, res)
20904         POST_IO
20905         RET(14)
20906 }
20907
20908 // STCC
20909 OPCODE(0x52E0)
20910 {
20911         u32 adr, res;
20912         u32 src, dst;
20913
20914         adr = AREG((Opcode >> 0) & 7) - 1;
20915         AREG((Opcode >> 0) & 7) = adr;
20916         if (flag_NotZ && (!(flag_C & 0x100)))
20917         {
20918         res = 0xFF;
20919         PRE_IO
20920         WRITE_BYTE_F(adr, res)
20921         POST_IO
20922         RET(14)
20923         }
20924         res = 0;
20925         PRE_IO
20926         WRITE_BYTE_F(adr, res)
20927         POST_IO
20928         RET(14)
20929 }
20930
20931 // STCC
20932 OPCODE(0x53E0)
20933 {
20934         u32 adr, res;
20935         u32 src, dst;
20936
20937         adr = AREG((Opcode >> 0) & 7) - 1;
20938         AREG((Opcode >> 0) & 7) = adr;
20939         if ((!flag_NotZ) || (flag_C & 0x100))
20940         {
20941         res = 0xFF;
20942         PRE_IO
20943         WRITE_BYTE_F(adr, res)
20944         POST_IO
20945         RET(14)
20946         }
20947         res = 0;
20948         PRE_IO
20949         WRITE_BYTE_F(adr, res)
20950         POST_IO
20951         RET(14)
20952 }
20953
20954 // STCC
20955 OPCODE(0x54E0)
20956 {
20957         u32 adr, res;
20958         u32 src, dst;
20959
20960         adr = AREG((Opcode >> 0) & 7) - 1;
20961         AREG((Opcode >> 0) & 7) = adr;
20962         if (!(flag_C & 0x100))
20963         {
20964         res = 0xFF;
20965         PRE_IO
20966         WRITE_BYTE_F(adr, res)
20967         POST_IO
20968         RET(14)
20969         }
20970         res = 0;
20971         PRE_IO
20972         WRITE_BYTE_F(adr, res)
20973         POST_IO
20974         RET(14)
20975 }
20976
20977 // STCC
20978 OPCODE(0x55E0)
20979 {
20980         u32 adr, res;
20981         u32 src, dst;
20982
20983         adr = AREG((Opcode >> 0) & 7) - 1;
20984         AREG((Opcode >> 0) & 7) = adr;
20985         if (flag_C & 0x100)
20986         {
20987         res = 0xFF;
20988         PRE_IO
20989         WRITE_BYTE_F(adr, res)
20990         POST_IO
20991         RET(14)
20992         }
20993         res = 0;
20994         PRE_IO
20995         WRITE_BYTE_F(adr, res)
20996         POST_IO
20997         RET(14)
20998 }
20999
21000 // STCC
21001 OPCODE(0x56E0)
21002 {
21003         u32 adr, res;
21004         u32 src, dst;
21005
21006         adr = AREG((Opcode >> 0) & 7) - 1;
21007         AREG((Opcode >> 0) & 7) = adr;
21008         if (flag_NotZ)
21009         {
21010         res = 0xFF;
21011         PRE_IO
21012         WRITE_BYTE_F(adr, res)
21013         POST_IO
21014         RET(14)
21015         }
21016         res = 0;
21017         PRE_IO
21018         WRITE_BYTE_F(adr, res)
21019         POST_IO
21020         RET(14)
21021 }
21022
21023 // STCC
21024 OPCODE(0x57E0)
21025 {
21026         u32 adr, res;
21027         u32 src, dst;
21028
21029         adr = AREG((Opcode >> 0) & 7) - 1;
21030         AREG((Opcode >> 0) & 7) = adr;
21031         if (!flag_NotZ)
21032         {
21033         res = 0xFF;
21034         PRE_IO
21035         WRITE_BYTE_F(adr, res)
21036         POST_IO
21037         RET(14)
21038         }
21039         res = 0;
21040         PRE_IO
21041         WRITE_BYTE_F(adr, res)
21042         POST_IO
21043         RET(14)
21044 }
21045
21046 // STCC
21047 OPCODE(0x58E0)
21048 {
21049         u32 adr, res;
21050         u32 src, dst;
21051
21052         adr = AREG((Opcode >> 0) & 7) - 1;
21053         AREG((Opcode >> 0) & 7) = adr;
21054         if (!(flag_V & 0x80))
21055         {
21056         res = 0xFF;
21057         PRE_IO
21058         WRITE_BYTE_F(adr, res)
21059         POST_IO
21060         RET(14)
21061         }
21062         res = 0;
21063         PRE_IO
21064         WRITE_BYTE_F(adr, res)
21065         POST_IO
21066         RET(14)
21067 }
21068
21069 // STCC
21070 OPCODE(0x59E0)
21071 {
21072         u32 adr, res;
21073         u32 src, dst;
21074
21075         adr = AREG((Opcode >> 0) & 7) - 1;
21076         AREG((Opcode >> 0) & 7) = adr;
21077         if (flag_V & 0x80)
21078         {
21079         res = 0xFF;
21080         PRE_IO
21081         WRITE_BYTE_F(adr, res)
21082         POST_IO
21083         RET(14)
21084         }
21085         res = 0;
21086         PRE_IO
21087         WRITE_BYTE_F(adr, res)
21088         POST_IO
21089         RET(14)
21090 }
21091
21092 // STCC
21093 OPCODE(0x5AE0)
21094 {
21095         u32 adr, res;
21096         u32 src, dst;
21097
21098         adr = AREG((Opcode >> 0) & 7) - 1;
21099         AREG((Opcode >> 0) & 7) = adr;
21100         if (!(flag_N & 0x80))
21101         {
21102         res = 0xFF;
21103         PRE_IO
21104         WRITE_BYTE_F(adr, res)
21105         POST_IO
21106         RET(14)
21107         }
21108         res = 0;
21109         PRE_IO
21110         WRITE_BYTE_F(adr, res)
21111         POST_IO
21112         RET(14)
21113 }
21114
21115 // STCC
21116 OPCODE(0x5BE0)
21117 {
21118         u32 adr, res;
21119         u32 src, dst;
21120
21121         adr = AREG((Opcode >> 0) & 7) - 1;
21122         AREG((Opcode >> 0) & 7) = adr;
21123         if (flag_N & 0x80)
21124         {
21125         res = 0xFF;
21126         PRE_IO
21127         WRITE_BYTE_F(adr, res)
21128         POST_IO
21129         RET(14)
21130         }
21131         res = 0;
21132         PRE_IO
21133         WRITE_BYTE_F(adr, res)
21134         POST_IO
21135         RET(14)
21136 }
21137
21138 // STCC
21139 OPCODE(0x5CE0)
21140 {
21141         u32 adr, res;
21142         u32 src, dst;
21143
21144         adr = AREG((Opcode >> 0) & 7) - 1;
21145         AREG((Opcode >> 0) & 7) = adr;
21146         if (!((flag_N ^ flag_V) & 0x80))
21147         {
21148         res = 0xFF;
21149         PRE_IO
21150         WRITE_BYTE_F(adr, res)
21151         POST_IO
21152         RET(14)
21153         }
21154         res = 0;
21155         PRE_IO
21156         WRITE_BYTE_F(adr, res)
21157         POST_IO
21158         RET(14)
21159 }
21160
21161 // STCC
21162 OPCODE(0x5DE0)
21163 {
21164         u32 adr, res;
21165         u32 src, dst;
21166
21167         adr = AREG((Opcode >> 0) & 7) - 1;
21168         AREG((Opcode >> 0) & 7) = adr;
21169         if ((flag_N ^ flag_V) & 0x80)
21170         {
21171         res = 0xFF;
21172         PRE_IO
21173         WRITE_BYTE_F(adr, res)
21174         POST_IO
21175         RET(14)
21176         }
21177         res = 0;
21178         PRE_IO
21179         WRITE_BYTE_F(adr, res)
21180         POST_IO
21181         RET(14)
21182 }
21183
21184 // STCC
21185 OPCODE(0x5EE0)
21186 {
21187         u32 adr, res;
21188         u32 src, dst;
21189
21190         adr = AREG((Opcode >> 0) & 7) - 1;
21191         AREG((Opcode >> 0) & 7) = adr;
21192         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21193         {
21194         res = 0xFF;
21195         PRE_IO
21196         WRITE_BYTE_F(adr, res)
21197         POST_IO
21198         RET(14)
21199         }
21200         res = 0;
21201         PRE_IO
21202         WRITE_BYTE_F(adr, res)
21203         POST_IO
21204         RET(14)
21205 }
21206
21207 // STCC
21208 OPCODE(0x5FE0)
21209 {
21210         u32 adr, res;
21211         u32 src, dst;
21212
21213         adr = AREG((Opcode >> 0) & 7) - 1;
21214         AREG((Opcode >> 0) & 7) = adr;
21215         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21216         {
21217         res = 0xFF;
21218         PRE_IO
21219         WRITE_BYTE_F(adr, res)
21220         POST_IO
21221         RET(14)
21222         }
21223         res = 0;
21224         PRE_IO
21225         WRITE_BYTE_F(adr, res)
21226         POST_IO
21227         RET(14)
21228 }
21229
21230 // STCC
21231 OPCODE(0x50E8)
21232 {
21233         u32 adr, res;
21234         u32 src, dst;
21235
21236         FETCH_SWORD(adr);
21237         adr += AREG((Opcode >> 0) & 7);
21238         res = 0xFF;
21239         PRE_IO
21240         WRITE_BYTE_F(adr, res)
21241         POST_IO
21242         RET(16)
21243 }
21244
21245 // STCC
21246 OPCODE(0x51E8)
21247 {
21248         u32 adr, res;
21249         u32 src, dst;
21250
21251         FETCH_SWORD(adr);
21252         adr += AREG((Opcode >> 0) & 7);
21253         res = 0;
21254         PRE_IO
21255         WRITE_BYTE_F(adr, res)
21256         POST_IO
21257         RET(16)
21258 }
21259
21260 // STCC
21261 OPCODE(0x52E8)
21262 {
21263         u32 adr, res;
21264         u32 src, dst;
21265
21266         FETCH_SWORD(adr);
21267         adr += AREG((Opcode >> 0) & 7);
21268         if (flag_NotZ && (!(flag_C & 0x100)))
21269         {
21270         res = 0xFF;
21271         PRE_IO
21272         WRITE_BYTE_F(adr, res)
21273         POST_IO
21274         RET(16)
21275         }
21276         res = 0;
21277         PRE_IO
21278         WRITE_BYTE_F(adr, res)
21279         POST_IO
21280         RET(16)
21281 }
21282
21283 // STCC
21284 OPCODE(0x53E8)
21285 {
21286         u32 adr, res;
21287         u32 src, dst;
21288
21289         FETCH_SWORD(adr);
21290         adr += AREG((Opcode >> 0) & 7);
21291         if ((!flag_NotZ) || (flag_C & 0x100))
21292         {
21293         res = 0xFF;
21294         PRE_IO
21295         WRITE_BYTE_F(adr, res)
21296         POST_IO
21297         RET(16)
21298         }
21299         res = 0;
21300         PRE_IO
21301         WRITE_BYTE_F(adr, res)
21302         POST_IO
21303         RET(16)
21304 }
21305
21306 // STCC
21307 OPCODE(0x54E8)
21308 {
21309         u32 adr, res;
21310         u32 src, dst;
21311
21312         FETCH_SWORD(adr);
21313         adr += AREG((Opcode >> 0) & 7);
21314         if (!(flag_C & 0x100))
21315         {
21316         res = 0xFF;
21317         PRE_IO
21318         WRITE_BYTE_F(adr, res)
21319         POST_IO
21320         RET(16)
21321         }
21322         res = 0;
21323         PRE_IO
21324         WRITE_BYTE_F(adr, res)
21325         POST_IO
21326         RET(16)
21327 }
21328
21329 // STCC
21330 OPCODE(0x55E8)
21331 {
21332         u32 adr, res;
21333         u32 src, dst;
21334
21335         FETCH_SWORD(adr);
21336         adr += AREG((Opcode >> 0) & 7);
21337         if (flag_C & 0x100)
21338         {
21339         res = 0xFF;
21340         PRE_IO
21341         WRITE_BYTE_F(adr, res)
21342         POST_IO
21343         RET(16)
21344         }
21345         res = 0;
21346         PRE_IO
21347         WRITE_BYTE_F(adr, res)
21348         POST_IO
21349         RET(16)
21350 }
21351
21352 // STCC
21353 OPCODE(0x56E8)
21354 {
21355         u32 adr, res;
21356         u32 src, dst;
21357
21358         FETCH_SWORD(adr);
21359         adr += AREG((Opcode >> 0) & 7);
21360         if (flag_NotZ)
21361         {
21362         res = 0xFF;
21363         PRE_IO
21364         WRITE_BYTE_F(adr, res)
21365         POST_IO
21366         RET(16)
21367         }
21368         res = 0;
21369         PRE_IO
21370         WRITE_BYTE_F(adr, res)
21371         POST_IO
21372         RET(16)
21373 }
21374
21375 // STCC
21376 OPCODE(0x57E8)
21377 {
21378         u32 adr, res;
21379         u32 src, dst;
21380
21381         FETCH_SWORD(adr);
21382         adr += AREG((Opcode >> 0) & 7);
21383         if (!flag_NotZ)
21384         {
21385         res = 0xFF;
21386         PRE_IO
21387         WRITE_BYTE_F(adr, res)
21388         POST_IO
21389         RET(16)
21390         }
21391         res = 0;
21392         PRE_IO
21393         WRITE_BYTE_F(adr, res)
21394         POST_IO
21395         RET(16)
21396 }
21397
21398 // STCC
21399 OPCODE(0x58E8)
21400 {
21401         u32 adr, res;
21402         u32 src, dst;
21403
21404         FETCH_SWORD(adr);
21405         adr += AREG((Opcode >> 0) & 7);
21406         if (!(flag_V & 0x80))
21407         {
21408         res = 0xFF;
21409         PRE_IO
21410         WRITE_BYTE_F(adr, res)
21411         POST_IO
21412         RET(16)
21413         }
21414         res = 0;
21415         PRE_IO
21416         WRITE_BYTE_F(adr, res)
21417         POST_IO
21418         RET(16)
21419 }
21420
21421 // STCC
21422 OPCODE(0x59E8)
21423 {
21424         u32 adr, res;
21425         u32 src, dst;
21426
21427         FETCH_SWORD(adr);
21428         adr += AREG((Opcode >> 0) & 7);
21429         if (flag_V & 0x80)
21430         {
21431         res = 0xFF;
21432         PRE_IO
21433         WRITE_BYTE_F(adr, res)
21434         POST_IO
21435         RET(16)
21436         }
21437         res = 0;
21438         PRE_IO
21439         WRITE_BYTE_F(adr, res)
21440         POST_IO
21441         RET(16)
21442 }
21443
21444 // STCC
21445 OPCODE(0x5AE8)
21446 {
21447         u32 adr, res;
21448         u32 src, dst;
21449
21450         FETCH_SWORD(adr);
21451         adr += AREG((Opcode >> 0) & 7);
21452         if (!(flag_N & 0x80))
21453         {
21454         res = 0xFF;
21455         PRE_IO
21456         WRITE_BYTE_F(adr, res)
21457         POST_IO
21458         RET(16)
21459         }
21460         res = 0;
21461         PRE_IO
21462         WRITE_BYTE_F(adr, res)
21463         POST_IO
21464         RET(16)
21465 }
21466
21467 // STCC
21468 OPCODE(0x5BE8)
21469 {
21470         u32 adr, res;
21471         u32 src, dst;
21472
21473         FETCH_SWORD(adr);
21474         adr += AREG((Opcode >> 0) & 7);
21475         if (flag_N & 0x80)
21476         {
21477         res = 0xFF;
21478         PRE_IO
21479         WRITE_BYTE_F(adr, res)
21480         POST_IO
21481         RET(16)
21482         }
21483         res = 0;
21484         PRE_IO
21485         WRITE_BYTE_F(adr, res)
21486         POST_IO
21487         RET(16)
21488 }
21489
21490 // STCC
21491 OPCODE(0x5CE8)
21492 {
21493         u32 adr, res;
21494         u32 src, dst;
21495
21496         FETCH_SWORD(adr);
21497         adr += AREG((Opcode >> 0) & 7);
21498         if (!((flag_N ^ flag_V) & 0x80))
21499         {
21500         res = 0xFF;
21501         PRE_IO
21502         WRITE_BYTE_F(adr, res)
21503         POST_IO
21504         RET(16)
21505         }
21506         res = 0;
21507         PRE_IO
21508         WRITE_BYTE_F(adr, res)
21509         POST_IO
21510         RET(16)
21511 }
21512
21513 // STCC
21514 OPCODE(0x5DE8)
21515 {
21516         u32 adr, res;
21517         u32 src, dst;
21518
21519         FETCH_SWORD(adr);
21520         adr += AREG((Opcode >> 0) & 7);
21521         if ((flag_N ^ flag_V) & 0x80)
21522         {
21523         res = 0xFF;
21524         PRE_IO
21525         WRITE_BYTE_F(adr, res)
21526         POST_IO
21527         RET(16)
21528         }
21529         res = 0;
21530         PRE_IO
21531         WRITE_BYTE_F(adr, res)
21532         POST_IO
21533         RET(16)
21534 }
21535
21536 // STCC
21537 OPCODE(0x5EE8)
21538 {
21539         u32 adr, res;
21540         u32 src, dst;
21541
21542         FETCH_SWORD(adr);
21543         adr += AREG((Opcode >> 0) & 7);
21544         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21545         {
21546         res = 0xFF;
21547         PRE_IO
21548         WRITE_BYTE_F(adr, res)
21549         POST_IO
21550         RET(16)
21551         }
21552         res = 0;
21553         PRE_IO
21554         WRITE_BYTE_F(adr, res)
21555         POST_IO
21556         RET(16)
21557 }
21558
21559 // STCC
21560 OPCODE(0x5FE8)
21561 {
21562         u32 adr, res;
21563         u32 src, dst;
21564
21565         FETCH_SWORD(adr);
21566         adr += AREG((Opcode >> 0) & 7);
21567         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21568         {
21569         res = 0xFF;
21570         PRE_IO
21571         WRITE_BYTE_F(adr, res)
21572         POST_IO
21573         RET(16)
21574         }
21575         res = 0;
21576         PRE_IO
21577         WRITE_BYTE_F(adr, res)
21578         POST_IO
21579         RET(16)
21580 }
21581
21582 // STCC
21583 OPCODE(0x50F0)
21584 {
21585         u32 adr, res;
21586         u32 src, dst;
21587
21588         adr = AREG((Opcode >> 0) & 7);
21589         DECODE_EXT_WORD
21590         res = 0xFF;
21591         PRE_IO
21592         WRITE_BYTE_F(adr, res)
21593         POST_IO
21594         RET(18)
21595 }
21596
21597 // STCC
21598 OPCODE(0x51F0)
21599 {
21600         u32 adr, res;
21601         u32 src, dst;
21602
21603         adr = AREG((Opcode >> 0) & 7);
21604         DECODE_EXT_WORD
21605         res = 0;
21606         PRE_IO
21607         WRITE_BYTE_F(adr, res)
21608         POST_IO
21609         RET(18)
21610 }
21611
21612 // STCC
21613 OPCODE(0x52F0)
21614 {
21615         u32 adr, res;
21616         u32 src, dst;
21617
21618         adr = AREG((Opcode >> 0) & 7);
21619         DECODE_EXT_WORD
21620         if (flag_NotZ && (!(flag_C & 0x100)))
21621         {
21622         res = 0xFF;
21623         PRE_IO
21624         WRITE_BYTE_F(adr, res)
21625         POST_IO
21626         RET(18)
21627         }
21628         res = 0;
21629         PRE_IO
21630         WRITE_BYTE_F(adr, res)
21631         POST_IO
21632         RET(18)
21633 }
21634
21635 // STCC
21636 OPCODE(0x53F0)
21637 {
21638         u32 adr, res;
21639         u32 src, dst;
21640
21641         adr = AREG((Opcode >> 0) & 7);
21642         DECODE_EXT_WORD
21643         if ((!flag_NotZ) || (flag_C & 0x100))
21644         {
21645         res = 0xFF;
21646         PRE_IO
21647         WRITE_BYTE_F(adr, res)
21648         POST_IO
21649         RET(18)
21650         }
21651         res = 0;
21652         PRE_IO
21653         WRITE_BYTE_F(adr, res)
21654         POST_IO
21655         RET(18)
21656 }
21657
21658 // STCC
21659 OPCODE(0x54F0)
21660 {
21661         u32 adr, res;
21662         u32 src, dst;
21663
21664         adr = AREG((Opcode >> 0) & 7);
21665         DECODE_EXT_WORD
21666         if (!(flag_C & 0x100))
21667         {
21668         res = 0xFF;
21669         PRE_IO
21670         WRITE_BYTE_F(adr, res)
21671         POST_IO
21672         RET(18)
21673         }
21674         res = 0;
21675         PRE_IO
21676         WRITE_BYTE_F(adr, res)
21677         POST_IO
21678         RET(18)
21679 }
21680
21681 // STCC
21682 OPCODE(0x55F0)
21683 {
21684         u32 adr, res;
21685         u32 src, dst;
21686
21687         adr = AREG((Opcode >> 0) & 7);
21688         DECODE_EXT_WORD
21689         if (flag_C & 0x100)
21690         {
21691         res = 0xFF;
21692         PRE_IO
21693         WRITE_BYTE_F(adr, res)
21694         POST_IO
21695         RET(18)
21696         }
21697         res = 0;
21698         PRE_IO
21699         WRITE_BYTE_F(adr, res)
21700         POST_IO
21701         RET(18)
21702 }
21703
21704 // STCC
21705 OPCODE(0x56F0)
21706 {
21707         u32 adr, res;
21708         u32 src, dst;
21709
21710         adr = AREG((Opcode >> 0) & 7);
21711         DECODE_EXT_WORD
21712         if (flag_NotZ)
21713         {
21714         res = 0xFF;
21715         PRE_IO
21716         WRITE_BYTE_F(adr, res)
21717         POST_IO
21718         RET(18)
21719         }
21720         res = 0;
21721         PRE_IO
21722         WRITE_BYTE_F(adr, res)
21723         POST_IO
21724         RET(18)
21725 }
21726
21727 // STCC
21728 OPCODE(0x57F0)
21729 {
21730         u32 adr, res;
21731         u32 src, dst;
21732
21733         adr = AREG((Opcode >> 0) & 7);
21734         DECODE_EXT_WORD
21735         if (!flag_NotZ)
21736         {
21737         res = 0xFF;
21738         PRE_IO
21739         WRITE_BYTE_F(adr, res)
21740         POST_IO
21741         RET(18)
21742         }
21743         res = 0;
21744         PRE_IO
21745         WRITE_BYTE_F(adr, res)
21746         POST_IO
21747         RET(18)
21748 }
21749
21750 // STCC
21751 OPCODE(0x58F0)
21752 {
21753         u32 adr, res;
21754         u32 src, dst;
21755
21756         adr = AREG((Opcode >> 0) & 7);
21757         DECODE_EXT_WORD
21758         if (!(flag_V & 0x80))
21759         {
21760         res = 0xFF;
21761         PRE_IO
21762         WRITE_BYTE_F(adr, res)
21763         POST_IO
21764         RET(18)
21765         }
21766         res = 0;
21767         PRE_IO
21768         WRITE_BYTE_F(adr, res)
21769         POST_IO
21770         RET(18)
21771 }
21772
21773 // STCC
21774 OPCODE(0x59F0)
21775 {
21776         u32 adr, res;
21777         u32 src, dst;
21778
21779         adr = AREG((Opcode >> 0) & 7);
21780         DECODE_EXT_WORD
21781         if (flag_V & 0x80)
21782         {
21783         res = 0xFF;
21784         PRE_IO
21785         WRITE_BYTE_F(adr, res)
21786         POST_IO
21787         RET(18)
21788         }
21789         res = 0;
21790         PRE_IO
21791         WRITE_BYTE_F(adr, res)
21792         POST_IO
21793         RET(18)
21794 }
21795
21796 // STCC
21797 OPCODE(0x5AF0)
21798 {
21799         u32 adr, res;
21800         u32 src, dst;
21801
21802         adr = AREG((Opcode >> 0) & 7);
21803         DECODE_EXT_WORD
21804         if (!(flag_N & 0x80))
21805         {
21806         res = 0xFF;
21807         PRE_IO
21808         WRITE_BYTE_F(adr, res)
21809         POST_IO
21810         RET(18)
21811         }
21812         res = 0;
21813         PRE_IO
21814         WRITE_BYTE_F(adr, res)
21815         POST_IO
21816         RET(18)
21817 }
21818
21819 // STCC
21820 OPCODE(0x5BF0)
21821 {
21822         u32 adr, res;
21823         u32 src, dst;
21824
21825         adr = AREG((Opcode >> 0) & 7);
21826         DECODE_EXT_WORD
21827         if (flag_N & 0x80)
21828         {
21829         res = 0xFF;
21830         PRE_IO
21831         WRITE_BYTE_F(adr, res)
21832         POST_IO
21833         RET(18)
21834         }
21835         res = 0;
21836         PRE_IO
21837         WRITE_BYTE_F(adr, res)
21838         POST_IO
21839         RET(18)
21840 }
21841
21842 // STCC
21843 OPCODE(0x5CF0)
21844 {
21845         u32 adr, res;
21846         u32 src, dst;
21847
21848         adr = AREG((Opcode >> 0) & 7);
21849         DECODE_EXT_WORD
21850         if (!((flag_N ^ flag_V) & 0x80))
21851         {
21852         res = 0xFF;
21853         PRE_IO
21854         WRITE_BYTE_F(adr, res)
21855         POST_IO
21856         RET(18)
21857         }
21858         res = 0;
21859         PRE_IO
21860         WRITE_BYTE_F(adr, res)
21861         POST_IO
21862         RET(18)
21863 }
21864
21865 // STCC
21866 OPCODE(0x5DF0)
21867 {
21868         u32 adr, res;
21869         u32 src, dst;
21870
21871         adr = AREG((Opcode >> 0) & 7);
21872         DECODE_EXT_WORD
21873         if ((flag_N ^ flag_V) & 0x80)
21874         {
21875         res = 0xFF;
21876         PRE_IO
21877         WRITE_BYTE_F(adr, res)
21878         POST_IO
21879         RET(18)
21880         }
21881         res = 0;
21882         PRE_IO
21883         WRITE_BYTE_F(adr, res)
21884         POST_IO
21885         RET(18)
21886 }
21887
21888 // STCC
21889 OPCODE(0x5EF0)
21890 {
21891         u32 adr, res;
21892         u32 src, dst;
21893
21894         adr = AREG((Opcode >> 0) & 7);
21895         DECODE_EXT_WORD
21896         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21897         {
21898         res = 0xFF;
21899         PRE_IO
21900         WRITE_BYTE_F(adr, res)
21901         POST_IO
21902         RET(18)
21903         }
21904         res = 0;
21905         PRE_IO
21906         WRITE_BYTE_F(adr, res)
21907         POST_IO
21908         RET(18)
21909 }
21910
21911 // STCC
21912 OPCODE(0x5FF0)
21913 {
21914         u32 adr, res;
21915         u32 src, dst;
21916
21917         adr = AREG((Opcode >> 0) & 7);
21918         DECODE_EXT_WORD
21919         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21920         {
21921         res = 0xFF;
21922         PRE_IO
21923         WRITE_BYTE_F(adr, res)
21924         POST_IO
21925         RET(18)
21926         }
21927         res = 0;
21928         PRE_IO
21929         WRITE_BYTE_F(adr, res)
21930         POST_IO
21931         RET(18)
21932 }
21933
21934 // STCC
21935 OPCODE(0x50F8)
21936 {
21937         u32 adr, res;
21938         u32 src, dst;
21939
21940         FETCH_SWORD(adr);
21941         res = 0xFF;
21942         PRE_IO
21943         WRITE_BYTE_F(adr, res)
21944         POST_IO
21945         RET(16)
21946 }
21947
21948 // STCC
21949 OPCODE(0x51F8)
21950 {
21951         u32 adr, res;
21952         u32 src, dst;
21953
21954         FETCH_SWORD(adr);
21955         res = 0;
21956         PRE_IO
21957         WRITE_BYTE_F(adr, res)
21958         POST_IO
21959         RET(16)
21960 }
21961
21962 // STCC
21963 OPCODE(0x52F8)
21964 {
21965         u32 adr, res;
21966         u32 src, dst;
21967
21968         FETCH_SWORD(adr);
21969         if (flag_NotZ && (!(flag_C & 0x100)))
21970         {
21971         res = 0xFF;
21972         PRE_IO
21973         WRITE_BYTE_F(adr, res)
21974         POST_IO
21975         RET(16)
21976         }
21977         res = 0;
21978         PRE_IO
21979         WRITE_BYTE_F(adr, res)
21980         POST_IO
21981         RET(16)
21982 }
21983
21984 // STCC
21985 OPCODE(0x53F8)
21986 {
21987         u32 adr, res;
21988         u32 src, dst;
21989
21990         FETCH_SWORD(adr);
21991         if ((!flag_NotZ) || (flag_C & 0x100))
21992         {
21993         res = 0xFF;
21994         PRE_IO
21995         WRITE_BYTE_F(adr, res)
21996         POST_IO
21997         RET(16)
21998         }
21999         res = 0;
22000         PRE_IO
22001         WRITE_BYTE_F(adr, res)
22002         POST_IO
22003         RET(16)
22004 }
22005
22006 // STCC
22007 OPCODE(0x54F8)
22008 {
22009         u32 adr, res;
22010         u32 src, dst;
22011
22012         FETCH_SWORD(adr);
22013         if (!(flag_C & 0x100))
22014         {
22015         res = 0xFF;
22016         PRE_IO
22017         WRITE_BYTE_F(adr, res)
22018         POST_IO
22019         RET(16)
22020         }
22021         res = 0;
22022         PRE_IO
22023         WRITE_BYTE_F(adr, res)
22024         POST_IO
22025         RET(16)
22026 }
22027
22028 // STCC
22029 OPCODE(0x55F8)
22030 {
22031         u32 adr, res;
22032         u32 src, dst;
22033
22034         FETCH_SWORD(adr);
22035         if (flag_C & 0x100)
22036         {
22037         res = 0xFF;
22038         PRE_IO
22039         WRITE_BYTE_F(adr, res)
22040         POST_IO
22041         RET(16)
22042         }
22043         res = 0;
22044         PRE_IO
22045         WRITE_BYTE_F(adr, res)
22046         POST_IO
22047         RET(16)
22048 }
22049
22050 // STCC
22051 OPCODE(0x56F8)
22052 {
22053         u32 adr, res;
22054         u32 src, dst;
22055
22056         FETCH_SWORD(adr);
22057         if (flag_NotZ)
22058         {
22059         res = 0xFF;
22060         PRE_IO
22061         WRITE_BYTE_F(adr, res)
22062         POST_IO
22063         RET(16)
22064         }
22065         res = 0;
22066         PRE_IO
22067         WRITE_BYTE_F(adr, res)
22068         POST_IO
22069         RET(16)
22070 }
22071
22072 // STCC
22073 OPCODE(0x57F8)
22074 {
22075         u32 adr, res;
22076         u32 src, dst;
22077
22078         FETCH_SWORD(adr);
22079         if (!flag_NotZ)
22080         {
22081         res = 0xFF;
22082         PRE_IO
22083         WRITE_BYTE_F(adr, res)
22084         POST_IO
22085         RET(16)
22086         }
22087         res = 0;
22088         PRE_IO
22089         WRITE_BYTE_F(adr, res)
22090         POST_IO
22091         RET(16)
22092 }
22093
22094 // STCC
22095 OPCODE(0x58F8)
22096 {
22097         u32 adr, res;
22098         u32 src, dst;
22099
22100         FETCH_SWORD(adr);
22101         if (!(flag_V & 0x80))
22102         {
22103         res = 0xFF;
22104         PRE_IO
22105         WRITE_BYTE_F(adr, res)
22106         POST_IO
22107         RET(16)
22108         }
22109         res = 0;
22110         PRE_IO
22111         WRITE_BYTE_F(adr, res)
22112         POST_IO
22113         RET(16)
22114 }
22115
22116 // STCC
22117 OPCODE(0x59F8)
22118 {
22119         u32 adr, res;
22120         u32 src, dst;
22121
22122         FETCH_SWORD(adr);
22123         if (flag_V & 0x80)
22124         {
22125         res = 0xFF;
22126         PRE_IO
22127         WRITE_BYTE_F(adr, res)
22128         POST_IO
22129         RET(16)
22130         }
22131         res = 0;
22132         PRE_IO
22133         WRITE_BYTE_F(adr, res)
22134         POST_IO
22135         RET(16)
22136 }
22137
22138 // STCC
22139 OPCODE(0x5AF8)
22140 {
22141         u32 adr, res;
22142         u32 src, dst;
22143
22144         FETCH_SWORD(adr);
22145         if (!(flag_N & 0x80))
22146         {
22147         res = 0xFF;
22148         PRE_IO
22149         WRITE_BYTE_F(adr, res)
22150         POST_IO
22151         RET(16)
22152         }
22153         res = 0;
22154         PRE_IO
22155         WRITE_BYTE_F(adr, res)
22156         POST_IO
22157         RET(16)
22158 }
22159
22160 // STCC
22161 OPCODE(0x5BF8)
22162 {
22163         u32 adr, res;
22164         u32 src, dst;
22165
22166         FETCH_SWORD(adr);
22167         if (flag_N & 0x80)
22168         {
22169         res = 0xFF;
22170         PRE_IO
22171         WRITE_BYTE_F(adr, res)
22172         POST_IO
22173         RET(16)
22174         }
22175         res = 0;
22176         PRE_IO
22177         WRITE_BYTE_F(adr, res)
22178         POST_IO
22179         RET(16)
22180 }
22181
22182 // STCC
22183 OPCODE(0x5CF8)
22184 {
22185         u32 adr, res;
22186         u32 src, dst;
22187
22188         FETCH_SWORD(adr);
22189         if (!((flag_N ^ flag_V) & 0x80))
22190         {
22191         res = 0xFF;
22192         PRE_IO
22193         WRITE_BYTE_F(adr, res)
22194         POST_IO
22195         RET(16)
22196         }
22197         res = 0;
22198         PRE_IO
22199         WRITE_BYTE_F(adr, res)
22200         POST_IO
22201         RET(16)
22202 }
22203
22204 // STCC
22205 OPCODE(0x5DF8)
22206 {
22207         u32 adr, res;
22208         u32 src, dst;
22209
22210         FETCH_SWORD(adr);
22211         if ((flag_N ^ flag_V) & 0x80)
22212         {
22213         res = 0xFF;
22214         PRE_IO
22215         WRITE_BYTE_F(adr, res)
22216         POST_IO
22217         RET(16)
22218         }
22219         res = 0;
22220         PRE_IO
22221         WRITE_BYTE_F(adr, res)
22222         POST_IO
22223         RET(16)
22224 }
22225
22226 // STCC
22227 OPCODE(0x5EF8)
22228 {
22229         u32 adr, res;
22230         u32 src, dst;
22231
22232         FETCH_SWORD(adr);
22233         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22234         {
22235         res = 0xFF;
22236         PRE_IO
22237         WRITE_BYTE_F(adr, res)
22238         POST_IO
22239         RET(16)
22240         }
22241         res = 0;
22242         PRE_IO
22243         WRITE_BYTE_F(adr, res)
22244         POST_IO
22245         RET(16)
22246 }
22247
22248 // STCC
22249 OPCODE(0x5FF8)
22250 {
22251         u32 adr, res;
22252         u32 src, dst;
22253
22254         FETCH_SWORD(adr);
22255         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22256         {
22257         res = 0xFF;
22258         PRE_IO
22259         WRITE_BYTE_F(adr, res)
22260         POST_IO
22261         RET(16)
22262         }
22263         res = 0;
22264         PRE_IO
22265         WRITE_BYTE_F(adr, res)
22266         POST_IO
22267         RET(16)
22268 }
22269
22270 // STCC
22271 OPCODE(0x50F9)
22272 {
22273         u32 adr, res;
22274         u32 src, dst;
22275
22276         FETCH_LONG(adr);
22277         res = 0xFF;
22278         PRE_IO
22279         WRITE_BYTE_F(adr, res)
22280         POST_IO
22281         RET(20)
22282 }
22283
22284 // STCC
22285 OPCODE(0x51F9)
22286 {
22287         u32 adr, res;
22288         u32 src, dst;
22289
22290         FETCH_LONG(adr);
22291         res = 0;
22292         PRE_IO
22293         WRITE_BYTE_F(adr, res)
22294         POST_IO
22295         RET(20)
22296 }
22297
22298 // STCC
22299 OPCODE(0x52F9)
22300 {
22301         u32 adr, res;
22302         u32 src, dst;
22303
22304         FETCH_LONG(adr);
22305         if (flag_NotZ && (!(flag_C & 0x100)))
22306         {
22307         res = 0xFF;
22308         PRE_IO
22309         WRITE_BYTE_F(adr, res)
22310         POST_IO
22311         RET(20)
22312         }
22313         res = 0;
22314         PRE_IO
22315         WRITE_BYTE_F(adr, res)
22316         POST_IO
22317         RET(20)
22318 }
22319
22320 // STCC
22321 OPCODE(0x53F9)
22322 {
22323         u32 adr, res;
22324         u32 src, dst;
22325
22326         FETCH_LONG(adr);
22327         if ((!flag_NotZ) || (flag_C & 0x100))
22328         {
22329         res = 0xFF;
22330         PRE_IO
22331         WRITE_BYTE_F(adr, res)
22332         POST_IO
22333         RET(20)
22334         }
22335         res = 0;
22336         PRE_IO
22337         WRITE_BYTE_F(adr, res)
22338         POST_IO
22339         RET(20)
22340 }
22341
22342 // STCC
22343 OPCODE(0x54F9)
22344 {
22345         u32 adr, res;
22346         u32 src, dst;
22347
22348         FETCH_LONG(adr);
22349         if (!(flag_C & 0x100))
22350         {
22351         res = 0xFF;
22352         PRE_IO
22353         WRITE_BYTE_F(adr, res)
22354         POST_IO
22355         RET(20)
22356         }
22357         res = 0;
22358         PRE_IO
22359         WRITE_BYTE_F(adr, res)
22360         POST_IO
22361         RET(20)
22362 }
22363
22364 // STCC
22365 OPCODE(0x55F9)
22366 {
22367         u32 adr, res;
22368         u32 src, dst;
22369
22370         FETCH_LONG(adr);
22371         if (flag_C & 0x100)
22372         {
22373         res = 0xFF;
22374         PRE_IO
22375         WRITE_BYTE_F(adr, res)
22376         POST_IO
22377         RET(20)
22378         }
22379         res = 0;
22380         PRE_IO
22381         WRITE_BYTE_F(adr, res)
22382         POST_IO
22383         RET(20)
22384 }
22385
22386 // STCC
22387 OPCODE(0x56F9)
22388 {
22389         u32 adr, res;
22390         u32 src, dst;
22391
22392         FETCH_LONG(adr);
22393         if (flag_NotZ)
22394         {
22395         res = 0xFF;
22396         PRE_IO
22397         WRITE_BYTE_F(adr, res)
22398         POST_IO
22399         RET(20)
22400         }
22401         res = 0;
22402         PRE_IO
22403         WRITE_BYTE_F(adr, res)
22404         POST_IO
22405         RET(20)
22406 }
22407
22408 // STCC
22409 OPCODE(0x57F9)
22410 {
22411         u32 adr, res;
22412         u32 src, dst;
22413
22414         FETCH_LONG(adr);
22415         if (!flag_NotZ)
22416         {
22417         res = 0xFF;
22418         PRE_IO
22419         WRITE_BYTE_F(adr, res)
22420         POST_IO
22421         RET(20)
22422         }
22423         res = 0;
22424         PRE_IO
22425         WRITE_BYTE_F(adr, res)
22426         POST_IO
22427         RET(20)
22428 }
22429
22430 // STCC
22431 OPCODE(0x58F9)
22432 {
22433         u32 adr, res;
22434         u32 src, dst;
22435
22436         FETCH_LONG(adr);
22437         if (!(flag_V & 0x80))
22438         {
22439         res = 0xFF;
22440         PRE_IO
22441         WRITE_BYTE_F(adr, res)
22442         POST_IO
22443         RET(20)
22444         }
22445         res = 0;
22446         PRE_IO
22447         WRITE_BYTE_F(adr, res)
22448         POST_IO
22449         RET(20)
22450 }
22451
22452 // STCC
22453 OPCODE(0x59F9)
22454 {
22455         u32 adr, res;
22456         u32 src, dst;
22457
22458         FETCH_LONG(adr);
22459         if (flag_V & 0x80)
22460         {
22461         res = 0xFF;
22462         PRE_IO
22463         WRITE_BYTE_F(adr, res)
22464         POST_IO
22465         RET(20)
22466         }
22467         res = 0;
22468         PRE_IO
22469         WRITE_BYTE_F(adr, res)
22470         POST_IO
22471         RET(20)
22472 }
22473
22474 // STCC
22475 OPCODE(0x5AF9)
22476 {
22477         u32 adr, res;
22478         u32 src, dst;
22479
22480         FETCH_LONG(adr);
22481         if (!(flag_N & 0x80))
22482         {
22483         res = 0xFF;
22484         PRE_IO
22485         WRITE_BYTE_F(adr, res)
22486         POST_IO
22487         RET(20)
22488         }
22489         res = 0;
22490         PRE_IO
22491         WRITE_BYTE_F(adr, res)
22492         POST_IO
22493         RET(20)
22494 }
22495
22496 // STCC
22497 OPCODE(0x5BF9)
22498 {
22499         u32 adr, res;
22500         u32 src, dst;
22501
22502         FETCH_LONG(adr);
22503         if (flag_N & 0x80)
22504         {
22505         res = 0xFF;
22506         PRE_IO
22507         WRITE_BYTE_F(adr, res)
22508         POST_IO
22509         RET(20)
22510         }
22511         res = 0;
22512         PRE_IO
22513         WRITE_BYTE_F(adr, res)
22514         POST_IO
22515         RET(20)
22516 }
22517
22518 // STCC
22519 OPCODE(0x5CF9)
22520 {
22521         u32 adr, res;
22522         u32 src, dst;
22523
22524         FETCH_LONG(adr);
22525         if (!((flag_N ^ flag_V) & 0x80))
22526         {
22527         res = 0xFF;
22528         PRE_IO
22529         WRITE_BYTE_F(adr, res)
22530         POST_IO
22531         RET(20)
22532         }
22533         res = 0;
22534         PRE_IO
22535         WRITE_BYTE_F(adr, res)
22536         POST_IO
22537         RET(20)
22538 }
22539
22540 // STCC
22541 OPCODE(0x5DF9)
22542 {
22543         u32 adr, res;
22544         u32 src, dst;
22545
22546         FETCH_LONG(adr);
22547         if ((flag_N ^ flag_V) & 0x80)
22548         {
22549         res = 0xFF;
22550         PRE_IO
22551         WRITE_BYTE_F(adr, res)
22552         POST_IO
22553         RET(20)
22554         }
22555         res = 0;
22556         PRE_IO
22557         WRITE_BYTE_F(adr, res)
22558         POST_IO
22559         RET(20)
22560 }
22561
22562 // STCC
22563 OPCODE(0x5EF9)
22564 {
22565         u32 adr, res;
22566         u32 src, dst;
22567
22568         FETCH_LONG(adr);
22569         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22570         {
22571         res = 0xFF;
22572         PRE_IO
22573         WRITE_BYTE_F(adr, res)
22574         POST_IO
22575         RET(20)
22576         }
22577         res = 0;
22578         PRE_IO
22579         WRITE_BYTE_F(adr, res)
22580         POST_IO
22581         RET(20)
22582 }
22583
22584 // STCC
22585 OPCODE(0x5FF9)
22586 {
22587         u32 adr, res;
22588         u32 src, dst;
22589
22590         FETCH_LONG(adr);
22591         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22592         {
22593         res = 0xFF;
22594         PRE_IO
22595         WRITE_BYTE_F(adr, res)
22596         POST_IO
22597         RET(20)
22598         }
22599         res = 0;
22600         PRE_IO
22601         WRITE_BYTE_F(adr, res)
22602         POST_IO
22603         RET(20)
22604 }
22605
22606 // STCC
22607 OPCODE(0x50DF)
22608 {
22609         u32 adr, res;
22610         u32 src, dst;
22611
22612         adr = AREG(7);
22613         AREG(7) += 2;
22614         res = 0xFF;
22615         PRE_IO
22616         WRITE_BYTE_F(adr, res)
22617         POST_IO
22618         RET(12)
22619 }
22620
22621 // STCC
22622 OPCODE(0x51DF)
22623 {
22624         u32 adr, res;
22625         u32 src, dst;
22626
22627         adr = AREG(7);
22628         AREG(7) += 2;
22629         res = 0;
22630         PRE_IO
22631         WRITE_BYTE_F(adr, res)
22632         POST_IO
22633         RET(12)
22634 }
22635
22636 // STCC
22637 OPCODE(0x52DF)
22638 {
22639         u32 adr, res;
22640         u32 src, dst;
22641
22642         adr = AREG(7);
22643         AREG(7) += 2;
22644         if (flag_NotZ && (!(flag_C & 0x100)))
22645         {
22646         res = 0xFF;
22647         PRE_IO
22648         WRITE_BYTE_F(adr, res)
22649         POST_IO
22650         RET(12)
22651         }
22652         res = 0;
22653         PRE_IO
22654         WRITE_BYTE_F(adr, res)
22655         POST_IO
22656         RET(12)
22657 }
22658
22659 // STCC
22660 OPCODE(0x53DF)
22661 {
22662         u32 adr, res;
22663         u32 src, dst;
22664
22665         adr = AREG(7);
22666         AREG(7) += 2;
22667         if ((!flag_NotZ) || (flag_C & 0x100))
22668         {
22669         res = 0xFF;
22670         PRE_IO
22671         WRITE_BYTE_F(adr, res)
22672         POST_IO
22673         RET(12)
22674         }
22675         res = 0;
22676         PRE_IO
22677         WRITE_BYTE_F(adr, res)
22678         POST_IO
22679         RET(12)
22680 }
22681
22682 // STCC
22683 OPCODE(0x54DF)
22684 {
22685         u32 adr, res;
22686         u32 src, dst;
22687
22688         adr = AREG(7);
22689         AREG(7) += 2;
22690         if (!(flag_C & 0x100))
22691         {
22692         res = 0xFF;
22693         PRE_IO
22694         WRITE_BYTE_F(adr, res)
22695         POST_IO
22696         RET(12)
22697         }
22698         res = 0;
22699         PRE_IO
22700         WRITE_BYTE_F(adr, res)
22701         POST_IO
22702         RET(12)
22703 }
22704
22705 // STCC
22706 OPCODE(0x55DF)
22707 {
22708         u32 adr, res;
22709         u32 src, dst;
22710
22711         adr = AREG(7);
22712         AREG(7) += 2;
22713         if (flag_C & 0x100)
22714         {
22715         res = 0xFF;
22716         PRE_IO
22717         WRITE_BYTE_F(adr, res)
22718         POST_IO
22719         RET(12)
22720         }
22721         res = 0;
22722         PRE_IO
22723         WRITE_BYTE_F(adr, res)
22724         POST_IO
22725         RET(12)
22726 }
22727
22728 // STCC
22729 OPCODE(0x56DF)
22730 {
22731         u32 adr, res;
22732         u32 src, dst;
22733
22734         adr = AREG(7);
22735         AREG(7) += 2;
22736         if (flag_NotZ)
22737         {
22738         res = 0xFF;
22739         PRE_IO
22740         WRITE_BYTE_F(adr, res)
22741         POST_IO
22742         RET(12)
22743         }
22744         res = 0;
22745         PRE_IO
22746         WRITE_BYTE_F(adr, res)
22747         POST_IO
22748         RET(12)
22749 }
22750
22751 // STCC
22752 OPCODE(0x57DF)
22753 {
22754         u32 adr, res;
22755         u32 src, dst;
22756
22757         adr = AREG(7);
22758         AREG(7) += 2;
22759         if (!flag_NotZ)
22760         {
22761         res = 0xFF;
22762         PRE_IO
22763         WRITE_BYTE_F(adr, res)
22764         POST_IO
22765         RET(12)
22766         }
22767         res = 0;
22768         PRE_IO
22769         WRITE_BYTE_F(adr, res)
22770         POST_IO
22771         RET(12)
22772 }
22773
22774 // STCC
22775 OPCODE(0x58DF)
22776 {
22777         u32 adr, res;
22778         u32 src, dst;
22779
22780         adr = AREG(7);
22781         AREG(7) += 2;
22782         if (!(flag_V & 0x80))
22783         {
22784         res = 0xFF;
22785         PRE_IO
22786         WRITE_BYTE_F(adr, res)
22787         POST_IO
22788         RET(12)
22789         }
22790         res = 0;
22791         PRE_IO
22792         WRITE_BYTE_F(adr, res)
22793         POST_IO
22794         RET(12)
22795 }
22796
22797 // STCC
22798 OPCODE(0x59DF)
22799 {
22800         u32 adr, res;
22801         u32 src, dst;
22802
22803         adr = AREG(7);
22804         AREG(7) += 2;
22805         if (flag_V & 0x80)
22806         {
22807         res = 0xFF;
22808         PRE_IO
22809         WRITE_BYTE_F(adr, res)
22810         POST_IO
22811         RET(12)
22812         }
22813         res = 0;
22814         PRE_IO
22815         WRITE_BYTE_F(adr, res)
22816         POST_IO
22817         RET(12)
22818 }
22819
22820 // STCC
22821 OPCODE(0x5ADF)
22822 {
22823         u32 adr, res;
22824         u32 src, dst;
22825
22826         adr = AREG(7);
22827         AREG(7) += 2;
22828         if (!(flag_N & 0x80))
22829         {
22830         res = 0xFF;
22831         PRE_IO
22832         WRITE_BYTE_F(adr, res)
22833         POST_IO
22834         RET(12)
22835         }
22836         res = 0;
22837         PRE_IO
22838         WRITE_BYTE_F(adr, res)
22839         POST_IO
22840         RET(12)
22841 }
22842
22843 // STCC
22844 OPCODE(0x5BDF)
22845 {
22846         u32 adr, res;
22847         u32 src, dst;
22848
22849         adr = AREG(7);
22850         AREG(7) += 2;
22851         if (flag_N & 0x80)
22852         {
22853         res = 0xFF;
22854         PRE_IO
22855         WRITE_BYTE_F(adr, res)
22856         POST_IO
22857         RET(12)
22858         }
22859         res = 0;
22860         PRE_IO
22861         WRITE_BYTE_F(adr, res)
22862         POST_IO
22863         RET(12)
22864 }
22865
22866 // STCC
22867 OPCODE(0x5CDF)
22868 {
22869         u32 adr, res;
22870         u32 src, dst;
22871
22872         adr = AREG(7);
22873         AREG(7) += 2;
22874         if (!((flag_N ^ flag_V) & 0x80))
22875         {
22876         res = 0xFF;
22877         PRE_IO
22878         WRITE_BYTE_F(adr, res)
22879         POST_IO
22880         RET(12)
22881         }
22882         res = 0;
22883         PRE_IO
22884         WRITE_BYTE_F(adr, res)
22885         POST_IO
22886         RET(12)
22887 }
22888
22889 // STCC
22890 OPCODE(0x5DDF)
22891 {
22892         u32 adr, res;
22893         u32 src, dst;
22894
22895         adr = AREG(7);
22896         AREG(7) += 2;
22897         if ((flag_N ^ flag_V) & 0x80)
22898         {
22899         res = 0xFF;
22900         PRE_IO
22901         WRITE_BYTE_F(adr, res)
22902         POST_IO
22903         RET(12)
22904         }
22905         res = 0;
22906         PRE_IO
22907         WRITE_BYTE_F(adr, res)
22908         POST_IO
22909         RET(12)
22910 }
22911
22912 // STCC
22913 OPCODE(0x5EDF)
22914 {
22915         u32 adr, res;
22916         u32 src, dst;
22917
22918         adr = AREG(7);
22919         AREG(7) += 2;
22920         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22921         {
22922         res = 0xFF;
22923         PRE_IO
22924         WRITE_BYTE_F(adr, res)
22925         POST_IO
22926         RET(12)
22927         }
22928         res = 0;
22929         PRE_IO
22930         WRITE_BYTE_F(adr, res)
22931         POST_IO
22932         RET(12)
22933 }
22934
22935 // STCC
22936 OPCODE(0x5FDF)
22937 {
22938         u32 adr, res;
22939         u32 src, dst;
22940
22941         adr = AREG(7);
22942         AREG(7) += 2;
22943         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22944         {
22945         res = 0xFF;
22946         PRE_IO
22947         WRITE_BYTE_F(adr, res)
22948         POST_IO
22949         RET(12)
22950         }
22951         res = 0;
22952         PRE_IO
22953         WRITE_BYTE_F(adr, res)
22954         POST_IO
22955         RET(12)
22956 }
22957
22958 // STCC
22959 OPCODE(0x50E7)
22960 {
22961         u32 adr, res;
22962         u32 src, dst;
22963
22964         adr = AREG(7) - 2;
22965         AREG(7) = adr;
22966         res = 0xFF;
22967         PRE_IO
22968         WRITE_BYTE_F(adr, res)
22969         POST_IO
22970         RET(14)
22971 }
22972
22973 // STCC
22974 OPCODE(0x51E7)
22975 {
22976         u32 adr, res;
22977         u32 src, dst;
22978
22979         adr = AREG(7) - 2;
22980         AREG(7) = adr;
22981         res = 0;
22982         PRE_IO
22983         WRITE_BYTE_F(adr, res)
22984         POST_IO
22985         RET(14)
22986 }
22987
22988 // STCC
22989 OPCODE(0x52E7)
22990 {
22991         u32 adr, res;
22992         u32 src, dst;
22993
22994         adr = AREG(7) - 2;
22995         AREG(7) = adr;
22996         if (flag_NotZ && (!(flag_C & 0x100)))
22997         {
22998         res = 0xFF;
22999         PRE_IO
23000         WRITE_BYTE_F(adr, res)
23001         POST_IO
23002         RET(14)
23003         }
23004         res = 0;
23005         PRE_IO
23006         WRITE_BYTE_F(adr, res)
23007         POST_IO
23008         RET(14)
23009 }
23010
23011 // STCC
23012 OPCODE(0x53E7)
23013 {
23014         u32 adr, res;
23015         u32 src, dst;
23016
23017         adr = AREG(7) - 2;
23018         AREG(7) = adr;
23019         if ((!flag_NotZ) || (flag_C & 0x100))
23020         {
23021         res = 0xFF;
23022         PRE_IO
23023         WRITE_BYTE_F(adr, res)
23024         POST_IO
23025         RET(14)
23026         }
23027         res = 0;
23028         PRE_IO
23029         WRITE_BYTE_F(adr, res)
23030         POST_IO
23031         RET(14)
23032 }
23033
23034 // STCC
23035 OPCODE(0x54E7)
23036 {
23037         u32 adr, res;
23038         u32 src, dst;
23039
23040         adr = AREG(7) - 2;
23041         AREG(7) = adr;
23042         if (!(flag_C & 0x100))
23043         {
23044         res = 0xFF;
23045         PRE_IO
23046         WRITE_BYTE_F(adr, res)
23047         POST_IO
23048         RET(14)
23049         }
23050         res = 0;
23051         PRE_IO
23052         WRITE_BYTE_F(adr, res)
23053         POST_IO
23054         RET(14)
23055 }
23056
23057 // STCC
23058 OPCODE(0x55E7)
23059 {
23060         u32 adr, res;
23061         u32 src, dst;
23062
23063         adr = AREG(7) - 2;
23064         AREG(7) = adr;
23065         if (flag_C & 0x100)
23066         {
23067         res = 0xFF;
23068         PRE_IO
23069         WRITE_BYTE_F(adr, res)
23070         POST_IO
23071         RET(14)
23072         }
23073         res = 0;
23074         PRE_IO
23075         WRITE_BYTE_F(adr, res)
23076         POST_IO
23077         RET(14)
23078 }
23079
23080 // STCC
23081 OPCODE(0x56E7)
23082 {
23083         u32 adr, res;
23084         u32 src, dst;
23085
23086         adr = AREG(7) - 2;
23087         AREG(7) = adr;
23088         if (flag_NotZ)
23089         {
23090         res = 0xFF;
23091         PRE_IO
23092         WRITE_BYTE_F(adr, res)
23093         POST_IO
23094         RET(14)
23095         }
23096         res = 0;
23097         PRE_IO
23098         WRITE_BYTE_F(adr, res)
23099         POST_IO
23100         RET(14)
23101 }
23102
23103 // STCC
23104 OPCODE(0x57E7)
23105 {
23106         u32 adr, res;
23107         u32 src, dst;
23108
23109         adr = AREG(7) - 2;
23110         AREG(7) = adr;
23111         if (!flag_NotZ)
23112         {
23113         res = 0xFF;
23114         PRE_IO
23115         WRITE_BYTE_F(adr, res)
23116         POST_IO
23117         RET(14)
23118         }
23119         res = 0;
23120         PRE_IO
23121         WRITE_BYTE_F(adr, res)
23122         POST_IO
23123         RET(14)
23124 }
23125
23126 // STCC
23127 OPCODE(0x58E7)
23128 {
23129         u32 adr, res;
23130         u32 src, dst;
23131
23132         adr = AREG(7) - 2;
23133         AREG(7) = adr;
23134         if (!(flag_V & 0x80))
23135         {
23136         res = 0xFF;
23137         PRE_IO
23138         WRITE_BYTE_F(adr, res)
23139         POST_IO
23140         RET(14)
23141         }
23142         res = 0;
23143         PRE_IO
23144         WRITE_BYTE_F(adr, res)
23145         POST_IO
23146         RET(14)
23147 }
23148
23149 // STCC
23150 OPCODE(0x59E7)
23151 {
23152         u32 adr, res;
23153         u32 src, dst;
23154
23155         adr = AREG(7) - 2;
23156         AREG(7) = adr;
23157         if (flag_V & 0x80)
23158         {
23159         res = 0xFF;
23160         PRE_IO
23161         WRITE_BYTE_F(adr, res)
23162         POST_IO
23163         RET(14)
23164         }
23165         res = 0;
23166         PRE_IO
23167         WRITE_BYTE_F(adr, res)
23168         POST_IO
23169         RET(14)
23170 }
23171
23172 // STCC
23173 OPCODE(0x5AE7)
23174 {
23175         u32 adr, res;
23176         u32 src, dst;
23177
23178         adr = AREG(7) - 2;
23179         AREG(7) = adr;
23180         if (!(flag_N & 0x80))
23181         {
23182         res = 0xFF;
23183         PRE_IO
23184         WRITE_BYTE_F(adr, res)
23185         POST_IO
23186         RET(14)
23187         }
23188         res = 0;
23189         PRE_IO
23190         WRITE_BYTE_F(adr, res)
23191         POST_IO
23192         RET(14)
23193 }
23194
23195 // STCC
23196 OPCODE(0x5BE7)
23197 {
23198         u32 adr, res;
23199         u32 src, dst;
23200
23201         adr = AREG(7) - 2;
23202         AREG(7) = adr;
23203         if (flag_N & 0x80)
23204         {
23205         res = 0xFF;
23206         PRE_IO
23207         WRITE_BYTE_F(adr, res)
23208         POST_IO
23209         RET(14)
23210         }
23211         res = 0;
23212         PRE_IO
23213         WRITE_BYTE_F(adr, res)
23214         POST_IO
23215         RET(14)
23216 }
23217
23218 // STCC
23219 OPCODE(0x5CE7)
23220 {
23221         u32 adr, res;
23222         u32 src, dst;
23223
23224         adr = AREG(7) - 2;
23225         AREG(7) = adr;
23226         if (!((flag_N ^ flag_V) & 0x80))
23227         {
23228         res = 0xFF;
23229         PRE_IO
23230         WRITE_BYTE_F(adr, res)
23231         POST_IO
23232         RET(14)
23233         }
23234         res = 0;
23235         PRE_IO
23236         WRITE_BYTE_F(adr, res)
23237         POST_IO
23238         RET(14)
23239 }
23240
23241 // STCC
23242 OPCODE(0x5DE7)
23243 {
23244         u32 adr, res;
23245         u32 src, dst;
23246
23247         adr = AREG(7) - 2;
23248         AREG(7) = adr;
23249         if ((flag_N ^ flag_V) & 0x80)
23250         {
23251         res = 0xFF;
23252         PRE_IO
23253         WRITE_BYTE_F(adr, res)
23254         POST_IO
23255         RET(14)
23256         }
23257         res = 0;
23258         PRE_IO
23259         WRITE_BYTE_F(adr, res)
23260         POST_IO
23261         RET(14)
23262 }
23263
23264 // STCC
23265 OPCODE(0x5EE7)
23266 {
23267         u32 adr, res;
23268         u32 src, dst;
23269
23270         adr = AREG(7) - 2;
23271         AREG(7) = adr;
23272         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
23273         {
23274         res = 0xFF;
23275         PRE_IO
23276         WRITE_BYTE_F(adr, res)
23277         POST_IO
23278         RET(14)
23279         }
23280         res = 0;
23281         PRE_IO
23282         WRITE_BYTE_F(adr, res)
23283         POST_IO
23284         RET(14)
23285 }
23286
23287 // STCC
23288 OPCODE(0x5FE7)
23289 {
23290         u32 adr, res;
23291         u32 src, dst;
23292
23293         adr = AREG(7) - 2;
23294         AREG(7) = adr;
23295         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
23296         {
23297         res = 0xFF;
23298         PRE_IO
23299         WRITE_BYTE_F(adr, res)
23300         POST_IO
23301         RET(14)
23302         }
23303         res = 0;
23304         PRE_IO
23305         WRITE_BYTE_F(adr, res)
23306         POST_IO
23307         RET(14)
23308 }
23309
23310 // DBCC
23311 OPCODE(0x50C8)
23312 {
23313         u32 adr, res;
23314         u32 src, dst;
23315
23316         PC++;
23317 RET(12)
23318 }
23319
23320 // DBCC
23321 OPCODE(0x51C8)
23322 {
23323         u32 adr, res;
23324         u32 src, dst;
23325
23326         NOT_POLLING
23327
23328         res = DREGu16((Opcode >> 0) & 7);
23329         res--;
23330         DREGu16((Opcode >> 0) & 7) = res;
23331         if ((s32)res != -1)
23332         {
23333                 u32 newPC;
23334
23335                 newPC = GET_PC;
23336                 newPC += GET_SWORD;
23337                 SET_PC(newPC);
23338                 CHECK_BRANCH_EXCEPTION(newPC)
23339         RET(10)
23340         }
23341         PC++;
23342 RET(14)
23343 }
23344
23345 // DBCC
23346 OPCODE(0x52C8)
23347 {
23348         u32 adr, res;
23349         u32 src, dst;
23350
23351         NOT_POLLING
23352
23353         if ((!flag_NotZ) || (flag_C & 0x100))
23354         {
23355         res = DREGu16((Opcode >> 0) & 7);
23356         res--;
23357         DREGu16((Opcode >> 0) & 7) = res;
23358         if ((s32)res != -1)
23359         {
23360                 u32 newPC;
23361
23362                 newPC = GET_PC;
23363                 newPC += GET_SWORD;
23364                 SET_PC(newPC);
23365                 CHECK_BRANCH_EXCEPTION(newPC)
23366         RET(10)
23367         }
23368         }
23369         else
23370         {
23371                 PC++;
23372         RET(12)
23373         }
23374         PC++;
23375 RET(14)
23376 }
23377
23378 // DBCC
23379 OPCODE(0x53C8)
23380 {
23381         u32 adr, res;
23382         u32 src, dst;
23383
23384         NOT_POLLING
23385
23386         if (flag_NotZ && (!(flag_C & 0x100)))
23387         {
23388         res = DREGu16((Opcode >> 0) & 7);
23389         res--;
23390         DREGu16((Opcode >> 0) & 7) = res;
23391         if ((s32)res != -1)
23392         {
23393                 u32 newPC;
23394
23395                 newPC = GET_PC;
23396                 newPC += GET_SWORD;
23397                 SET_PC(newPC);
23398                 CHECK_BRANCH_EXCEPTION(newPC)
23399         RET(10)
23400         }
23401         }
23402         else
23403         {
23404                 PC++;
23405         RET(12)
23406         }
23407         PC++;
23408 RET(14)
23409 }
23410
23411 // DBCC
23412 OPCODE(0x54C8)
23413 {
23414         u32 adr, res;
23415         u32 src, dst;
23416
23417         NOT_POLLING
23418
23419         if (flag_C & 0x100)
23420         {
23421         res = DREGu16((Opcode >> 0) & 7);
23422         res--;
23423         DREGu16((Opcode >> 0) & 7) = res;
23424         if ((s32)res != -1)
23425         {
23426                 u32 newPC;
23427
23428                 newPC = GET_PC;
23429                 newPC += GET_SWORD;
23430                 SET_PC(newPC);
23431                 CHECK_BRANCH_EXCEPTION(newPC)
23432         RET(10)
23433         }
23434         }
23435         else
23436         {
23437                 PC++;
23438         RET(12)
23439         }
23440         PC++;
23441 RET(14)
23442 }
23443
23444 // DBCC
23445 OPCODE(0x55C8)
23446 {
23447         u32 adr, res;
23448         u32 src, dst;
23449
23450         NOT_POLLING
23451
23452         if (!(flag_C & 0x100))
23453         {
23454         res = DREGu16((Opcode >> 0) & 7);
23455         res--;
23456         DREGu16((Opcode >> 0) & 7) = res;
23457         if ((s32)res != -1)
23458         {
23459                 u32 newPC;
23460
23461                 newPC = GET_PC;
23462                 newPC += GET_SWORD;
23463                 SET_PC(newPC);
23464                 CHECK_BRANCH_EXCEPTION(newPC)
23465         RET(10)
23466         }
23467         }
23468         else
23469         {
23470                 PC++;
23471         RET(12)
23472         }
23473         PC++;
23474 RET(14)
23475 }
23476
23477 // DBCC
23478 OPCODE(0x56C8)
23479 {
23480         u32 adr, res;
23481         u32 src, dst;
23482
23483         NOT_POLLING
23484
23485         if (!flag_NotZ)
23486         {
23487         res = DREGu16((Opcode >> 0) & 7);
23488         res--;
23489         DREGu16((Opcode >> 0) & 7) = res;
23490         if ((s32)res != -1)
23491         {
23492                 u32 newPC;
23493
23494                 newPC = GET_PC;
23495                 newPC += GET_SWORD;
23496                 SET_PC(newPC);
23497                 CHECK_BRANCH_EXCEPTION(newPC)
23498         RET(10)
23499         }
23500         }
23501         else
23502         {
23503                 PC++;
23504         RET(12)
23505         }
23506         PC++;
23507 RET(14)
23508 }
23509
23510 // DBCC
23511 OPCODE(0x57C8)
23512 {
23513         u32 adr, res;
23514         u32 src, dst;
23515
23516         NOT_POLLING
23517
23518         if (flag_NotZ)
23519         {
23520         res = DREGu16((Opcode >> 0) & 7);
23521         res--;
23522         DREGu16((Opcode >> 0) & 7) = res;
23523         if ((s32)res != -1)
23524         {
23525                 u32 newPC;
23526
23527                 newPC = GET_PC;
23528                 newPC += GET_SWORD;
23529                 SET_PC(newPC);
23530                 CHECK_BRANCH_EXCEPTION(newPC)
23531         RET(10)
23532         }
23533         }
23534         else
23535         {
23536                 PC++;
23537         RET(12)
23538         }
23539         PC++;
23540 RET(14)
23541 }
23542
23543 // DBCC
23544 OPCODE(0x58C8)
23545 {
23546         u32 adr, res;
23547         u32 src, dst;
23548
23549         NOT_POLLING
23550
23551         if (flag_V & 0x80)
23552         {
23553         res = DREGu16((Opcode >> 0) & 7);
23554         res--;
23555         DREGu16((Opcode >> 0) & 7) = res;
23556         if ((s32)res != -1)
23557         {
23558                 u32 newPC;
23559
23560                 newPC = GET_PC;
23561                 newPC += GET_SWORD;
23562                 SET_PC(newPC);
23563                 CHECK_BRANCH_EXCEPTION(newPC)
23564         RET(10)
23565         }
23566         }
23567         else
23568         {
23569                 PC++;
23570         RET(12)
23571         }
23572         PC++;
23573 RET(14)
23574 }
23575
23576 // DBCC
23577 OPCODE(0x59C8)
23578 {
23579         u32 adr, res;
23580         u32 src, dst;
23581
23582         NOT_POLLING
23583
23584         if (!(flag_V & 0x80))
23585         {
23586         res = DREGu16((Opcode >> 0) & 7);
23587         res--;
23588         DREGu16((Opcode >> 0) & 7) = res;
23589         if ((s32)res != -1)
23590         {
23591                 u32 newPC;
23592
23593                 newPC = GET_PC;
23594                 newPC += GET_SWORD;
23595                 SET_PC(newPC);
23596                 CHECK_BRANCH_EXCEPTION(newPC)
23597         RET(10)
23598         }
23599         }
23600         else
23601         {
23602                 PC++;
23603         RET(12)
23604         }
23605         PC++;
23606 RET(14)
23607 }
23608
23609 // DBCC
23610 OPCODE(0x5AC8)
23611 {
23612         u32 adr, res;
23613         u32 src, dst;
23614
23615         NOT_POLLING
23616
23617         if (flag_N & 0x80)
23618         {
23619         res = DREGu16((Opcode >> 0) & 7);
23620         res--;
23621         DREGu16((Opcode >> 0) & 7) = res;
23622         if ((s32)res != -1)
23623         {
23624                 u32 newPC;
23625
23626                 newPC = GET_PC;
23627                 newPC += GET_SWORD;
23628                 SET_PC(newPC);
23629                 CHECK_BRANCH_EXCEPTION(newPC)
23630         RET(10)
23631         }
23632         }
23633         else
23634         {
23635                 PC++;
23636         RET(12)
23637         }
23638         PC++;
23639 RET(14)
23640 }
23641
23642 // DBCC
23643 OPCODE(0x5BC8)
23644 {
23645         u32 adr, res;
23646         u32 src, dst;
23647
23648         NOT_POLLING
23649
23650         if (!(flag_N & 0x80))
23651         {
23652         res = DREGu16((Opcode >> 0) & 7);
23653         res--;
23654         DREGu16((Opcode >> 0) & 7) = res;
23655         if ((s32)res != -1)
23656         {
23657                 u32 newPC;
23658
23659                 newPC = GET_PC;
23660                 newPC += GET_SWORD;
23661                 SET_PC(newPC);
23662                 CHECK_BRANCH_EXCEPTION(newPC)
23663         RET(10)
23664         }
23665         }
23666         else
23667         {
23668                 PC++;
23669         RET(12)
23670         }
23671         PC++;
23672 RET(14)
23673 }
23674
23675 // DBCC
23676 OPCODE(0x5CC8)
23677 {
23678         u32 adr, res;
23679         u32 src, dst;
23680
23681         NOT_POLLING
23682
23683         if ((flag_N ^ flag_V) & 0x80)
23684         {
23685         res = DREGu16((Opcode >> 0) & 7);
23686         res--;
23687         DREGu16((Opcode >> 0) & 7) = res;
23688         if ((s32)res != -1)
23689         {
23690                 u32 newPC;
23691
23692                 newPC = GET_PC;
23693                 newPC += GET_SWORD;
23694                 SET_PC(newPC);
23695                 CHECK_BRANCH_EXCEPTION(newPC)
23696         RET(10)
23697         }
23698         }
23699         else
23700         {
23701                 PC++;
23702         RET(12)
23703         }
23704         PC++;
23705 RET(14)
23706 }
23707
23708 // DBCC
23709 OPCODE(0x5DC8)
23710 {
23711         u32 adr, res;
23712         u32 src, dst;
23713
23714         NOT_POLLING
23715
23716         if (!((flag_N ^ flag_V) & 0x80))
23717         {
23718         res = DREGu16((Opcode >> 0) & 7);
23719         res--;
23720         DREGu16((Opcode >> 0) & 7) = res;
23721         if ((s32)res != -1)
23722         {
23723                 u32 newPC;
23724
23725                 newPC = GET_PC;
23726                 newPC += GET_SWORD;
23727                 SET_PC(newPC);
23728                 CHECK_BRANCH_EXCEPTION(newPC)
23729         RET(10)
23730         }
23731         }
23732         else
23733         {
23734                 PC++;
23735         RET(12)
23736         }
23737         PC++;
23738 RET(14)
23739 }
23740
23741 // DBCC
23742 OPCODE(0x5EC8)
23743 {
23744         u32 adr, res;
23745         u32 src, dst;
23746
23747         NOT_POLLING
23748
23749         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
23750         {
23751         res = DREGu16((Opcode >> 0) & 7);
23752         res--;
23753         DREGu16((Opcode >> 0) & 7) = res;
23754         if ((s32)res != -1)
23755         {
23756                 u32 newPC;
23757
23758                 newPC = GET_PC;
23759                 newPC += GET_SWORD;
23760                 SET_PC(newPC);
23761                 CHECK_BRANCH_EXCEPTION(newPC)
23762         RET(10)
23763         }
23764         }
23765         else
23766         {
23767                 PC++;
23768         RET(12)
23769         }
23770         PC++;
23771 RET(14)
23772 }
23773
23774 // DBCC
23775 OPCODE(0x5FC8)
23776 {
23777         u32 adr, res;
23778         u32 src, dst;
23779
23780         NOT_POLLING
23781
23782         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
23783         {
23784         res = DREGu16((Opcode >> 0) & 7);
23785         res--;
23786         DREGu16((Opcode >> 0) & 7) = res;
23787         if ((s32)res != -1)
23788         {
23789                 u32 newPC;
23790
23791                 newPC = GET_PC;
23792                 newPC += GET_SWORD;
23793                 SET_PC(newPC);
23794                 CHECK_BRANCH_EXCEPTION(newPC)
23795         RET(10)
23796         }
23797         }
23798         else
23799         {
23800                 PC++;
23801         RET(12)
23802         }
23803         PC++;
23804 RET(14)
23805 }
23806
23807 // ADDQ
23808 OPCODE(0x5000)
23809 {
23810         u32 adr, res;
23811         u32 src, dst;
23812
23813         src = (((Opcode >> 9) - 1) & 7) + 1;
23814         dst = DREGu8((Opcode >> 0) & 7);
23815         res = dst + src;
23816         flag_N = flag_X = flag_C = res;
23817         flag_V = (src ^ res) & (dst ^ res);
23818         flag_NotZ = res & 0xFF;
23819         DREGu8((Opcode >> 0) & 7) = res;
23820 RET(4)
23821 }
23822
23823 // ADDQ
23824 OPCODE(0x5010)
23825 {
23826         u32 adr, res;
23827         u32 src, dst;
23828
23829         src = (((Opcode >> 9) - 1) & 7) + 1;
23830         adr = AREG((Opcode >> 0) & 7);
23831         PRE_IO
23832         READ_BYTE_F(adr, dst)
23833         res = dst + src;
23834         flag_N = flag_X = flag_C = res;
23835         flag_V = (src ^ res) & (dst ^ res);
23836         flag_NotZ = res & 0xFF;
23837         WRITE_BYTE_F(adr, res)
23838         POST_IO
23839 RET(12)
23840 }
23841
23842 // ADDQ
23843 OPCODE(0x5018)
23844 {
23845         u32 adr, res;
23846         u32 src, dst;
23847
23848         src = (((Opcode >> 9) - 1) & 7) + 1;
23849         adr = AREG((Opcode >> 0) & 7);
23850         AREG((Opcode >> 0) & 7) += 1;
23851         PRE_IO
23852         READ_BYTE_F(adr, dst)
23853         res = dst + src;
23854         flag_N = flag_X = flag_C = res;
23855         flag_V = (src ^ res) & (dst ^ res);
23856         flag_NotZ = res & 0xFF;
23857         WRITE_BYTE_F(adr, res)
23858         POST_IO
23859 RET(12)
23860 }
23861
23862 // ADDQ
23863 OPCODE(0x5020)
23864 {
23865         u32 adr, res;
23866         u32 src, dst;
23867
23868         src = (((Opcode >> 9) - 1) & 7) + 1;
23869         adr = AREG((Opcode >> 0) & 7) - 1;
23870         AREG((Opcode >> 0) & 7) = adr;
23871         PRE_IO
23872         READ_BYTE_F(adr, dst)
23873         res = dst + src;
23874         flag_N = flag_X = flag_C = res;
23875         flag_V = (src ^ res) & (dst ^ res);
23876         flag_NotZ = res & 0xFF;
23877         WRITE_BYTE_F(adr, res)
23878         POST_IO
23879 RET(14)
23880 }
23881
23882 // ADDQ
23883 OPCODE(0x5028)
23884 {
23885         u32 adr, res;
23886         u32 src, dst;
23887
23888         src = (((Opcode >> 9) - 1) & 7) + 1;
23889         FETCH_SWORD(adr);
23890         adr += AREG((Opcode >> 0) & 7);
23891         PRE_IO
23892         READ_BYTE_F(adr, dst)
23893         res = dst + src;
23894         flag_N = flag_X = flag_C = res;
23895         flag_V = (src ^ res) & (dst ^ res);
23896         flag_NotZ = res & 0xFF;
23897         WRITE_BYTE_F(adr, res)
23898         POST_IO
23899 RET(16)
23900 }
23901
23902 // ADDQ
23903 OPCODE(0x5030)
23904 {
23905         u32 adr, res;
23906         u32 src, dst;
23907
23908         src = (((Opcode >> 9) - 1) & 7) + 1;
23909         adr = AREG((Opcode >> 0) & 7);
23910         DECODE_EXT_WORD
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(18)
23920 }
23921
23922 // ADDQ
23923 OPCODE(0x5038)
23924 {
23925         u32 adr, res;
23926         u32 src, dst;
23927
23928         src = (((Opcode >> 9) - 1) & 7) + 1;
23929         FETCH_SWORD(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(16)
23939 }
23940
23941 // ADDQ
23942 OPCODE(0x5039)
23943 {
23944         u32 adr, res;
23945         u32 src, dst;
23946
23947         src = (((Opcode >> 9) - 1) & 7) + 1;
23948         FETCH_LONG(adr);
23949         PRE_IO
23950         READ_BYTE_F(adr, dst)
23951         res = dst + src;
23952         flag_N = flag_X = flag_C = res;
23953         flag_V = (src ^ res) & (dst ^ res);
23954         flag_NotZ = res & 0xFF;
23955         WRITE_BYTE_F(adr, res)
23956         POST_IO
23957 RET(20)
23958 }
23959
23960 // ADDQ
23961 OPCODE(0x501F)
23962 {
23963         u32 adr, res;
23964         u32 src, dst;
23965
23966         src = (((Opcode >> 9) - 1) & 7) + 1;
23967         adr = AREG(7);
23968         AREG(7) += 2;
23969         PRE_IO
23970         READ_BYTE_F(adr, dst)
23971         res = dst + src;
23972         flag_N = flag_X = flag_C = res;
23973         flag_V = (src ^ res) & (dst ^ res);
23974         flag_NotZ = res & 0xFF;
23975         WRITE_BYTE_F(adr, res)
23976         POST_IO
23977 RET(12)
23978 }
23979
23980 // ADDQ
23981 OPCODE(0x5027)
23982 {
23983         u32 adr, res;
23984         u32 src, dst;
23985
23986         src = (((Opcode >> 9) - 1) & 7) + 1;
23987         adr = AREG(7) - 2;
23988         AREG(7) = adr;
23989         PRE_IO
23990         READ_BYTE_F(adr, dst)
23991         res = dst + src;
23992         flag_N = flag_X = flag_C = res;
23993         flag_V = (src ^ res) & (dst ^ res);
23994         flag_NotZ = res & 0xFF;
23995         WRITE_BYTE_F(adr, res)
23996         POST_IO
23997 RET(14)
23998 }
23999
24000 // ADDQ
24001 OPCODE(0x5040)
24002 {
24003         u32 adr, res;
24004         u32 src, dst;
24005
24006         src = (((Opcode >> 9) - 1) & 7) + 1;
24007         dst = DREGu16((Opcode >> 0) & 7);
24008         res = dst + src;
24009         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24010         flag_N = flag_X = flag_C = res >> 8;
24011         flag_NotZ = res & 0xFFFF;
24012         DREGu16((Opcode >> 0) & 7) = res;
24013 RET(4)
24014 }
24015
24016 // ADDQ
24017 OPCODE(0x5048)
24018 {
24019         u32 adr, res;
24020         u32 src, dst;
24021
24022         src = (((Opcode >> 9) - 1) & 7) + 1;
24023         dst = AREGu32((Opcode >> 0) & 7);
24024         res = dst + src;
24025         AREG((Opcode >> 0) & 7) = res;
24026 #ifdef USE_CYCLONE_TIMING
24027 RET(4)
24028 #else
24029 RET(8)
24030 #endif
24031 }
24032
24033 // ADDQ
24034 OPCODE(0x5050)
24035 {
24036         u32 adr, res;
24037         u32 src, dst;
24038
24039         src = (((Opcode >> 9) - 1) & 7) + 1;
24040         adr = AREG((Opcode >> 0) & 7);
24041         PRE_IO
24042         READ_WORD_F(adr, dst)
24043         res = dst + src;
24044         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24045         flag_N = flag_X = flag_C = res >> 8;
24046         flag_NotZ = res & 0xFFFF;
24047         WRITE_WORD_F(adr, res)
24048         POST_IO
24049 RET(12)
24050 }
24051
24052 // ADDQ
24053 OPCODE(0x5058)
24054 {
24055         u32 adr, res;
24056         u32 src, dst;
24057
24058         src = (((Opcode >> 9) - 1) & 7) + 1;
24059         adr = AREG((Opcode >> 0) & 7);
24060         AREG((Opcode >> 0) & 7) += 2;
24061         PRE_IO
24062         READ_WORD_F(adr, dst)
24063         res = dst + src;
24064         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24065         flag_N = flag_X = flag_C = res >> 8;
24066         flag_NotZ = res & 0xFFFF;
24067         WRITE_WORD_F(adr, res)
24068         POST_IO
24069 RET(12)
24070 }
24071
24072 // ADDQ
24073 OPCODE(0x5060)
24074 {
24075         u32 adr, res;
24076         u32 src, dst;
24077
24078         src = (((Opcode >> 9) - 1) & 7) + 1;
24079         adr = AREG((Opcode >> 0) & 7) - 2;
24080         AREG((Opcode >> 0) & 7) = adr;
24081         PRE_IO
24082         READ_WORD_F(adr, dst)
24083         res = dst + src;
24084         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24085         flag_N = flag_X = flag_C = res >> 8;
24086         flag_NotZ = res & 0xFFFF;
24087         WRITE_WORD_F(adr, res)
24088         POST_IO
24089 RET(14)
24090 }
24091
24092 // ADDQ
24093 OPCODE(0x5068)
24094 {
24095         u32 adr, res;
24096         u32 src, dst;
24097
24098         src = (((Opcode >> 9) - 1) & 7) + 1;
24099         FETCH_SWORD(adr);
24100         adr += AREG((Opcode >> 0) & 7);
24101         PRE_IO
24102         READ_WORD_F(adr, dst)
24103         res = dst + src;
24104         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24105         flag_N = flag_X = flag_C = res >> 8;
24106         flag_NotZ = res & 0xFFFF;
24107         WRITE_WORD_F(adr, res)
24108         POST_IO
24109 RET(16)
24110 }
24111
24112 // ADDQ
24113 OPCODE(0x5070)
24114 {
24115         u32 adr, res;
24116         u32 src, dst;
24117
24118         src = (((Opcode >> 9) - 1) & 7) + 1;
24119         adr = AREG((Opcode >> 0) & 7);
24120         DECODE_EXT_WORD
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(18)
24130 }
24131
24132 // ADDQ
24133 OPCODE(0x5078)
24134 {
24135         u32 adr, res;
24136         u32 src, dst;
24137
24138         src = (((Opcode >> 9) - 1) & 7) + 1;
24139         FETCH_SWORD(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(16)
24149 }
24150
24151 // ADDQ
24152 OPCODE(0x5079)
24153 {
24154         u32 adr, res;
24155         u32 src, dst;
24156
24157         src = (((Opcode >> 9) - 1) & 7) + 1;
24158         FETCH_LONG(adr);
24159         PRE_IO
24160         READ_WORD_F(adr, dst)
24161         res = dst + src;
24162         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24163         flag_N = flag_X = flag_C = res >> 8;
24164         flag_NotZ = res & 0xFFFF;
24165         WRITE_WORD_F(adr, res)
24166         POST_IO
24167 RET(20)
24168 }
24169
24170 // ADDQ
24171 OPCODE(0x505F)
24172 {
24173         u32 adr, res;
24174         u32 src, dst;
24175
24176         src = (((Opcode >> 9) - 1) & 7) + 1;
24177         adr = AREG(7);
24178         AREG(7) += 2;
24179         PRE_IO
24180         READ_WORD_F(adr, dst)
24181         res = dst + src;
24182         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24183         flag_N = flag_X = flag_C = res >> 8;
24184         flag_NotZ = res & 0xFFFF;
24185         WRITE_WORD_F(adr, res)
24186         POST_IO
24187 RET(12)
24188 }
24189
24190 // ADDQ
24191 OPCODE(0x5067)
24192 {
24193         u32 adr, res;
24194         u32 src, dst;
24195
24196         src = (((Opcode >> 9) - 1) & 7) + 1;
24197         adr = AREG(7) - 2;
24198         AREG(7) = adr;
24199         PRE_IO
24200         READ_WORD_F(adr, dst)
24201         res = dst + src;
24202         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24203         flag_N = flag_X = flag_C = res >> 8;
24204         flag_NotZ = res & 0xFFFF;
24205         WRITE_WORD_F(adr, res)
24206         POST_IO
24207 RET(14)
24208 }
24209
24210 // ADDQ
24211 OPCODE(0x5080)
24212 {
24213         u32 adr, res;
24214         u32 src, dst;
24215
24216         src = (((Opcode >> 9) - 1) & 7) + 1;
24217         dst = DREGu32((Opcode >> 0) & 7);
24218         res = dst + src;
24219         flag_NotZ = res;
24220         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24221         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24222         flag_N = res >> 24;
24223         DREGu32((Opcode >> 0) & 7) = res;
24224 RET(8)
24225 }
24226
24227 // ADDQ
24228 OPCODE(0x5088)
24229 {
24230         u32 adr, res;
24231         u32 src, dst;
24232
24233         src = (((Opcode >> 9) - 1) & 7) + 1;
24234         dst = AREGu32((Opcode >> 0) & 7);
24235         res = dst + src;
24236         AREG((Opcode >> 0) & 7) = res;
24237 RET(8)
24238 }
24239
24240 // ADDQ
24241 OPCODE(0x5090)
24242 {
24243         u32 adr, res;
24244         u32 src, dst;
24245
24246         src = (((Opcode >> 9) - 1) & 7) + 1;
24247         adr = AREG((Opcode >> 0) & 7);
24248         PRE_IO
24249         READ_LONG_F(adr, dst)
24250         res = dst + src;
24251         flag_NotZ = res;
24252         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24253         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24254         flag_N = res >> 24;
24255         WRITE_LONG_F(adr, res)
24256         POST_IO
24257 RET(20)
24258 }
24259
24260 // ADDQ
24261 OPCODE(0x5098)
24262 {
24263         u32 adr, res;
24264         u32 src, dst;
24265
24266         src = (((Opcode >> 9) - 1) & 7) + 1;
24267         adr = AREG((Opcode >> 0) & 7);
24268         AREG((Opcode >> 0) & 7) += 4;
24269         PRE_IO
24270         READ_LONG_F(adr, dst)
24271         res = dst + src;
24272         flag_NotZ = res;
24273         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24274         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24275         flag_N = res >> 24;
24276         WRITE_LONG_F(adr, res)
24277         POST_IO
24278 RET(20)
24279 }
24280
24281 // ADDQ
24282 OPCODE(0x50A0)
24283 {
24284         u32 adr, res;
24285         u32 src, dst;
24286
24287         src = (((Opcode >> 9) - 1) & 7) + 1;
24288         adr = AREG((Opcode >> 0) & 7) - 4;
24289         AREG((Opcode >> 0) & 7) = adr;
24290         PRE_IO
24291         READ_LONG_F(adr, dst)
24292         res = dst + src;
24293         flag_NotZ = res;
24294         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24295         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24296         flag_N = res >> 24;
24297         WRITE_LONG_F(adr, res)
24298         POST_IO
24299 RET(22)
24300 }
24301
24302 // ADDQ
24303 OPCODE(0x50A8)
24304 {
24305         u32 adr, res;
24306         u32 src, dst;
24307
24308         src = (((Opcode >> 9) - 1) & 7) + 1;
24309         FETCH_SWORD(adr);
24310         adr += AREG((Opcode >> 0) & 7);
24311         PRE_IO
24312         READ_LONG_F(adr, dst)
24313         res = dst + src;
24314         flag_NotZ = res;
24315         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24316         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24317         flag_N = res >> 24;
24318         WRITE_LONG_F(adr, res)
24319         POST_IO
24320 RET(24)
24321 }
24322
24323 // ADDQ
24324 OPCODE(0x50B0)
24325 {
24326         u32 adr, res;
24327         u32 src, dst;
24328
24329         src = (((Opcode >> 9) - 1) & 7) + 1;
24330         adr = AREG((Opcode >> 0) & 7);
24331         DECODE_EXT_WORD
24332         PRE_IO
24333         READ_LONG_F(adr, dst)
24334         res = dst + src;
24335         flag_NotZ = res;
24336         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24337         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24338         flag_N = res >> 24;
24339         WRITE_LONG_F(adr, res)
24340         POST_IO
24341 RET(26)
24342 }
24343
24344 // ADDQ
24345 OPCODE(0x50B8)
24346 {
24347         u32 adr, res;
24348         u32 src, dst;
24349
24350         src = (((Opcode >> 9) - 1) & 7) + 1;
24351         FETCH_SWORD(adr);
24352         PRE_IO
24353         READ_LONG_F(adr, dst)
24354         res = dst + src;
24355         flag_NotZ = res;
24356         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24357         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24358         flag_N = res >> 24;
24359         WRITE_LONG_F(adr, res)
24360         POST_IO
24361 RET(24)
24362 }
24363
24364 // ADDQ
24365 OPCODE(0x50B9)
24366 {
24367         u32 adr, res;
24368         u32 src, dst;
24369
24370         src = (((Opcode >> 9) - 1) & 7) + 1;
24371         FETCH_LONG(adr);
24372         PRE_IO
24373         READ_LONG_F(adr, dst)
24374         res = dst + src;
24375         flag_NotZ = res;
24376         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24377         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24378         flag_N = res >> 24;
24379         WRITE_LONG_F(adr, res)
24380         POST_IO
24381 RET(28)
24382 }
24383
24384 // ADDQ
24385 OPCODE(0x509F)
24386 {
24387         u32 adr, res;
24388         u32 src, dst;
24389
24390         src = (((Opcode >> 9) - 1) & 7) + 1;
24391         adr = AREG(7);
24392         AREG(7) += 4;
24393         PRE_IO
24394         READ_LONG_F(adr, dst)
24395         res = dst + src;
24396         flag_NotZ = res;
24397         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24398         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24399         flag_N = res >> 24;
24400         WRITE_LONG_F(adr, res)
24401         POST_IO
24402 RET(20)
24403 }
24404
24405 // ADDQ
24406 OPCODE(0x50A7)
24407 {
24408         u32 adr, res;
24409         u32 src, dst;
24410
24411         src = (((Opcode >> 9) - 1) & 7) + 1;
24412         adr = AREG(7) - 4;
24413         AREG(7) = adr;
24414         PRE_IO
24415         READ_LONG_F(adr, dst)
24416         res = dst + src;
24417         flag_NotZ = res;
24418         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24419         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24420         flag_N = res >> 24;
24421         WRITE_LONG_F(adr, res)
24422         POST_IO
24423 RET(22)
24424 }
24425
24426 // SUBQ
24427 OPCODE(0x5100)
24428 {
24429         u32 adr, res;
24430         u32 src, dst;
24431
24432         src = (((Opcode >> 9) - 1) & 7) + 1;
24433         dst = DREGu8((Opcode >> 0) & 7);
24434         res = dst - src;
24435         flag_N = flag_X = flag_C = res;
24436         flag_V = (src ^ dst) & (res ^ dst);
24437         flag_NotZ = res & 0xFF;
24438         DREGu8((Opcode >> 0) & 7) = res;
24439 RET(4)
24440 }
24441
24442 // SUBQ
24443 OPCODE(0x5110)
24444 {
24445         u32 adr, res;
24446         u32 src, dst;
24447
24448         src = (((Opcode >> 9) - 1) & 7) + 1;
24449         adr = AREG((Opcode >> 0) & 7);
24450         PRE_IO
24451         READ_BYTE_F(adr, dst)
24452         res = dst - src;
24453         flag_N = flag_X = flag_C = res;
24454         flag_V = (src ^ dst) & (res ^ dst);
24455         flag_NotZ = res & 0xFF;
24456         WRITE_BYTE_F(adr, res)
24457         POST_IO
24458 RET(12)
24459 }
24460
24461 // SUBQ
24462 OPCODE(0x5118)
24463 {
24464         u32 adr, res;
24465         u32 src, dst;
24466
24467         src = (((Opcode >> 9) - 1) & 7) + 1;
24468         adr = AREG((Opcode >> 0) & 7);
24469         AREG((Opcode >> 0) & 7) += 1;
24470         PRE_IO
24471         READ_BYTE_F(adr, dst)
24472         res = dst - src;
24473         flag_N = flag_X = flag_C = res;
24474         flag_V = (src ^ dst) & (res ^ dst);
24475         flag_NotZ = res & 0xFF;
24476         WRITE_BYTE_F(adr, res)
24477         POST_IO
24478 RET(12)
24479 }
24480
24481 // SUBQ
24482 OPCODE(0x5120)
24483 {
24484         u32 adr, res;
24485         u32 src, dst;
24486
24487         src = (((Opcode >> 9) - 1) & 7) + 1;
24488         adr = AREG((Opcode >> 0) & 7) - 1;
24489         AREG((Opcode >> 0) & 7) = adr;
24490         PRE_IO
24491         READ_BYTE_F(adr, dst)
24492         res = dst - src;
24493         flag_N = flag_X = flag_C = res;
24494         flag_V = (src ^ dst) & (res ^ dst);
24495         flag_NotZ = res & 0xFF;
24496         WRITE_BYTE_F(adr, res)
24497         POST_IO
24498 RET(14)
24499 }
24500
24501 // SUBQ
24502 OPCODE(0x5128)
24503 {
24504         u32 adr, res;
24505         u32 src, dst;
24506
24507         src = (((Opcode >> 9) - 1) & 7) + 1;
24508         FETCH_SWORD(adr);
24509         adr += AREG((Opcode >> 0) & 7);
24510         PRE_IO
24511         READ_BYTE_F(adr, dst)
24512         res = dst - src;
24513         flag_N = flag_X = flag_C = res;
24514         flag_V = (src ^ dst) & (res ^ dst);
24515         flag_NotZ = res & 0xFF;
24516         WRITE_BYTE_F(adr, res)
24517         POST_IO
24518 RET(16)
24519 }
24520
24521 // SUBQ
24522 OPCODE(0x5130)
24523 {
24524         u32 adr, res;
24525         u32 src, dst;
24526
24527         src = (((Opcode >> 9) - 1) & 7) + 1;
24528         adr = AREG((Opcode >> 0) & 7);
24529         DECODE_EXT_WORD
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(18)
24539 }
24540
24541 // SUBQ
24542 OPCODE(0x5138)
24543 {
24544         u32 adr, res;
24545         u32 src, dst;
24546
24547         src = (((Opcode >> 9) - 1) & 7) + 1;
24548         FETCH_SWORD(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(16)
24558 }
24559
24560 // SUBQ
24561 OPCODE(0x5139)
24562 {
24563         u32 adr, res;
24564         u32 src, dst;
24565
24566         src = (((Opcode >> 9) - 1) & 7) + 1;
24567         FETCH_LONG(adr);
24568         PRE_IO
24569         READ_BYTE_F(adr, dst)
24570         res = dst - src;
24571         flag_N = flag_X = flag_C = res;
24572         flag_V = (src ^ dst) & (res ^ dst);
24573         flag_NotZ = res & 0xFF;
24574         WRITE_BYTE_F(adr, res)
24575         POST_IO
24576 RET(20)
24577 }
24578
24579 // SUBQ
24580 OPCODE(0x511F)
24581 {
24582         u32 adr, res;
24583         u32 src, dst;
24584
24585         src = (((Opcode >> 9) - 1) & 7) + 1;
24586         adr = AREG(7);
24587         AREG(7) += 2;
24588         PRE_IO
24589         READ_BYTE_F(adr, dst)
24590         res = dst - src;
24591         flag_N = flag_X = flag_C = res;
24592         flag_V = (src ^ dst) & (res ^ dst);
24593         flag_NotZ = res & 0xFF;
24594         WRITE_BYTE_F(adr, res)
24595         POST_IO
24596 RET(12)
24597 }
24598
24599 // SUBQ
24600 OPCODE(0x5127)
24601 {
24602         u32 adr, res;
24603         u32 src, dst;
24604
24605         src = (((Opcode >> 9) - 1) & 7) + 1;
24606         adr = AREG(7) - 2;
24607         AREG(7) = adr;
24608         PRE_IO
24609         READ_BYTE_F(adr, dst)
24610         res = dst - src;
24611         flag_N = flag_X = flag_C = res;
24612         flag_V = (src ^ dst) & (res ^ dst);
24613         flag_NotZ = res & 0xFF;
24614         WRITE_BYTE_F(adr, res)
24615         POST_IO
24616 RET(14)
24617 }
24618
24619 // SUBQ
24620 OPCODE(0x5140)
24621 {
24622         u32 adr, res;
24623         u32 src, dst;
24624
24625         src = (((Opcode >> 9) - 1) & 7) + 1;
24626         dst = DREGu16((Opcode >> 0) & 7);
24627         res = dst - src;
24628         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24629         flag_N = flag_X = flag_C = res >> 8;
24630         flag_NotZ = res & 0xFFFF;
24631         DREGu16((Opcode >> 0) & 7) = res;
24632 RET(4)
24633 }
24634
24635 // SUBQ
24636 OPCODE(0x5148)
24637 {
24638         u32 adr, res;
24639         u32 src, dst;
24640
24641         src = (((Opcode >> 9) - 1) & 7) + 1;
24642         dst = AREGu32((Opcode >> 0) & 7);
24643         res = dst - src;
24644         AREG((Opcode >> 0) & 7) = res;
24645 RET(8)
24646 }
24647
24648 // SUBQ
24649 OPCODE(0x5150)
24650 {
24651         u32 adr, res;
24652         u32 src, dst;
24653
24654         src = (((Opcode >> 9) - 1) & 7) + 1;
24655         adr = AREG((Opcode >> 0) & 7);
24656         PRE_IO
24657         READ_WORD_F(adr, dst)
24658         res = dst - src;
24659         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24660         flag_N = flag_X = flag_C = res >> 8;
24661         flag_NotZ = res & 0xFFFF;
24662         WRITE_WORD_F(adr, res)
24663         POST_IO
24664 RET(12)
24665 }
24666
24667 // SUBQ
24668 OPCODE(0x5158)
24669 {
24670         u32 adr, res;
24671         u32 src, dst;
24672
24673         src = (((Opcode >> 9) - 1) & 7) + 1;
24674         adr = AREG((Opcode >> 0) & 7);
24675         AREG((Opcode >> 0) & 7) += 2;
24676         PRE_IO
24677         READ_WORD_F(adr, dst)
24678         res = dst - src;
24679         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24680         flag_N = flag_X = flag_C = res >> 8;
24681         flag_NotZ = res & 0xFFFF;
24682         WRITE_WORD_F(adr, res)
24683         POST_IO
24684 RET(12)
24685 }
24686
24687 // SUBQ
24688 OPCODE(0x5160)
24689 {
24690         u32 adr, res;
24691         u32 src, dst;
24692
24693         src = (((Opcode >> 9) - 1) & 7) + 1;
24694         adr = AREG((Opcode >> 0) & 7) - 2;
24695         AREG((Opcode >> 0) & 7) = adr;
24696         PRE_IO
24697         READ_WORD_F(adr, dst)
24698         res = dst - src;
24699         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24700         flag_N = flag_X = flag_C = res >> 8;
24701         flag_NotZ = res & 0xFFFF;
24702         WRITE_WORD_F(adr, res)
24703         POST_IO
24704 RET(14)
24705 }
24706
24707 // SUBQ
24708 OPCODE(0x5168)
24709 {
24710         u32 adr, res;
24711         u32 src, dst;
24712
24713         src = (((Opcode >> 9) - 1) & 7) + 1;
24714         FETCH_SWORD(adr);
24715         adr += AREG((Opcode >> 0) & 7);
24716         PRE_IO
24717         READ_WORD_F(adr, dst)
24718         res = dst - src;
24719         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24720         flag_N = flag_X = flag_C = res >> 8;
24721         flag_NotZ = res & 0xFFFF;
24722         WRITE_WORD_F(adr, res)
24723         POST_IO
24724 RET(16)
24725 }
24726
24727 // SUBQ
24728 OPCODE(0x5170)
24729 {
24730         u32 adr, res;
24731         u32 src, dst;
24732
24733         src = (((Opcode >> 9) - 1) & 7) + 1;
24734         adr = AREG((Opcode >> 0) & 7);
24735         DECODE_EXT_WORD
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(18)
24745 }
24746
24747 // SUBQ
24748 OPCODE(0x5178)
24749 {
24750         u32 adr, res;
24751         u32 src, dst;
24752
24753         src = (((Opcode >> 9) - 1) & 7) + 1;
24754         FETCH_SWORD(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(16)
24764 }
24765
24766 // SUBQ
24767 OPCODE(0x5179)
24768 {
24769         u32 adr, res;
24770         u32 src, dst;
24771
24772         src = (((Opcode >> 9) - 1) & 7) + 1;
24773         FETCH_LONG(adr);
24774         PRE_IO
24775         READ_WORD_F(adr, dst)
24776         res = dst - src;
24777         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24778         flag_N = flag_X = flag_C = res >> 8;
24779         flag_NotZ = res & 0xFFFF;
24780         WRITE_WORD_F(adr, res)
24781         POST_IO
24782 RET(20)
24783 }
24784
24785 // SUBQ
24786 OPCODE(0x515F)
24787 {
24788         u32 adr, res;
24789         u32 src, dst;
24790
24791         src = (((Opcode >> 9) - 1) & 7) + 1;
24792         adr = AREG(7);
24793         AREG(7) += 2;
24794         PRE_IO
24795         READ_WORD_F(adr, dst)
24796         res = dst - src;
24797         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24798         flag_N = flag_X = flag_C = res >> 8;
24799         flag_NotZ = res & 0xFFFF;
24800         WRITE_WORD_F(adr, res)
24801         POST_IO
24802 RET(12)
24803 }
24804
24805 // SUBQ
24806 OPCODE(0x5167)
24807 {
24808         u32 adr, res;
24809         u32 src, dst;
24810
24811         src = (((Opcode >> 9) - 1) & 7) + 1;
24812         adr = AREG(7) - 2;
24813         AREG(7) = adr;
24814         PRE_IO
24815         READ_WORD_F(adr, dst)
24816         res = dst - src;
24817         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24818         flag_N = flag_X = flag_C = res >> 8;
24819         flag_NotZ = res & 0xFFFF;
24820         WRITE_WORD_F(adr, res)
24821         POST_IO
24822 RET(14)
24823 }
24824
24825 // SUBQ
24826 OPCODE(0x5180)
24827 {
24828         u32 adr, res;
24829         u32 src, dst;
24830
24831         src = (((Opcode >> 9) - 1) & 7) + 1;
24832         dst = DREGu32((Opcode >> 0) & 7);
24833         res = dst - src;
24834         flag_NotZ = res;
24835         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24836         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24837         flag_N = res >> 24;
24838         DREGu32((Opcode >> 0) & 7) = res;
24839 RET(8)
24840 }
24841
24842 // SUBQ
24843 OPCODE(0x5188)
24844 {
24845         u32 adr, res;
24846         u32 src, dst;
24847
24848         src = (((Opcode >> 9) - 1) & 7) + 1;
24849         dst = AREGu32((Opcode >> 0) & 7);
24850         res = dst - src;
24851         AREG((Opcode >> 0) & 7) = res;
24852 RET(8)
24853 }
24854
24855 // SUBQ
24856 OPCODE(0x5190)
24857 {
24858         u32 adr, res;
24859         u32 src, dst;
24860
24861         src = (((Opcode >> 9) - 1) & 7) + 1;
24862         adr = AREG((Opcode >> 0) & 7);
24863         PRE_IO
24864         READ_LONG_F(adr, dst)
24865         res = dst - src;
24866         flag_NotZ = res;
24867         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24868         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24869         flag_N = res >> 24;
24870         WRITE_LONG_F(adr, res)
24871         POST_IO
24872 RET(20)
24873 }
24874
24875 // SUBQ
24876 OPCODE(0x5198)
24877 {
24878         u32 adr, res;
24879         u32 src, dst;
24880
24881         src = (((Opcode >> 9) - 1) & 7) + 1;
24882         adr = AREG((Opcode >> 0) & 7);
24883         AREG((Opcode >> 0) & 7) += 4;
24884         PRE_IO
24885         READ_LONG_F(adr, dst)
24886         res = dst - src;
24887         flag_NotZ = res;
24888         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24889         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24890         flag_N = res >> 24;
24891         WRITE_LONG_F(adr, res)
24892         POST_IO
24893 RET(20)
24894 }
24895
24896 // SUBQ
24897 OPCODE(0x51A0)
24898 {
24899         u32 adr, res;
24900         u32 src, dst;
24901
24902         src = (((Opcode >> 9) - 1) & 7) + 1;
24903         adr = AREG((Opcode >> 0) & 7) - 4;
24904         AREG((Opcode >> 0) & 7) = adr;
24905         PRE_IO
24906         READ_LONG_F(adr, dst)
24907         res = dst - src;
24908         flag_NotZ = res;
24909         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24910         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24911         flag_N = res >> 24;
24912         WRITE_LONG_F(adr, res)
24913         POST_IO
24914 RET(22)
24915 }
24916
24917 // SUBQ
24918 OPCODE(0x51A8)
24919 {
24920         u32 adr, res;
24921         u32 src, dst;
24922
24923         src = (((Opcode >> 9) - 1) & 7) + 1;
24924         FETCH_SWORD(adr);
24925         adr += AREG((Opcode >> 0) & 7);
24926         PRE_IO
24927         READ_LONG_F(adr, dst)
24928         res = dst - src;
24929         flag_NotZ = res;
24930         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24931         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24932         flag_N = res >> 24;
24933         WRITE_LONG_F(adr, res)
24934         POST_IO
24935 RET(24)
24936 }
24937
24938 // SUBQ
24939 OPCODE(0x51B0)
24940 {
24941         u32 adr, res;
24942         u32 src, dst;
24943
24944         src = (((Opcode >> 9) - 1) & 7) + 1;
24945         adr = AREG((Opcode >> 0) & 7);
24946         DECODE_EXT_WORD
24947         PRE_IO
24948         READ_LONG_F(adr, dst)
24949         res = dst - src;
24950         flag_NotZ = res;
24951         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24952         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24953         flag_N = res >> 24;
24954         WRITE_LONG_F(adr, res)
24955         POST_IO
24956 RET(26)
24957 }
24958
24959 // SUBQ
24960 OPCODE(0x51B8)
24961 {
24962         u32 adr, res;
24963         u32 src, dst;
24964
24965         src = (((Opcode >> 9) - 1) & 7) + 1;
24966         FETCH_SWORD(adr);
24967         PRE_IO
24968         READ_LONG_F(adr, dst)
24969         res = dst - src;
24970         flag_NotZ = res;
24971         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24972         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24973         flag_N = res >> 24;
24974         WRITE_LONG_F(adr, res)
24975         POST_IO
24976 RET(24)
24977 }
24978
24979 // SUBQ
24980 OPCODE(0x51B9)
24981 {
24982         u32 adr, res;
24983         u32 src, dst;
24984
24985         src = (((Opcode >> 9) - 1) & 7) + 1;
24986         FETCH_LONG(adr);
24987         PRE_IO
24988         READ_LONG_F(adr, dst)
24989         res = dst - src;
24990         flag_NotZ = res;
24991         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24992         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24993         flag_N = res >> 24;
24994         WRITE_LONG_F(adr, res)
24995         POST_IO
24996 RET(28)
24997 }
24998
24999 // SUBQ
25000 OPCODE(0x519F)
25001 {
25002         u32 adr, res;
25003         u32 src, dst;
25004
25005         src = (((Opcode >> 9) - 1) & 7) + 1;
25006         adr = AREG(7);
25007         AREG(7) += 4;
25008         PRE_IO
25009         READ_LONG_F(adr, dst)
25010         res = dst - src;
25011         flag_NotZ = res;
25012         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25013         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25014         flag_N = res >> 24;
25015         WRITE_LONG_F(adr, res)
25016         POST_IO
25017 RET(20)
25018 }
25019
25020 // SUBQ
25021 OPCODE(0x51A7)
25022 {
25023         u32 adr, res;
25024         u32 src, dst;
25025
25026         src = (((Opcode >> 9) - 1) & 7) + 1;
25027         adr = AREG(7) - 4;
25028         AREG(7) = adr;
25029         PRE_IO
25030         READ_LONG_F(adr, dst)
25031         res = dst - src;
25032         flag_NotZ = res;
25033         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25034         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25035         flag_N = res >> 24;
25036         WRITE_LONG_F(adr, res)
25037         POST_IO
25038 RET(22)
25039 }
25040
25041 // BCC
25042 OPCODE(0x6201)
25043 {
25044         u32 adr, res;
25045         u32 src, dst;
25046
25047         if (flag_NotZ && (!(flag_C & 0x100)))
25048         {
25049                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25050         m68kcontext.io_cycle_counter -= 2;
25051         }
25052 RET(8)
25053 }
25054
25055 // BCC
25056 OPCODE(0x6301)
25057 {
25058         u32 adr, res;
25059         u32 src, dst;
25060
25061         if ((!flag_NotZ) || (flag_C & 0x100))
25062         {
25063                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25064         m68kcontext.io_cycle_counter -= 2;
25065         }
25066 RET(8)
25067 }
25068
25069 // BCC
25070 OPCODE(0x6401)
25071 {
25072         u32 adr, res;
25073         u32 src, dst;
25074
25075         if (!(flag_C & 0x100))
25076         {
25077                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25078         m68kcontext.io_cycle_counter -= 2;
25079         }
25080 RET(8)
25081 }
25082
25083 // BCC
25084 OPCODE(0x6501)
25085 {
25086         u32 adr, res;
25087         u32 src, dst;
25088
25089         if (flag_C & 0x100)
25090         {
25091                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25092         m68kcontext.io_cycle_counter -= 2;
25093         }
25094 RET(8)
25095 }
25096
25097 // BCC
25098 OPCODE(0x6601)
25099 {
25100         u32 adr, res;
25101         u32 src, dst;
25102
25103         if (flag_NotZ)
25104         {
25105                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25106         m68kcontext.io_cycle_counter -= 2;
25107         }
25108 RET(8)
25109 }
25110
25111 // BCC
25112 OPCODE(0x6701)
25113 {
25114         u32 adr, res;
25115         u32 src, dst;
25116
25117         if (!flag_NotZ)
25118         {
25119                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25120         m68kcontext.io_cycle_counter -= 2;
25121         }
25122 RET(8)
25123 }
25124
25125 // BCC
25126 OPCODE(0x6801)
25127 {
25128         u32 adr, res;
25129         u32 src, dst;
25130
25131         if (!(flag_V & 0x80))
25132         {
25133                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25134         m68kcontext.io_cycle_counter -= 2;
25135         }
25136 RET(8)
25137 }
25138
25139 // BCC
25140 OPCODE(0x6901)
25141 {
25142         u32 adr, res;
25143         u32 src, dst;
25144
25145         if (flag_V & 0x80)
25146         {
25147                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25148         m68kcontext.io_cycle_counter -= 2;
25149         }
25150 RET(8)
25151 }
25152
25153 // BCC
25154 OPCODE(0x6A01)
25155 {
25156         u32 adr, res;
25157         u32 src, dst;
25158
25159         if (!(flag_N & 0x80))
25160         {
25161                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25162         m68kcontext.io_cycle_counter -= 2;
25163         }
25164 RET(8)
25165 }
25166
25167 // BCC
25168 OPCODE(0x6B01)
25169 {
25170         u32 adr, res;
25171         u32 src, dst;
25172
25173         if (flag_N & 0x80)
25174         {
25175                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25176         m68kcontext.io_cycle_counter -= 2;
25177         }
25178 RET(8)
25179 }
25180
25181 // BCC
25182 OPCODE(0x6C01)
25183 {
25184         u32 adr, res;
25185         u32 src, dst;
25186
25187         if (!((flag_N ^ flag_V) & 0x80))
25188         {
25189                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25190         m68kcontext.io_cycle_counter -= 2;
25191         }
25192 RET(8)
25193 }
25194
25195 // BCC
25196 OPCODE(0x6D01)
25197 {
25198         u32 adr, res;
25199         u32 src, dst;
25200
25201         if ((flag_N ^ flag_V) & 0x80)
25202         {
25203                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25204         m68kcontext.io_cycle_counter -= 2;
25205         }
25206 RET(8)
25207 }
25208
25209 // BCC
25210 OPCODE(0x6E01)
25211 {
25212         u32 adr, res;
25213         u32 src, dst;
25214
25215         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
25216         {
25217                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25218         m68kcontext.io_cycle_counter -= 2;
25219         }
25220 RET(8)
25221 }
25222
25223 // BCC
25224 OPCODE(0x6F01)
25225 {
25226         u32 adr, res;
25227         u32 src, dst;
25228
25229         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
25230         {
25231                 PC += ((s8)(Opcode & 0xFE)) >> 1;
25232         m68kcontext.io_cycle_counter -= 2;
25233         }
25234 RET(8)
25235 }
25236
25237 // BCC16
25238 OPCODE(0x6200)
25239 {
25240         u32 adr, res;
25241         u32 src, dst;
25242
25243         if (flag_NotZ && (!(flag_C & 0x100)))
25244         {
25245                 u32 newPC;
25246
25247                 newPC = GET_PC;
25248                 newPC += GET_SWORD;
25249                 SET_PC(newPC);
25250                 CHECK_BRANCH_EXCEPTION(newPC)
25251                 RET(10)
25252         }
25253         PC++;
25254 RET(12)
25255 }
25256
25257 // BCC16
25258 OPCODE(0x6300)
25259 {
25260         u32 adr, res;
25261         u32 src, dst;
25262
25263         if ((!flag_NotZ) || (flag_C & 0x100))
25264         {
25265                 u32 newPC;
25266
25267                 newPC = GET_PC;
25268                 newPC += GET_SWORD;
25269                 SET_PC(newPC);
25270                 CHECK_BRANCH_EXCEPTION(newPC)
25271                 RET(10)
25272         }
25273         PC++;
25274 RET(12)
25275 }
25276
25277 // BCC16
25278 OPCODE(0x6400)
25279 {
25280         u32 adr, res;
25281         u32 src, dst;
25282
25283         if (!(flag_C & 0x100))
25284         {
25285                 u32 newPC;
25286
25287                 newPC = GET_PC;
25288                 newPC += GET_SWORD;
25289                 SET_PC(newPC);
25290                 CHECK_BRANCH_EXCEPTION(newPC)
25291                 RET(10)
25292         }
25293         PC++;
25294 RET(12)
25295 }
25296
25297 // BCC16
25298 OPCODE(0x6500)
25299 {
25300         u32 adr, res;
25301         u32 src, dst;
25302
25303         if (flag_C & 0x100)
25304         {
25305                 u32 newPC;
25306
25307                 newPC = GET_PC;
25308                 newPC += GET_SWORD;
25309                 SET_PC(newPC);
25310                 CHECK_BRANCH_EXCEPTION(newPC)
25311                 RET(10)
25312         }
25313         PC++;
25314 RET(12)
25315 }
25316
25317 // BCC16
25318 OPCODE(0x6600)
25319 {
25320         u32 adr, res;
25321         u32 src, dst;
25322
25323         if (flag_NotZ)
25324         {
25325                 u32 newPC;
25326
25327                 newPC = GET_PC;
25328                 newPC += GET_SWORD;
25329                 SET_PC(newPC);
25330                 CHECK_BRANCH_EXCEPTION(newPC)
25331                 RET(10)
25332         }
25333         PC++;
25334 RET(12)
25335 }
25336
25337 // BCC16
25338 OPCODE(0x6700)
25339 {
25340         u32 adr, res;
25341         u32 src, dst;
25342
25343         if (!flag_NotZ)
25344         {
25345                 u32 newPC;
25346
25347                 newPC = GET_PC;
25348                 newPC += GET_SWORD;
25349                 SET_PC(newPC);
25350                 CHECK_BRANCH_EXCEPTION(newPC)
25351                 RET(10)
25352         }
25353         PC++;
25354 RET(12)
25355 }
25356
25357 // BCC16
25358 OPCODE(0x6800)
25359 {
25360         u32 adr, res;
25361         u32 src, dst;
25362
25363         if (!(flag_V & 0x80))
25364         {
25365                 u32 newPC;
25366
25367                 newPC = GET_PC;
25368                 newPC += GET_SWORD;
25369                 SET_PC(newPC);
25370                 CHECK_BRANCH_EXCEPTION(newPC)
25371                 RET(10)
25372         }
25373         PC++;
25374 RET(12)
25375 }
25376
25377 // BCC16
25378 OPCODE(0x6900)
25379 {
25380         u32 adr, res;
25381         u32 src, dst;
25382
25383         if (flag_V & 0x80)
25384         {
25385                 u32 newPC;
25386
25387                 newPC = GET_PC;
25388                 newPC += GET_SWORD;
25389                 SET_PC(newPC);
25390                 CHECK_BRANCH_EXCEPTION(newPC)
25391                 RET(10)
25392         }
25393         PC++;
25394 RET(12)
25395 }
25396
25397 // BCC16
25398 OPCODE(0x6A00)
25399 {
25400         u32 adr, res;
25401         u32 src, dst;
25402
25403         if (!(flag_N & 0x80))
25404         {
25405                 u32 newPC;
25406
25407                 newPC = GET_PC;
25408                 newPC += GET_SWORD;
25409                 SET_PC(newPC);
25410                 CHECK_BRANCH_EXCEPTION(newPC)
25411                 RET(10)
25412         }
25413         PC++;
25414 RET(12)
25415 }
25416
25417 // BCC16
25418 OPCODE(0x6B00)
25419 {
25420         u32 adr, res;
25421         u32 src, dst;
25422
25423         if (flag_N & 0x80)
25424         {
25425                 u32 newPC;
25426
25427                 newPC = GET_PC;
25428                 newPC += GET_SWORD;
25429                 SET_PC(newPC);
25430                 CHECK_BRANCH_EXCEPTION(newPC)
25431                 RET(10)
25432         }
25433         PC++;
25434 RET(12)
25435 }
25436
25437 // BCC16
25438 OPCODE(0x6C00)
25439 {
25440         u32 adr, res;
25441         u32 src, dst;
25442
25443         if (!((flag_N ^ flag_V) & 0x80))
25444         {
25445                 u32 newPC;
25446
25447                 newPC = GET_PC;
25448                 newPC += GET_SWORD;
25449                 SET_PC(newPC);
25450                 CHECK_BRANCH_EXCEPTION(newPC)
25451                 RET(10)
25452         }
25453         PC++;
25454 RET(12)
25455 }
25456
25457 // BCC16
25458 OPCODE(0x6D00)
25459 {
25460         u32 adr, res;
25461         u32 src, dst;
25462
25463         if ((flag_N ^ flag_V) & 0x80)
25464         {
25465                 u32 newPC;
25466
25467                 newPC = GET_PC;
25468                 newPC += GET_SWORD;
25469                 SET_PC(newPC);
25470                 CHECK_BRANCH_EXCEPTION(newPC)
25471                 RET(10)
25472         }
25473         PC++;
25474 RET(12)
25475 }
25476
25477 // BCC16
25478 OPCODE(0x6E00)
25479 {
25480         u32 adr, res;
25481         u32 src, dst;
25482
25483         if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
25484         {
25485                 u32 newPC;
25486
25487                 newPC = GET_PC;
25488                 newPC += GET_SWORD;
25489                 SET_PC(newPC);
25490                 CHECK_BRANCH_EXCEPTION(newPC)
25491                 RET(10)
25492         }
25493         PC++;
25494 RET(12)
25495 }
25496
25497 // BCC16
25498 OPCODE(0x6F00)
25499 {
25500         u32 adr, res;
25501         u32 src, dst;
25502
25503         if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
25504         {
25505                 u32 newPC;
25506
25507                 newPC = GET_PC;
25508                 newPC += GET_SWORD;
25509                 SET_PC(newPC);
25510                 CHECK_BRANCH_EXCEPTION(newPC)
25511                 RET(10)
25512         }
25513         PC++;
25514 RET(12)
25515 }
25516
25517 // BRA
25518 OPCODE(0x6001)
25519 {
25520 #ifdef FAMEC_CHECK_BRANCHES
25521         u32 newPC = GET_PC;
25522         s8 offs=Opcode;
25523         newPC += offs;
25524         SET_PC(newPC);
25525         CHECK_BRANCH_EXCEPTION(offs)
25526 #else
25527         PC += ((s8)(Opcode & 0xFE)) >> 1;
25528 #endif
25529 RET(10)
25530 }
25531
25532 // BRA16
25533 OPCODE(0x6000)
25534 {
25535         u32 adr, res;
25536         u32 src, dst;
25537
25538         {
25539                 u32 newPC;
25540
25541                 newPC = GET_PC;
25542                 newPC += GET_SWORD;
25543                 SET_PC(newPC);
25544                 CHECK_BRANCH_EXCEPTION(newPC)
25545         }
25546 RET(10)
25547 }
25548
25549 // BSR
25550 OPCODE(0x6101)
25551 {
25552         u32 adr, res;
25553         u32 src, dst;
25554         u32 oldPC;
25555         s8 offs;
25556
25557         PRE_IO
25558
25559         oldPC = GET_PC;
25560         PUSH_32_F(oldPC)
25561 #ifdef FAMEC_CHECK_BRANCHES
25562         offs = Opcode;
25563         oldPC += offs;
25564         SET_PC(oldPC);
25565         CHECK_BRANCH_EXCEPTION(offs)
25566 #else
25567         PC += ((s8)(Opcode & 0xFE)) >> 1;
25568 #endif
25569         POST_IO
25570 RET(18)
25571 }
25572
25573 // BSR16
25574 OPCODE(0x6100)
25575 {
25576         u32 adr, res;
25577         u32 src, dst;
25578
25579         PRE_IO
25580         {
25581                 u32 oldPC, newPC;
25582
25583                 newPC = GET_PC;
25584                 oldPC = newPC + 2;
25585                 PUSH_32_F(oldPC)
25586                 newPC += GET_SWORD;
25587                 SET_PC(newPC);
25588                 CHECK_BRANCH_EXCEPTION(newPC)
25589         }
25590         POST_IO
25591 RET(18)
25592 }
25593
25594 // MOVEQ
25595 OPCODE(0x7000)
25596 {
25597         u32 adr, res;
25598         u32 src, dst;
25599
25600         res = (s32)(s8)Opcode;
25601         flag_C = flag_V = 0;
25602         flag_N = flag_NotZ = res;
25603         DREGu32((Opcode >> 9) & 7) = res;
25604 RET(4)
25605 }
25606
25607 // ORaD
25608 OPCODE(0x8000)
25609 {
25610         u32 adr, res;
25611         u32 src, dst;
25612
25613         src = DREGu8((Opcode >> 0) & 7);
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 RET(4)
25622 }
25623
25624 // ORaD
25625 OPCODE(0x8010)
25626 {
25627         u32 adr, res;
25628         u32 src, dst;
25629
25630         adr = AREG((Opcode >> 0) & 7);
25631         PRE_IO
25632         READ_BYTE_F(adr, src)
25633         res = DREGu8((Opcode >> 9) & 7);
25634         res |= src;
25635         flag_C = 0;
25636         flag_V = 0;
25637         flag_NotZ = res;
25638         flag_N = res;
25639         DREGu8((Opcode >> 9) & 7) = res;
25640         POST_IO
25641 RET(8)
25642 }
25643
25644 // ORaD
25645 OPCODE(0x8018)
25646 {
25647         u32 adr, res;
25648         u32 src, dst;
25649
25650         adr = AREG((Opcode >> 0) & 7);
25651         AREG((Opcode >> 0) & 7) += 1;
25652         PRE_IO
25653         READ_BYTE_F(adr, src)
25654         res = DREGu8((Opcode >> 9) & 7);
25655         res |= src;
25656         flag_C = 0;
25657         flag_V = 0;
25658         flag_NotZ = res;
25659         flag_N = res;
25660         DREGu8((Opcode >> 9) & 7) = res;
25661         POST_IO
25662 RET(8)
25663 }
25664
25665 // ORaD
25666 OPCODE(0x8020)
25667 {
25668         u32 adr, res;
25669         u32 src, dst;
25670
25671         adr = AREG((Opcode >> 0) & 7) - 1;
25672         AREG((Opcode >> 0) & 7) = adr;
25673         PRE_IO
25674         READ_BYTE_F(adr, src)
25675         res = DREGu8((Opcode >> 9) & 7);
25676         res |= src;
25677         flag_C = 0;
25678         flag_V = 0;
25679         flag_NotZ = res;
25680         flag_N = res;
25681         DREGu8((Opcode >> 9) & 7) = res;
25682         POST_IO
25683 RET(10)
25684 }
25685
25686 // ORaD
25687 OPCODE(0x8028)
25688 {
25689         u32 adr, res;
25690         u32 src, dst;
25691
25692         FETCH_SWORD(adr);
25693         adr += AREG((Opcode >> 0) & 7);
25694         PRE_IO
25695         READ_BYTE_F(adr, src)
25696         res = DREGu8((Opcode >> 9) & 7);
25697         res |= src;
25698         flag_C = 0;
25699         flag_V = 0;
25700         flag_NotZ = res;
25701         flag_N = res;
25702         DREGu8((Opcode >> 9) & 7) = res;
25703         POST_IO
25704 RET(12)
25705 }
25706
25707 // ORaD
25708 OPCODE(0x8030)
25709 {
25710         u32 adr, res;
25711         u32 src, dst;
25712
25713         adr = AREG((Opcode >> 0) & 7);
25714         DECODE_EXT_WORD
25715         PRE_IO
25716         READ_BYTE_F(adr, src)
25717         res = DREGu8((Opcode >> 9) & 7);
25718         res |= src;
25719         flag_C = 0;
25720         flag_V = 0;
25721         flag_NotZ = res;
25722         flag_N = res;
25723         DREGu8((Opcode >> 9) & 7) = res;
25724         POST_IO
25725 RET(14)
25726 }
25727
25728 // ORaD
25729 OPCODE(0x8038)
25730 {
25731         u32 adr, res;
25732         u32 src, dst;
25733
25734         FETCH_SWORD(adr);
25735         PRE_IO
25736         READ_BYTE_F(adr, src)
25737         res = DREGu8((Opcode >> 9) & 7);
25738         res |= src;
25739         flag_C = 0;
25740         flag_V = 0;
25741         flag_NotZ = res;
25742         flag_N = res;
25743         DREGu8((Opcode >> 9) & 7) = res;
25744         POST_IO
25745 RET(12)
25746 }
25747
25748 // ORaD
25749 OPCODE(0x8039)
25750 {
25751         u32 adr, res;
25752         u32 src, dst;
25753
25754         FETCH_LONG(adr);
25755         PRE_IO
25756         READ_BYTE_F(adr, src)
25757         res = DREGu8((Opcode >> 9) & 7);
25758         res |= src;
25759         flag_C = 0;
25760         flag_V = 0;
25761         flag_NotZ = res;
25762         flag_N = res;
25763         DREGu8((Opcode >> 9) & 7) = res;
25764         POST_IO
25765 RET(16)
25766 }
25767
25768 // ORaD
25769 OPCODE(0x803A)
25770 {
25771         u32 adr, res;
25772         u32 src, dst;
25773
25774         adr = GET_SWORD + GET_PC;
25775         PC++;
25776         PRE_IO
25777         READ_BYTE_F(adr, src)
25778         res = DREGu8((Opcode >> 9) & 7);
25779         res |= src;
25780         flag_C = 0;
25781         flag_V = 0;
25782         flag_NotZ = res;
25783         flag_N = res;
25784         DREGu8((Opcode >> 9) & 7) = res;
25785         POST_IO
25786 RET(12)
25787 }
25788
25789 // ORaD
25790 OPCODE(0x803B)
25791 {
25792         u32 adr, res;
25793         u32 src, dst;
25794
25795         adr = GET_PC;
25796         DECODE_EXT_WORD
25797         PRE_IO
25798         READ_BYTE_F(adr, src)
25799         res = DREGu8((Opcode >> 9) & 7);
25800         res |= src;
25801         flag_C = 0;
25802         flag_V = 0;
25803         flag_NotZ = res;
25804         flag_N = res;
25805         DREGu8((Opcode >> 9) & 7) = res;
25806         POST_IO
25807 RET(14)
25808 }
25809
25810 // ORaD
25811 OPCODE(0x803C)
25812 {
25813         u32 adr, res;
25814         u32 src, dst;
25815
25816         FETCH_BYTE(src);
25817         res = DREGu8((Opcode >> 9) & 7);
25818         res |= src;
25819         flag_C = 0;
25820         flag_V = 0;
25821         flag_NotZ = res;
25822         flag_N = res;
25823         DREGu8((Opcode >> 9) & 7) = res;
25824 RET(8)
25825 }
25826
25827 // ORaD
25828 OPCODE(0x801F)
25829 {
25830         u32 adr, res;
25831         u32 src, dst;
25832
25833         adr = AREG(7);
25834         AREG(7) += 2;
25835         PRE_IO
25836         READ_BYTE_F(adr, src)
25837         res = DREGu8((Opcode >> 9) & 7);
25838         res |= src;
25839         flag_C = 0;
25840         flag_V = 0;
25841         flag_NotZ = res;
25842         flag_N = res;
25843         DREGu8((Opcode >> 9) & 7) = res;
25844         POST_IO
25845 RET(8)
25846 }
25847
25848 // ORaD
25849 OPCODE(0x8027)
25850 {
25851         u32 adr, res;
25852         u32 src, dst;
25853
25854         adr = AREG(7) - 2;
25855         AREG(7) = adr;
25856         PRE_IO
25857         READ_BYTE_F(adr, src)
25858         res = DREGu8((Opcode >> 9) & 7);
25859         res |= src;
25860         flag_C = 0;
25861         flag_V = 0;
25862         flag_NotZ = res;
25863         flag_N = res;
25864         DREGu8((Opcode >> 9) & 7) = res;
25865         POST_IO
25866 RET(10)
25867 }
25868
25869 // ORaD
25870 OPCODE(0x8040)
25871 {
25872         u32 adr, res;
25873         u32 src, dst;
25874
25875         src = DREGu16((Opcode >> 0) & 7);
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 RET(4)
25884 }
25885
25886 // ORaD
25887 OPCODE(0x8050)
25888 {
25889         u32 adr, res;
25890         u32 src, dst;
25891
25892         adr = AREG((Opcode >> 0) & 7);
25893         PRE_IO
25894         READ_WORD_F(adr, src)
25895         res = DREGu16((Opcode >> 9) & 7);
25896         res |= src;
25897         flag_C = 0;
25898         flag_V = 0;
25899         flag_NotZ = res;
25900         flag_N = res >> 8;
25901         DREGu16((Opcode >> 9) & 7) = res;
25902         POST_IO
25903 RET(8)
25904 }
25905
25906 // ORaD
25907 OPCODE(0x8058)
25908 {
25909         u32 adr, res;
25910         u32 src, dst;
25911
25912         adr = AREG((Opcode >> 0) & 7);
25913         AREG((Opcode >> 0) & 7) += 2;
25914         PRE_IO
25915         READ_WORD_F(adr, src)
25916         res = DREGu16((Opcode >> 9) & 7);
25917         res |= src;
25918         flag_C = 0;
25919         flag_V = 0;
25920         flag_NotZ = res;
25921         flag_N = res >> 8;
25922         DREGu16((Opcode >> 9) & 7) = res;
25923         POST_IO
25924 RET(8)
25925 }
25926
25927 // ORaD
25928 OPCODE(0x8060)
25929 {
25930         u32 adr, res;
25931         u32 src, dst;
25932
25933         adr = AREG((Opcode >> 0) & 7) - 2;
25934         AREG((Opcode >> 0) & 7) = adr;
25935         PRE_IO
25936         READ_WORD_F(adr, src)
25937         res = DREGu16((Opcode >> 9) & 7);
25938         res |= src;
25939         flag_C = 0;
25940         flag_V = 0;
25941         flag_NotZ = res;
25942         flag_N = res >> 8;
25943         DREGu16((Opcode >> 9) & 7) = res;
25944         POST_IO
25945 RET(10)
25946 }
25947
25948 // ORaD
25949 OPCODE(0x8068)
25950 {
25951         u32 adr, res;
25952         u32 src, dst;
25953
25954         FETCH_SWORD(adr);
25955         adr += AREG((Opcode >> 0) & 7);
25956         PRE_IO
25957         READ_WORD_F(adr, src)
25958         res = DREGu16((Opcode >> 9) & 7);
25959         res |= src;
25960         flag_C = 0;
25961         flag_V = 0;
25962         flag_NotZ = res;
25963         flag_N = res >> 8;
25964         DREGu16((Opcode >> 9) & 7) = res;
25965         POST_IO
25966 RET(12)
25967 }
25968
25969 // ORaD
25970 OPCODE(0x8070)
25971 {
25972         u32 adr, res;
25973         u32 src, dst;
25974
25975         adr = AREG((Opcode >> 0) & 7);
25976         DECODE_EXT_WORD
25977         PRE_IO
25978         READ_WORD_F(adr, src)
25979         res = DREGu16((Opcode >> 9) & 7);
25980         res |= src;
25981         flag_C = 0;
25982         flag_V = 0;
25983         flag_NotZ = res;
25984         flag_N = res >> 8;
25985         DREGu16((Opcode >> 9) & 7) = res;
25986         POST_IO
25987 RET(14)
25988 }
25989
25990 // ORaD
25991 OPCODE(0x8078)
25992 {
25993         u32 adr, res;
25994         u32 src, dst;
25995
25996         FETCH_SWORD(adr);
25997         PRE_IO
25998         READ_WORD_F(adr, src)
25999         res = DREGu16((Opcode >> 9) & 7);
26000         res |= src;
26001         flag_C = 0;
26002         flag_V = 0;
26003         flag_NotZ = res;
26004         flag_N = res >> 8;
26005         DREGu16((Opcode >> 9) & 7) = res;
26006         POST_IO
26007 RET(12)
26008 }
26009
26010 // ORaD
26011 OPCODE(0x8079)
26012 {
26013         u32 adr, res;
26014         u32 src, dst;
26015
26016         FETCH_LONG(adr);
26017         PRE_IO
26018         READ_WORD_F(adr, src)
26019         res = DREGu16((Opcode >> 9) & 7);
26020         res |= src;
26021         flag_C = 0;
26022         flag_V = 0;
26023         flag_NotZ = res;
26024         flag_N = res >> 8;
26025         DREGu16((Opcode >> 9) & 7) = res;
26026         POST_IO
26027 RET(16)
26028 }
26029
26030 // ORaD
26031 OPCODE(0x807A)
26032 {
26033         u32 adr, res;
26034         u32 src, dst;
26035
26036         adr = GET_SWORD + GET_PC;
26037         PC++;
26038         PRE_IO
26039         READ_WORD_F(adr, src)
26040         res = DREGu16((Opcode >> 9) & 7);
26041         res |= src;
26042         flag_C = 0;
26043         flag_V = 0;
26044         flag_NotZ = res;
26045         flag_N = res >> 8;
26046         DREGu16((Opcode >> 9) & 7) = res;
26047         POST_IO
26048 RET(12)
26049 }
26050
26051 // ORaD
26052 OPCODE(0x807B)
26053 {
26054         u32 adr, res;
26055         u32 src, dst;
26056
26057         adr = GET_PC;
26058         DECODE_EXT_WORD
26059         PRE_IO
26060         READ_WORD_F(adr, src)
26061         res = DREGu16((Opcode >> 9) & 7);
26062         res |= src;
26063         flag_C = 0;
26064         flag_V = 0;
26065         flag_NotZ = res;
26066         flag_N = res >> 8;
26067         DREGu16((Opcode >> 9) & 7) = res;
26068         POST_IO
26069 RET(14)
26070 }
26071
26072 // ORaD
26073 OPCODE(0x807C)
26074 {
26075         u32 adr, res;
26076         u32 src, dst;
26077
26078         FETCH_WORD(src);
26079         res = DREGu16((Opcode >> 9) & 7);
26080         res |= src;
26081         flag_C = 0;
26082         flag_V = 0;
26083         flag_NotZ = res;
26084         flag_N = res >> 8;
26085         DREGu16((Opcode >> 9) & 7) = res;
26086 RET(8)
26087 }
26088
26089 // ORaD
26090 OPCODE(0x805F)
26091 {
26092         u32 adr, res;
26093         u32 src, dst;
26094
26095         adr = AREG(7);
26096         AREG(7) += 2;
26097         PRE_IO
26098         READ_WORD_F(adr, src)
26099         res = DREGu16((Opcode >> 9) & 7);
26100         res |= src;
26101         flag_C = 0;
26102         flag_V = 0;
26103         flag_NotZ = res;
26104         flag_N = res >> 8;
26105         DREGu16((Opcode >> 9) & 7) = res;
26106         POST_IO
26107 RET(8)
26108 }
26109
26110 // ORaD
26111 OPCODE(0x8067)
26112 {
26113         u32 adr, res;
26114         u32 src, dst;
26115
26116         adr = AREG(7) - 2;
26117         AREG(7) = adr;
26118         PRE_IO
26119         READ_WORD_F(adr, src)
26120         res = DREGu16((Opcode >> 9) & 7);
26121         res |= src;
26122         flag_C = 0;
26123         flag_V = 0;
26124         flag_NotZ = res;
26125         flag_N = res >> 8;
26126         DREGu16((Opcode >> 9) & 7) = res;
26127         POST_IO
26128 RET(10)
26129 }
26130
26131 // ORaD
26132 OPCODE(0x8080)
26133 {
26134         u32 adr, res;
26135         u32 src, dst;
26136
26137         src = DREGu32((Opcode >> 0) & 7);
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 RET(8)
26146 }
26147
26148 // ORaD
26149 OPCODE(0x8090)
26150 {
26151         u32 adr, res;
26152         u32 src, dst;
26153
26154         adr = AREG((Opcode >> 0) & 7);
26155         PRE_IO
26156         READ_LONG_F(adr, src)
26157         res = DREGu32((Opcode >> 9) & 7);
26158         res |= src;
26159         flag_C = 0;
26160         flag_V = 0;
26161         flag_NotZ = res;
26162         flag_N = res >> 24;
26163         DREGu32((Opcode >> 9) & 7) = res;
26164         POST_IO
26165 RET(14)
26166 }
26167
26168 // ORaD
26169 OPCODE(0x8098)
26170 {
26171         u32 adr, res;
26172         u32 src, dst;
26173
26174         adr = AREG((Opcode >> 0) & 7);
26175         AREG((Opcode >> 0) & 7) += 4;
26176         PRE_IO
26177         READ_LONG_F(adr, src)
26178         res = DREGu32((Opcode >> 9) & 7);
26179         res |= src;
26180         flag_C = 0;
26181         flag_V = 0;
26182         flag_NotZ = res;
26183         flag_N = res >> 24;
26184         DREGu32((Opcode >> 9) & 7) = res;
26185         POST_IO
26186 RET(14)
26187 }
26188
26189 // ORaD
26190 OPCODE(0x80A0)
26191 {
26192         u32 adr, res;
26193         u32 src, dst;
26194
26195         adr = AREG((Opcode >> 0) & 7) - 4;
26196         AREG((Opcode >> 0) & 7) = adr;
26197         PRE_IO
26198         READ_LONG_F(adr, src)
26199         res = DREGu32((Opcode >> 9) & 7);
26200         res |= src;
26201         flag_C = 0;
26202         flag_V = 0;
26203         flag_NotZ = res;
26204         flag_N = res >> 24;
26205         DREGu32((Opcode >> 9) & 7) = res;
26206         POST_IO
26207 RET(16)
26208 }
26209
26210 // ORaD
26211 OPCODE(0x80A8)
26212 {
26213         u32 adr, res;
26214         u32 src, dst;
26215
26216         FETCH_SWORD(adr);
26217         adr += AREG((Opcode >> 0) & 7);
26218         PRE_IO
26219         READ_LONG_F(adr, src)
26220         res = DREGu32((Opcode >> 9) & 7);
26221         res |= src;
26222         flag_C = 0;
26223         flag_V = 0;
26224         flag_NotZ = res;
26225         flag_N = res >> 24;
26226         DREGu32((Opcode >> 9) & 7) = res;
26227         POST_IO
26228 RET(18)
26229 }
26230
26231 // ORaD
26232 OPCODE(0x80B0)
26233 {
26234         u32 adr, res;
26235         u32 src, dst;
26236
26237         adr = AREG((Opcode >> 0) & 7);
26238         DECODE_EXT_WORD
26239         PRE_IO
26240         READ_LONG_F(adr, src)
26241         res = DREGu32((Opcode >> 9) & 7);
26242         res |= src;
26243         flag_C = 0;
26244         flag_V = 0;
26245         flag_NotZ = res;
26246         flag_N = res >> 24;
26247         DREGu32((Opcode >> 9) & 7) = res;
26248         POST_IO
26249 RET(20)
26250 }
26251
26252 // ORaD
26253 OPCODE(0x80B8)
26254 {
26255         u32 adr, res;
26256         u32 src, dst;
26257
26258         FETCH_SWORD(adr);
26259         PRE_IO
26260         READ_LONG_F(adr, src)
26261         res = DREGu32((Opcode >> 9) & 7);
26262         res |= src;
26263         flag_C = 0;
26264         flag_V = 0;
26265         flag_NotZ = res;
26266         flag_N = res >> 24;
26267         DREGu32((Opcode >> 9) & 7) = res;
26268         POST_IO
26269 RET(18)
26270 }
26271
26272 // ORaD
26273 OPCODE(0x80B9)
26274 {
26275         u32 adr, res;
26276         u32 src, dst;
26277
26278         FETCH_LONG(adr);
26279         PRE_IO
26280         READ_LONG_F(adr, src)
26281         res = DREGu32((Opcode >> 9) & 7);
26282         res |= src;
26283         flag_C = 0;
26284         flag_V = 0;
26285         flag_NotZ = res;
26286         flag_N = res >> 24;
26287         DREGu32((Opcode >> 9) & 7) = res;
26288         POST_IO
26289 RET(22)
26290 }
26291
26292 // ORaD
26293 OPCODE(0x80BA)
26294 {
26295         u32 adr, res;
26296         u32 src, dst;
26297
26298         adr = GET_SWORD + GET_PC;
26299         PC++;
26300         PRE_IO
26301         READ_LONG_F(adr, src)
26302         res = DREGu32((Opcode >> 9) & 7);
26303         res |= src;
26304         flag_C = 0;
26305         flag_V = 0;
26306         flag_NotZ = res;
26307         flag_N = res >> 24;
26308         DREGu32((Opcode >> 9) & 7) = res;
26309         POST_IO
26310 RET(18)
26311 }
26312
26313 // ORaD
26314 OPCODE(0x80BB)
26315 {
26316         u32 adr, res;
26317         u32 src, dst;
26318
26319         adr = GET_PC;
26320         DECODE_EXT_WORD
26321         PRE_IO
26322         READ_LONG_F(adr, src)
26323         res = DREGu32((Opcode >> 9) & 7);
26324         res |= src;
26325         flag_C = 0;
26326         flag_V = 0;
26327         flag_NotZ = res;
26328         flag_N = res >> 24;
26329         DREGu32((Opcode >> 9) & 7) = res;
26330         POST_IO
26331 RET(20)
26332 }
26333
26334 // ORaD
26335 OPCODE(0x80BC)
26336 {
26337         u32 adr, res;
26338         u32 src, dst;
26339
26340         FETCH_LONG(src);
26341         res = DREGu32((Opcode >> 9) & 7);
26342         res |= src;
26343         flag_C = 0;
26344         flag_V = 0;
26345         flag_NotZ = res;
26346         flag_N = res >> 24;
26347         DREGu32((Opcode >> 9) & 7) = res;
26348 RET(16)
26349 }
26350
26351 // ORaD
26352 OPCODE(0x809F)
26353 {
26354         u32 adr, res;
26355         u32 src, dst;
26356
26357         adr = AREG(7);
26358         AREG(7) += 4;
26359         PRE_IO
26360         READ_LONG_F(adr, src)
26361         res = DREGu32((Opcode >> 9) & 7);
26362         res |= src;
26363         flag_C = 0;
26364         flag_V = 0;
26365         flag_NotZ = res;
26366         flag_N = res >> 24;
26367         DREGu32((Opcode >> 9) & 7) = res;
26368         POST_IO
26369 RET(14)
26370 }
26371
26372 // ORaD
26373 OPCODE(0x80A7)
26374 {
26375         u32 adr, res;
26376         u32 src, dst;
26377
26378         adr = AREG(7) - 4;
26379         AREG(7) = adr;
26380         PRE_IO
26381         READ_LONG_F(adr, src)
26382         res = DREGu32((Opcode >> 9) & 7);
26383         res |= src;
26384         flag_C = 0;
26385         flag_V = 0;
26386         flag_NotZ = res;
26387         flag_N = res >> 24;
26388         DREGu32((Opcode >> 9) & 7) = res;
26389         POST_IO
26390 RET(16)
26391 }
26392
26393 // ORDa
26394 OPCODE(0x8110)
26395 {
26396         u32 adr, res;
26397         u32 src, dst;
26398
26399         src = DREGu8((Opcode >> 9) & 7);
26400         adr = AREG((Opcode >> 0) & 7);
26401         PRE_IO
26402         READ_BYTE_F(adr, res)
26403         res |= src;
26404         flag_C = 0;
26405         flag_V = 0;
26406         flag_NotZ = res;
26407         flag_N = res;
26408         WRITE_BYTE_F(adr, res)
26409         POST_IO
26410 RET(12)
26411 }
26412
26413 // ORDa
26414 OPCODE(0x8118)
26415 {
26416         u32 adr, res;
26417         u32 src, dst;
26418
26419         src = DREGu8((Opcode >> 9) & 7);
26420         adr = AREG((Opcode >> 0) & 7);
26421         AREG((Opcode >> 0) & 7) += 1;
26422         PRE_IO
26423         READ_BYTE_F(adr, res)
26424         res |= src;
26425         flag_C = 0;
26426         flag_V = 0;
26427         flag_NotZ = res;
26428         flag_N = res;
26429         WRITE_BYTE_F(adr, res)
26430         POST_IO
26431 RET(12)
26432 }
26433
26434 // ORDa
26435 OPCODE(0x8120)
26436 {
26437         u32 adr, res;
26438         u32 src, dst;
26439
26440         src = DREGu8((Opcode >> 9) & 7);
26441         adr = AREG((Opcode >> 0) & 7) - 1;
26442         AREG((Opcode >> 0) & 7) = adr;
26443         PRE_IO
26444         READ_BYTE_F(adr, res)
26445         res |= src;
26446         flag_C = 0;
26447         flag_V = 0;
26448         flag_NotZ = res;
26449         flag_N = res;
26450         WRITE_BYTE_F(adr, res)
26451         POST_IO
26452 RET(14)
26453 }
26454
26455 // ORDa
26456 OPCODE(0x8128)
26457 {
26458         u32 adr, res;
26459         u32 src, dst;
26460
26461         src = DREGu8((Opcode >> 9) & 7);
26462         FETCH_SWORD(adr);
26463         adr += AREG((Opcode >> 0) & 7);
26464         PRE_IO
26465         READ_BYTE_F(adr, res)
26466         res |= src;
26467         flag_C = 0;
26468         flag_V = 0;
26469         flag_NotZ = res;
26470         flag_N = res;
26471         WRITE_BYTE_F(adr, res)
26472         POST_IO
26473 RET(16)
26474 }
26475
26476 // ORDa
26477 OPCODE(0x8130)
26478 {
26479         u32 adr, res;
26480         u32 src, dst;
26481
26482         src = DREGu8((Opcode >> 9) & 7);
26483         adr = AREG((Opcode >> 0) & 7);
26484         DECODE_EXT_WORD
26485         PRE_IO
26486         READ_BYTE_F(adr, res)
26487         res |= src;
26488         flag_C = 0;
26489         flag_V = 0;
26490         flag_NotZ = res;
26491         flag_N = res;
26492         WRITE_BYTE_F(adr, res)
26493         POST_IO
26494 RET(18)
26495 }
26496
26497 // ORDa
26498 OPCODE(0x8138)
26499 {
26500         u32 adr, res;
26501         u32 src, dst;
26502
26503         src = DREGu8((Opcode >> 9) & 7);
26504         FETCH_SWORD(adr);
26505         PRE_IO
26506         READ_BYTE_F(adr, res)
26507         res |= src;
26508         flag_C = 0;
26509         flag_V = 0;
26510         flag_NotZ = res;
26511         flag_N = res;
26512         WRITE_BYTE_F(adr, res)
26513         POST_IO
26514 RET(16)
26515 }
26516
26517 // ORDa
26518 OPCODE(0x8139)
26519 {
26520         u32 adr, res;
26521         u32 src, dst;
26522
26523         src = DREGu8((Opcode >> 9) & 7);
26524         FETCH_LONG(adr);
26525         PRE_IO
26526         READ_BYTE_F(adr, res)
26527         res |= src;
26528         flag_C = 0;
26529         flag_V = 0;
26530         flag_NotZ = res;
26531         flag_N = res;
26532         WRITE_BYTE_F(adr, res)
26533         POST_IO
26534 RET(20)
26535 }
26536
26537 // ORDa
26538 OPCODE(0x811F)
26539 {
26540         u32 adr, res;
26541         u32 src, dst;
26542
26543         src = DREGu8((Opcode >> 9) & 7);
26544         adr = AREG(7);
26545         AREG(7) += 2;
26546         PRE_IO
26547         READ_BYTE_F(adr, res)
26548         res |= src;
26549         flag_C = 0;
26550         flag_V = 0;
26551         flag_NotZ = res;
26552         flag_N = res;
26553         WRITE_BYTE_F(adr, res)
26554         POST_IO
26555 RET(12)
26556 }
26557
26558 // ORDa
26559 OPCODE(0x8127)
26560 {
26561         u32 adr, res;
26562         u32 src, dst;
26563
26564         src = DREGu8((Opcode >> 9) & 7);
26565         adr = AREG(7) - 2;
26566         AREG(7) = adr;
26567         PRE_IO
26568         READ_BYTE_F(adr, res)
26569         res |= src;
26570         flag_C = 0;
26571         flag_V = 0;
26572         flag_NotZ = res;
26573         flag_N = res;
26574         WRITE_BYTE_F(adr, res)
26575         POST_IO
26576 RET(14)
26577 }
26578
26579 // ORDa
26580 OPCODE(0x8150)
26581 {
26582         u32 adr, res;
26583         u32 src, dst;
26584
26585         src = DREGu16((Opcode >> 9) & 7);
26586         adr = AREG((Opcode >> 0) & 7);
26587         PRE_IO
26588         READ_WORD_F(adr, res)
26589         res |= src;
26590         flag_C = 0;
26591         flag_V = 0;
26592         flag_NotZ = res;
26593         flag_N = res >> 8;
26594         WRITE_WORD_F(adr, res)
26595         POST_IO
26596 RET(12)
26597 }
26598
26599 // ORDa
26600 OPCODE(0x8158)
26601 {
26602         u32 adr, res;
26603         u32 src, dst;
26604
26605         src = DREGu16((Opcode >> 9) & 7);
26606         adr = AREG((Opcode >> 0) & 7);
26607         AREG((Opcode >> 0) & 7) += 2;
26608         PRE_IO
26609         READ_WORD_F(adr, res)
26610         res |= src;
26611         flag_C = 0;
26612         flag_V = 0;
26613         flag_NotZ = res;
26614         flag_N = res >> 8;
26615         WRITE_WORD_F(adr, res)
26616         POST_IO
26617 RET(12)
26618 }
26619
26620 // ORDa
26621 OPCODE(0x8160)
26622 {
26623         u32 adr, res;
26624         u32 src, dst;
26625
26626         src = DREGu16((Opcode >> 9) & 7);
26627         adr = AREG((Opcode >> 0) & 7) - 2;
26628         AREG((Opcode >> 0) & 7) = adr;
26629         PRE_IO
26630         READ_WORD_F(adr, res)
26631         res |= src;
26632         flag_C = 0;
26633         flag_V = 0;
26634         flag_NotZ = res;
26635         flag_N = res >> 8;
26636         WRITE_WORD_F(adr, res)
26637         POST_IO
26638 RET(14)
26639 }
26640
26641 // ORDa
26642 OPCODE(0x8168)
26643 {
26644         u32 adr, res;
26645         u32 src, dst;
26646
26647         src = DREGu16((Opcode >> 9) & 7);
26648         FETCH_SWORD(adr);
26649         adr += AREG((Opcode >> 0) & 7);
26650         PRE_IO
26651         READ_WORD_F(adr, res)
26652         res |= src;
26653         flag_C = 0;
26654         flag_V = 0;
26655         flag_NotZ = res;
26656         flag_N = res >> 8;
26657         WRITE_WORD_F(adr, res)
26658         POST_IO
26659 RET(16)
26660 }
26661
26662 // ORDa
26663 OPCODE(0x8170)
26664 {
26665         u32 adr, res;
26666         u32 src, dst;
26667
26668         src = DREGu16((Opcode >> 9) & 7);
26669         adr = AREG((Opcode >> 0) & 7);
26670         DECODE_EXT_WORD
26671         PRE_IO
26672         READ_WORD_F(adr, res)
26673         res |= src;
26674         flag_C = 0;
26675         flag_V = 0;
26676         flag_NotZ = res;
26677         flag_N = res >> 8;
26678         WRITE_WORD_F(adr, res)
26679         POST_IO
26680 RET(18)
26681 }
26682
26683 // ORDa
26684 OPCODE(0x8178)
26685 {
26686         u32 adr, res;
26687         u32 src, dst;
26688
26689         src = DREGu16((Opcode >> 9) & 7);
26690         FETCH_SWORD(adr);
26691         PRE_IO
26692         READ_WORD_F(adr, res)
26693         res |= src;
26694         flag_C = 0;
26695         flag_V = 0;
26696         flag_NotZ = res;
26697         flag_N = res >> 8;
26698         WRITE_WORD_F(adr, res)
26699         POST_IO
26700 RET(16)
26701 }
26702
26703 // ORDa
26704 OPCODE(0x8179)
26705 {
26706         u32 adr, res;
26707         u32 src, dst;
26708
26709         src = DREGu16((Opcode >> 9) & 7);
26710         FETCH_LONG(adr);
26711         PRE_IO
26712         READ_WORD_F(adr, res)
26713         res |= src;
26714         flag_C = 0;
26715         flag_V = 0;
26716         flag_NotZ = res;
26717         flag_N = res >> 8;
26718         WRITE_WORD_F(adr, res)
26719         POST_IO
26720 RET(20)
26721 }
26722
26723 // ORDa
26724 OPCODE(0x815F)
26725 {
26726         u32 adr, res;
26727         u32 src, dst;
26728
26729         src = DREGu16((Opcode >> 9) & 7);
26730         adr = AREG(7);
26731         AREG(7) += 2;
26732         PRE_IO
26733         READ_WORD_F(adr, res)
26734         res |= src;
26735         flag_C = 0;
26736         flag_V = 0;
26737         flag_NotZ = res;
26738         flag_N = res >> 8;
26739         WRITE_WORD_F(adr, res)
26740         POST_IO
26741 RET(12)
26742 }
26743
26744 // ORDa
26745 OPCODE(0x8167)
26746 {
26747         u32 adr, res;
26748         u32 src, dst;
26749
26750         src = DREGu16((Opcode >> 9) & 7);
26751         adr = AREG(7) - 2;
26752         AREG(7) = adr;
26753         PRE_IO
26754         READ_WORD_F(adr, res)
26755         res |= src;
26756         flag_C = 0;
26757         flag_V = 0;
26758         flag_NotZ = res;
26759         flag_N = res >> 8;
26760         WRITE_WORD_F(adr, res)
26761         POST_IO
26762 RET(14)
26763 }
26764
26765 // ORDa
26766 OPCODE(0x8190)
26767 {
26768         u32 adr, res;
26769         u32 src, dst;
26770
26771         src = DREGu32((Opcode >> 9) & 7);
26772         adr = AREG((Opcode >> 0) & 7);
26773         PRE_IO
26774         READ_LONG_F(adr, res)
26775         res |= src;
26776         flag_C = 0;
26777         flag_V = 0;
26778         flag_NotZ = res;
26779         flag_N = res >> 24;
26780         WRITE_LONG_F(adr, res)
26781         POST_IO
26782 RET(20)
26783 }
26784
26785 // ORDa
26786 OPCODE(0x8198)
26787 {
26788         u32 adr, res;
26789         u32 src, dst;
26790
26791         src = DREGu32((Opcode >> 9) & 7);
26792         adr = AREG((Opcode >> 0) & 7);
26793         AREG((Opcode >> 0) & 7) += 4;
26794         PRE_IO
26795         READ_LONG_F(adr, res)
26796         res |= src;
26797         flag_C = 0;
26798         flag_V = 0;
26799         flag_NotZ = res;
26800         flag_N = res >> 24;
26801         WRITE_LONG_F(adr, res)
26802         POST_IO
26803 RET(20)
26804 }
26805
26806 // ORDa
26807 OPCODE(0x81A0)
26808 {
26809         u32 adr, res;
26810         u32 src, dst;
26811
26812         src = DREGu32((Opcode >> 9) & 7);
26813         adr = AREG((Opcode >> 0) & 7) - 4;
26814         AREG((Opcode >> 0) & 7) = adr;
26815         PRE_IO
26816         READ_LONG_F(adr, res)
26817         res |= src;
26818         flag_C = 0;
26819         flag_V = 0;
26820         flag_NotZ = res;
26821         flag_N = res >> 24;
26822         WRITE_LONG_F(adr, res)
26823         POST_IO
26824 RET(22)
26825 }
26826
26827 // ORDa
26828 OPCODE(0x81A8)
26829 {
26830         u32 adr, res;
26831         u32 src, dst;
26832
26833         src = DREGu32((Opcode >> 9) & 7);
26834         FETCH_SWORD(adr);
26835         adr += AREG((Opcode >> 0) & 7);
26836         PRE_IO
26837         READ_LONG_F(adr, res)
26838         res |= src;
26839         flag_C = 0;
26840         flag_V = 0;
26841         flag_NotZ = res;
26842         flag_N = res >> 24;
26843         WRITE_LONG_F(adr, res)
26844         POST_IO
26845 RET(24)
26846 }
26847
26848 // ORDa
26849 OPCODE(0x81B0)
26850 {
26851         u32 adr, res;
26852         u32 src, dst;
26853
26854         src = DREGu32((Opcode >> 9) & 7);
26855         adr = AREG((Opcode >> 0) & 7);
26856         DECODE_EXT_WORD
26857         PRE_IO
26858         READ_LONG_F(adr, res)
26859         res |= src;
26860         flag_C = 0;
26861         flag_V = 0;
26862         flag_NotZ = res;
26863         flag_N = res >> 24;
26864         WRITE_LONG_F(adr, res)
26865         POST_IO
26866 RET(26)
26867 }
26868
26869 // ORDa
26870 OPCODE(0x81B8)
26871 {
26872         u32 adr, res;
26873         u32 src, dst;
26874
26875         src = DREGu32((Opcode >> 9) & 7);
26876         FETCH_SWORD(adr);
26877         PRE_IO
26878         READ_LONG_F(adr, res)
26879         res |= src;
26880         flag_C = 0;
26881         flag_V = 0;
26882         flag_NotZ = res;
26883         flag_N = res >> 24;
26884         WRITE_LONG_F(adr, res)
26885         POST_IO
26886 RET(24)
26887 }
26888
26889 // ORDa
26890 OPCODE(0x81B9)
26891 {
26892         u32 adr, res;
26893         u32 src, dst;
26894
26895         src = DREGu32((Opcode >> 9) & 7);
26896         FETCH_LONG(adr);
26897         PRE_IO
26898         READ_LONG_F(adr, res)
26899         res |= src;
26900         flag_C = 0;
26901         flag_V = 0;
26902         flag_NotZ = res;
26903         flag_N = res >> 24;
26904         WRITE_LONG_F(adr, res)
26905         POST_IO
26906 RET(28)
26907 }
26908
26909 // ORDa
26910 OPCODE(0x819F)
26911 {
26912         u32 adr, res;
26913         u32 src, dst;
26914
26915         src = DREGu32((Opcode >> 9) & 7);
26916         adr = AREG(7);
26917         AREG(7) += 4;
26918         PRE_IO
26919         READ_LONG_F(adr, res)
26920         res |= src;
26921         flag_C = 0;
26922         flag_V = 0;
26923         flag_NotZ = res;
26924         flag_N = res >> 24;
26925         WRITE_LONG_F(adr, res)
26926         POST_IO
26927 RET(20)
26928 }
26929
26930 // ORDa
26931 OPCODE(0x81A7)
26932 {
26933         u32 adr, res;
26934         u32 src, dst;
26935
26936         src = DREGu32((Opcode >> 9) & 7);
26937         adr = AREG(7) - 4;
26938         AREG(7) = adr;
26939         PRE_IO
26940         READ_LONG_F(adr, res)
26941         res |= src;
26942         flag_C = 0;
26943         flag_V = 0;
26944         flag_NotZ = res;
26945         flag_N = res >> 24;
26946         WRITE_LONG_F(adr, res)
26947         POST_IO
26948 RET(22)
26949 }
26950
26951 // SBCD
26952 OPCODE(0x8100)
26953 {
26954         u32 adr, res;
26955         u32 src, dst;
26956         u32 corf = 0;
26957
26958         src = DREGu8((Opcode >> 0) & 7);
26959         dst = DREGu8((Opcode >> 9) & 7);
26960         res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
26961         if (res > 0xF) corf = 6;
26962         res += (dst & 0xF0) - (src & 0xF0);
26963         flag_V = res;
26964         flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
26965         if (res > 0xff) res += 0xA0;
26966         res = (res - corf) & 0xFF;
26967         flag_V &= ~res;
26968         flag_NotZ |= res;
26969         flag_N = res;
26970         DREGu8((Opcode >> 9) & 7) = res;
26971 RET(6)
26972 }
26973
26974 // SBCDM
26975 OPCODE(0x8108)
26976 {
26977         u32 adr, res;
26978         u32 src, dst;
26979         u32 corf = 0;
26980
26981         adr = AREG((Opcode >> 0) & 7) - 1;
26982         AREG((Opcode >> 0) & 7) = adr;
26983         PRE_IO
26984         READ_BYTE_F(adr, src)
26985         adr = AREG((Opcode >> 9) & 7) - 1;
26986         AREG((Opcode >> 9) & 7) = adr;
26987         READ_BYTE_F(adr, dst)
26988         res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
26989         if (res > 0xF) corf = 6;
26990         res += (dst & 0xF0) - (src & 0xF0);
26991         flag_V = res;
26992         flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
26993         if (res > 0xff) res += 0xA0;
26994         res = (res - corf) & 0xFF;
26995         flag_V &= ~res;
26996         flag_NotZ |= res;
26997         flag_N = res;
26998         WRITE_BYTE_F(adr, res)
26999         POST_IO
27000 RET(18)
27001 }
27002
27003 // SBCD7M
27004 OPCODE(0x810F)
27005 {
27006         u32 adr, res;
27007         u32 src, dst;
27008         u32 corf = 0;
27009
27010         adr = AREG(7) - 2;
27011         AREG(7) = adr;
27012         PRE_IO
27013         READ_BYTE_F(adr, src)
27014         adr = AREG((Opcode >> 9) & 7) - 1;
27015         AREG((Opcode >> 9) & 7) = adr;
27016         READ_BYTE_F(adr, dst)
27017         res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
27018         if (res > 0xF) corf = 6;
27019         res += (dst & 0xF0) - (src & 0xF0);
27020         flag_V = res;
27021         flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
27022         if (res > 0xff) res += 0xA0;
27023         res = (res - corf) & 0xFF;
27024         flag_V &= ~res;
27025         flag_NotZ |= res;
27026         flag_N = res;
27027         WRITE_BYTE_F(adr, res)
27028         POST_IO
27029 RET(18)
27030 }
27031
27032 // SBCDM7
27033 OPCODE(0x8F08)
27034 {
27035         u32 adr, res;
27036         u32 src, dst;
27037         u32 corf = 0;
27038
27039         adr = AREG((Opcode >> 0) & 7) - 1;
27040         AREG((Opcode >> 0) & 7) = adr;
27041         PRE_IO
27042         READ_BYTE_F(adr, src)
27043         adr = AREG(7) - 2;
27044         AREG(7) = adr;
27045         READ_BYTE_F(adr, dst)
27046         res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
27047         if (res > 0xF) corf = 6;
27048         res += (dst & 0xF0) - (src & 0xF0);
27049         flag_V = res;
27050         flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
27051         if (res > 0xff) res += 0xA0;
27052         res = (res - corf) & 0xFF;
27053         flag_V &= ~res;
27054         flag_NotZ |= res;
27055         flag_N = res;
27056         WRITE_BYTE_F(adr, res)
27057         POST_IO
27058 RET(18)
27059 }
27060
27061 // SBCD7M7
27062 OPCODE(0x8F0F)
27063 {
27064         u32 adr, res;
27065         u32 src, dst;
27066         u32 corf = 0;
27067
27068         adr = AREG(7) - 2;
27069         AREG(7) = adr;
27070         PRE_IO
27071         READ_BYTE_F(adr, src)
27072         adr = AREG(7) - 2;
27073         AREG(7) = adr;
27074         READ_BYTE_F(adr, dst)
27075         res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
27076         if (res > 0xF) corf = 6;
27077         res += (dst & 0xF0) - (src & 0xF0);
27078         flag_V = res;
27079         flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
27080         if (res > 0xff) res += 0xA0;
27081         res = (res - corf) & 0xFF;
27082         flag_V &= ~res;
27083         flag_NotZ |= res;
27084         flag_N = res;
27085         WRITE_BYTE_F(adr, res)
27086         POST_IO
27087 RET(18)
27088 }
27089
27090 // DIVU
27091 OPCODE(0x80C0)
27092 {
27093         u32 adr, res;
27094         u32 src, dst;
27095
27096         src = DREGu16((Opcode >> 0) & 7);
27097         if (src == 0)
27098         {
27099                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27100 #ifdef USE_CYCLONE_TIMING_DIV
27101 RET(140)
27102 #else
27103 RET(10)
27104 #endif
27105         }
27106         dst = DREGu32((Opcode >> 9) & 7);
27107         {
27108                 u32 q, r;
27109
27110                 q = dst / src;
27111                 r = dst % src;
27112
27113                 if (q & 0xFFFF0000)
27114                 {
27115                         flag_V = M68K_SR_V;
27116 #ifdef USE_CYCLONE_TIMING_DIV
27117 RET(140)
27118 #else
27119 RET(70)
27120 #endif
27121                 }
27122                 q &= 0x0000FFFF;
27123                 flag_NotZ = q;
27124                 flag_N = q >> 8;
27125                 flag_V = flag_C = 0;
27126                 res = q | (r << 16);
27127         DREGu32((Opcode >> 9) & 7) = res;
27128         }
27129 #ifdef USE_CYCLONE_TIMING_DIV
27130 RET(140)
27131 #else
27132 RET(90)
27133 #endif
27134 }
27135
27136 // DIVU
27137 OPCODE(0x80D0)
27138 {
27139         u32 adr, res;
27140         u32 src, dst;
27141
27142         adr = AREG((Opcode >> 0) & 7);
27143         PRE_IO
27144         READ_WORD_F(adr, src)
27145         if (src == 0)
27146         {
27147                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27148 #ifdef USE_CYCLONE_TIMING_DIV
27149 RET(144)
27150 #else
27151 RET(14)
27152 #endif
27153         }
27154         dst = DREGu32((Opcode >> 9) & 7);
27155         {
27156                 u32 q, r;
27157
27158                 q = dst / src;
27159                 r = dst % src;
27160
27161                 if (q & 0xFFFF0000)
27162                 {
27163                         flag_V = M68K_SR_V;
27164 #ifdef USE_CYCLONE_TIMING_DIV
27165 RET(144)
27166 #else
27167         RET(74)
27168 #endif
27169                 }
27170                 q &= 0x0000FFFF;
27171                 flag_NotZ = q;
27172                 flag_N = q >> 8;
27173                 flag_V = flag_C = 0;
27174                 res = q | (r << 16);
27175         DREGu32((Opcode >> 9) & 7) = res;
27176         }
27177 #ifdef USE_CYCLONE_TIMING_DIV
27178 RET(144)
27179 #else
27180 RET(94)
27181 #endif
27182 }
27183
27184 // DIVU
27185 OPCODE(0x80D8)
27186 {
27187         u32 adr, res;
27188         u32 src, dst;
27189
27190         adr = AREG((Opcode >> 0) & 7);
27191         AREG((Opcode >> 0) & 7) += 2;
27192         PRE_IO
27193         READ_WORD_F(adr, src)
27194         if (src == 0)
27195         {
27196                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27197 #ifdef USE_CYCLONE_TIMING_DIV
27198 RET(144)
27199 #else
27200 RET(14)
27201 #endif
27202         }
27203         dst = DREGu32((Opcode >> 9) & 7);
27204         {
27205                 u32 q, r;
27206
27207                 q = dst / src;
27208                 r = dst % src;
27209
27210                 if (q & 0xFFFF0000)
27211                 {
27212                         flag_V = M68K_SR_V;
27213 #ifdef USE_CYCLONE_TIMING_DIV
27214 RET(144)
27215 #else
27216         RET(74)
27217 #endif
27218                 }
27219                 q &= 0x0000FFFF;
27220                 flag_NotZ = q;
27221                 flag_N = q >> 8;
27222                 flag_V = flag_C = 0;
27223                 res = q | (r << 16);
27224         DREGu32((Opcode >> 9) & 7) = res;
27225         }
27226 #ifdef USE_CYCLONE_TIMING_DIV
27227 RET(144)
27228 #else
27229 RET(94)
27230 #endif
27231 }
27232
27233 // DIVU
27234 OPCODE(0x80E0)
27235 {
27236         u32 adr, res;
27237         u32 src, dst;
27238
27239         adr = AREG((Opcode >> 0) & 7) - 2;
27240         AREG((Opcode >> 0) & 7) = adr;
27241         PRE_IO
27242         READ_WORD_F(adr, src)
27243         if (src == 0)
27244         {
27245                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27246 #ifdef USE_CYCLONE_TIMING_DIV
27247 RET(146)
27248 #else
27249 RET(16)
27250 #endif
27251         }
27252         dst = DREGu32((Opcode >> 9) & 7);
27253         {
27254                 u32 q, r;
27255
27256                 q = dst / src;
27257                 r = dst % src;
27258
27259                 if (q & 0xFFFF0000)
27260                 {
27261                         flag_V = M68K_SR_V;
27262 #ifdef USE_CYCLONE_TIMING_DIV
27263 RET(146)
27264 #else
27265         RET(76)
27266 #endif
27267                 }
27268                 q &= 0x0000FFFF;
27269                 flag_NotZ = q;
27270                 flag_N = q >> 8;
27271                 flag_V = flag_C = 0;
27272                 res = q | (r << 16);
27273         DREGu32((Opcode >> 9) & 7) = res;
27274         }
27275 #ifdef USE_CYCLONE_TIMING_DIV
27276 RET(146)
27277 #else
27278 RET(96)
27279 #endif
27280 }
27281
27282 // DIVU
27283 OPCODE(0x80E8)
27284 {
27285         u32 adr, res;
27286         u32 src, dst;
27287
27288         FETCH_SWORD(adr);
27289         adr += AREG((Opcode >> 0) & 7);
27290         PRE_IO
27291         READ_WORD_F(adr, src)
27292         if (src == 0)
27293         {
27294                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27295 #ifdef USE_CYCLONE_TIMING_DIV
27296 RET(148)
27297 #else
27298 RET(18)
27299 #endif
27300         }
27301         dst = DREGu32((Opcode >> 9) & 7);
27302         {
27303                 u32 q, r;
27304
27305                 q = dst / src;
27306                 r = dst % src;
27307
27308                 if (q & 0xFFFF0000)
27309                 {
27310                         flag_V = M68K_SR_V;
27311 #ifdef USE_CYCLONE_TIMING_DIV
27312 RET(148)
27313 #else
27314         RET(78)
27315 #endif
27316                 }
27317                 q &= 0x0000FFFF;
27318                 flag_NotZ = q;
27319                 flag_N = q >> 8;
27320                 flag_V = flag_C = 0;
27321                 res = q | (r << 16);
27322         DREGu32((Opcode >> 9) & 7) = res;
27323         }
27324 #ifdef USE_CYCLONE_TIMING_DIV
27325 RET(148)
27326 #else
27327 RET(98)
27328 #endif
27329 }
27330
27331 // DIVU
27332 OPCODE(0x80F0)
27333 {
27334         u32 adr, res;
27335         u32 src, dst;
27336
27337         adr = AREG((Opcode >> 0) & 7);
27338         DECODE_EXT_WORD
27339         PRE_IO
27340         READ_WORD_F(adr, src)
27341         if (src == 0)
27342         {
27343                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27344 #ifdef USE_CYCLONE_TIMING_DIV
27345 RET(150)
27346 #else
27347 RET(20)
27348 #endif
27349         }
27350         dst = DREGu32((Opcode >> 9) & 7);
27351         {
27352                 u32 q, r;
27353
27354                 q = dst / src;
27355                 r = dst % src;
27356
27357                 if (q & 0xFFFF0000)
27358                 {
27359                         flag_V = M68K_SR_V;
27360 #ifdef USE_CYCLONE_TIMING_DIV
27361 RET(150)
27362 #else
27363         RET(80)
27364 #endif
27365                 }
27366                 q &= 0x0000FFFF;
27367                 flag_NotZ = q;
27368                 flag_N = q >> 8;
27369                 flag_V = flag_C = 0;
27370                 res = q | (r << 16);
27371         DREGu32((Opcode >> 9) & 7) = res;
27372         }
27373 #ifdef USE_CYCLONE_TIMING_DIV
27374 RET(150)
27375 #else
27376 RET(100)
27377 #endif
27378 }
27379
27380 // DIVU
27381 OPCODE(0x80F8)
27382 {
27383         u32 adr, res;
27384         u32 src, dst;
27385
27386         FETCH_SWORD(adr);
27387         PRE_IO
27388         READ_WORD_F(adr, src)
27389         if (src == 0)
27390         {
27391                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27392 #ifdef USE_CYCLONE_TIMING_DIV
27393 RET(148)
27394 #else
27395 RET(18)
27396 #endif
27397         }
27398         dst = DREGu32((Opcode >> 9) & 7);
27399         {
27400                 u32 q, r;
27401
27402                 q = dst / src;
27403                 r = dst % src;
27404
27405                 if (q & 0xFFFF0000)
27406                 {
27407                         flag_V = M68K_SR_V;
27408 #ifdef USE_CYCLONE_TIMING_DIV
27409 RET(148)
27410 #else
27411         RET(78)
27412 #endif
27413                 }
27414                 q &= 0x0000FFFF;
27415                 flag_NotZ = q;
27416                 flag_N = q >> 8;
27417                 flag_V = flag_C = 0;
27418                 res = q | (r << 16);
27419         DREGu32((Opcode >> 9) & 7) = res;
27420         }
27421 #ifdef USE_CYCLONE_TIMING_DIV
27422 RET(148)
27423 #else
27424 RET(98)
27425 #endif
27426 }
27427
27428 // DIVU
27429 OPCODE(0x80F9)
27430 {
27431         u32 adr, res;
27432         u32 src, dst;
27433
27434         FETCH_LONG(adr);
27435         PRE_IO
27436         READ_WORD_F(adr, src)
27437         if (src == 0)
27438         {
27439                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27440 #ifdef USE_CYCLONE_TIMING_DIV
27441 RET(152)
27442 #else
27443 RET(22)
27444 #endif
27445         }
27446         dst = DREGu32((Opcode >> 9) & 7);
27447         {
27448                 u32 q, r;
27449
27450                 q = dst / src;
27451                 r = dst % src;
27452
27453                 if (q & 0xFFFF0000)
27454                 {
27455                         flag_V = M68K_SR_V;
27456 #ifdef USE_CYCLONE_TIMING_DIV
27457 RET(152)
27458 #else
27459         RET(82)
27460 #endif
27461                 }
27462                 q &= 0x0000FFFF;
27463                 flag_NotZ = q;
27464                 flag_N = q >> 8;
27465                 flag_V = flag_C = 0;
27466                 res = q | (r << 16);
27467         DREGu32((Opcode >> 9) & 7) = res;
27468         }
27469 #ifdef USE_CYCLONE_TIMING_DIV
27470 RET(152)
27471 #else
27472 RET(102)
27473 #endif
27474 }
27475
27476 // DIVU
27477 OPCODE(0x80FA)
27478 {
27479         u32 adr, res;
27480         u32 src, dst;
27481
27482         adr = GET_SWORD + GET_PC;
27483         PC++;
27484         PRE_IO
27485         READ_WORD_F(adr, src)
27486         if (src == 0)
27487         {
27488                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27489 #ifdef USE_CYCLONE_TIMING_DIV
27490 RET(148)
27491 #else
27492 RET(18)
27493 #endif
27494         }
27495         dst = DREGu32((Opcode >> 9) & 7);
27496         {
27497                 u32 q, r;
27498
27499                 q = dst / src;
27500                 r = dst % src;
27501
27502                 if (q & 0xFFFF0000)
27503                 {
27504                         flag_V = M68K_SR_V;
27505 #ifdef USE_CYCLONE_TIMING_DIV
27506 RET(148)
27507 #else
27508         RET(78)
27509 #endif
27510                 }
27511                 q &= 0x0000FFFF;
27512                 flag_NotZ = q;
27513                 flag_N = q >> 8;
27514                 flag_V = flag_C = 0;
27515                 res = q | (r << 16);
27516         DREGu32((Opcode >> 9) & 7) = res;
27517         }
27518 #ifdef USE_CYCLONE_TIMING_DIV
27519 RET(148)
27520 #else
27521 RET(98)
27522 #endif
27523 }
27524
27525 // DIVU
27526 OPCODE(0x80FB)
27527 {
27528         u32 adr, res;
27529         u32 src, dst;
27530
27531         adr = GET_PC;
27532         DECODE_EXT_WORD
27533         PRE_IO
27534         READ_WORD_F(adr, src)
27535         if (src == 0)
27536         {
27537                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27538 #ifdef USE_CYCLONE_TIMING_DIV
27539 RET(150)
27540 #else
27541 RET(20)
27542 #endif
27543         }
27544         dst = DREGu32((Opcode >> 9) & 7);
27545         {
27546                 u32 q, r;
27547
27548                 q = dst / src;
27549                 r = dst % src;
27550
27551                 if (q & 0xFFFF0000)
27552                 {
27553                         flag_V = M68K_SR_V;
27554 #ifdef USE_CYCLONE_TIMING_DIV
27555 RET(150)
27556 #else
27557         RET(80)
27558 #endif
27559                 }
27560                 q &= 0x0000FFFF;
27561                 flag_NotZ = q;
27562                 flag_N = q >> 8;
27563                 flag_V = flag_C = 0;
27564                 res = q | (r << 16);
27565         DREGu32((Opcode >> 9) & 7) = res;
27566         }
27567 #ifdef USE_CYCLONE_TIMING_DIV
27568 RET(150)
27569 #else
27570 RET(100)
27571 #endif
27572 }
27573
27574 // DIVU
27575 OPCODE(0x80FC)
27576 {
27577         u32 adr, res;
27578         u32 src, dst;
27579
27580         FETCH_WORD(src);
27581         if (src == 0)
27582         {
27583                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27584 #ifdef USE_CYCLONE_TIMING_DIV
27585 RET(144)
27586 #else
27587 RET(14)
27588 #endif
27589         }
27590         dst = DREGu32((Opcode >> 9) & 7);
27591         {
27592                 u32 q, r;
27593
27594                 q = dst / src;
27595                 r = dst % src;
27596
27597                 if (q & 0xFFFF0000)
27598                 {
27599                         flag_V = M68K_SR_V;
27600 #ifdef USE_CYCLONE_TIMING_DIV
27601 RET(144)
27602 #else
27603         RET(74)
27604 #endif
27605                 }
27606                 q &= 0x0000FFFF;
27607                 flag_NotZ = q;
27608                 flag_N = q >> 8;
27609                 flag_V = flag_C = 0;
27610                 res = q | (r << 16);
27611         DREGu32((Opcode >> 9) & 7) = res;
27612         }
27613 #ifdef USE_CYCLONE_TIMING_DIV
27614 RET(144)
27615 #else
27616 RET(94)
27617 #endif
27618 }
27619
27620 // DIVU
27621 OPCODE(0x80DF)
27622 {
27623         u32 adr, res;
27624         u32 src, dst;
27625
27626         adr = AREG(7);
27627         AREG(7) += 2;
27628         PRE_IO
27629         READ_WORD_F(adr, src)
27630         if (src == 0)
27631         {
27632                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27633 #ifdef USE_CYCLONE_TIMING_DIV
27634 RET(144)
27635 #else
27636 RET(14)
27637 #endif
27638         }
27639         dst = DREGu32((Opcode >> 9) & 7);
27640         {
27641                 u32 q, r;
27642
27643                 q = dst / src;
27644                 r = dst % src;
27645
27646                 if (q & 0xFFFF0000)
27647                 {
27648                         flag_V = M68K_SR_V;
27649 #ifdef USE_CYCLONE_TIMING_DIV
27650 RET(144)
27651 #else
27652         RET(74)
27653 #endif
27654                 }
27655                 q &= 0x0000FFFF;
27656                 flag_NotZ = q;
27657                 flag_N = q >> 8;
27658                 flag_V = flag_C = 0;
27659                 res = q | (r << 16);
27660         DREGu32((Opcode >> 9) & 7) = res;
27661         }
27662 #ifdef USE_CYCLONE_TIMING_DIV
27663 RET(144)
27664 #else
27665 RET(94)
27666 #endif
27667 }
27668
27669 // DIVU
27670 OPCODE(0x80E7)
27671 {
27672         u32 adr, res;
27673         u32 src, dst;
27674
27675         adr = AREG(7) - 2;
27676         AREG(7) = adr;
27677         PRE_IO
27678         READ_WORD_F(adr, src)
27679         if (src == 0)
27680         {
27681                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27682 #ifdef USE_CYCLONE_TIMING_DIV
27683 RET(146)
27684 #else
27685 RET(16)
27686 #endif
27687         }
27688         dst = DREGu32((Opcode >> 9) & 7);
27689         {
27690                 u32 q, r;
27691
27692                 q = dst / src;
27693                 r = dst % src;
27694
27695                 if (q & 0xFFFF0000)
27696                 {
27697                         flag_V = M68K_SR_V;
27698 #ifdef USE_CYCLONE_TIMING_DIV
27699 RET(146)
27700 #else
27701         RET(76)
27702 #endif
27703                 }
27704                 q &= 0x0000FFFF;
27705                 flag_NotZ = q;
27706                 flag_N = q >> 8;
27707                 flag_V = flag_C = 0;
27708                 res = q | (r << 16);
27709         DREGu32((Opcode >> 9) & 7) = res;
27710         }
27711 #ifdef USE_CYCLONE_TIMING_DIV
27712 RET(146)
27713 #else
27714 RET(96)
27715 #endif
27716 }
27717
27718 // DIVS
27719 OPCODE(0x81C0)
27720 {
27721         u32 adr, res;
27722         u32 src, dst;
27723
27724         src = (s32)DREGs16((Opcode >> 0) & 7);
27725         if (src == 0)
27726         {
27727                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27728 #ifdef USE_CYCLONE_TIMING_DIV
27729 goto end81C0;
27730 #endif
27731                 RET(10)
27732         }
27733         dst = DREGu32((Opcode >> 9) & 7);
27734         if ((dst == 0x80000000) && (src == (u32)-1))
27735         {
27736                 flag_NotZ = flag_N = 0;
27737                 flag_V = flag_C = 0;
27738                 res = 0;
27739         DREGu32((Opcode >> 9) & 7) = res;
27740 #ifdef USE_CYCLONE_TIMING_DIV
27741 goto end81C0;
27742 #endif
27743         RET(50)
27744         }
27745         {
27746                 s32 q, r;
27747
27748                 q = (s32)dst / (s32)src;
27749                 r = (s32)dst % (s32)src;
27750
27751                 if ((q > 0x7FFF) || (q < -0x8000))
27752                 {
27753                         flag_V = M68K_SR_V;
27754 #ifdef USE_CYCLONE_TIMING_DIV
27755 goto end81C0;
27756 #endif
27757         RET(80)
27758                 }
27759                 q &= 0x0000FFFF;
27760                 flag_NotZ = q;
27761                 flag_N = q >> 8;
27762                 flag_V = flag_C = 0;
27763                 res = q | (r << 16);
27764         DREGu32((Opcode >> 9) & 7) = res;
27765         }
27766 #ifdef USE_CYCLONE_TIMING_DIV
27767 end81C0: m68kcontext.io_cycle_counter -= 50;
27768 #endif
27769 RET(108)
27770 }
27771
27772 // DIVS
27773 OPCODE(0x81D0)
27774 {
27775         u32 adr, res;
27776         u32 src, dst;
27777
27778         adr = AREG((Opcode >> 0) & 7);
27779         PRE_IO
27780         READSX_WORD_F(adr, src)
27781         if (src == 0)
27782         {
27783                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27784 #ifdef USE_CYCLONE_TIMING_DIV
27785 goto end81D0;
27786 #endif
27787                 RET(14)
27788         }
27789         dst = DREGu32((Opcode >> 9) & 7);
27790         if ((dst == 0x80000000) && (src == (u32)-1))
27791         {
27792                 flag_NotZ = flag_N = 0;
27793                 flag_V = flag_C = 0;
27794                 res = 0;
27795         DREGu32((Opcode >> 9) & 7) = res;
27796 #ifdef USE_CYCLONE_TIMING_DIV
27797 goto end81D0;
27798 #endif
27799         RET(54)
27800         }
27801         {
27802                 s32 q, r;
27803
27804                 q = (s32)dst / (s32)src;
27805                 r = (s32)dst % (s32)src;
27806
27807                 if ((q > 0x7FFF) || (q < -0x8000))
27808                 {
27809                         flag_V = M68K_SR_V;
27810 #ifdef USE_CYCLONE_TIMING_DIV
27811 goto end81D0;
27812 #endif
27813         RET(84)
27814                 }
27815                 q &= 0x0000FFFF;
27816                 flag_NotZ = q;
27817                 flag_N = q >> 8;
27818                 flag_V = flag_C = 0;
27819                 res = q | (r << 16);
27820         DREGu32((Opcode >> 9) & 7) = res;
27821         }
27822 #ifdef USE_CYCLONE_TIMING_DIV
27823 end81D0: m68kcontext.io_cycle_counter -= 50;
27824 #endif
27825 RET(112)
27826 }
27827
27828 // DIVS
27829 OPCODE(0x81D8)
27830 {
27831         u32 adr, res;
27832         u32 src, dst;
27833
27834         adr = AREG((Opcode >> 0) & 7);
27835         AREG((Opcode >> 0) & 7) += 2;
27836         PRE_IO
27837         READSX_WORD_F(adr, src)
27838         if (src == 0)
27839         {
27840                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27841 #ifdef USE_CYCLONE_TIMING_DIV
27842 goto end81D8;
27843 #endif
27844                 RET(14)
27845         }
27846         dst = DREGu32((Opcode >> 9) & 7);
27847         if ((dst == 0x80000000) && (src == (u32)-1))
27848         {
27849                 flag_NotZ = flag_N = 0;
27850                 flag_V = flag_C = 0;
27851                 res = 0;
27852         DREGu32((Opcode >> 9) & 7) = res;
27853 #ifdef USE_CYCLONE_TIMING_DIV
27854 goto end81D8;
27855 #endif
27856         RET(54)
27857         }
27858         {
27859                 s32 q, r;
27860
27861                 q = (s32)dst / (s32)src;
27862                 r = (s32)dst % (s32)src;
27863
27864                 if ((q > 0x7FFF) || (q < -0x8000))
27865                 {
27866                         flag_V = M68K_SR_V;
27867 #ifdef USE_CYCLONE_TIMING_DIV
27868 goto end81D8;
27869 #endif
27870         RET(84)
27871                 }
27872                 q &= 0x0000FFFF;
27873                 flag_NotZ = q;
27874                 flag_N = q >> 8;
27875                 flag_V = flag_C = 0;
27876                 res = q | (r << 16);
27877         DREGu32((Opcode >> 9) & 7) = res;
27878         }
27879 #ifdef USE_CYCLONE_TIMING_DIV
27880 end81D8: m68kcontext.io_cycle_counter -= 50;
27881 #endif
27882 RET(112)
27883 }
27884
27885 // DIVS
27886 OPCODE(0x81E0)
27887 {
27888         u32 adr, res;
27889         u32 src, dst;
27890
27891         adr = AREG((Opcode >> 0) & 7) - 2;
27892         AREG((Opcode >> 0) & 7) = adr;
27893         PRE_IO
27894         READSX_WORD_F(adr, src)
27895         if (src == 0)
27896         {
27897                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27898 #ifdef USE_CYCLONE_TIMING_DIV
27899 goto end81E0;
27900 #endif
27901                 RET(16)
27902         }
27903         dst = DREGu32((Opcode >> 9) & 7);
27904         if ((dst == 0x80000000) && (src == (u32)-1))
27905         {
27906                 flag_NotZ = flag_N = 0;
27907                 flag_V = flag_C = 0;
27908                 res = 0;
27909         DREGu32((Opcode >> 9) & 7) = res;
27910 #ifdef USE_CYCLONE_TIMING_DIV
27911 goto end81E0;
27912 #endif
27913         RET(56)
27914         }
27915         {
27916                 s32 q, r;
27917
27918                 q = (s32)dst / (s32)src;
27919                 r = (s32)dst % (s32)src;
27920
27921                 if ((q > 0x7FFF) || (q < -0x8000))
27922                 {
27923                         flag_V = M68K_SR_V;
27924 #ifdef USE_CYCLONE_TIMING_DIV
27925 goto end81E0;
27926 #endif
27927         RET(86)
27928                 }
27929                 q &= 0x0000FFFF;
27930                 flag_NotZ = q;
27931                 flag_N = q >> 8;
27932                 flag_V = flag_C = 0;
27933                 res = q | (r << 16);
27934         DREGu32((Opcode >> 9) & 7) = res;
27935         }
27936 #ifdef USE_CYCLONE_TIMING_DIV
27937 end81E0: m68kcontext.io_cycle_counter -= 50;
27938 #endif
27939 RET(114)
27940 }
27941
27942 // DIVS
27943 OPCODE(0x81E8)
27944 {
27945         u32 adr, res;
27946         u32 src, dst;
27947
27948         FETCH_SWORD(adr);
27949         adr += AREG((Opcode >> 0) & 7);
27950         PRE_IO
27951         READSX_WORD_F(adr, src)
27952         if (src == 0)
27953         {
27954                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27955 #ifdef USE_CYCLONE_TIMING_DIV
27956 goto end81E8;
27957 #endif
27958                 RET(18)
27959         }
27960         dst = DREGu32((Opcode >> 9) & 7);
27961         if ((dst == 0x80000000) && (src == (u32)-1))
27962         {
27963                 flag_NotZ = flag_N = 0;
27964                 flag_V = flag_C = 0;
27965                 res = 0;
27966         DREGu32((Opcode >> 9) & 7) = res;
27967 #ifdef USE_CYCLONE_TIMING_DIV
27968 goto end81E8;
27969 #endif
27970         RET(58)
27971         }
27972         {
27973                 s32 q, r;
27974
27975                 q = (s32)dst / (s32)src;
27976                 r = (s32)dst % (s32)src;
27977
27978                 if ((q > 0x7FFF) || (q < -0x8000))
27979                 {
27980                         flag_V = M68K_SR_V;
27981 #ifdef USE_CYCLONE_TIMING_DIV
27982 goto end81E8;
27983 #endif
27984         RET(88)
27985                 }
27986                 q &= 0x0000FFFF;
27987                 flag_NotZ = q;
27988                 flag_N = q >> 8;
27989                 flag_V = flag_C = 0;
27990                 res = q | (r << 16);
27991         DREGu32((Opcode >> 9) & 7) = res;
27992         }
27993 #ifdef USE_CYCLONE_TIMING_DIV
27994 end81E8: m68kcontext.io_cycle_counter -= 50;
27995 #endif
27996 RET(116)
27997 }
27998
27999 // DIVS
28000 OPCODE(0x81F0)
28001 {
28002         u32 adr, res;
28003         u32 src, dst;
28004
28005         adr = AREG((Opcode >> 0) & 7);
28006         DECODE_EXT_WORD
28007         PRE_IO
28008         READSX_WORD_F(adr, src)
28009         if (src == 0)
28010         {
28011                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28012 #ifdef USE_CYCLONE_TIMING_DIV
28013 goto end81F0;
28014 #endif
28015                 RET(20)
28016         }
28017         dst = DREGu32((Opcode >> 9) & 7);
28018         if ((dst == 0x80000000) && (src == (u32)-1))
28019         {
28020                 flag_NotZ = flag_N = 0;
28021                 flag_V = flag_C = 0;
28022                 res = 0;
28023         DREGu32((Opcode >> 9) & 7) = res;
28024 #ifdef USE_CYCLONE_TIMING_DIV
28025 goto end81F0;
28026 #endif
28027         RET(60)
28028         }
28029         {
28030                 s32 q, r;
28031
28032                 q = (s32)dst / (s32)src;
28033                 r = (s32)dst % (s32)src;
28034
28035                 if ((q > 0x7FFF) || (q < -0x8000))
28036                 {
28037                         flag_V = M68K_SR_V;
28038 #ifdef USE_CYCLONE_TIMING_DIV
28039 goto end81F0;
28040 #endif
28041         RET(90)
28042                 }
28043                 q &= 0x0000FFFF;
28044                 flag_NotZ = q;
28045                 flag_N = q >> 8;
28046                 flag_V = flag_C = 0;
28047                 res = q | (r << 16);
28048         DREGu32((Opcode >> 9) & 7) = res;
28049         }
28050 #ifdef USE_CYCLONE_TIMING_DIV
28051 end81F0: m68kcontext.io_cycle_counter -= 50;
28052 #endif
28053 RET(118)
28054 }
28055
28056 // DIVS
28057 OPCODE(0x81F8)
28058 {
28059         u32 adr, res;
28060         u32 src, dst;
28061
28062         FETCH_SWORD(adr);
28063         PRE_IO
28064         READSX_WORD_F(adr, src)
28065         if (src == 0)
28066         {
28067                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28068 #ifdef USE_CYCLONE_TIMING_DIV
28069 goto end81F8;
28070 #endif
28071                 RET(18)
28072         }
28073         dst = DREGu32((Opcode >> 9) & 7);
28074         if ((dst == 0x80000000) && (src == (u32)-1))
28075         {
28076                 flag_NotZ = flag_N = 0;
28077                 flag_V = flag_C = 0;
28078                 res = 0;
28079         DREGu32((Opcode >> 9) & 7) = res;
28080 #ifdef USE_CYCLONE_TIMING_DIV
28081 goto end81F8;
28082 #endif
28083         RET(58)
28084         }
28085         {
28086                 s32 q, r;
28087
28088                 q = (s32)dst / (s32)src;
28089                 r = (s32)dst % (s32)src;
28090
28091                 if ((q > 0x7FFF) || (q < -0x8000))
28092                 {
28093                         flag_V = M68K_SR_V;
28094 #ifdef USE_CYCLONE_TIMING_DIV
28095 goto end81F8;
28096 #endif
28097         RET(88)
28098                 }
28099                 q &= 0x0000FFFF;
28100                 flag_NotZ = q;
28101                 flag_N = q >> 8;
28102                 flag_V = flag_C = 0;
28103                 res = q | (r << 16);
28104         DREGu32((Opcode >> 9) & 7) = res;
28105         }
28106 #ifdef USE_CYCLONE_TIMING_DIV
28107 end81F8: m68kcontext.io_cycle_counter -= 50;
28108 #endif
28109 RET(116)
28110 }
28111
28112 // DIVS
28113 OPCODE(0x81F9)
28114 {
28115         u32 adr, res;
28116         u32 src, dst;
28117
28118         FETCH_LONG(adr);
28119         PRE_IO
28120         READSX_WORD_F(adr, src)
28121         if (src == 0)
28122         {
28123                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28124 #ifdef USE_CYCLONE_TIMING_DIV
28125 goto end81F9;
28126 #endif
28127                 RET(22)
28128         }
28129         dst = DREGu32((Opcode >> 9) & 7);
28130         if ((dst == 0x80000000) && (src == (u32)-1))
28131         {
28132                 flag_NotZ = flag_N = 0;
28133                 flag_V = flag_C = 0;
28134                 res = 0;
28135         DREGu32((Opcode >> 9) & 7) = res;
28136 #ifdef USE_CYCLONE_TIMING_DIV
28137 goto end81F9;
28138 #endif
28139         RET(62)
28140         }
28141         {
28142                 s32 q, r;
28143
28144                 q = (s32)dst / (s32)src;
28145                 r = (s32)dst % (s32)src;
28146
28147                 if ((q > 0x7FFF) || (q < -0x8000))
28148                 {
28149                         flag_V = M68K_SR_V;
28150 #ifdef USE_CYCLONE_TIMING_DIV
28151 goto end81F9;
28152 #endif
28153         RET(92)
28154                 }
28155                 q &= 0x0000FFFF;
28156                 flag_NotZ = q;
28157                 flag_N = q >> 8;
28158                 flag_V = flag_C = 0;
28159                 res = q | (r << 16);
28160         DREGu32((Opcode >> 9) & 7) = res;
28161         }
28162 #ifdef USE_CYCLONE_TIMING_DIV
28163 end81F9: m68kcontext.io_cycle_counter -= 50;
28164 #endif
28165 RET(120)
28166 }
28167
28168 // DIVS
28169 OPCODE(0x81FA)
28170 {
28171         u32 adr, res;
28172         u32 src, dst;
28173
28174         adr = GET_SWORD + GET_PC;
28175         PC++;
28176         PRE_IO
28177         READSX_WORD_F(adr, src)
28178         if (src == 0)
28179         {
28180                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28181 #ifdef USE_CYCLONE_TIMING_DIV
28182 goto end81FA;
28183 #endif
28184                 RET(18)
28185         }
28186         dst = DREGu32((Opcode >> 9) & 7);
28187         if ((dst == 0x80000000) && (src == (u32)-1))
28188         {
28189                 flag_NotZ = flag_N = 0;
28190                 flag_V = flag_C = 0;
28191                 res = 0;
28192         DREGu32((Opcode >> 9) & 7) = res;
28193 #ifdef USE_CYCLONE_TIMING_DIV
28194 goto end81FA;
28195 #endif
28196         RET(58)
28197         }
28198         {
28199                 s32 q, r;
28200
28201                 q = (s32)dst / (s32)src;
28202                 r = (s32)dst % (s32)src;
28203
28204                 if ((q > 0x7FFF) || (q < -0x8000))
28205                 {
28206                         flag_V = M68K_SR_V;
28207 #ifdef USE_CYCLONE_TIMING_DIV
28208 goto end81FA;
28209 #endif
28210         RET(88)
28211                 }
28212                 q &= 0x0000FFFF;
28213                 flag_NotZ = q;
28214                 flag_N = q >> 8;
28215                 flag_V = flag_C = 0;
28216                 res = q | (r << 16);
28217         DREGu32((Opcode >> 9) & 7) = res;
28218         }
28219 #ifdef USE_CYCLONE_TIMING_DIV
28220 end81FA: m68kcontext.io_cycle_counter -= 50;
28221 #endif
28222 RET(116)
28223 }
28224
28225 // DIVS
28226 OPCODE(0x81FB)
28227 {
28228         u32 adr, res;
28229         u32 src, dst;
28230
28231         adr = GET_PC;
28232         DECODE_EXT_WORD
28233         PRE_IO
28234         READSX_WORD_F(adr, src)
28235         if (src == 0)
28236         {
28237                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28238 #ifdef USE_CYCLONE_TIMING_DIV
28239 goto end81FB;
28240 #endif
28241                 RET(20)
28242         }
28243         dst = DREGu32((Opcode >> 9) & 7);
28244         if ((dst == 0x80000000) && (src == (u32)-1))
28245         {
28246                 flag_NotZ = flag_N = 0;
28247                 flag_V = flag_C = 0;
28248                 res = 0;
28249         DREGu32((Opcode >> 9) & 7) = res;
28250 #ifdef USE_CYCLONE_TIMING_DIV
28251 goto end81FB;
28252 #endif
28253         RET(60)
28254         }
28255         {
28256                 s32 q, r;
28257
28258                 q = (s32)dst / (s32)src;
28259                 r = (s32)dst % (s32)src;
28260
28261                 if ((q > 0x7FFF) || (q < -0x8000))
28262                 {
28263                         flag_V = M68K_SR_V;
28264 #ifdef USE_CYCLONE_TIMING_DIV
28265 goto end81FB;
28266 #endif
28267         RET(90)
28268                 }
28269                 q &= 0x0000FFFF;
28270                 flag_NotZ = q;
28271                 flag_N = q >> 8;
28272                 flag_V = flag_C = 0;
28273                 res = q | (r << 16);
28274         DREGu32((Opcode >> 9) & 7) = res;
28275         }
28276 #ifdef USE_CYCLONE_TIMING_DIV
28277 end81FB: m68kcontext.io_cycle_counter -= 50;
28278 #endif
28279 RET(118)
28280 }
28281
28282 // DIVS
28283 OPCODE(0x81FC)
28284 {
28285         u32 adr, res;
28286         u32 src, dst;
28287
28288         FETCH_SWORD(src);
28289         if (src == 0)
28290         {
28291                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28292 #ifdef USE_CYCLONE_TIMING_DIV
28293 goto end81FC;
28294 #endif
28295                 RET(14)
28296         }
28297         dst = DREGu32((Opcode >> 9) & 7);
28298         if ((dst == 0x80000000) && (src == (u32)-1))
28299         {
28300                 flag_NotZ = flag_N = 0;
28301                 flag_V = flag_C = 0;
28302                 res = 0;
28303         DREGu32((Opcode >> 9) & 7) = res;
28304 #ifdef USE_CYCLONE_TIMING_DIV
28305 goto end81FC;
28306 #endif
28307         RET(54)
28308         }
28309         {
28310                 s32 q, r;
28311
28312                 q = (s32)dst / (s32)src;
28313                 r = (s32)dst % (s32)src;
28314
28315                 if ((q > 0x7FFF) || (q < -0x8000))
28316                 {
28317                         flag_V = M68K_SR_V;
28318 #ifdef USE_CYCLONE_TIMING_DIV
28319 goto end81FC;
28320 #endif
28321         RET(84)
28322                 }
28323                 q &= 0x0000FFFF;
28324                 flag_NotZ = q;
28325                 flag_N = q >> 8;
28326                 flag_V = flag_C = 0;
28327                 res = q | (r << 16);
28328         DREGu32((Opcode >> 9) & 7) = res;
28329         }
28330 #ifdef USE_CYCLONE_TIMING_DIV
28331 end81FC: m68kcontext.io_cycle_counter -= 50;
28332 #endif
28333 RET(112)
28334 }
28335
28336 // DIVS
28337 OPCODE(0x81DF)
28338 {
28339         u32 adr, res;
28340         u32 src, dst;
28341
28342         adr = AREG(7);
28343         AREG(7) += 2;
28344         PRE_IO
28345         READSX_WORD_F(adr, src)
28346         if (src == 0)
28347         {
28348                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28349 #ifdef USE_CYCLONE_TIMING_DIV
28350 goto end81DF;
28351 #endif
28352                 RET(14)
28353         }
28354         dst = DREGu32((Opcode >> 9) & 7);
28355         if ((dst == 0x80000000) && (src == (u32)-1))
28356         {
28357                 flag_NotZ = flag_N = 0;
28358                 flag_V = flag_C = 0;
28359                 res = 0;
28360         DREGu32((Opcode >> 9) & 7) = res;
28361 #ifdef USE_CYCLONE_TIMING_DIV
28362 goto end81DF;
28363 #endif
28364         RET(54)
28365         }
28366         {
28367                 s32 q, r;
28368
28369                 q = (s32)dst / (s32)src;
28370                 r = (s32)dst % (s32)src;
28371
28372                 if ((q > 0x7FFF) || (q < -0x8000))
28373                 {
28374                         flag_V = M68K_SR_V;
28375 #ifdef USE_CYCLONE_TIMING_DIV
28376 goto end81DF;
28377 #endif
28378         RET(84)
28379                 }
28380                 q &= 0x0000FFFF;
28381                 flag_NotZ = q;
28382                 flag_N = q >> 8;
28383                 flag_V = flag_C = 0;
28384                 res = q | (r << 16);
28385         DREGu32((Opcode >> 9) & 7) = res;
28386         }
28387 #ifdef USE_CYCLONE_TIMING_DIV
28388 end81DF: m68kcontext.io_cycle_counter -= 50;
28389 #endif
28390 RET(112)
28391 }
28392
28393 // DIVS
28394 OPCODE(0x81E7)
28395 {
28396         u32 adr, res;
28397         u32 src, dst;
28398
28399         adr = AREG(7) - 2;
28400         AREG(7) = adr;
28401         PRE_IO
28402         READSX_WORD_F(adr, src)
28403         if (src == 0)
28404         {
28405                 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28406 #ifdef USE_CYCLONE_TIMING_DIV
28407 goto end81E7;
28408 #endif
28409                 RET(16)
28410         }
28411         dst = DREGu32((Opcode >> 9) & 7);
28412         if ((dst == 0x80000000) && (src == (u32)-1))
28413         {
28414                 flag_NotZ = flag_N = 0;
28415                 flag_V = flag_C = 0;
28416                 res = 0;
28417         DREGu32((Opcode >> 9) & 7) = res;
28418 #ifdef USE_CYCLONE_TIMING_DIV
28419 goto end81E7;
28420 #endif
28421         RET(56)
28422         }
28423         {
28424                 s32 q, r;
28425
28426                 q = (s32)dst / (s32)src;
28427                 r = (s32)dst % (s32)src;
28428
28429                 if ((q > 0x7FFF) || (q < -0x8000))
28430                 {
28431                         flag_V = M68K_SR_V;
28432 #ifdef USE_CYCLONE_TIMING_DIV
28433 goto end81E7;
28434 #endif
28435         RET(86)
28436                 }
28437                 q &= 0x0000FFFF;
28438                 flag_NotZ = q;
28439                 flag_N = q >> 8;
28440                 flag_V = flag_C = 0;
28441                 res = q | (r << 16);
28442         DREGu32((Opcode >> 9) & 7) = res;
28443         }
28444 #ifdef USE_CYCLONE_TIMING_DIV
28445 end81E7: m68kcontext.io_cycle_counter -= 50;
28446 #endif
28447 RET(114)
28448 }
28449
28450 // SUBaD
28451 OPCODE(0x9000)
28452 {
28453         u32 adr, res;
28454         u32 src, dst;
28455
28456         src = DREGu8((Opcode >> 0) & 7);
28457         dst = DREGu8((Opcode >> 9) & 7);
28458         res = dst - src;
28459         flag_N = flag_X = flag_C = res;
28460         flag_V = (src ^ dst) & (res ^ dst);
28461         flag_NotZ = res & 0xFF;
28462         DREGu8((Opcode >> 9) & 7) = res;
28463 RET(4)
28464 }
28465
28466 // SUBaD
28467 #if 0
28468 OPCODE(0x9008)
28469 {
28470         u32 adr, res;
28471         u32 src, dst;
28472
28473         // can't read byte from Ax registers !
28474         m68kcontext.execinfo |= M68K_FAULTED;
28475         m68kcontext.io_cycle_counter = 0;
28476 /*
28477         goto famec_Exec_End;
28478         dst = DREGu8((Opcode >> 9) & 7);
28479         res = dst - src;
28480         flag_N = flag_X = flag_C = res;
28481         flag_V = (src ^ dst) & (res ^ dst);
28482         flag_NotZ = res & 0xFF;
28483         DREGu8((Opcode >> 9) & 7) = res;
28484 */
28485 RET(4)
28486 }
28487 #endif
28488
28489 // SUBaD
28490 OPCODE(0x9010)
28491 {
28492         u32 adr, res;
28493         u32 src, dst;
28494
28495         adr = AREG((Opcode >> 0) & 7);
28496         PRE_IO
28497         READ_BYTE_F(adr, src)
28498         dst = DREGu8((Opcode >> 9) & 7);
28499         res = dst - src;
28500         flag_N = flag_X = flag_C = res;
28501         flag_V = (src ^ dst) & (res ^ dst);
28502         flag_NotZ = res & 0xFF;
28503         DREGu8((Opcode >> 9) & 7) = res;
28504         POST_IO
28505 RET(8)
28506 }
28507
28508 // SUBaD
28509 OPCODE(0x9018)
28510 {
28511         u32 adr, res;
28512         u32 src, dst;
28513
28514         adr = AREG((Opcode >> 0) & 7);
28515         AREG((Opcode >> 0) & 7) += 1;
28516         PRE_IO
28517         READ_BYTE_F(adr, src)
28518         dst = DREGu8((Opcode >> 9) & 7);
28519         res = dst - src;
28520         flag_N = flag_X = flag_C = res;
28521         flag_V = (src ^ dst) & (res ^ dst);
28522         flag_NotZ = res & 0xFF;
28523         DREGu8((Opcode >> 9) & 7) = res;
28524         POST_IO
28525 RET(8)
28526 }
28527
28528 // SUBaD
28529 OPCODE(0x9020)
28530 {
28531         u32 adr, res;
28532         u32 src, dst;
28533
28534         adr = AREG((Opcode >> 0) & 7) - 1;
28535         AREG((Opcode >> 0) & 7) = adr;
28536         PRE_IO
28537         READ_BYTE_F(adr, src)
28538         dst = DREGu8((Opcode >> 9) & 7);
28539         res = dst - src;
28540         flag_N = flag_X = flag_C = res;
28541         flag_V = (src ^ dst) & (res ^ dst);
28542         flag_NotZ = res & 0xFF;
28543         DREGu8((Opcode >> 9) & 7) = res;
28544         POST_IO
28545 RET(10)
28546 }
28547
28548 // SUBaD
28549 OPCODE(0x9028)
28550 {
28551         u32 adr, res;
28552         u32 src, dst;
28553
28554         FETCH_SWORD(adr);
28555         adr += AREG((Opcode >> 0) & 7);
28556         PRE_IO
28557         READ_BYTE_F(adr, src)
28558         dst = DREGu8((Opcode >> 9) & 7);
28559         res = dst - src;
28560         flag_N = flag_X = flag_C = res;
28561         flag_V = (src ^ dst) & (res ^ dst);
28562         flag_NotZ = res & 0xFF;
28563         DREGu8((Opcode >> 9) & 7) = res;
28564         POST_IO
28565 RET(12)
28566 }
28567
28568 // SUBaD
28569 OPCODE(0x9030)
28570 {
28571         u32 adr, res;
28572         u32 src, dst;
28573
28574         adr = AREG((Opcode >> 0) & 7);
28575         DECODE_EXT_WORD
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(14)
28586 }
28587
28588 // SUBaD
28589 OPCODE(0x9038)
28590 {
28591         u32 adr, res;
28592         u32 src, dst;
28593
28594         FETCH_SWORD(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(12)
28605 }
28606
28607 // SUBaD
28608 OPCODE(0x9039)
28609 {
28610         u32 adr, res;
28611         u32 src, dst;
28612
28613         FETCH_LONG(adr);
28614         PRE_IO
28615         READ_BYTE_F(adr, src)
28616         dst = DREGu8((Opcode >> 9) & 7);
28617         res = dst - src;
28618         flag_N = flag_X = flag_C = res;
28619         flag_V = (src ^ dst) & (res ^ dst);
28620         flag_NotZ = res & 0xFF;
28621         DREGu8((Opcode >> 9) & 7) = res;
28622         POST_IO
28623 RET(16)
28624 }
28625
28626 // SUBaD
28627 OPCODE(0x903A)
28628 {
28629         u32 adr, res;
28630         u32 src, dst;
28631
28632         adr = GET_SWORD + GET_PC;
28633         PC++;
28634         PRE_IO
28635         READ_BYTE_F(adr, src)
28636         dst = DREGu8((Opcode >> 9) & 7);
28637         res = dst - src;
28638         flag_N = flag_X = flag_C = res;
28639         flag_V = (src ^ dst) & (res ^ dst);
28640         flag_NotZ = res & 0xFF;
28641         DREGu8((Opcode >> 9) & 7) = res;
28642         POST_IO
28643 RET(12)
28644 }
28645
28646 // SUBaD
28647 OPCODE(0x903B)
28648 {
28649         u32 adr, res;
28650         u32 src, dst;
28651
28652         adr = GET_PC;
28653         DECODE_EXT_WORD
28654         PRE_IO
28655         READ_BYTE_F(adr, src)
28656         dst = DREGu8((Opcode >> 9) & 7);
28657         res = dst - src;
28658         flag_N = flag_X = flag_C = res;
28659         flag_V = (src ^ dst) & (res ^ dst);
28660         flag_NotZ = res & 0xFF;
28661         DREGu8((Opcode >> 9) & 7) = res;
28662         POST_IO
28663 RET(14)
28664 }
28665
28666 // SUBaD
28667 OPCODE(0x903C)
28668 {
28669         u32 adr, res;
28670         u32 src, dst;
28671
28672         FETCH_BYTE(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 RET(8)
28680 }
28681
28682 // SUBaD
28683 OPCODE(0x901F)
28684 {
28685         u32 adr, res;
28686         u32 src, dst;
28687
28688         adr = AREG(7);
28689         AREG(7) += 2;
28690         PRE_IO
28691         READ_BYTE_F(adr, src)
28692         dst = DREGu8((Opcode >> 9) & 7);
28693         res = dst - src;
28694         flag_N = flag_X = flag_C = res;
28695         flag_V = (src ^ dst) & (res ^ dst);
28696         flag_NotZ = res & 0xFF;
28697         DREGu8((Opcode >> 9) & 7) = res;
28698         POST_IO
28699 RET(8)
28700 }
28701
28702 // SUBaD
28703 OPCODE(0x9027)
28704 {
28705         u32 adr, res;
28706         u32 src, dst;
28707
28708         adr = AREG(7) - 2;
28709         AREG(7) = adr;
28710         PRE_IO
28711         READ_BYTE_F(adr, src)
28712         dst = DREGu8((Opcode >> 9) & 7);
28713         res = dst - src;
28714         flag_N = flag_X = flag_C = res;
28715         flag_V = (src ^ dst) & (res ^ dst);
28716         flag_NotZ = res & 0xFF;
28717         DREGu8((Opcode >> 9) & 7) = res;
28718         POST_IO
28719 RET(10)
28720 }
28721
28722 // SUBaD
28723 OPCODE(0x9040)
28724 {
28725         u32 adr, res;
28726         u32 src, dst;
28727
28728         src = DREGu16((Opcode >> 0) & 7);
28729         dst = DREGu16((Opcode >> 9) & 7);
28730         res = dst - src;
28731         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28732         flag_N = flag_X = flag_C = res >> 8;
28733         flag_NotZ = res & 0xFFFF;
28734         DREGu16((Opcode >> 9) & 7) = res;
28735 RET(4)
28736 }
28737
28738 // SUBaD
28739 OPCODE(0x9048)
28740 {
28741         u32 adr, res;
28742         u32 src, dst;
28743
28744         src = AREGu16((Opcode >> 0) & 7);
28745         dst = DREGu16((Opcode >> 9) & 7);
28746         res = dst - src;
28747         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28748         flag_N = flag_X = flag_C = res >> 8;
28749         flag_NotZ = res & 0xFFFF;
28750         DREGu16((Opcode >> 9) & 7) = res;
28751 RET(4)
28752 }
28753
28754 // SUBaD
28755 OPCODE(0x9050)
28756 {
28757         u32 adr, res;
28758         u32 src, dst;
28759
28760         adr = AREG((Opcode >> 0) & 7);
28761         PRE_IO
28762         READ_WORD_F(adr, src)
28763         dst = DREGu16((Opcode >> 9) & 7);
28764         res = dst - src;
28765         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28766         flag_N = flag_X = flag_C = res >> 8;
28767         flag_NotZ = res & 0xFFFF;
28768         DREGu16((Opcode >> 9) & 7) = res;
28769         POST_IO
28770 RET(8)
28771 }
28772
28773 // SUBaD
28774 OPCODE(0x9058)
28775 {
28776         u32 adr, res;
28777         u32 src, dst;
28778
28779         adr = AREG((Opcode >> 0) & 7);
28780         AREG((Opcode >> 0) & 7) += 2;
28781         PRE_IO
28782         READ_WORD_F(adr, src)
28783         dst = DREGu16((Opcode >> 9) & 7);
28784         res = dst - src;
28785         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28786         flag_N = flag_X = flag_C = res >> 8;
28787         flag_NotZ = res & 0xFFFF;
28788         DREGu16((Opcode >> 9) & 7) = res;
28789         POST_IO
28790 RET(8)
28791 }
28792
28793 // SUBaD
28794 OPCODE(0x9060)
28795 {
28796         u32 adr, res;
28797         u32 src, dst;
28798
28799         adr = AREG((Opcode >> 0) & 7) - 2;
28800         AREG((Opcode >> 0) & 7) = adr;
28801         PRE_IO
28802         READ_WORD_F(adr, src)
28803         dst = DREGu16((Opcode >> 9) & 7);
28804         res = dst - src;
28805         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28806         flag_N = flag_X = flag_C = res >> 8;
28807         flag_NotZ = res & 0xFFFF;
28808         DREGu16((Opcode >> 9) & 7) = res;
28809         POST_IO
28810 RET(10)
28811 }
28812
28813 // SUBaD
28814 OPCODE(0x9068)
28815 {
28816         u32 adr, res;
28817         u32 src, dst;
28818
28819         FETCH_SWORD(adr);
28820         adr += AREG((Opcode >> 0) & 7);
28821         PRE_IO
28822         READ_WORD_F(adr, src)
28823         dst = DREGu16((Opcode >> 9) & 7);
28824         res = dst - src;
28825         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28826         flag_N = flag_X = flag_C = res >> 8;
28827         flag_NotZ = res & 0xFFFF;
28828         DREGu16((Opcode >> 9) & 7) = res;
28829         POST_IO
28830 RET(12)
28831 }
28832
28833 // SUBaD
28834 OPCODE(0x9070)
28835 {
28836         u32 adr, res;
28837         u32 src, dst;
28838
28839         adr = AREG((Opcode >> 0) & 7);
28840         DECODE_EXT_WORD
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(14)
28851 }
28852
28853 // SUBaD
28854 OPCODE(0x9078)
28855 {
28856         u32 adr, res;
28857         u32 src, dst;
28858
28859         FETCH_SWORD(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(12)
28870 }
28871
28872 // SUBaD
28873 OPCODE(0x9079)
28874 {
28875         u32 adr, res;
28876         u32 src, dst;
28877
28878         FETCH_LONG(adr);
28879         PRE_IO
28880         READ_WORD_F(adr, src)
28881         dst = DREGu16((Opcode >> 9) & 7);
28882         res = dst - src;
28883         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28884         flag_N = flag_X = flag_C = res >> 8;
28885         flag_NotZ = res & 0xFFFF;
28886         DREGu16((Opcode >> 9) & 7) = res;
28887         POST_IO
28888 RET(16)
28889 }
28890
28891 // SUBaD
28892 OPCODE(0x907A)
28893 {
28894         u32 adr, res;
28895         u32 src, dst;
28896
28897         adr = GET_SWORD + GET_PC;
28898         PC++;
28899         PRE_IO
28900         READ_WORD_F(adr, src)
28901         dst = DREGu16((Opcode >> 9) & 7);
28902         res = dst - src;
28903         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28904         flag_N = flag_X = flag_C = res >> 8;
28905         flag_NotZ = res & 0xFFFF;
28906         DREGu16((Opcode >> 9) & 7) = res;
28907         POST_IO
28908 RET(12)
28909 }
28910
28911 // SUBaD
28912 OPCODE(0x907B)
28913 {
28914         u32 adr, res;
28915         u32 src, dst;
28916
28917         adr = GET_PC;
28918         DECODE_EXT_WORD
28919         PRE_IO
28920         READ_WORD_F(adr, src)
28921         dst = DREGu16((Opcode >> 9) & 7);
28922         res = dst - src;
28923         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28924         flag_N = flag_X = flag_C = res >> 8;
28925         flag_NotZ = res & 0xFFFF;
28926         DREGu16((Opcode >> 9) & 7) = res;
28927         POST_IO
28928 RET(14)
28929 }
28930
28931 // SUBaD
28932 OPCODE(0x907C)
28933 {
28934         u32 adr, res;
28935         u32 src, dst;
28936
28937         FETCH_WORD(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 RET(8)
28945 }
28946
28947 // SUBaD
28948 OPCODE(0x905F)
28949 {
28950         u32 adr, res;
28951         u32 src, dst;
28952
28953         adr = AREG(7);
28954         AREG(7) += 2;
28955         PRE_IO
28956         READ_WORD_F(adr, src)
28957         dst = DREGu16((Opcode >> 9) & 7);
28958         res = dst - src;
28959         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28960         flag_N = flag_X = flag_C = res >> 8;
28961         flag_NotZ = res & 0xFFFF;
28962         DREGu16((Opcode >> 9) & 7) = res;
28963         POST_IO
28964 RET(8)
28965 }
28966
28967 // SUBaD
28968 OPCODE(0x9067)
28969 {
28970         u32 adr, res;
28971         u32 src, dst;
28972
28973         adr = AREG(7) - 2;
28974         AREG(7) = adr;
28975         PRE_IO
28976         READ_WORD_F(adr, src)
28977         dst = DREGu16((Opcode >> 9) & 7);
28978         res = dst - src;
28979         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28980         flag_N = flag_X = flag_C = res >> 8;
28981         flag_NotZ = res & 0xFFFF;
28982         DREGu16((Opcode >> 9) & 7) = res;
28983         POST_IO
28984 RET(10)
28985 }
28986
28987 // SUBaD
28988 OPCODE(0x9080)
28989 {
28990         u32 adr, res;
28991         u32 src, dst;
28992
28993         src = DREGu32((Opcode >> 0) & 7);
28994         dst = DREGu32((Opcode >> 9) & 7);
28995         res = dst - src;
28996         flag_NotZ = res;
28997         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
28998         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
28999         flag_N = res >> 24;
29000         DREGu32((Opcode >> 9) & 7) = res;
29001 RET(8)
29002 }
29003
29004 // SUBaD
29005 OPCODE(0x9088)
29006 {
29007         u32 adr, res;
29008         u32 src, dst;
29009
29010         src = AREGu32((Opcode >> 0) & 7);
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 RET(8)
29019 }
29020
29021 // SUBaD
29022 OPCODE(0x9090)
29023 {
29024         u32 adr, res;
29025         u32 src, dst;
29026
29027         adr = AREG((Opcode >> 0) & 7);
29028         PRE_IO
29029         READ_LONG_F(adr, src)
29030         dst = DREGu32((Opcode >> 9) & 7);
29031         res = dst - src;
29032         flag_NotZ = res;
29033         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29034         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29035         flag_N = res >> 24;
29036         DREGu32((Opcode >> 9) & 7) = res;
29037         POST_IO
29038 RET(14)
29039 }
29040
29041 // SUBaD
29042 OPCODE(0x9098)
29043 {
29044         u32 adr, res;
29045         u32 src, dst;
29046
29047         adr = AREG((Opcode >> 0) & 7);
29048         AREG((Opcode >> 0) & 7) += 4;
29049         PRE_IO
29050         READ_LONG_F(adr, src)
29051         dst = DREGu32((Opcode >> 9) & 7);
29052         res = dst - src;
29053         flag_NotZ = res;
29054         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29055         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29056         flag_N = res >> 24;
29057         DREGu32((Opcode >> 9) & 7) = res;
29058         POST_IO
29059 RET(14)
29060 }
29061
29062 // SUBaD
29063 OPCODE(0x90A0)
29064 {
29065         u32 adr, res;
29066         u32 src, dst;
29067
29068         adr = AREG((Opcode >> 0) & 7) - 4;
29069         AREG((Opcode >> 0) & 7) = adr;
29070         PRE_IO
29071         READ_LONG_F(adr, src)
29072         dst = DREGu32((Opcode >> 9) & 7);
29073         res = dst - src;
29074         flag_NotZ = res;
29075         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29076         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29077         flag_N = res >> 24;
29078         DREGu32((Opcode >> 9) & 7) = res;
29079         POST_IO
29080 RET(16)
29081 }
29082
29083 // SUBaD
29084 OPCODE(0x90A8)
29085 {
29086         u32 adr, res;
29087         u32 src, dst;
29088
29089         FETCH_SWORD(adr);
29090         adr += AREG((Opcode >> 0) & 7);
29091         PRE_IO
29092         READ_LONG_F(adr, src)
29093         dst = DREGu32((Opcode >> 9) & 7);
29094         res = dst - src;
29095         flag_NotZ = res;
29096         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29097         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29098         flag_N = res >> 24;
29099         DREGu32((Opcode >> 9) & 7) = res;
29100         POST_IO
29101 RET(18)
29102 }
29103
29104 // SUBaD
29105 OPCODE(0x90B0)
29106 {
29107         u32 adr, res;
29108         u32 src, dst;
29109
29110         adr = AREG((Opcode >> 0) & 7);
29111         DECODE_EXT_WORD
29112         PRE_IO
29113         READ_LONG_F(adr, src)
29114         dst = DREGu32((Opcode >> 9) & 7);
29115         res = dst - src;
29116         flag_NotZ = res;
29117         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29118         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29119         flag_N = res >> 24;
29120         DREGu32((Opcode >> 9) & 7) = res;
29121         POST_IO
29122 RET(20)
29123 }
29124
29125 // SUBaD
29126 OPCODE(0x90B8)
29127 {
29128         u32 adr, res;
29129         u32 src, dst;
29130
29131         FETCH_SWORD(adr);
29132         PRE_IO
29133         READ_LONG_F(adr, src)
29134         dst = DREGu32((Opcode >> 9) & 7);
29135         res = dst - src;
29136         flag_NotZ = res;
29137         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29138         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29139         flag_N = res >> 24;
29140         DREGu32((Opcode >> 9) & 7) = res;
29141         POST_IO
29142 RET(18)
29143 }
29144
29145 // SUBaD
29146 OPCODE(0x90B9)
29147 {
29148         u32 adr, res;
29149         u32 src, dst;
29150
29151         FETCH_LONG(adr);
29152         PRE_IO
29153         READ_LONG_F(adr, src)
29154         dst = DREGu32((Opcode >> 9) & 7);
29155         res = dst - src;
29156         flag_NotZ = res;
29157         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29158         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29159         flag_N = res >> 24;
29160         DREGu32((Opcode >> 9) & 7) = res;
29161         POST_IO
29162 RET(22)
29163 }
29164
29165 // SUBaD
29166 OPCODE(0x90BA)
29167 {
29168         u32 adr, res;
29169         u32 src, dst;
29170
29171         adr = GET_SWORD + GET_PC;
29172         PC++;
29173         PRE_IO
29174         READ_LONG_F(adr, src)
29175         dst = DREGu32((Opcode >> 9) & 7);
29176         res = dst - src;
29177         flag_NotZ = res;
29178         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29179         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29180         flag_N = res >> 24;
29181         DREGu32((Opcode >> 9) & 7) = res;
29182         POST_IO
29183 RET(18)
29184 }
29185
29186 // SUBaD
29187 OPCODE(0x90BB)
29188 {
29189         u32 adr, res;
29190         u32 src, dst;
29191
29192         adr = GET_PC;
29193         DECODE_EXT_WORD
29194         PRE_IO
29195         READ_LONG_F(adr, src)
29196         dst = DREGu32((Opcode >> 9) & 7);
29197         res = dst - src;
29198         flag_NotZ = res;
29199         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29200         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29201         flag_N = res >> 24;
29202         DREGu32((Opcode >> 9) & 7) = res;
29203         POST_IO
29204 RET(20)
29205 }
29206
29207 // SUBaD
29208 OPCODE(0x90BC)
29209 {
29210         u32 adr, res;
29211         u32 src, dst;
29212
29213         FETCH_LONG(src);
29214         dst = DREGu32((Opcode >> 9) & 7);
29215         res = dst - src;
29216         flag_NotZ = res;
29217         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29218         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29219         flag_N = res >> 24;
29220         DREGu32((Opcode >> 9) & 7) = res;
29221 RET(16)
29222 }
29223
29224 // SUBaD
29225 OPCODE(0x909F)
29226 {
29227         u32 adr, res;
29228         u32 src, dst;
29229
29230         adr = AREG(7);
29231         AREG(7) += 4;
29232         PRE_IO
29233         READ_LONG_F(adr, src)
29234         dst = DREGu32((Opcode >> 9) & 7);
29235         res = dst - src;
29236         flag_NotZ = res;
29237         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29238         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29239         flag_N = res >> 24;
29240         DREGu32((Opcode >> 9) & 7) = res;
29241         POST_IO
29242 RET(14)
29243 }
29244
29245 // SUBaD
29246 OPCODE(0x90A7)
29247 {
29248         u32 adr, res;
29249         u32 src, dst;
29250
29251         adr = AREG(7) - 4;
29252         AREG(7) = adr;
29253         PRE_IO
29254         READ_LONG_F(adr, src)
29255         dst = DREGu32((Opcode >> 9) & 7);
29256         res = dst - src;
29257         flag_NotZ = res;
29258         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29259         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29260         flag_N = res >> 24;
29261         DREGu32((Opcode >> 9) & 7) = res;
29262         POST_IO
29263 RET(16)
29264 }
29265
29266 // SUBDa
29267 OPCODE(0x9110)
29268 {
29269         u32 adr, res;
29270         u32 src, dst;
29271
29272         src = DREGu8((Opcode >> 9) & 7);
29273         adr = AREG((Opcode >> 0) & 7);
29274         PRE_IO
29275         READ_BYTE_F(adr, dst)
29276         res = dst - src;
29277         flag_N = flag_X = flag_C = res;
29278         flag_V = (src ^ dst) & (res ^ dst);
29279         flag_NotZ = res & 0xFF;
29280         WRITE_BYTE_F(adr, res)
29281         POST_IO
29282 RET(12)
29283 }
29284
29285 // SUBDa
29286 OPCODE(0x9118)
29287 {
29288         u32 adr, res;
29289         u32 src, dst;
29290
29291         src = DREGu8((Opcode >> 9) & 7);
29292         adr = AREG((Opcode >> 0) & 7);
29293         AREG((Opcode >> 0) & 7) += 1;
29294         PRE_IO
29295         READ_BYTE_F(adr, dst)
29296         res = dst - src;
29297         flag_N = flag_X = flag_C = res;
29298         flag_V = (src ^ dst) & (res ^ dst);
29299         flag_NotZ = res & 0xFF;
29300         WRITE_BYTE_F(adr, res)
29301         POST_IO
29302 RET(12)
29303 }
29304
29305 // SUBDa
29306 OPCODE(0x9120)
29307 {
29308         u32 adr, res;
29309         u32 src, dst;
29310
29311         src = DREGu8((Opcode >> 9) & 7);
29312         adr = AREG((Opcode >> 0) & 7) - 1;
29313         AREG((Opcode >> 0) & 7) = adr;
29314         PRE_IO
29315         READ_BYTE_F(adr, dst)
29316         res = dst - src;
29317         flag_N = flag_X = flag_C = res;
29318         flag_V = (src ^ dst) & (res ^ dst);
29319         flag_NotZ = res & 0xFF;
29320         WRITE_BYTE_F(adr, res)
29321         POST_IO
29322 RET(14)
29323 }
29324
29325 // SUBDa
29326 OPCODE(0x9128)
29327 {
29328         u32 adr, res;
29329         u32 src, dst;
29330
29331         src = DREGu8((Opcode >> 9) & 7);
29332         FETCH_SWORD(adr);
29333         adr += AREG((Opcode >> 0) & 7);
29334         PRE_IO
29335         READ_BYTE_F(adr, dst)
29336         res = dst - src;
29337         flag_N = flag_X = flag_C = res;
29338         flag_V = (src ^ dst) & (res ^ dst);
29339         flag_NotZ = res & 0xFF;
29340         WRITE_BYTE_F(adr, res)
29341         POST_IO
29342 RET(16)
29343 }
29344
29345 // SUBDa
29346 OPCODE(0x9130)
29347 {
29348         u32 adr, res;
29349         u32 src, dst;
29350
29351         src = DREGu8((Opcode >> 9) & 7);
29352         adr = AREG((Opcode >> 0) & 7);
29353         DECODE_EXT_WORD
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(18)
29363 }
29364
29365 // SUBDa
29366 OPCODE(0x9138)
29367 {
29368         u32 adr, res;
29369         u32 src, dst;
29370
29371         src = DREGu8((Opcode >> 9) & 7);
29372         FETCH_SWORD(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(16)
29382 }
29383
29384 // SUBDa
29385 OPCODE(0x9139)
29386 {
29387         u32 adr, res;
29388         u32 src, dst;
29389
29390         src = DREGu8((Opcode >> 9) & 7);
29391         FETCH_LONG(adr);
29392         PRE_IO
29393         READ_BYTE_F(adr, dst)
29394         res = dst - src;
29395         flag_N = flag_X = flag_C = res;
29396         flag_V = (src ^ dst) & (res ^ dst);
29397         flag_NotZ = res & 0xFF;
29398         WRITE_BYTE_F(adr, res)
29399         POST_IO
29400 RET(20)
29401 }
29402
29403 // SUBDa
29404 OPCODE(0x911F)
29405 {
29406         u32 adr, res;
29407         u32 src, dst;
29408
29409         src = DREGu8((Opcode >> 9) & 7);
29410         adr = AREG(7);
29411         AREG(7) += 2;
29412         PRE_IO
29413         READ_BYTE_F(adr, dst)
29414         res = dst - src;
29415         flag_N = flag_X = flag_C = res;
29416         flag_V = (src ^ dst) & (res ^ dst);
29417         flag_NotZ = res & 0xFF;
29418         WRITE_BYTE_F(adr, res)
29419         POST_IO
29420 RET(12)
29421 }
29422
29423 // SUBDa
29424 OPCODE(0x9127)
29425 {
29426         u32 adr, res;
29427         u32 src, dst;
29428
29429         src = DREGu8((Opcode >> 9) & 7);
29430         adr = AREG(7) - 2;
29431         AREG(7) = adr;
29432         PRE_IO
29433         READ_BYTE_F(adr, dst)
29434         res = dst - src;
29435         flag_N = flag_X = flag_C = res;
29436         flag_V = (src ^ dst) & (res ^ dst);
29437         flag_NotZ = res & 0xFF;
29438         WRITE_BYTE_F(adr, res)
29439         POST_IO
29440 RET(14)
29441 }
29442
29443 // SUBDa
29444 OPCODE(0x9150)
29445 {
29446         u32 adr, res;
29447         u32 src, dst;
29448
29449         src = DREGu16((Opcode >> 9) & 7);
29450         adr = AREG((Opcode >> 0) & 7);
29451         PRE_IO
29452         READ_WORD_F(adr, dst)
29453         res = dst - src;
29454         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29455         flag_N = flag_X = flag_C = res >> 8;
29456         flag_NotZ = res & 0xFFFF;
29457         WRITE_WORD_F(adr, res)
29458         POST_IO
29459 RET(12)
29460 }
29461
29462 // SUBDa
29463 OPCODE(0x9158)
29464 {
29465         u32 adr, res;
29466         u32 src, dst;
29467
29468         src = DREGu16((Opcode >> 9) & 7);
29469         adr = AREG((Opcode >> 0) & 7);
29470         AREG((Opcode >> 0) & 7) += 2;
29471         PRE_IO
29472         READ_WORD_F(adr, dst)
29473         res = dst - src;
29474         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29475         flag_N = flag_X = flag_C = res >> 8;
29476         flag_NotZ = res & 0xFFFF;
29477         WRITE_WORD_F(adr, res)
29478         POST_IO
29479 RET(12)
29480 }
29481
29482 // SUBDa
29483 OPCODE(0x9160)
29484 {
29485         u32 adr, res;
29486         u32 src, dst;
29487
29488         src = DREGu16((Opcode >> 9) & 7);
29489         adr = AREG((Opcode >> 0) & 7) - 2;
29490         AREG((Opcode >> 0) & 7) = adr;
29491         PRE_IO
29492         READ_WORD_F(adr, dst)
29493         res = dst - src;
29494         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29495         flag_N = flag_X = flag_C = res >> 8;
29496         flag_NotZ = res & 0xFFFF;
29497         WRITE_WORD_F(adr, res)
29498         POST_IO
29499 RET(14)
29500 }
29501
29502 // SUBDa
29503 OPCODE(0x9168)
29504 {
29505         u32 adr, res;
29506         u32 src, dst;
29507
29508         src = DREGu16((Opcode >> 9) & 7);
29509         FETCH_SWORD(adr);
29510         adr += AREG((Opcode >> 0) & 7);
29511         PRE_IO
29512         READ_WORD_F(adr, dst)
29513         res = dst - src;
29514         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29515         flag_N = flag_X = flag_C = res >> 8;
29516         flag_NotZ = res & 0xFFFF;
29517         WRITE_WORD_F(adr, res)
29518         POST_IO
29519 RET(16)
29520 }
29521
29522 // SUBDa
29523 OPCODE(0x9170)
29524 {
29525         u32 adr, res;
29526         u32 src, dst;
29527
29528         src = DREGu16((Opcode >> 9) & 7);
29529         adr = AREG((Opcode >> 0) & 7);
29530         DECODE_EXT_WORD
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(18)
29540 }
29541
29542 // SUBDa
29543 OPCODE(0x9178)
29544 {
29545         u32 adr, res;
29546         u32 src, dst;
29547
29548         src = DREGu16((Opcode >> 9) & 7);
29549         FETCH_SWORD(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(16)
29559 }
29560
29561 // SUBDa
29562 OPCODE(0x9179)
29563 {
29564         u32 adr, res;
29565         u32 src, dst;
29566
29567         src = DREGu16((Opcode >> 9) & 7);
29568         FETCH_LONG(adr);
29569         PRE_IO
29570         READ_WORD_F(adr, dst)
29571         res = dst - src;
29572         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29573         flag_N = flag_X = flag_C = res >> 8;
29574         flag_NotZ = res & 0xFFFF;
29575         WRITE_WORD_F(adr, res)
29576         POST_IO
29577 RET(20)
29578 }
29579
29580 // SUBDa
29581 OPCODE(0x915F)
29582 {
29583         u32 adr, res;
29584         u32 src, dst;
29585
29586         src = DREGu16((Opcode >> 9) & 7);
29587         adr = AREG(7);
29588         AREG(7) += 2;
29589         PRE_IO
29590         READ_WORD_F(adr, dst)
29591         res = dst - src;
29592         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29593         flag_N = flag_X = flag_C = res >> 8;
29594         flag_NotZ = res & 0xFFFF;
29595         WRITE_WORD_F(adr, res)
29596         POST_IO
29597 RET(12)
29598 }
29599
29600 // SUBDa
29601 OPCODE(0x9167)
29602 {
29603         u32 adr, res;
29604         u32 src, dst;
29605
29606         src = DREGu16((Opcode >> 9) & 7);
29607         adr = AREG(7) - 2;
29608         AREG(7) = adr;
29609         PRE_IO
29610         READ_WORD_F(adr, dst)
29611         res = dst - src;
29612         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29613         flag_N = flag_X = flag_C = res >> 8;
29614         flag_NotZ = res & 0xFFFF;
29615         WRITE_WORD_F(adr, res)
29616         POST_IO
29617 RET(14)
29618 }
29619
29620 // SUBDa
29621 OPCODE(0x9190)
29622 {
29623         u32 adr, res;
29624         u32 src, dst;
29625
29626         src = DREGu32((Opcode >> 9) & 7);
29627         adr = AREG((Opcode >> 0) & 7);
29628         PRE_IO
29629         READ_LONG_F(adr, dst)
29630         res = dst - src;
29631         flag_NotZ = res;
29632         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29633         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29634         flag_N = res >> 24;
29635         WRITE_LONG_F(adr, res)
29636         POST_IO
29637 RET(20)
29638 }
29639
29640 // SUBDa
29641 OPCODE(0x9198)
29642 {
29643         u32 adr, res;
29644         u32 src, dst;
29645
29646         src = DREGu32((Opcode >> 9) & 7);
29647         adr = AREG((Opcode >> 0) & 7);
29648         AREG((Opcode >> 0) & 7) += 4;
29649         PRE_IO
29650         READ_LONG_F(adr, dst)
29651         res = dst - src;
29652         flag_NotZ = res;
29653         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29654         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29655         flag_N = res >> 24;
29656         WRITE_LONG_F(adr, res)
29657         POST_IO
29658 RET(20)
29659 }
29660
29661 // SUBDa
29662 OPCODE(0x91A0)
29663 {
29664         u32 adr, res;
29665         u32 src, dst;
29666
29667         src = DREGu32((Opcode >> 9) & 7);
29668         adr = AREG((Opcode >> 0) & 7) - 4;
29669         AREG((Opcode >> 0) & 7) = adr;
29670         PRE_IO
29671         READ_LONG_F(adr, dst)
29672         res = dst - src;
29673         flag_NotZ = res;
29674         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29675         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29676         flag_N = res >> 24;
29677         WRITE_LONG_F(adr, res)
29678         POST_IO
29679 RET(22)
29680 }
29681
29682 // SUBDa
29683 OPCODE(0x91A8)
29684 {
29685         u32 adr, res;
29686         u32 src, dst;
29687
29688         src = DREGu32((Opcode >> 9) & 7);
29689         FETCH_SWORD(adr);
29690         adr += AREG((Opcode >> 0) & 7);
29691         PRE_IO
29692         READ_LONG_F(adr, dst)
29693         res = dst - src;
29694         flag_NotZ = res;
29695         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29696         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29697         flag_N = res >> 24;
29698         WRITE_LONG_F(adr, res)
29699         POST_IO
29700 RET(24)
29701 }
29702
29703 // SUBDa
29704 OPCODE(0x91B0)
29705 {
29706         u32 adr, res;
29707         u32 src, dst;
29708
29709         src = DREGu32((Opcode >> 9) & 7);
29710         adr = AREG((Opcode >> 0) & 7);
29711         DECODE_EXT_WORD
29712         PRE_IO
29713         READ_LONG_F(adr, dst)
29714         res = dst - src;
29715         flag_NotZ = res;
29716         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29717         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29718         flag_N = res >> 24;
29719         WRITE_LONG_F(adr, res)
29720         POST_IO
29721 RET(26)
29722 }
29723
29724 // SUBDa
29725 OPCODE(0x91B8)
29726 {
29727         u32 adr, res;
29728         u32 src, dst;
29729
29730         src = DREGu32((Opcode >> 9) & 7);
29731         FETCH_SWORD(adr);
29732         PRE_IO
29733         READ_LONG_F(adr, dst)
29734         res = dst - src;
29735         flag_NotZ = res;
29736         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29737         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29738         flag_N = res >> 24;
29739         WRITE_LONG_F(adr, res)
29740         POST_IO
29741 RET(24)
29742 }
29743
29744 // SUBDa
29745 OPCODE(0x91B9)
29746 {
29747         u32 adr, res;
29748         u32 src, dst;
29749
29750         src = DREGu32((Opcode >> 9) & 7);
29751         FETCH_LONG(adr);
29752         PRE_IO
29753         READ_LONG_F(adr, dst)
29754         res = dst - src;
29755         flag_NotZ = res;
29756         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29757         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29758         flag_N = res >> 24;
29759         WRITE_LONG_F(adr, res)
29760         POST_IO
29761 RET(28)
29762 }
29763
29764 // SUBDa
29765 OPCODE(0x919F)
29766 {
29767         u32 adr, res;
29768         u32 src, dst;
29769
29770         src = DREGu32((Opcode >> 9) & 7);
29771         adr = AREG(7);
29772         AREG(7) += 4;
29773         PRE_IO
29774         READ_LONG_F(adr, dst)
29775         res = dst - src;
29776         flag_NotZ = res;
29777         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29778         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29779         flag_N = res >> 24;
29780         WRITE_LONG_F(adr, res)
29781         POST_IO
29782 RET(20)
29783 }
29784
29785 // SUBDa
29786 OPCODE(0x91A7)
29787 {
29788         u32 adr, res;
29789         u32 src, dst;
29790
29791         src = DREGu32((Opcode >> 9) & 7);
29792         adr = AREG(7) - 4;
29793         AREG(7) = adr;
29794         PRE_IO
29795         READ_LONG_F(adr, dst)
29796         res = dst - src;
29797         flag_NotZ = res;
29798         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29799         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29800         flag_N = res >> 24;
29801         WRITE_LONG_F(adr, res)
29802         POST_IO
29803 RET(22)
29804 }
29805
29806 // SUBX
29807 OPCODE(0x9100)
29808 {
29809         u32 adr, res;
29810         u32 src, dst;
29811
29812         src = DREGu8((Opcode >> 0) & 7);
29813         dst = DREGu8((Opcode >> 9) & 7);
29814         res = dst - src - ((flag_X >> 8) & 1);
29815         flag_N = flag_X = flag_C = res;
29816         flag_V = (src ^ dst) & (res ^ dst);
29817         flag_NotZ |= res & 0xFF;
29818         DREGu8((Opcode >> 9) & 7) = res;
29819 RET(4)
29820 }
29821
29822 // SUBX
29823 OPCODE(0x9140)
29824 {
29825         u32 adr, res;
29826         u32 src, dst;
29827
29828         src = DREGu16((Opcode >> 0) & 7);
29829         dst = DREGu16((Opcode >> 9) & 7);
29830         res = dst - src - ((flag_X >> 8) & 1);
29831         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29832         flag_N = flag_X = flag_C = res >> 8;
29833         flag_NotZ |= res & 0xFFFF;
29834         DREGu16((Opcode >> 9) & 7) = res;
29835 RET(4)
29836 }
29837
29838 // SUBX
29839 OPCODE(0x9180)
29840 {
29841         u32 adr, res;
29842         u32 src, dst;
29843
29844         src = DREGu32((Opcode >> 0) & 7);
29845         dst = DREGu32((Opcode >> 9) & 7);
29846         res = dst - src - ((flag_X >> 8) & 1);
29847         flag_NotZ |= res;
29848         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29849         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29850         flag_N = res >> 24;
29851         DREGu32((Opcode >> 9) & 7) = res;
29852 RET(8)
29853 }
29854
29855 // SUBXM
29856 OPCODE(0x9108)
29857 {
29858         u32 adr, res;
29859         u32 src, dst;
29860
29861         adr = AREG((Opcode >> 0) & 7) - 1;
29862         AREG((Opcode >> 0) & 7) = adr;
29863         PRE_IO
29864         READ_BYTE_F(adr, src)
29865         adr = AREG((Opcode >> 9) & 7) - 1;
29866         AREG((Opcode >> 9) & 7) = adr;
29867         READ_BYTE_F(adr, dst)
29868         res = dst - src - ((flag_X >> 8) & 1);
29869         flag_N = flag_X = flag_C = res;
29870         flag_V = (src ^ dst) & (res ^ dst);
29871         flag_NotZ |= res & 0xFF;
29872         WRITE_BYTE_F(adr, res)
29873         POST_IO
29874 RET(18)
29875 }
29876
29877 // SUBXM
29878 OPCODE(0x9148)
29879 {
29880         u32 adr, res;
29881         u32 src, dst;
29882
29883         adr = AREG((Opcode >> 0) & 7) - 2;
29884         AREG((Opcode >> 0) & 7) = adr;
29885         PRE_IO
29886         READ_WORD_F(adr, src)
29887         adr = AREG((Opcode >> 9) & 7) - 2;
29888         AREG((Opcode >> 9) & 7) = adr;
29889         READ_WORD_F(adr, dst)
29890         res = dst - src - ((flag_X >> 8) & 1);
29891         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29892         flag_N = flag_X = flag_C = res >> 8;
29893         flag_NotZ |= res & 0xFFFF;
29894         WRITE_WORD_F(adr, res)
29895         POST_IO
29896 RET(18)
29897 }
29898
29899 // SUBXM
29900 OPCODE(0x9188)
29901 {
29902         u32 adr, res;
29903         u32 src, dst;
29904
29905         adr = AREG((Opcode >> 0) & 7) - 4;
29906         AREG((Opcode >> 0) & 7) = adr;
29907         PRE_IO
29908         READ_LONG_F(adr, src)
29909         adr = AREG((Opcode >> 9) & 7) - 4;
29910         AREG((Opcode >> 9) & 7) = adr;
29911         READ_LONG_F(adr, dst)
29912         res = dst - src - ((flag_X >> 8) & 1);
29913         flag_NotZ |= res;
29914         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29915         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29916         flag_N = res >> 24;
29917         WRITE_LONG_F(adr, res)
29918         POST_IO
29919 RET(30)
29920 }
29921
29922 // SUBX7M
29923 OPCODE(0x910F)
29924 {
29925         u32 adr, res;
29926         u32 src, dst;
29927
29928         adr = AREG(7) - 2;
29929         AREG(7) = adr;
29930         PRE_IO
29931         READ_BYTE_F(adr, src)
29932         adr = AREG((Opcode >> 9) & 7) - 1;
29933         AREG((Opcode >> 9) & 7) = adr;
29934         READ_BYTE_F(adr, dst)
29935         res = dst - src - ((flag_X >> 8) & 1);
29936         flag_N = flag_X = flag_C = res;
29937         flag_V = (src ^ dst) & (res ^ dst);
29938         flag_NotZ |= res & 0xFF;
29939         WRITE_BYTE_F(adr, res)
29940         POST_IO
29941 RET(18)
29942 }
29943
29944 // SUBX7M
29945 OPCODE(0x914F)
29946 {
29947         u32 adr, res;
29948         u32 src, dst;
29949
29950         adr = AREG(7) - 2;
29951         AREG(7) = adr;
29952         PRE_IO
29953         READ_WORD_F(adr, src)
29954         adr = AREG((Opcode >> 9) & 7) - 2;
29955         AREG((Opcode >> 9) & 7) = adr;
29956         READ_WORD_F(adr, dst)
29957         res = dst - src - ((flag_X >> 8) & 1);
29958         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29959         flag_N = flag_X = flag_C = res >> 8;
29960         flag_NotZ |= res & 0xFFFF;
29961         WRITE_WORD_F(adr, res)
29962         POST_IO
29963 RET(18)
29964 }
29965
29966 // SUBX7M
29967 OPCODE(0x918F)
29968 {
29969         u32 adr, res;
29970         u32 src, dst;
29971
29972         adr = AREG(7) - 4;
29973         AREG(7) = adr;
29974         PRE_IO
29975         READ_LONG_F(adr, src)
29976         adr = AREG((Opcode >> 9) & 7) - 4;
29977         AREG((Opcode >> 9) & 7) = adr;
29978         READ_LONG_F(adr, dst)
29979         res = dst - src - ((flag_X >> 8) & 1);
29980         flag_NotZ |= res;
29981         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29982         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29983         flag_N = res >> 24;
29984         WRITE_LONG_F(adr, res)
29985         POST_IO
29986 RET(30)
29987 }
29988
29989 // SUBXM7
29990 OPCODE(0x9F08)
29991 {
29992         u32 adr, res;
29993         u32 src, dst;
29994
29995         adr = AREG((Opcode >> 0) & 7) - 1;
29996         AREG((Opcode >> 0) & 7) = adr;
29997         PRE_IO
29998         READ_BYTE_F(adr, src)
29999         adr = AREG(7) - 2;
30000         AREG(7) = adr;
30001         READ_BYTE_F(adr, dst)
30002         res = dst - src - ((flag_X >> 8) & 1);
30003         flag_N = flag_X = flag_C = res;
30004         flag_V = (src ^ dst) & (res ^ dst);
30005         flag_NotZ |= res & 0xFF;
30006         WRITE_BYTE_F(adr, res)
30007         POST_IO
30008 RET(18)
30009 }
30010
30011 // SUBXM7
30012 OPCODE(0x9F48)
30013 {
30014         u32 adr, res;
30015         u32 src, dst;
30016
30017         adr = AREG((Opcode >> 0) & 7) - 2;
30018         AREG((Opcode >> 0) & 7) = adr;
30019         PRE_IO
30020         READ_WORD_F(adr, src)
30021         adr = AREG(7) - 2;
30022         AREG(7) = adr;
30023         READ_WORD_F(adr, dst)
30024         res = dst - src - ((flag_X >> 8) & 1);
30025         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30026         flag_N = flag_X = flag_C = res >> 8;
30027         flag_NotZ |= res & 0xFFFF;
30028         WRITE_WORD_F(adr, res)
30029         POST_IO
30030 RET(18)
30031 }
30032
30033 // SUBXM7
30034 OPCODE(0x9F88)
30035 {
30036         u32 adr, res;
30037         u32 src, dst;
30038
30039         adr = AREG((Opcode >> 0) & 7) - 4;
30040         AREG((Opcode >> 0) & 7) = adr;
30041         PRE_IO
30042         READ_LONG_F(adr, src)
30043         adr = AREG(7) - 4;
30044         AREG(7) = adr;
30045         READ_LONG_F(adr, dst)
30046         res = dst - src - ((flag_X >> 8) & 1);
30047         flag_NotZ |= res;
30048         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30049         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30050         flag_N = res >> 24;
30051         WRITE_LONG_F(adr, res)
30052         POST_IO
30053 RET(30)
30054 }
30055
30056 // SUBX7M7
30057 OPCODE(0x9F0F)
30058 {
30059         u32 adr, res;
30060         u32 src, dst;
30061
30062         adr = AREG(7) - 2;
30063         AREG(7) = adr;
30064         PRE_IO
30065         READ_BYTE_F(adr, src)
30066         adr = AREG(7) - 2;
30067         AREG(7) = adr;
30068         READ_BYTE_F(adr, dst)
30069         res = dst - src - ((flag_X >> 8) & 1);
30070         flag_N = flag_X = flag_C = res;
30071         flag_V = (src ^ dst) & (res ^ dst);
30072         flag_NotZ |= res & 0xFF;
30073         WRITE_BYTE_F(adr, res)
30074         POST_IO
30075 RET(18)
30076 }
30077
30078 // SUBX7M7
30079 OPCODE(0x9F4F)
30080 {
30081         u32 adr, res;
30082         u32 src, dst;
30083
30084         adr = AREG(7) - 2;
30085         AREG(7) = adr;
30086         PRE_IO
30087         READ_WORD_F(adr, src)
30088         adr = AREG(7) - 2;
30089         AREG(7) = adr;
30090         READ_WORD_F(adr, dst)
30091         res = dst - src - ((flag_X >> 8) & 1);
30092         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30093         flag_N = flag_X = flag_C = res >> 8;
30094         flag_NotZ |= res & 0xFFFF;
30095         WRITE_WORD_F(adr, res)
30096         POST_IO
30097 RET(18)
30098 }
30099
30100 // SUBX7M7
30101 OPCODE(0x9F8F)
30102 {
30103         u32 adr, res;
30104         u32 src, dst;
30105
30106         adr = AREG(7) - 4;
30107         AREG(7) = adr;
30108         PRE_IO
30109         READ_LONG_F(adr, src)
30110         adr = AREG(7) - 4;
30111         AREG(7) = adr;
30112         READ_LONG_F(adr, dst)
30113         res = dst - src - ((flag_X >> 8) & 1);
30114         flag_NotZ |= res;
30115         flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30116         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30117         flag_N = res >> 24;
30118         WRITE_LONG_F(adr, res)
30119         POST_IO
30120 RET(30)
30121 }
30122
30123 // SUBA
30124 OPCODE(0x90C0)
30125 {
30126         u32 adr, res;
30127         u32 src, dst;
30128
30129         src = (s32)DREGs16((Opcode >> 0) & 7);
30130         dst = AREGu32((Opcode >> 9) & 7);
30131         res = dst - src;
30132         AREG((Opcode >> 9) & 7) = res;
30133 RET(8)
30134 }
30135
30136 // SUBA
30137 OPCODE(0x90C8)
30138 {
30139         u32 adr, res;
30140         u32 src, dst;
30141
30142         src = (s32)AREGs16((Opcode >> 0) & 7);
30143         dst = AREGu32((Opcode >> 9) & 7);
30144         res = dst - src;
30145         AREG((Opcode >> 9) & 7) = res;
30146 RET(8)
30147 }
30148
30149 // SUBA
30150 OPCODE(0x90D0)
30151 {
30152         u32 adr, res;
30153         u32 src, dst;
30154
30155         adr = AREG((Opcode >> 0) & 7);
30156         PRE_IO
30157         READSX_WORD_F(adr, src)
30158         dst = AREGu32((Opcode >> 9) & 7);
30159         res = dst - src;
30160         AREG((Opcode >> 9) & 7) = res;
30161         POST_IO
30162 #ifdef USE_CYCLONE_TIMING
30163 RET(12)
30164 #else
30165 RET(10)
30166 #endif
30167 }
30168
30169 // SUBA
30170 OPCODE(0x90D8)
30171 {
30172         u32 adr, res;
30173         u32 src, dst;
30174
30175         adr = AREG((Opcode >> 0) & 7);
30176         AREG((Opcode >> 0) & 7) += 2;
30177         PRE_IO
30178         READSX_WORD_F(adr, src)
30179         dst = AREGu32((Opcode >> 9) & 7);
30180         res = dst - src;
30181         AREG((Opcode >> 9) & 7) = res;
30182         POST_IO
30183 #ifdef USE_CYCLONE_TIMING
30184 RET(12)
30185 #else
30186 RET(10)
30187 #endif
30188 }
30189
30190 // SUBA
30191 OPCODE(0x90E0)
30192 {
30193         u32 adr, res;
30194         u32 src, dst;
30195
30196         adr = AREG((Opcode >> 0) & 7) - 2;
30197         AREG((Opcode >> 0) & 7) = adr;
30198         PRE_IO
30199         READSX_WORD_F(adr, src)
30200         dst = AREGu32((Opcode >> 9) & 7);
30201         res = dst - src;
30202         AREG((Opcode >> 9) & 7) = res;
30203         POST_IO
30204 #ifdef USE_CYCLONE_TIMING
30205 RET(14)
30206 #else
30207 RET(12)
30208 #endif
30209 }
30210
30211 // SUBA
30212 OPCODE(0x90E8)
30213 {
30214         u32 adr, res;
30215         u32 src, dst;
30216
30217         FETCH_SWORD(adr);
30218         adr += AREG((Opcode >> 0) & 7);
30219         PRE_IO
30220         READSX_WORD_F(adr, src)
30221         dst = AREGu32((Opcode >> 9) & 7);
30222         res = dst - src;
30223         AREG((Opcode >> 9) & 7) = res;
30224         POST_IO
30225 #ifdef USE_CYCLONE_TIMING
30226 RET(16)
30227 #else
30228 RET(14)
30229 #endif
30230 }
30231
30232 // SUBA
30233 OPCODE(0x90F0)
30234 {
30235         u32 adr, res;
30236         u32 src, dst;
30237
30238         adr = AREG((Opcode >> 0) & 7);
30239         DECODE_EXT_WORD
30240         PRE_IO
30241         READSX_WORD_F(adr, src)
30242         dst = AREGu32((Opcode >> 9) & 7);
30243         res = dst - src;
30244         AREG((Opcode >> 9) & 7) = res;
30245         POST_IO
30246 #ifdef USE_CYCLONE_TIMING
30247 RET(18)
30248 #else
30249 RET(16)
30250 #endif
30251 }
30252
30253 // SUBA
30254 OPCODE(0x90F8)
30255 {
30256         u32 adr, res;
30257         u32 src, dst;
30258
30259         FETCH_SWORD(adr);
30260         PRE_IO
30261         READSX_WORD_F(adr, src)
30262         dst = AREGu32((Opcode >> 9) & 7);
30263         res = dst - src;
30264         AREG((Opcode >> 9) & 7) = res;
30265         POST_IO
30266 #ifdef USE_CYCLONE_TIMING
30267 RET(16)
30268 #else
30269 RET(14)
30270 #endif
30271 }
30272
30273 // SUBA
30274 OPCODE(0x90F9)
30275 {
30276         u32 adr, res;
30277         u32 src, dst;
30278
30279         FETCH_LONG(adr);
30280         PRE_IO
30281         READSX_WORD_F(adr, src)
30282         dst = AREGu32((Opcode >> 9) & 7);
30283         res = dst - src;
30284         AREG((Opcode >> 9) & 7) = res;
30285         POST_IO
30286 #ifdef USE_CYCLONE_TIMING
30287 RET(20)
30288 #else
30289 RET(18)
30290 #endif
30291 }
30292
30293 // SUBA
30294 OPCODE(0x90FA)
30295 {
30296         u32 adr, res;
30297         u32 src, dst;
30298
30299         adr = GET_SWORD + GET_PC;
30300         PC++;
30301         PRE_IO
30302         READSX_WORD_F(adr, src)
30303         dst = AREGu32((Opcode >> 9) & 7);
30304         res = dst - src;
30305         AREG((Opcode >> 9) & 7) = res;
30306         POST_IO
30307 #ifdef USE_CYCLONE_TIMING
30308 RET(16)
30309 #else
30310 RET(14)
30311 #endif
30312 }
30313
30314 // SUBA
30315 OPCODE(0x90FB)
30316 {
30317         u32 adr, res;
30318         u32 src, dst;
30319
30320         adr = GET_PC;
30321         DECODE_EXT_WORD
30322         PRE_IO
30323         READSX_WORD_F(adr, src)
30324         dst = AREGu32((Opcode >> 9) & 7);
30325         res = dst - src;
30326         AREG((Opcode >> 9) & 7) = res;
30327         POST_IO
30328 #ifdef USE_CYCLONE_TIMING
30329 RET(18)
30330 #else
30331 RET(16)
30332 #endif
30333 }
30334
30335 // SUBA
30336 OPCODE(0x90FC)
30337 {
30338         u32 adr, res;
30339         u32 src, dst;
30340
30341         FETCH_SWORD(src);
30342         dst = AREGu32((Opcode >> 9) & 7);
30343         res = dst - src;
30344         AREG((Opcode >> 9) & 7) = res;
30345 RET(12)
30346 }
30347
30348 // SUBA
30349 OPCODE(0x90DF)
30350 {
30351         u32 adr, res;
30352         u32 src, dst;
30353
30354         adr = AREG(7);
30355         AREG(7) += 2;
30356         PRE_IO
30357         READSX_WORD_F(adr, src)
30358         dst = AREGu32((Opcode >> 9) & 7);
30359         res = dst - src;
30360         AREG((Opcode >> 9) & 7) = res;
30361         POST_IO
30362 #ifdef USE_CYCLONE_TIMING
30363 RET(12)
30364 #else
30365 RET(10)
30366 #endif
30367 }
30368
30369 // SUBA
30370 OPCODE(0x90E7)
30371 {
30372         u32 adr, res;
30373         u32 src, dst;
30374
30375         adr = AREG(7) - 2;
30376         AREG(7) = adr;
30377         PRE_IO
30378         READSX_WORD_F(adr, src)
30379         dst = AREGu32((Opcode >> 9) & 7);
30380         res = dst - src;
30381         AREG((Opcode >> 9) & 7) = res;
30382         POST_IO
30383 #ifdef USE_CYCLONE_TIMING
30384 RET(14)
30385 #else
30386 RET(12)
30387 #endif
30388 }
30389
30390 // SUBA
30391 OPCODE(0x91C0)
30392 {
30393         u32 adr, res;
30394         u32 src, dst;
30395
30396         src = (s32)DREGs32((Opcode >> 0) & 7);
30397         dst = AREGu32((Opcode >> 9) & 7);
30398         res = dst - src;
30399         AREG((Opcode >> 9) & 7) = res;
30400 #ifdef USE_CYCLONE_TIMING
30401 RET(8)
30402 #else
30403 RET(6)
30404 #endif
30405 }
30406
30407 // SUBA
30408 OPCODE(0x91C8)
30409 {
30410         u32 adr, res;
30411         u32 src, dst;
30412
30413         src = (s32)AREGs32((Opcode >> 0) & 7);
30414         dst = AREGu32((Opcode >> 9) & 7);
30415         res = dst - src;
30416         AREG((Opcode >> 9) & 7) = res;
30417 #ifdef USE_CYCLONE_TIMING
30418 RET(8)
30419 #else
30420 RET(6)
30421 #endif
30422 }
30423
30424 // SUBA
30425 OPCODE(0x91D0)
30426 {
30427         u32 adr, res;
30428         u32 src, dst;
30429
30430         adr = AREG((Opcode >> 0) & 7);
30431         PRE_IO
30432         READSX_LONG_F(adr, src)
30433         dst = AREGu32((Opcode >> 9) & 7);
30434         res = dst - src;
30435         AREG((Opcode >> 9) & 7) = res;
30436         POST_IO
30437 RET(14)
30438 }
30439
30440 // SUBA
30441 OPCODE(0x91D8)
30442 {
30443         u32 adr, res;
30444         u32 src, dst;
30445
30446         adr = AREG((Opcode >> 0) & 7);
30447         AREG((Opcode >> 0) & 7) += 4;
30448         PRE_IO
30449         READSX_LONG_F(adr, src)
30450         dst = AREGu32((Opcode >> 9) & 7);
30451         res = dst - src;
30452         AREG((Opcode >> 9) & 7) = res;
30453         POST_IO
30454 RET(14)
30455 }
30456
30457 // SUBA
30458 OPCODE(0x91E0)
30459 {
30460         u32 adr, res;
30461         u32 src, dst;
30462
30463         adr = AREG((Opcode >> 0) & 7) - 4;
30464         AREG((Opcode >> 0) & 7) = adr;
30465         PRE_IO
30466         READSX_LONG_F(adr, src)
30467         dst = AREGu32((Opcode >> 9) & 7);
30468         res = dst - src;
30469         AREG((Opcode >> 9) & 7) = res;
30470         POST_IO
30471 RET(16)
30472 }
30473
30474 // SUBA
30475 OPCODE(0x91E8)
30476 {
30477         u32 adr, res;
30478         u32 src, dst;
30479
30480         FETCH_SWORD(adr);
30481         adr += AREG((Opcode >> 0) & 7);
30482         PRE_IO
30483         READSX_LONG_F(adr, src)
30484         dst = AREGu32((Opcode >> 9) & 7);
30485         res = dst - src;
30486         AREG((Opcode >> 9) & 7) = res;
30487         POST_IO
30488 RET(18)
30489 }
30490
30491 // SUBA
30492 OPCODE(0x91F0)
30493 {
30494         u32 adr, res;
30495         u32 src, dst;
30496
30497         adr = AREG((Opcode >> 0) & 7);
30498         DECODE_EXT_WORD
30499         PRE_IO
30500         READSX_LONG_F(adr, src)
30501         dst = AREGu32((Opcode >> 9) & 7);
30502         res = dst - src;
30503         AREG((Opcode >> 9) & 7) = res;
30504         POST_IO
30505 RET(20)
30506 }
30507
30508 // SUBA
30509 OPCODE(0x91F8)
30510 {
30511         u32 adr, res;
30512         u32 src, dst;
30513
30514         FETCH_SWORD(adr);
30515         PRE_IO
30516         READSX_LONG_F(adr, src)
30517         dst = AREGu32((Opcode >> 9) & 7);
30518         res = dst - src;
30519         AREG((Opcode >> 9) & 7) = res;
30520         POST_IO
30521 RET(18)
30522 }
30523
30524 // SUBA
30525 OPCODE(0x91F9)
30526 {
30527         u32 adr, res;
30528         u32 src, dst;
30529
30530         FETCH_LONG(adr);
30531         PRE_IO
30532         READSX_LONG_F(adr, src)
30533         dst = AREGu32((Opcode >> 9) & 7);
30534         res = dst - src;
30535         AREG((Opcode >> 9) & 7) = res;
30536         POST_IO
30537 RET(22)
30538 }
30539
30540 // SUBA
30541 OPCODE(0x91FA)
30542 {
30543         u32 adr, res;
30544         u32 src, dst;
30545
30546         adr = GET_SWORD + GET_PC;
30547         PC++;
30548         PRE_IO
30549         READSX_LONG_F(adr, src)
30550         dst = AREGu32((Opcode >> 9) & 7);
30551         res = dst - src;
30552         AREG((Opcode >> 9) & 7) = res;
30553         POST_IO
30554 RET(18)
30555 }
30556
30557 // SUBA
30558 OPCODE(0x91FB)
30559 {
30560         u32 adr, res;
30561         u32 src, dst;
30562
30563         adr = GET_PC;
30564         DECODE_EXT_WORD
30565         PRE_IO
30566         READSX_LONG_F(adr, src)
30567         dst = AREGu32((Opcode >> 9) & 7);
30568         res = dst - src;
30569         AREG((Opcode >> 9) & 7) = res;
30570         POST_IO
30571 RET(20)
30572 }
30573
30574 // SUBA
30575 OPCODE(0x91FC)
30576 {
30577         u32 adr, res;
30578         u32 src, dst;
30579
30580         FETCH_LONG(src);
30581         dst = AREGu32((Opcode >> 9) & 7);
30582         res = dst - src;
30583         AREG((Opcode >> 9) & 7) = res;
30584 #ifdef USE_CYCLONE_TIMING
30585 RET(16)
30586 #else
30587 RET(14)
30588 #endif
30589 }
30590
30591 // SUBA
30592 OPCODE(0x91DF)
30593 {
30594         u32 adr, res;
30595         u32 src, dst;
30596
30597         adr = AREG(7);
30598         AREG(7) += 4;
30599         PRE_IO
30600         READSX_LONG_F(adr, src)
30601         dst = AREGu32((Opcode >> 9) & 7);
30602         res = dst - src;
30603         AREG((Opcode >> 9) & 7) = res;
30604         POST_IO
30605 RET(14)
30606 }
30607
30608 // SUBA
30609 OPCODE(0x91E7)
30610 {
30611         u32 adr, res;
30612         u32 src, dst;
30613
30614         adr = AREG(7) - 4;
30615         AREG(7) = adr;
30616         PRE_IO
30617         READSX_LONG_F(adr, src)
30618         dst = AREGu32((Opcode >> 9) & 7);
30619         res = dst - src;
30620         AREG((Opcode >> 9) & 7) = res;
30621         POST_IO
30622 RET(16)
30623 }
30624
30625 // CMP
30626 OPCODE(0xB000)
30627 {
30628         u32 adr, res;
30629         u32 src, dst;
30630
30631         src = DREGu8((Opcode >> 0) & 7);
30632         dst = DREGu8((Opcode >> 9) & 7);
30633         res = dst - src;
30634         flag_N = flag_C = res;
30635         flag_V = (src ^ dst) & (res ^ dst);
30636         flag_NotZ = res & 0xFF;
30637 RET(4)
30638 }
30639
30640 // CMP
30641 #if 0
30642 OPCODE(0xB008)
30643 {
30644         u32 adr, res;
30645         u32 src, dst;
30646
30647         // can't read byte from Ax registers !
30648         m68kcontext.execinfo |= M68K_FAULTED;
30649         m68kcontext.io_cycle_counter = 0;
30650 /*
30651         goto famec_Exec_End;
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 */
30658 RET(4)
30659 }
30660 #endif
30661
30662 // CMP
30663 OPCODE(0xB010)
30664 {
30665         u32 adr, res;
30666         u32 src, dst;
30667
30668         adr = AREG((Opcode >> 0) & 7);
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(0xB018)
30682 {
30683         u32 adr, res;
30684         u32 src, dst;
30685
30686         adr = AREG((Opcode >> 0) & 7);
30687         AREG((Opcode >> 0) & 7) += 1;
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(8)
30697 }
30698
30699 // CMP
30700 OPCODE(0xB020)
30701 {
30702         u32 adr, res;
30703         u32 src, dst;
30704
30705         adr = AREG((Opcode >> 0) & 7) - 1;
30706         AREG((Opcode >> 0) & 7) = adr;
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(10)
30716 }
30717
30718 // CMP
30719 OPCODE(0xB028)
30720 {
30721         u32 adr, res;
30722         u32 src, dst;
30723
30724         FETCH_SWORD(adr);
30725         adr += AREG((Opcode >> 0) & 7);
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(12)
30735 }
30736
30737 // CMP
30738 OPCODE(0xB030)
30739 {
30740         u32 adr, res;
30741         u32 src, dst;
30742
30743         adr = AREG((Opcode >> 0) & 7);
30744         DECODE_EXT_WORD
30745         PRE_IO
30746         READ_BYTE_F(adr, src)
30747         dst = DREGu8((Opcode >> 9) & 7);
30748         res = dst - src;
30749         flag_N = flag_C = res;
30750         flag_V = (src ^ dst) & (res ^ dst);
30751         flag_NotZ = res & 0xFF;
30752         POST_IO
30753 RET(14)
30754 }
30755
30756 // CMP
30757 OPCODE(0xB038)
30758 {
30759         u32 adr, res;
30760         u32 src, dst;
30761
30762         FETCH_SWORD(adr);
30763         PRE_IO
30764         READ_BYTE_F(adr, src)
30765         dst = DREGu8((Opcode >> 9) & 7);
30766         res = dst - src;
30767         flag_N = flag_C = res;
30768         flag_V = (src ^ dst) & (res ^ dst);
30769         flag_NotZ = res & 0xFF;
30770         POST_IO
30771 RET(12)
30772 }
30773
30774 // CMP
30775 OPCODE(0xB039)
30776 {
30777         u32 adr, res;
30778         u32 src, dst;
30779
30780         FETCH_LONG(adr);
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(16)
30790 }
30791
30792 // CMP
30793 OPCODE(0xB03A)
30794 {
30795         u32 adr, res;
30796         u32 src, dst;
30797
30798         adr = GET_SWORD + GET_PC;
30799         PC++;
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(12)
30809 }
30810
30811 // CMP
30812 OPCODE(0xB03B)
30813 {
30814         u32 adr, res;
30815         u32 src, dst;
30816
30817         adr = GET_PC;
30818         DECODE_EXT_WORD
30819         PRE_IO
30820         READ_BYTE_F(adr, src)
30821         dst = DREGu8((Opcode >> 9) & 7);
30822         res = dst - src;
30823         flag_N = flag_C = res;
30824         flag_V = (src ^ dst) & (res ^ dst);
30825         flag_NotZ = res & 0xFF;
30826         POST_IO
30827 RET(14)
30828 }
30829
30830 // CMP
30831 OPCODE(0xB03C)
30832 {
30833         u32 adr, res;
30834         u32 src, dst;
30835
30836         FETCH_BYTE(src);
30837         dst = DREGu8((Opcode >> 9) & 7);
30838         res = dst - src;
30839         flag_N = flag_C = res;
30840         flag_V = (src ^ dst) & (res ^ dst);
30841         flag_NotZ = res & 0xFF;
30842 RET(8)
30843 }
30844
30845 // CMP
30846 OPCODE(0xB01F)
30847 {
30848         u32 adr, res;
30849         u32 src, dst;
30850
30851         adr = AREG(7);
30852         AREG(7) += 2;
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(8)
30862 }
30863
30864 // CMP
30865 OPCODE(0xB027)
30866 {
30867         u32 adr, res;
30868         u32 src, dst;
30869
30870         adr = AREG(7) - 2;
30871         AREG(7) = adr;
30872         PRE_IO
30873         READ_BYTE_F(adr, src)
30874         dst = DREGu8((Opcode >> 9) & 7);
30875         res = dst - src;
30876         flag_N = flag_C = res;
30877         flag_V = (src ^ dst) & (res ^ dst);
30878         flag_NotZ = res & 0xFF;
30879         POST_IO
30880 RET(10)
30881 }
30882
30883 // CMP
30884 OPCODE(0xB040)
30885 {
30886         u32 adr, res;
30887         u32 src, dst;
30888
30889         src = DREGu16((Opcode >> 0) & 7);
30890         dst = DREGu16((Opcode >> 9) & 7);
30891         res = dst - src;
30892         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30893         flag_N = flag_C = res >> 8;
30894         flag_NotZ = res & 0xFFFF;
30895 RET(4)
30896 }
30897
30898 // CMP
30899 OPCODE(0xB048)
30900 {
30901         u32 adr, res;
30902         u32 src, dst;
30903
30904         src = AREGu16((Opcode >> 0) & 7);
30905         dst = DREGu16((Opcode >> 9) & 7);
30906         res = dst - src;
30907         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30908         flag_N = flag_C = res >> 8;
30909         flag_NotZ = res & 0xFFFF;
30910 RET(4)
30911 }
30912
30913 // CMP
30914 OPCODE(0xB050)
30915 {
30916         u32 adr, res;
30917         u32 src, dst;
30918
30919         adr = AREG((Opcode >> 0) & 7);
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(0xB058)
30933 {
30934         u32 adr, res;
30935         u32 src, dst;
30936
30937         adr = AREG((Opcode >> 0) & 7);
30938         AREG((Opcode >> 0) & 7) += 2;
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(8)
30948 }
30949
30950 // CMP
30951 OPCODE(0xB060)
30952 {
30953         u32 adr, res;
30954         u32 src, dst;
30955
30956         adr = AREG((Opcode >> 0) & 7) - 2;
30957         AREG((Opcode >> 0) & 7) = adr;
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(10)
30967 }
30968
30969 // CMP
30970 OPCODE(0xB068)
30971 {
30972         u32 adr, res;
30973         u32 src, dst;
30974
30975         FETCH_SWORD(adr);
30976         adr += AREG((Opcode >> 0) & 7);
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(12)
30986 }
30987
30988 // CMP
30989 OPCODE(0xB070)
30990 {
30991         u32 adr, res;
30992         u32 src, dst;
30993
30994         adr = AREG((Opcode >> 0) & 7);
30995         DECODE_EXT_WORD
30996         PRE_IO
30997         READ_WORD_F(adr, src)
30998         dst = DREGu16((Opcode >> 9) & 7);
30999         res = dst - src;
31000         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31001         flag_N = flag_C = res >> 8;
31002         flag_NotZ = res & 0xFFFF;
31003         POST_IO
31004 RET(14)
31005 }
31006
31007 // CMP
31008 OPCODE(0xB078)
31009 {
31010         u32 adr, res;
31011         u32 src, dst;
31012
31013         FETCH_SWORD(adr);
31014         PRE_IO
31015         READ_WORD_F(adr, src)
31016         dst = DREGu16((Opcode >> 9) & 7);
31017         res = dst - src;
31018         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31019         flag_N = flag_C = res >> 8;
31020         flag_NotZ = res & 0xFFFF;
31021         POST_IO
31022 RET(12)
31023 }
31024
31025 // CMP
31026 OPCODE(0xB079)
31027 {
31028         u32 adr, res;
31029         u32 src, dst;
31030
31031         FETCH_LONG(adr);
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(16)
31041 }
31042
31043 // CMP
31044 OPCODE(0xB07A)
31045 {
31046         u32 adr, res;
31047         u32 src, dst;
31048
31049         adr = GET_SWORD + GET_PC;
31050         PC++;
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(12)
31060 }
31061
31062 // CMP
31063 OPCODE(0xB07B)
31064 {
31065         u32 adr, res;
31066         u32 src, dst;
31067
31068         adr = GET_PC;
31069         DECODE_EXT_WORD
31070         PRE_IO
31071         READ_WORD_F(adr, src)
31072         dst = DREGu16((Opcode >> 9) & 7);
31073         res = dst - src;
31074         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31075         flag_N = flag_C = res >> 8;
31076         flag_NotZ = res & 0xFFFF;
31077         POST_IO
31078 RET(14)
31079 }
31080
31081 // CMP
31082 OPCODE(0xB07C)
31083 {
31084         u32 adr, res;
31085         u32 src, dst;
31086
31087         FETCH_WORD(src);
31088         dst = DREGu16((Opcode >> 9) & 7);
31089         res = dst - src;
31090         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31091         flag_N = flag_C = res >> 8;
31092         flag_NotZ = res & 0xFFFF;
31093 RET(8)
31094 }
31095
31096 // CMP
31097 OPCODE(0xB05F)
31098 {
31099         u32 adr, res;
31100         u32 src, dst;
31101
31102         adr = AREG(7);
31103         AREG(7) += 2;
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(8)
31113 }
31114
31115 // CMP
31116 OPCODE(0xB067)
31117 {
31118         u32 adr, res;
31119         u32 src, dst;
31120
31121         adr = AREG(7) - 2;
31122         AREG(7) = adr;
31123         PRE_IO
31124         READ_WORD_F(adr, src)
31125         dst = DREGu16((Opcode >> 9) & 7);
31126         res = dst - src;
31127         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31128         flag_N = flag_C = res >> 8;
31129         flag_NotZ = res & 0xFFFF;
31130         POST_IO
31131 RET(10)
31132 }
31133
31134 // CMP
31135 OPCODE(0xB080)
31136 {
31137         u32 adr, res;
31138         u32 src, dst;
31139
31140         src = DREGu32((Opcode >> 0) & 7);
31141         dst = DREGu32((Opcode >> 9) & 7);
31142         res = dst - src;
31143         flag_NotZ = res;
31144         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31145         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31146         flag_N = res >> 24;
31147 RET(6)
31148 }
31149
31150 // CMP
31151 OPCODE(0xB088)
31152 {
31153         u32 adr, res;
31154         u32 src, dst;
31155
31156         src = AREGu32((Opcode >> 0) & 7);
31157         dst = DREGu32((Opcode >> 9) & 7);
31158         res = dst - src;
31159         flag_NotZ = res;
31160         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31161         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31162         flag_N = res >> 24;
31163 RET(6)
31164 }
31165
31166 // CMP
31167 OPCODE(0xB090)
31168 {
31169         u32 adr, res;
31170         u32 src, dst;
31171
31172         adr = AREG((Opcode >> 0) & 7);
31173         PRE_IO
31174         READ_LONG_F(adr, src)
31175         dst = DREGu32((Opcode >> 9) & 7);
31176         res = dst - src;
31177         flag_NotZ = res;
31178         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31179         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31180         flag_N = res >> 24;
31181         POST_IO
31182 RET(14)
31183 }
31184
31185 // CMP
31186 OPCODE(0xB098)
31187 {
31188         u32 adr, res;
31189         u32 src, dst;
31190
31191         adr = AREG((Opcode >> 0) & 7);
31192         AREG((Opcode >> 0) & 7) += 4;
31193         PRE_IO
31194         READ_LONG_F(adr, src)
31195         dst = DREGu32((Opcode >> 9) & 7);
31196         res = dst - src;
31197         flag_NotZ = res;
31198         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31199         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31200         flag_N = res >> 24;
31201         POST_IO
31202 RET(14)
31203 }
31204
31205 // CMP
31206 OPCODE(0xB0A0)
31207 {
31208         u32 adr, res;
31209         u32 src, dst;
31210
31211         adr = AREG((Opcode >> 0) & 7) - 4;
31212         AREG((Opcode >> 0) & 7) = adr;
31213         PRE_IO
31214         READ_LONG_F(adr, src)
31215         dst = DREGu32((Opcode >> 9) & 7);
31216         res = dst - src;
31217         flag_NotZ = res;
31218         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31219         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31220         flag_N = res >> 24;
31221         POST_IO
31222 RET(16)
31223 }
31224
31225 // CMP
31226 OPCODE(0xB0A8)
31227 {
31228         u32 adr, res;
31229         u32 src, dst;
31230
31231         FETCH_SWORD(adr);
31232         adr += AREG((Opcode >> 0) & 7);
31233         PRE_IO
31234         READ_LONG_F(adr, src)
31235         dst = DREGu32((Opcode >> 9) & 7);
31236         res = dst - src;
31237         flag_NotZ = res;
31238         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31239         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31240         flag_N = res >> 24;
31241         POST_IO
31242 RET(18)
31243 }
31244
31245 // CMP
31246 OPCODE(0xB0B0)
31247 {
31248         u32 adr, res;
31249         u32 src, dst;
31250
31251         adr = AREG((Opcode >> 0) & 7);
31252         DECODE_EXT_WORD
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(20)
31263 }
31264
31265 // CMP
31266 OPCODE(0xB0B8)
31267 {
31268         u32 adr, res;
31269         u32 src, dst;
31270
31271         FETCH_SWORD(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(18)
31282 }
31283
31284 // CMP
31285 OPCODE(0xB0B9)
31286 {
31287         u32 adr, res;
31288         u32 src, dst;
31289
31290         FETCH_LONG(adr);
31291         PRE_IO
31292         READ_LONG_F(adr, src)
31293         dst = DREGu32((Opcode >> 9) & 7);
31294         res = dst - src;
31295         flag_NotZ = res;
31296         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31297         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31298         flag_N = res >> 24;
31299         POST_IO
31300 RET(22)
31301 }
31302
31303 // CMP
31304 OPCODE(0xB0BA)
31305 {
31306         u32 adr, res;
31307         u32 src, dst;
31308
31309         adr = GET_SWORD + GET_PC;
31310         PC++;
31311         PRE_IO
31312         READ_LONG_F(adr, src)
31313         dst = DREGu32((Opcode >> 9) & 7);
31314         res = dst - src;
31315         flag_NotZ = res;
31316         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31317         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31318         flag_N = res >> 24;
31319         POST_IO
31320 RET(18)
31321 }
31322
31323 // CMP
31324 OPCODE(0xB0BB)
31325 {
31326         u32 adr, res;
31327         u32 src, dst;
31328
31329         adr = GET_PC;
31330         DECODE_EXT_WORD
31331         PRE_IO
31332         READ_LONG_F(adr, src)
31333         dst = DREGu32((Opcode >> 9) & 7);
31334         res = dst - src;
31335         flag_NotZ = res;
31336         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31337         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31338         flag_N = res >> 24;
31339         POST_IO
31340 RET(20)
31341 }
31342
31343 // CMP
31344 OPCODE(0xB0BC)
31345 {
31346         u32 adr, res;
31347         u32 src, dst;
31348
31349         FETCH_LONG(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 RET(14)
31357 }
31358
31359 // CMP
31360 OPCODE(0xB09F)
31361 {
31362         u32 adr, res;
31363         u32 src, dst;
31364
31365         adr = AREG(7);
31366         AREG(7) += 4;
31367         PRE_IO
31368         READ_LONG_F(adr, src)
31369         dst = DREGu32((Opcode >> 9) & 7);
31370         res = dst - src;
31371         flag_NotZ = res;
31372         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31373         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31374         flag_N = res >> 24;
31375         POST_IO
31376 RET(14)
31377 }
31378
31379 // CMP
31380 OPCODE(0xB0A7)
31381 {
31382         u32 adr, res;
31383         u32 src, dst;
31384
31385         adr = AREG(7) - 4;
31386         AREG(7) = adr;
31387         PRE_IO
31388         READ_LONG_F(adr, src)
31389         dst = DREGu32((Opcode >> 9) & 7);
31390         res = dst - src;
31391         flag_NotZ = res;
31392         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31393         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31394         flag_N = res >> 24;
31395         POST_IO
31396 RET(16)
31397 }
31398
31399 // CMPM
31400 OPCODE(0xB108)
31401 {
31402         u32 adr, res;
31403         u32 src, dst;
31404
31405         adr = AREG((Opcode >> 0) & 7);
31406         AREG((Opcode >> 0) & 7) += 1;
31407         PRE_IO
31408         READ_BYTE_F(adr, src)
31409         adr = AREG((Opcode >> 9) & 7);
31410         AREG((Opcode >> 9) & 7) += 1;
31411         READ_BYTE_F(adr, dst)
31412         res = dst - src;
31413         flag_N = flag_C = res;
31414         flag_V = (src ^ dst) & (res ^ dst);
31415         flag_NotZ = res & 0xFF;
31416         POST_IO
31417 RET(12)
31418 }
31419
31420 // CMPM
31421 OPCODE(0xB148)
31422 {
31423         u32 adr, res;
31424         u32 src, dst;
31425
31426         adr = AREG((Opcode >> 0) & 7);
31427         AREG((Opcode >> 0) & 7) += 2;
31428         PRE_IO
31429         READ_WORD_F(adr, src)
31430         adr = AREG((Opcode >> 9) & 7);
31431         AREG((Opcode >> 9) & 7) += 2;
31432         READ_WORD_F(adr, dst)
31433         res = dst - src;
31434         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31435         flag_N = flag_C = res >> 8;
31436         flag_NotZ = res & 0xFFFF;
31437         POST_IO
31438 RET(12)
31439 }
31440
31441 // CMPM
31442 OPCODE(0xB188)
31443 {
31444         u32 adr, res;
31445         u32 src, dst;
31446
31447         adr = AREG((Opcode >> 0) & 7);
31448         AREG((Opcode >> 0) & 7) += 4;
31449         PRE_IO
31450         READ_LONG_F(adr, src)
31451         adr = AREG((Opcode >> 9) & 7);
31452         AREG((Opcode >> 9) & 7) += 4;
31453         READ_LONG_F(adr, dst)
31454         res = dst - src;
31455         flag_NotZ = res;
31456         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31457         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31458         flag_N = res >> 24;
31459         POST_IO
31460 RET(20)
31461 }
31462
31463 // CMP7M
31464 OPCODE(0xB10F)
31465 {
31466         u32 adr, res;
31467         u32 src, dst;
31468
31469         adr = AREG(7);
31470         AREG(7) += 2;
31471         PRE_IO
31472         READ_BYTE_F(adr, src)
31473         adr = AREG((Opcode >> 9) & 7);
31474         AREG((Opcode >> 9) & 7) += 1;
31475         READ_BYTE_F(adr, dst)
31476         res = dst - src;
31477         flag_N = flag_C = res;
31478         flag_V = (src ^ dst) & (res ^ dst);
31479         flag_NotZ = res & 0xFF;
31480         POST_IO
31481 RET(12)
31482 }
31483
31484 // CMP7M
31485 OPCODE(0xB14F)
31486 {
31487         u32 adr, res;
31488         u32 src, dst;
31489
31490         adr = AREG(7);
31491         AREG(7) += 2;
31492         PRE_IO
31493         READ_WORD_F(adr, src)
31494         adr = AREG((Opcode >> 9) & 7);
31495         AREG((Opcode >> 9) & 7) += 2;
31496         READ_WORD_F(adr, dst)
31497         res = dst - src;
31498         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31499         flag_N = flag_C = res >> 8;
31500         flag_NotZ = res & 0xFFFF;
31501         POST_IO
31502 RET(12)
31503 }
31504
31505 // CMP7M
31506 OPCODE(0xB18F)
31507 {
31508         u32 adr, res;
31509         u32 src, dst;
31510
31511         adr = AREG(7);
31512         AREG(7) += 4;
31513         PRE_IO
31514         READ_LONG_F(adr, src)
31515         adr = AREG((Opcode >> 9) & 7);
31516         AREG((Opcode >> 9) & 7) += 4;
31517         READ_LONG_F(adr, dst)
31518         res = dst - src;
31519         flag_NotZ = res;
31520         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31521         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31522         flag_N = res >> 24;
31523         POST_IO
31524 RET(20)
31525 }
31526
31527 // CMPM7
31528 OPCODE(0xBF08)
31529 {
31530         u32 adr, res;
31531         u32 src, dst;
31532
31533         adr = AREG((Opcode >> 0) & 7);
31534         AREG((Opcode >> 0) & 7) += 1;
31535         PRE_IO
31536         READ_BYTE_F(adr, src)
31537         adr = AREG(7);
31538         AREG(7) += 2;
31539         READ_BYTE_F(adr, dst)
31540         res = dst - src;
31541         flag_N = flag_C = res;
31542         flag_V = (src ^ dst) & (res ^ dst);
31543         flag_NotZ = res & 0xFF;
31544         POST_IO
31545 RET(12)
31546 }
31547
31548 // CMPM7
31549 OPCODE(0xBF48)
31550 {
31551         u32 adr, res;
31552         u32 src, dst;
31553
31554         adr = AREG((Opcode >> 0) & 7);
31555         AREG((Opcode >> 0) & 7) += 2;
31556         PRE_IO
31557         READ_WORD_F(adr, src)
31558         adr = AREG(7);
31559         AREG(7) += 2;
31560         READ_WORD_F(adr, dst)
31561         res = dst - src;
31562         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31563         flag_N = flag_C = res >> 8;
31564         flag_NotZ = res & 0xFFFF;
31565         POST_IO
31566 RET(12)
31567 }
31568
31569 // CMPM7
31570 OPCODE(0xBF88)
31571 {
31572         u32 adr, res;
31573         u32 src, dst;
31574
31575         adr = AREG((Opcode >> 0) & 7);
31576         AREG((Opcode >> 0) & 7) += 4;
31577         PRE_IO
31578         READ_LONG_F(adr, src)
31579         adr = AREG(7);
31580         AREG(7) += 4;
31581         READ_LONG_F(adr, dst)
31582         res = dst - src;
31583         flag_NotZ = res;
31584         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31585         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31586         flag_N = res >> 24;
31587         POST_IO
31588 RET(20)
31589 }
31590
31591 // CMP7M7
31592 OPCODE(0xBF0F)
31593 {
31594         u32 adr, res;
31595         u32 src, dst;
31596
31597         adr = AREG(7);
31598         AREG(7) += 2;
31599         PRE_IO
31600         READ_BYTE_F(adr, src)
31601         adr = AREG(7);
31602         AREG(7) += 2;
31603         READ_BYTE_F(adr, dst)
31604         res = dst - src;
31605         flag_N = flag_C = res;
31606         flag_V = (src ^ dst) & (res ^ dst);
31607         flag_NotZ = res & 0xFF;
31608         POST_IO
31609 RET(12)
31610 }
31611
31612 // CMP7M7
31613 OPCODE(0xBF4F)
31614 {
31615         u32 adr, res;
31616         u32 src, dst;
31617
31618         adr = AREG(7);
31619         AREG(7) += 2;
31620         PRE_IO
31621         READ_WORD_F(adr, src)
31622         adr = AREG(7);
31623         AREG(7) += 2;
31624         READ_WORD_F(adr, dst)
31625         res = dst - src;
31626         flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31627         flag_N = flag_C = res >> 8;
31628         flag_NotZ = res & 0xFFFF;
31629         POST_IO
31630 RET(12)
31631 }
31632
31633 // CMP7M7
31634 OPCODE(0xBF8F)
31635 {
31636         u32 adr, res;
31637         u32 src, dst;
31638
31639         adr = AREG(7);
31640         AREG(7) += 4;
31641         PRE_IO
31642         READ_LONG_F(adr, src)
31643         adr = AREG(7);
31644         AREG(7) += 4;
31645         READ_LONG_F(adr, dst)
31646         res = dst - src;
31647         flag_NotZ = res;
31648         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31649         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31650         flag_N = res >> 24;
31651         POST_IO
31652 RET(20)
31653 }
31654
31655 // EORDa
31656 OPCODE(0xB100)
31657 {
31658         u32 adr, res;
31659         u32 src, dst;
31660
31661         src = DREGu8((Opcode >> 9) & 7);
31662         res = DREGu8((Opcode >> 0) & 7);
31663         res ^= src;
31664         flag_C = 0;
31665         flag_V = 0;
31666         flag_NotZ = res;
31667         flag_N = res;
31668         DREGu8((Opcode >> 0) & 7) = res;
31669 RET(4)
31670 }
31671
31672 // EORDa
31673 OPCODE(0xB110)
31674 {
31675         u32 adr, res;
31676         u32 src, dst;
31677
31678         src = DREGu8((Opcode >> 9) & 7);
31679         adr = AREG((Opcode >> 0) & 7);
31680         PRE_IO
31681         READ_BYTE_F(adr, res)
31682         res ^= src;
31683         flag_C = 0;
31684         flag_V = 0;
31685         flag_NotZ = res;
31686         flag_N = res;
31687         WRITE_BYTE_F(adr, res)
31688         POST_IO
31689 RET(12)
31690 }
31691
31692 // EORDa
31693 OPCODE(0xB118)
31694 {
31695         u32 adr, res;
31696         u32 src, dst;
31697
31698         src = DREGu8((Opcode >> 9) & 7);
31699         adr = AREG((Opcode >> 0) & 7);
31700         AREG((Opcode >> 0) & 7) += 1;
31701         PRE_IO
31702         READ_BYTE_F(adr, res)
31703         res ^= src;
31704         flag_C = 0;
31705         flag_V = 0;
31706         flag_NotZ = res;
31707         flag_N = res;
31708         WRITE_BYTE_F(adr, res)
31709         POST_IO
31710 RET(12)
31711 }
31712
31713 // EORDa
31714 OPCODE(0xB120)
31715 {
31716         u32 adr, res;
31717         u32 src, dst;
31718
31719         src = DREGu8((Opcode >> 9) & 7);
31720         adr = AREG((Opcode >> 0) & 7) - 1;
31721         AREG((Opcode >> 0) & 7) = adr;
31722         PRE_IO
31723         READ_BYTE_F(adr, res)
31724         res ^= src;
31725         flag_C = 0;
31726         flag_V = 0;
31727         flag_NotZ = res;
31728         flag_N = res;
31729         WRITE_BYTE_F(adr, res)
31730         POST_IO
31731 RET(14)
31732 }
31733
31734 // EORDa
31735 OPCODE(0xB128)
31736 {
31737         u32 adr, res;
31738         u32 src, dst;
31739
31740         src = DREGu8((Opcode >> 9) & 7);
31741         FETCH_SWORD(adr);
31742         adr += AREG((Opcode >> 0) & 7);
31743         PRE_IO
31744         READ_BYTE_F(adr, res)
31745         res ^= src;
31746         flag_C = 0;
31747         flag_V = 0;
31748         flag_NotZ = res;
31749         flag_N = res;
31750         WRITE_BYTE_F(adr, res)
31751         POST_IO
31752 RET(16)
31753 }
31754
31755 // EORDa
31756 OPCODE(0xB130)
31757 {
31758         u32 adr, res;
31759         u32 src, dst;
31760
31761         src = DREGu8((Opcode >> 9) & 7);
31762         adr = AREG((Opcode >> 0) & 7);
31763         DECODE_EXT_WORD
31764         PRE_IO
31765         READ_BYTE_F(adr, res)
31766         res ^= src;
31767         flag_C = 0;
31768         flag_V = 0;
31769         flag_NotZ = res;
31770         flag_N = res;
31771         WRITE_BYTE_F(adr, res)
31772         POST_IO
31773 RET(18)
31774 }
31775
31776 // EORDa
31777 OPCODE(0xB138)
31778 {
31779         u32 adr, res;
31780         u32 src, dst;
31781
31782         src = DREGu8((Opcode >> 9) & 7);
31783         FETCH_SWORD(adr);
31784         PRE_IO
31785         READ_BYTE_F(adr, res)
31786         res ^= src;
31787         flag_C = 0;
31788         flag_V = 0;
31789         flag_NotZ = res;
31790         flag_N = res;
31791         WRITE_BYTE_F(adr, res)
31792         POST_IO
31793 RET(16)
31794 }
31795
31796 // EORDa
31797 OPCODE(0xB139)
31798 {
31799         u32 adr, res;
31800         u32 src, dst;
31801
31802         src = DREGu8((Opcode >> 9) & 7);
31803         FETCH_LONG(adr);
31804         PRE_IO
31805         READ_BYTE_F(adr, res)
31806         res ^= src;
31807         flag_C = 0;
31808         flag_V = 0;
31809         flag_NotZ = res;
31810         flag_N = res;
31811         WRITE_BYTE_F(adr, res)
31812         POST_IO
31813 RET(20)
31814 }
31815
31816 // EORDa
31817 OPCODE(0xB11F)
31818 {
31819         u32 adr, res;
31820         u32 src, dst;
31821
31822         src = DREGu8((Opcode >> 9) & 7);
31823         adr = AREG(7);
31824         AREG(7) += 2;
31825         PRE_IO
31826         READ_BYTE_F(adr, res)
31827         res ^= src;
31828         flag_C = 0;
31829         flag_V = 0;
31830         flag_NotZ = res;
31831         flag_N = res;
31832         WRITE_BYTE_F(adr, res)
31833         POST_IO
31834 RET(12)
31835 }
31836
31837 // EORDa
31838 OPCODE(0xB127)
31839 {
31840         u32 adr, res;
31841         u32 src, dst;
31842
31843         src = DREGu8((Opcode >> 9) & 7);
31844         adr = AREG(7) - 2;
31845         AREG(7) = adr;
31846         PRE_IO
31847         READ_BYTE_F(adr, res)
31848         res ^= src;
31849         flag_C = 0;
31850         flag_V = 0;
31851         flag_NotZ = res;
31852         flag_N = res;
31853         WRITE_BYTE_F(adr, res)
31854         POST_IO
31855 RET(14)
31856 }
31857
31858 // EORDa
31859 OPCODE(0xB140)
31860 {
31861         u32 adr, res;
31862         u32 src, dst;
31863
31864         src = DREGu16((Opcode >> 9) & 7);
31865         res = DREGu16((Opcode >> 0) & 7);
31866         res ^= src;
31867         flag_C = 0;
31868         flag_V = 0;
31869         flag_NotZ = res;
31870         flag_N = res >> 8;
31871         DREGu16((Opcode >> 0) & 7) = res;
31872 RET(4)
31873 }
31874
31875 // EORDa
31876 OPCODE(0xB150)
31877 {
31878         u32 adr, res;
31879         u32 src, dst;
31880
31881         src = DREGu16((Opcode >> 9) & 7);
31882         adr = AREG((Opcode >> 0) & 7);
31883         PRE_IO
31884         READ_WORD_F(adr, res)
31885         res ^= src;
31886         flag_C = 0;
31887         flag_V = 0;
31888         flag_NotZ = res;
31889         flag_N = res >> 8;
31890         WRITE_WORD_F(adr, res)
31891         POST_IO
31892 RET(12)
31893 }
31894
31895 // EORDa
31896 OPCODE(0xB158)
31897 {
31898         u32 adr, res;
31899         u32 src, dst;
31900
31901         src = DREGu16((Opcode >> 9) & 7);
31902         adr = AREG((Opcode >> 0) & 7);
31903         AREG((Opcode >> 0) & 7) += 2;
31904         PRE_IO
31905         READ_WORD_F(adr, res)
31906         res ^= src;
31907         flag_C = 0;
31908         flag_V = 0;
31909         flag_NotZ = res;
31910         flag_N = res >> 8;
31911         WRITE_WORD_F(adr, res)
31912         POST_IO
31913 RET(12)
31914 }
31915
31916 // EORDa
31917 OPCODE(0xB160)
31918 {
31919         u32 adr, res;
31920         u32 src, dst;
31921
31922         src = DREGu16((Opcode >> 9) & 7);
31923         adr = AREG((Opcode >> 0) & 7) - 2;
31924         AREG((Opcode >> 0) & 7) = adr;
31925         PRE_IO
31926         READ_WORD_F(adr, res)
31927         res ^= src;
31928         flag_C = 0;
31929         flag_V = 0;
31930         flag_NotZ = res;
31931         flag_N = res >> 8;
31932         WRITE_WORD_F(adr, res)
31933         POST_IO
31934 RET(14)
31935 }
31936
31937 // EORDa
31938 OPCODE(0xB168)
31939 {
31940         u32 adr, res;
31941         u32 src, dst;
31942
31943         src = DREGu16((Opcode >> 9) & 7);
31944         FETCH_SWORD(adr);
31945         adr += AREG((Opcode >> 0) & 7);
31946         PRE_IO
31947         READ_WORD_F(adr, res)
31948         res ^= src;
31949         flag_C = 0;
31950         flag_V = 0;
31951         flag_NotZ = res;
31952         flag_N = res >> 8;
31953         WRITE_WORD_F(adr, res)
31954         POST_IO
31955 RET(16)
31956 }
31957
31958 // EORDa
31959 OPCODE(0xB170)
31960 {
31961         u32 adr, res;
31962         u32 src, dst;
31963
31964         src = DREGu16((Opcode >> 9) & 7);
31965         adr = AREG((Opcode >> 0) & 7);
31966         DECODE_EXT_WORD
31967         PRE_IO
31968         READ_WORD_F(adr, res)
31969         res ^= src;
31970         flag_C = 0;
31971         flag_V = 0;
31972         flag_NotZ = res;
31973         flag_N = res >> 8;
31974         WRITE_WORD_F(adr, res)
31975         POST_IO
31976 RET(18)
31977 }
31978
31979 // EORDa
31980 OPCODE(0xB178)
31981 {
31982         u32 adr, res;
31983         u32 src, dst;
31984
31985         src = DREGu16((Opcode >> 9) & 7);
31986         FETCH_SWORD(adr);
31987         PRE_IO
31988         READ_WORD_F(adr, res)
31989         res ^= src;
31990         flag_C = 0;
31991         flag_V = 0;
31992         flag_NotZ = res;
31993         flag_N = res >> 8;
31994         WRITE_WORD_F(adr, res)
31995         POST_IO
31996 RET(16)
31997 }
31998
31999 // EORDa
32000 OPCODE(0xB179)
32001 {
32002         u32 adr, res;
32003         u32 src, dst;
32004
32005         src = DREGu16((Opcode >> 9) & 7);
32006         FETCH_LONG(adr);
32007         PRE_IO
32008         READ_WORD_F(adr, res)
32009         res ^= src;
32010         flag_C = 0;
32011         flag_V = 0;
32012         flag_NotZ = res;
32013         flag_N = res >> 8;
32014         WRITE_WORD_F(adr, res)
32015         POST_IO
32016 RET(20)
32017 }
32018
32019 // EORDa
32020 OPCODE(0xB15F)
32021 {
32022         u32 adr, res;
32023         u32 src, dst;
32024
32025         src = DREGu16((Opcode >> 9) & 7);
32026         adr = AREG(7);
32027         AREG(7) += 2;
32028         PRE_IO
32029         READ_WORD_F(adr, res)
32030         res ^= src;
32031         flag_C = 0;
32032         flag_V = 0;
32033         flag_NotZ = res;
32034         flag_N = res >> 8;
32035         WRITE_WORD_F(adr, res)
32036         POST_IO
32037 RET(12)
32038 }
32039
32040 // EORDa
32041 OPCODE(0xB167)
32042 {
32043         u32 adr, res;
32044         u32 src, dst;
32045
32046         src = DREGu16((Opcode >> 9) & 7);
32047         adr = AREG(7) - 2;
32048         AREG(7) = adr;
32049         PRE_IO
32050         READ_WORD_F(adr, res)
32051         res ^= src;
32052         flag_C = 0;
32053         flag_V = 0;
32054         flag_NotZ = res;
32055         flag_N = res >> 8;
32056         WRITE_WORD_F(adr, res)
32057         POST_IO
32058 RET(14)
32059 }
32060
32061 // EORDa
32062 OPCODE(0xB180)
32063 {
32064         u32 adr, res;
32065         u32 src, dst;
32066
32067         src = DREGu32((Opcode >> 9) & 7);
32068         res = DREGu32((Opcode >> 0) & 7);
32069         res ^= src;
32070         flag_C = 0;
32071         flag_V = 0;
32072         flag_NotZ = res;
32073         flag_N = res >> 24;
32074         DREGu32((Opcode >> 0) & 7) = res;
32075 RET(8)
32076 }
32077
32078 // EORDa
32079 OPCODE(0xB190)
32080 {
32081         u32 adr, res;
32082         u32 src, dst;
32083
32084         src = DREGu32((Opcode >> 9) & 7);
32085         adr = AREG((Opcode >> 0) & 7);
32086         PRE_IO
32087         READ_LONG_F(adr, res)
32088         res ^= src;
32089         flag_C = 0;
32090         flag_V = 0;
32091         flag_NotZ = res;
32092         flag_N = res >> 24;
32093         WRITE_LONG_F(adr, res)
32094         POST_IO
32095 RET(20)
32096 }
32097
32098 // EORDa
32099 OPCODE(0xB198)
32100 {
32101         u32 adr, res;
32102         u32 src, dst;
32103
32104         src = DREGu32((Opcode >> 9) & 7);
32105         adr = AREG((Opcode >> 0) & 7);
32106         AREG((Opcode >> 0) & 7) += 4;
32107         PRE_IO
32108         READ_LONG_F(adr, res)
32109         res ^= src;
32110         flag_C = 0;
32111         flag_V = 0;
32112         flag_NotZ = res;
32113         flag_N = res >> 24;
32114         WRITE_LONG_F(adr, res)
32115         POST_IO
32116 RET(20)
32117 }
32118
32119 // EORDa
32120 OPCODE(0xB1A0)
32121 {
32122         u32 adr, res;
32123         u32 src, dst;
32124
32125         src = DREGu32((Opcode >> 9) & 7);
32126         adr = AREG((Opcode >> 0) & 7) - 4;
32127         AREG((Opcode >> 0) & 7) = adr;
32128         PRE_IO
32129         READ_LONG_F(adr, res)
32130         res ^= src;
32131         flag_C = 0;
32132         flag_V = 0;
32133         flag_NotZ = res;
32134         flag_N = res >> 24;
32135         WRITE_LONG_F(adr, res)
32136         POST_IO
32137 RET(22)
32138 }
32139
32140 // EORDa
32141 OPCODE(0xB1A8)
32142 {
32143         u32 adr, res;
32144         u32 src, dst;
32145
32146         src = DREGu32((Opcode >> 9) & 7);
32147         FETCH_SWORD(adr);
32148         adr += AREG((Opcode >> 0) & 7);
32149         PRE_IO
32150         READ_LONG_F(adr, res)
32151         res ^= src;
32152         flag_C = 0;
32153         flag_V = 0;
32154         flag_NotZ = res;
32155         flag_N = res >> 24;
32156         WRITE_LONG_F(adr, res)
32157         POST_IO
32158 RET(24)
32159 }
32160
32161 // EORDa
32162 OPCODE(0xB1B0)
32163 {
32164         u32 adr, res;
32165         u32 src, dst;
32166
32167         src = DREGu32((Opcode >> 9) & 7);
32168         adr = AREG((Opcode >> 0) & 7);
32169         DECODE_EXT_WORD
32170         PRE_IO
32171         READ_LONG_F(adr, res)
32172         res ^= src;
32173         flag_C = 0;
32174         flag_V = 0;
32175         flag_NotZ = res;
32176         flag_N = res >> 24;
32177         WRITE_LONG_F(adr, res)
32178         POST_IO
32179 RET(26)
32180 }
32181
32182 // EORDa
32183 OPCODE(0xB1B8)
32184 {
32185         u32 adr, res;
32186         u32 src, dst;
32187
32188         src = DREGu32((Opcode >> 9) & 7);
32189         FETCH_SWORD(adr);
32190         PRE_IO
32191         READ_LONG_F(adr, res)
32192         res ^= src;
32193         flag_C = 0;
32194         flag_V = 0;
32195         flag_NotZ = res;
32196         flag_N = res >> 24;
32197         WRITE_LONG_F(adr, res)
32198         POST_IO
32199 RET(24)
32200 }
32201
32202 // EORDa
32203 OPCODE(0xB1B9)
32204 {
32205         u32 adr, res;
32206         u32 src, dst;
32207
32208         src = DREGu32((Opcode >> 9) & 7);
32209         FETCH_LONG(adr);
32210         PRE_IO
32211         READ_LONG_F(adr, res)
32212         res ^= src;
32213         flag_C = 0;
32214         flag_V = 0;
32215         flag_NotZ = res;
32216         flag_N = res >> 24;
32217         WRITE_LONG_F(adr, res)
32218         POST_IO
32219 RET(28)
32220 }
32221
32222 // EORDa
32223 OPCODE(0xB19F)
32224 {
32225         u32 adr, res;
32226         u32 src, dst;
32227
32228         src = DREGu32((Opcode >> 9) & 7);
32229         adr = AREG(7);
32230         AREG(7) += 4;
32231         PRE_IO
32232         READ_LONG_F(adr, res)
32233         res ^= src;
32234         flag_C = 0;
32235         flag_V = 0;
32236         flag_NotZ = res;
32237         flag_N = res >> 24;
32238         WRITE_LONG_F(adr, res)
32239         POST_IO
32240 RET(20)
32241 }
32242
32243 // EORDa
32244 OPCODE(0xB1A7)
32245 {
32246         u32 adr, res;
32247         u32 src, dst;
32248
32249         src = DREGu32((Opcode >> 9) & 7);
32250         adr = AREG(7) - 4;
32251         AREG(7) = adr;
32252         PRE_IO
32253         READ_LONG_F(adr, res)
32254         res ^= src;
32255         flag_C = 0;
32256         flag_V = 0;
32257         flag_NotZ = res;
32258         flag_N = res >> 24;
32259         WRITE_LONG_F(adr, res)
32260         POST_IO
32261 RET(22)
32262 }
32263
32264 // CMPA
32265 OPCODE(0xB0C0)
32266 {
32267         u32 adr, res;
32268         u32 src, dst;
32269
32270         src = (s32)DREGs16((Opcode >> 0) & 7);
32271         dst = AREGu32((Opcode >> 9) & 7);
32272         res = dst - src;
32273         flag_NotZ = res;
32274         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32275         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32276         flag_N = res >> 24;
32277 RET(6)
32278 }
32279
32280 // CMPA
32281 OPCODE(0xB0C8)
32282 {
32283         u32 adr, res;
32284         u32 src, dst;
32285
32286         src = (s32)AREGs16((Opcode >> 0) & 7);
32287         dst = AREGu32((Opcode >> 9) & 7);
32288         res = dst - src;
32289         flag_NotZ = res;
32290         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32291         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32292         flag_N = res >> 24;
32293 RET(6)
32294 }
32295
32296 // CMPA
32297 OPCODE(0xB0D0)
32298 {
32299         u32 adr, res;
32300         u32 src, dst;
32301
32302         adr = AREG((Opcode >> 0) & 7);
32303         PRE_IO
32304         READSX_WORD_F(adr, src)
32305         dst = AREGu32((Opcode >> 9) & 7);
32306         res = dst - src;
32307         flag_NotZ = res;
32308         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32309         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32310         flag_N = res >> 24;
32311         POST_IO
32312 RET(10)
32313 }
32314
32315 // CMPA
32316 OPCODE(0xB0D8)
32317 {
32318         u32 adr, res;
32319         u32 src, dst;
32320
32321         adr = AREG((Opcode >> 0) & 7);
32322         AREG((Opcode >> 0) & 7) += 2;
32323         PRE_IO
32324         READSX_WORD_F(adr, src)
32325         dst = AREGu32((Opcode >> 9) & 7);
32326         res = dst - src;
32327         flag_NotZ = res;
32328         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32329         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32330         flag_N = res >> 24;
32331         POST_IO
32332 RET(10)
32333 }
32334
32335 // CMPA
32336 OPCODE(0xB0E0)
32337 {
32338         u32 adr, res;
32339         u32 src, dst;
32340
32341         adr = AREG((Opcode >> 0) & 7) - 2;
32342         AREG((Opcode >> 0) & 7) = adr;
32343         PRE_IO
32344         READSX_WORD_F(adr, src)
32345         dst = AREGu32((Opcode >> 9) & 7);
32346         res = dst - src;
32347         flag_NotZ = res;
32348         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32349         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32350         flag_N = res >> 24;
32351         POST_IO
32352 RET(12)
32353 }
32354
32355 // CMPA
32356 OPCODE(0xB0E8)
32357 {
32358         u32 adr, res;
32359         u32 src, dst;
32360
32361         FETCH_SWORD(adr);
32362         adr += AREG((Opcode >> 0) & 7);
32363         PRE_IO
32364         READSX_WORD_F(adr, src)
32365         dst = AREGu32((Opcode >> 9) & 7);
32366         res = dst - src;
32367         flag_NotZ = res;
32368         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32369         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32370         flag_N = res >> 24;
32371         POST_IO
32372 RET(14)
32373 }
32374
32375 // CMPA
32376 OPCODE(0xB0F0)
32377 {
32378         u32 adr, res;
32379         u32 src, dst;
32380
32381         adr = AREG((Opcode >> 0) & 7);
32382         DECODE_EXT_WORD
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(16)
32393 }
32394
32395 // CMPA
32396 OPCODE(0xB0F8)
32397 {
32398         u32 adr, res;
32399         u32 src, dst;
32400
32401         FETCH_SWORD(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(14)
32412 }
32413
32414 // CMPA
32415 OPCODE(0xB0F9)
32416 {
32417         u32 adr, res;
32418         u32 src, dst;
32419
32420         FETCH_LONG(adr);
32421         PRE_IO
32422         READSX_WORD_F(adr, src)
32423         dst = AREGu32((Opcode >> 9) & 7);
32424         res = dst - src;
32425         flag_NotZ = res;
32426         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32427         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32428         flag_N = res >> 24;
32429         POST_IO
32430 RET(18)
32431 }
32432
32433 // CMPA
32434 OPCODE(0xB0FA)
32435 {
32436         u32 adr, res;
32437         u32 src, dst;
32438
32439         adr = GET_SWORD + GET_PC;
32440         PC++;
32441         PRE_IO
32442         READSX_WORD_F(adr, src)
32443         dst = AREGu32((Opcode >> 9) & 7);
32444         res = dst - src;
32445         flag_NotZ = res;
32446         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32447         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32448         flag_N = res >> 24;
32449         POST_IO
32450 RET(14)
32451 }
32452
32453 // CMPA
32454 OPCODE(0xB0FB)
32455 {
32456         u32 adr, res;
32457         u32 src, dst;
32458
32459         adr = GET_PC;
32460         DECODE_EXT_WORD
32461         PRE_IO
32462         READSX_WORD_F(adr, src)
32463         dst = AREGu32((Opcode >> 9) & 7);
32464         res = dst - src;
32465         flag_NotZ = res;
32466         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32467         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32468         flag_N = res >> 24;
32469         POST_IO
32470 RET(16)
32471 }
32472
32473 // CMPA
32474 OPCODE(0xB0FC)
32475 {
32476         u32 adr, res;
32477         u32 src, dst;
32478
32479         FETCH_SWORD(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 RET(10)
32487 }
32488
32489 // CMPA
32490 OPCODE(0xB0DF)
32491 {
32492         u32 adr, res;
32493         u32 src, dst;
32494
32495         adr = AREG(7);
32496         AREG(7) += 2;
32497         PRE_IO
32498         READSX_WORD_F(adr, src)
32499         dst = AREGu32((Opcode >> 9) & 7);
32500         res = dst - src;
32501         flag_NotZ = res;
32502         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32503         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32504         flag_N = res >> 24;
32505         POST_IO
32506 RET(10)
32507 }
32508
32509 // CMPA
32510 OPCODE(0xB0E7)
32511 {
32512         u32 adr, res;
32513         u32 src, dst;
32514
32515         adr = AREG(7) - 2;
32516         AREG(7) = adr;
32517         PRE_IO
32518         READSX_WORD_F(adr, src)
32519         dst = AREGu32((Opcode >> 9) & 7);
32520         res = dst - src;
32521         flag_NotZ = res;
32522         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32523         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32524         flag_N = res >> 24;
32525         POST_IO
32526 RET(12)
32527 }
32528
32529 // CMPA
32530 OPCODE(0xB1C0)
32531 {
32532         u32 adr, res;
32533         u32 src, dst;
32534
32535         src = (s32)DREGs32((Opcode >> 0) & 7);
32536         dst = AREGu32((Opcode >> 9) & 7);
32537         res = dst - src;
32538         flag_NotZ = res;
32539         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32540         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32541         flag_N = res >> 24;
32542 RET(6)
32543 }
32544
32545 // CMPA
32546 OPCODE(0xB1C8)
32547 {
32548         u32 adr, res;
32549         u32 src, dst;
32550
32551         src = (s32)AREGs32((Opcode >> 0) & 7);
32552         dst = AREGu32((Opcode >> 9) & 7);
32553         res = dst - src;
32554         flag_NotZ = res;
32555         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32556         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32557         flag_N = res >> 24;
32558 RET(6)
32559 }
32560
32561 // CMPA
32562 OPCODE(0xB1D0)
32563 {
32564         u32 adr, res;
32565         u32 src, dst;
32566
32567         adr = AREG((Opcode >> 0) & 7);
32568         PRE_IO
32569         READSX_LONG_F(adr, src)
32570         dst = AREGu32((Opcode >> 9) & 7);
32571         res = dst - src;
32572         flag_NotZ = res;
32573         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32574         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32575         flag_N = res >> 24;
32576         POST_IO
32577 RET(14)
32578 }
32579
32580 // CMPA
32581 OPCODE(0xB1D8)
32582 {
32583         u32 adr, res;
32584         u32 src, dst;
32585
32586         adr = AREG((Opcode >> 0) & 7);
32587         AREG((Opcode >> 0) & 7) += 4;
32588         PRE_IO
32589         READSX_LONG_F(adr, src)
32590         dst = AREGu32((Opcode >> 9) & 7);
32591         res = dst - src;
32592         flag_NotZ = res;
32593         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32594         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32595         flag_N = res >> 24;
32596         POST_IO
32597 RET(14)
32598 }
32599
32600 // CMPA
32601 OPCODE(0xB1E0)
32602 {
32603         u32 adr, res;
32604         u32 src, dst;
32605
32606         adr = AREG((Opcode >> 0) & 7) - 4;
32607         AREG((Opcode >> 0) & 7) = adr;
32608         PRE_IO
32609         READSX_LONG_F(adr, src)
32610         dst = AREGu32((Opcode >> 9) & 7);
32611         res = dst - src;
32612         flag_NotZ = res;
32613         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32614         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32615         flag_N = res >> 24;
32616         POST_IO
32617 RET(16)
32618 }
32619
32620 // CMPA
32621 OPCODE(0xB1E8)
32622 {
32623         u32 adr, res;
32624         u32 src, dst;
32625
32626         FETCH_SWORD(adr);
32627         adr += AREG((Opcode >> 0) & 7);
32628         PRE_IO
32629         READSX_LONG_F(adr, src)
32630         dst = AREGu32((Opcode >> 9) & 7);
32631         res = dst - src;
32632         flag_NotZ = res;
32633         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32634         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32635         flag_N = res >> 24;
32636         POST_IO
32637 RET(18)
32638 }
32639
32640 // CMPA
32641 OPCODE(0xB1F0)
32642 {
32643         u32 adr, res;
32644         u32 src, dst;
32645
32646         adr = AREG((Opcode >> 0) & 7);
32647         DECODE_EXT_WORD
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(20)
32658 }
32659
32660 // CMPA
32661 OPCODE(0xB1F8)
32662 {
32663         u32 adr, res;
32664         u32 src, dst;
32665
32666         FETCH_SWORD(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(18)
32677 }
32678
32679 // CMPA
32680 OPCODE(0xB1F9)
32681 {
32682         u32 adr, res;
32683         u32 src, dst;
32684
32685         FETCH_LONG(adr);
32686         PRE_IO
32687         READSX_LONG_F(adr, src)
32688         dst = AREGu32((Opcode >> 9) & 7);
32689         res = dst - src;
32690         flag_NotZ = res;
32691         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32692         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32693         flag_N = res >> 24;
32694         POST_IO
32695 RET(22)
32696 }
32697
32698 // CMPA
32699 OPCODE(0xB1FA)
32700 {
32701         u32 adr, res;
32702         u32 src, dst;
32703
32704         adr = GET_SWORD + GET_PC;
32705         PC++;
32706         PRE_IO
32707         READSX_LONG_F(adr, src)
32708         dst = AREGu32((Opcode >> 9) & 7);
32709         res = dst - src;
32710         flag_NotZ = res;
32711         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32712         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32713         flag_N = res >> 24;
32714         POST_IO
32715 RET(18)
32716 }
32717
32718 // CMPA
32719 OPCODE(0xB1FB)
32720 {
32721         u32 adr, res;
32722         u32 src, dst;
32723
32724         adr = GET_PC;
32725         DECODE_EXT_WORD
32726         PRE_IO
32727         READSX_LONG_F(adr, src)
32728         dst = AREGu32((Opcode >> 9) & 7);
32729         res = dst - src;
32730         flag_NotZ = res;
32731         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32732         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32733         flag_N = res >> 24;
32734         POST_IO
32735 RET(20)
32736 }
32737
32738 // CMPA
32739 OPCODE(0xB1FC)
32740 {
32741         u32 adr, res;
32742         u32 src, dst;
32743
32744         FETCH_LONG(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 RET(14)
32752 }
32753
32754 // CMPA
32755 OPCODE(0xB1DF)
32756 {
32757         u32 adr, res;
32758         u32 src, dst;
32759
32760         adr = AREG(7);
32761         AREG(7) += 4;
32762         PRE_IO
32763         READSX_LONG_F(adr, src)
32764         dst = AREGu32((Opcode >> 9) & 7);
32765         res = dst - src;
32766         flag_NotZ = res;
32767         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32768         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32769         flag_N = res >> 24;
32770         POST_IO
32771 RET(14)
32772 }
32773
32774 // CMPA
32775 OPCODE(0xB1E7)
32776 {
32777         u32 adr, res;
32778         u32 src, dst;
32779
32780         adr = AREG(7) - 4;
32781         AREG(7) = adr;
32782         PRE_IO
32783         READSX_LONG_F(adr, src)
32784         dst = AREGu32((Opcode >> 9) & 7);
32785         res = dst - src;
32786         flag_NotZ = res;
32787         flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32788         flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32789         flag_N = res >> 24;
32790         POST_IO
32791 RET(16)
32792 }
32793
32794 // ANDaD
32795 OPCODE(0xC000)
32796 {
32797         u32 adr, res;
32798         u32 src, dst;
32799
32800         src = DREGu8((Opcode >> 0) & 7);
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 RET(4)
32809 }
32810
32811 // ANDaD
32812 OPCODE(0xC010)
32813 {
32814         u32 adr, res;
32815         u32 src, dst;
32816
32817         adr = AREG((Opcode >> 0) & 7);
32818         PRE_IO
32819         READ_BYTE_F(adr, src)
32820         res = DREGu8((Opcode >> 9) & 7);
32821         res &= src;
32822         flag_C = 0;
32823         flag_V = 0;
32824         flag_NotZ = res;
32825         flag_N = res;
32826         DREGu8((Opcode >> 9) & 7) = res;
32827         POST_IO
32828 RET(8)
32829 }
32830
32831 // ANDaD
32832 OPCODE(0xC018)
32833 {
32834         u32 adr, res;
32835         u32 src, dst;
32836
32837         adr = AREG((Opcode >> 0) & 7);
32838         AREG((Opcode >> 0) & 7) += 1;
32839         PRE_IO
32840         READ_BYTE_F(adr, src)
32841         res = DREGu8((Opcode >> 9) & 7);
32842         res &= src;
32843         flag_C = 0;
32844         flag_V = 0;
32845         flag_NotZ = res;
32846         flag_N = res;
32847         DREGu8((Opcode >> 9) & 7) = res;
32848         POST_IO
32849 RET(8)
32850 }
32851
32852 // ANDaD
32853 OPCODE(0xC020)
32854 {
32855         u32 adr, res;
32856         u32 src, dst;
32857
32858         adr = AREG((Opcode >> 0) & 7) - 1;
32859         AREG((Opcode >> 0) & 7) = adr;
32860         PRE_IO
32861         READ_BYTE_F(adr, src)
32862         res = DREGu8((Opcode >> 9) & 7);
32863         res &= src;
32864         flag_C = 0;
32865         flag_V = 0;
32866         flag_NotZ = res;
32867         flag_N = res;
32868         DREGu8((Opcode >> 9) & 7) = res;
32869         POST_IO
32870 RET(10)
32871 }
32872
32873 // ANDaD
32874 OPCODE(0xC028)
32875 {
32876         u32 adr, res;
32877         u32 src, dst;
32878
32879         FETCH_SWORD(adr);
32880         adr += AREG((Opcode >> 0) & 7);
32881         PRE_IO
32882         READ_BYTE_F(adr, src)
32883         res = DREGu8((Opcode >> 9) & 7);
32884         res &= src;
32885         flag_C = 0;
32886         flag_V = 0;
32887         flag_NotZ = res;
32888         flag_N = res;
32889         DREGu8((Opcode >> 9) & 7) = res;
32890         POST_IO
32891 RET(12)
32892 }
32893
32894 // ANDaD
32895 OPCODE(0xC030)
32896 {
32897         u32 adr, res;
32898         u32 src, dst;
32899
32900         adr = AREG((Opcode >> 0) & 7);
32901         DECODE_EXT_WORD
32902         PRE_IO
32903         READ_BYTE_F(adr, src)
32904         res = DREGu8((Opcode >> 9) & 7);
32905         res &= src;
32906         flag_C = 0;
32907         flag_V = 0;
32908         flag_NotZ = res;
32909         flag_N = res;
32910         DREGu8((Opcode >> 9) & 7) = res;
32911         POST_IO
32912 RET(14)
32913 }
32914
32915 // ANDaD
32916 OPCODE(0xC038)
32917 {
32918         u32 adr, res;
32919         u32 src, dst;
32920
32921         FETCH_SWORD(adr);
32922         PRE_IO
32923         READ_BYTE_F(adr, src)
32924         res = DREGu8((Opcode >> 9) & 7);
32925         res &= src;
32926         flag_C = 0;
32927         flag_V = 0;
32928         flag_NotZ = res;
32929         flag_N = res;
32930         DREGu8((Opcode >> 9) & 7) = res;
32931         POST_IO
32932 RET(12)
32933 }
32934
32935 // ANDaD
32936 OPCODE(0xC039)
32937 {
32938         u32 adr, res;
32939         u32 src, dst;
32940
32941         FETCH_LONG(adr);
32942         PRE_IO
32943         READ_BYTE_F(adr, src)
32944         res = DREGu8((Opcode >> 9) & 7);
32945         res &= src;
32946         flag_C = 0;
32947         flag_V = 0;
32948         flag_NotZ = res;
32949         flag_N = res;
32950         DREGu8((Opcode >> 9) & 7) = res;
32951         POST_IO
32952 RET(16)
32953 }
32954
32955 // ANDaD
32956 OPCODE(0xC03A)
32957 {
32958         u32 adr, res;
32959         u32 src, dst;
32960
32961         adr = GET_SWORD + GET_PC;
32962         PC++;
32963         PRE_IO
32964         READ_BYTE_F(adr, src)
32965         res = DREGu8((Opcode >> 9) & 7);
32966         res &= src;
32967         flag_C = 0;
32968         flag_V = 0;
32969         flag_NotZ = res;
32970         flag_N = res;
32971         DREGu8((Opcode >> 9) & 7) = res;
32972         POST_IO
32973 RET(12)
32974 }
32975
32976 // ANDaD
32977 OPCODE(0xC03B)
32978 {
32979         u32 adr, res;
32980         u32 src, dst;
32981
32982         adr = GET_PC;
32983         DECODE_EXT_WORD
32984         PRE_IO
32985         READ_BYTE_F(adr, src)
32986         res = DREGu8((Opcode >> 9) & 7);
32987         res &= src;
32988         flag_C = 0;
32989         flag_V = 0;
32990         flag_NotZ = res;
32991         flag_N = res;
32992         DREGu8((Opcode >> 9) & 7) = res;
32993         POST_IO
32994 RET(14)
32995 }
32996
32997 // ANDaD
32998 OPCODE(0xC03C)
32999 {
33000         u32 adr, res;
33001         u32 src, dst;
33002
33003         FETCH_BYTE(src);
33004         res = DREGu8((Opcode >> 9) & 7);
33005         res &= src;
33006         flag_C = 0;
33007         flag_V = 0;
33008         flag_NotZ = res;
33009         flag_N = res;
33010         DREGu8((Opcode >> 9) & 7) = res;
33011 RET(8)
33012 }
33013
33014 // ANDaD
33015 OPCODE(0xC01F)
33016 {
33017         u32 adr, res;
33018         u32 src, dst;
33019
33020         adr = AREG(7);
33021         AREG(7) += 2;
33022         PRE_IO
33023         READ_BYTE_F(adr, src)
33024         res = DREGu8((Opcode >> 9) & 7);
33025         res &= src;
33026         flag_C = 0;
33027         flag_V = 0;
33028         flag_NotZ = res;
33029         flag_N = res;
33030         DREGu8((Opcode >> 9) & 7) = res;
33031         POST_IO
33032 RET(8)
33033 }
33034
33035 // ANDaD
33036 OPCODE(0xC027)
33037 {
33038         u32 adr, res;
33039         u32 src, dst;
33040
33041         adr = AREG(7) - 2;
33042         AREG(7) = adr;
33043         PRE_IO
33044         READ_BYTE_F(adr, src)
33045         res = DREGu8((Opcode >> 9) & 7);
33046         res &= src;
33047         flag_C = 0;
33048         flag_V = 0;
33049         flag_NotZ = res;
33050         flag_N = res;
33051         DREGu8((Opcode >> 9) & 7) = res;
33052         POST_IO
33053 RET(10)
33054 }
33055
33056 // ANDaD
33057 OPCODE(0xC040)
33058 {
33059         u32 adr, res;
33060         u32 src, dst;
33061
33062         src = DREGu16((Opcode >> 0) & 7);
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 RET(4)
33071 }
33072
33073 // ANDaD
33074 OPCODE(0xC050)
33075 {
33076         u32 adr, res;
33077         u32 src, dst;
33078
33079         adr = AREG((Opcode >> 0) & 7);
33080         PRE_IO
33081         READ_WORD_F(adr, src)
33082         res = DREGu16((Opcode >> 9) & 7);
33083         res &= src;
33084         flag_C = 0;
33085         flag_V = 0;
33086         flag_NotZ = res;
33087         flag_N = res >> 8;
33088         DREGu16((Opcode >> 9) & 7) = res;
33089         POST_IO
33090 RET(8)
33091 }
33092
33093 // ANDaD
33094 OPCODE(0xC058)
33095 {
33096         u32 adr, res;
33097         u32 src, dst;
33098
33099         adr = AREG((Opcode >> 0) & 7);
33100         AREG((Opcode >> 0) & 7) += 2;
33101         PRE_IO
33102         READ_WORD_F(adr, src)
33103         res = DREGu16((Opcode >> 9) & 7);
33104         res &= src;
33105         flag_C = 0;
33106         flag_V = 0;
33107         flag_NotZ = res;
33108         flag_N = res >> 8;
33109         DREGu16((Opcode >> 9) & 7) = res;
33110         POST_IO
33111 RET(8)
33112 }
33113
33114 // ANDaD
33115 OPCODE(0xC060)
33116 {
33117         u32 adr, res;
33118         u32 src, dst;
33119
33120         adr = AREG((Opcode >> 0) & 7) - 2;
33121         AREG((Opcode >> 0) & 7) = adr;
33122         PRE_IO
33123         READ_WORD_F(adr, src)
33124         res = DREGu16((Opcode >> 9) & 7);
33125         res &= src;
33126         flag_C = 0;
33127         flag_V = 0;
33128         flag_NotZ = res;
33129         flag_N = res >> 8;
33130         DREGu16((Opcode >> 9) & 7) = res;
33131         POST_IO
33132 RET(10)
33133 }
33134
33135 // ANDaD
33136 OPCODE(0xC068)
33137 {
33138         u32 adr, res;
33139         u32 src, dst;
33140
33141         FETCH_SWORD(adr);
33142         adr += AREG((Opcode >> 0) & 7);
33143         PRE_IO
33144         READ_WORD_F(adr, src)
33145         res = DREGu16((Opcode >> 9) & 7);
33146         res &= src;
33147         flag_C = 0;
33148         flag_V = 0;
33149         flag_NotZ = res;
33150         flag_N = res >> 8;
33151         DREGu16((Opcode >> 9) & 7) = res;
33152         POST_IO
33153 RET(12)
33154 }
33155
33156 // ANDaD
33157 OPCODE(0xC070)
33158 {
33159         u32 adr, res;
33160         u32 src, dst;
33161
33162         adr = AREG((Opcode >> 0) & 7);
33163         DECODE_EXT_WORD
33164         PRE_IO
33165         READ_WORD_F(adr, src)
33166         res = DREGu16((Opcode >> 9) & 7);
33167         res &= src;
33168         flag_C = 0;
33169         flag_V = 0;
33170         flag_NotZ = res;
33171         flag_N = res >> 8;
33172         DREGu16((Opcode >> 9) & 7) = res;
33173         POST_IO
33174 RET(14)
33175 }
33176
33177 // ANDaD
33178 OPCODE(0xC078)
33179 {
33180         u32 adr, res;
33181         u32 src, dst;
33182
33183         FETCH_SWORD(adr);
33184         PRE_IO
33185         READ_WORD_F(adr, src)
33186         res = DREGu16((Opcode >> 9) & 7);
33187         res &= src;
33188         flag_C = 0;
33189         flag_V = 0;
33190         flag_NotZ = res;
33191         flag_N = res >> 8;
33192         DREGu16((Opcode >> 9) & 7) = res;
33193         POST_IO
33194 RET(12)
33195 }
33196
33197 // ANDaD
33198 OPCODE(0xC079)
33199 {
33200         u32 adr, res;
33201         u32 src, dst;
33202
33203         FETCH_LONG(adr);
33204         PRE_IO
33205         READ_WORD_F(adr, src)
33206         res = DREGu16((Opcode >> 9) & 7);
33207         res &= src;
33208         flag_C = 0;
33209         flag_V = 0;
33210         flag_NotZ = res;
33211         flag_N = res >> 8;
33212         DREGu16((Opcode >> 9) & 7) = res;
33213         POST_IO
33214 RET(16)
33215 }
33216
33217 // ANDaD
33218 OPCODE(0xC07A)
33219 {
33220         u32 adr, res;
33221         u32 src, dst;
33222
33223         adr = GET_SWORD + GET_PC;
33224         PC++;
33225         PRE_IO
33226         READ_WORD_F(adr, src)
33227         res = DREGu16((Opcode >> 9) & 7);
33228         res &= src;
33229         flag_C = 0;
33230         flag_V = 0;
33231         flag_NotZ = res;
33232         flag_N = res >> 8;
33233         DREGu16((Opcode >> 9) & 7) = res;
33234         POST_IO
33235 RET(12)
33236 }
33237
33238 // ANDaD
33239 OPCODE(0xC07B)
33240 {
33241         u32 adr, res;
33242         u32 src, dst;
33243
33244         adr = GET_PC;
33245         DECODE_EXT_WORD
33246         PRE_IO
33247         READ_WORD_F(adr, src)
33248         res = DREGu16((Opcode >> 9) & 7);
33249         res &= src;
33250         flag_C = 0;
33251         flag_V = 0;
33252         flag_NotZ = res;
33253         flag_N = res >> 8;
33254         DREGu16((Opcode >> 9) & 7) = res;
33255         POST_IO
33256 RET(14)
33257 }
33258
33259 // ANDaD
33260 OPCODE(0xC07C)
33261 {
33262         u32 adr, res;
33263         u32 src, dst;
33264
33265         FETCH_WORD(src);
33266         res = DREGu16((Opcode >> 9) & 7);
33267         res &= src;
33268         flag_C = 0;
33269         flag_V = 0;
33270         flag_NotZ = res;
33271         flag_N = res >> 8;
33272         DREGu16((Opcode >> 9) & 7) = res;
33273 RET(8)
33274 }
33275
33276 // ANDaD
33277 OPCODE(0xC05F)
33278 {
33279         u32 adr, res;
33280         u32 src, dst;
33281
33282         adr = AREG(7);
33283         AREG(7) += 2;
33284         PRE_IO
33285         READ_WORD_F(adr, src)
33286         res = DREGu16((Opcode >> 9) & 7);
33287         res &= src;
33288         flag_C = 0;
33289         flag_V = 0;
33290         flag_NotZ = res;
33291         flag_N = res >> 8;
33292         DREGu16((Opcode >> 9) & 7) = res;
33293         POST_IO
33294 RET(8)
33295 }
33296
33297 // ANDaD
33298 OPCODE(0xC067)
33299 {
33300         u32 adr, res;
33301         u32 src, dst;
33302
33303         adr = AREG(7) - 2;
33304         AREG(7) = adr;
33305         PRE_IO
33306         READ_WORD_F(adr, src)
33307         res = DREGu16((Opcode >> 9) & 7);
33308         res &= src;
33309         flag_C = 0;
33310         flag_V = 0;
33311         flag_NotZ = res;
33312         flag_N = res >> 8;
33313         DREGu16((Opcode >> 9) & 7) = res;
33314         POST_IO
33315 RET(10)
33316 }
33317
33318 // ANDaD
33319 OPCODE(0xC080)
33320 {
33321         u32 adr, res;
33322         u32 src, dst;
33323
33324         src = DREGu32((Opcode >> 0) & 7);
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 RET(8)
33333 }
33334
33335 // ANDaD
33336 OPCODE(0xC090)
33337 {
33338         u32 adr, res;
33339         u32 src, dst;
33340
33341         adr = AREG((Opcode >> 0) & 7);
33342         PRE_IO
33343         READ_LONG_F(adr, src)
33344         res = DREGu32((Opcode >> 9) & 7);
33345         res &= src;
33346         flag_C = 0;
33347         flag_V = 0;
33348         flag_NotZ = res;
33349         flag_N = res >> 24;
33350         DREGu32((Opcode >> 9) & 7) = res;
33351         POST_IO
33352 RET(14)
33353 }
33354
33355 // ANDaD
33356 OPCODE(0xC098)
33357 {
33358         u32 adr, res;
33359         u32 src, dst;
33360
33361         adr = AREG((Opcode >> 0) & 7);
33362         AREG((Opcode >> 0) & 7) += 4;
33363         PRE_IO
33364         READ_LONG_F(adr, src)
33365         res = DREGu32((Opcode >> 9) & 7);
33366         res &= src;
33367         flag_C = 0;
33368         flag_V = 0;
33369         flag_NotZ = res;
33370         flag_N = res >> 24;
33371         DREGu32((Opcode >> 9) & 7) = res;
33372         POST_IO
33373 RET(14)
33374 }
33375
33376 // ANDaD
33377 OPCODE(0xC0A0)
33378 {
33379         u32 adr, res;
33380         u32 src, dst;
33381
33382         adr = AREG((Opcode >> 0) & 7) - 4;
33383         AREG((Opcode >> 0) & 7) = adr;
33384         PRE_IO
33385         READ_LONG_F(adr, src)
33386         res = DREGu32((Opcode >> 9) & 7);
33387         res &= src;
33388         flag_C = 0;
33389         flag_V = 0;
33390         flag_NotZ = res;
33391         flag_N = res >> 24;
33392         DREGu32((Opcode >> 9) & 7) = res;
33393         POST_IO
33394 RET(16)
33395 }
33396
33397 // ANDaD
33398 OPCODE(0xC0A8)
33399 {
33400         u32 adr, res;
33401         u32 src, dst;
33402
33403         FETCH_SWORD(adr);
33404         adr += AREG((Opcode >> 0) & 7);
33405         PRE_IO
33406         READ_LONG_F(adr, src)
33407         res = DREGu32((Opcode >> 9) & 7);
33408         res &= src;
33409         flag_C = 0;
33410         flag_V = 0;
33411         flag_NotZ = res;
33412         flag_N = res >> 24;
33413         DREGu32((Opcode >> 9) & 7) = res;
33414         POST_IO
33415 RET(18)
33416 }
33417
33418 // ANDaD
33419 OPCODE(0xC0B0)
33420 {
33421         u32 adr, res;
33422         u32 src, dst;
33423
33424         adr = AREG((Opcode >> 0) & 7);
33425         DECODE_EXT_WORD
33426         PRE_IO
33427         READ_LONG_F(adr, src)
33428         res = DREGu32((Opcode >> 9) & 7);
33429         res &= src;
33430         flag_C = 0;
33431         flag_V = 0;
33432         flag_NotZ = res;
33433         flag_N = res >> 24;
33434         DREGu32((Opcode >> 9) & 7) = res;
33435         POST_IO
33436 RET(20)
33437 }
33438
33439 // ANDaD
33440 OPCODE(0xC0B8)
33441 {
33442         u32 adr, res;
33443         u32 src, dst;
33444
33445         FETCH_SWORD(adr);
33446         PRE_IO
33447         READ_LONG_F(adr, src)
33448         res = DREGu32((Opcode >> 9) & 7);
33449         res &= src;
33450         flag_C = 0;
33451         flag_V = 0;
33452         flag_NotZ = res;
33453         flag_N = res >> 24;
33454         DREGu32((Opcode >> 9) & 7) = res;
33455         POST_IO
33456 RET(18)
33457 }
33458
33459 // ANDaD
33460 OPCODE(0xC0B9)
33461 {
33462         u32 adr, res;
33463         u32 src, dst;
33464
33465         FETCH_LONG(adr);
33466         PRE_IO
33467         READ_LONG_F(adr, src)
33468         res = DREGu32((Opcode >> 9) & 7);
33469         res &= src;
33470         flag_C = 0;
33471         flag_V = 0;
33472         flag_NotZ = res;
33473         flag_N = res >> 24;
33474         DREGu32((Opcode >> 9) & 7) = res;
33475         POST_IO
33476 RET(22)
33477 }
33478
33479 // ANDaD
33480 OPCODE(0xC0BA)
33481 {
33482         u32 adr, res;
33483         u32 src, dst;
33484
33485         adr = GET_SWORD + GET_PC;
33486         PC++;
33487         PRE_IO
33488         READ_LONG_F(adr, src)
33489         res = DREGu32((Opcode >> 9) & 7);
33490         res &= src;
33491         flag_C = 0;
33492         flag_V = 0;
33493         flag_NotZ = res;
33494         flag_N = res >> 24;
33495         DREGu32((Opcode >> 9) & 7) = res;
33496         POST_IO
33497 RET(18)
33498 }
33499
33500 // ANDaD
33501 OPCODE(0xC0BB)
33502 {
33503         u32 adr, res;
33504         u32 src, dst;
33505
33506         adr = GET_PC;
33507         DECODE_EXT_WORD
33508         PRE_IO
33509         READ_LONG_F(adr, src)
33510         res = DREGu32((Opcode >> 9) & 7);
33511         res &= src;
33512         flag_C = 0;
33513         flag_V = 0;
33514         flag_NotZ = res;
33515         flag_N = res >> 24;
33516         DREGu32((Opcode >> 9) & 7) = res;
33517         POST_IO
33518 RET(20)
33519 }
33520
33521 // ANDaD
33522 OPCODE(0xC0BC)
33523 {
33524         u32 adr, res;
33525         u32 src, dst;
33526
33527         FETCH_LONG(src);
33528         res = DREGu32((Opcode >> 9) & 7);
33529         res &= src;
33530         flag_C = 0;
33531         flag_V = 0;
33532         flag_NotZ = res;
33533         flag_N = res >> 24;
33534         DREGu32((Opcode >> 9) & 7) = res;
33535 RET(16)
33536 }
33537
33538 // ANDaD
33539 OPCODE(0xC09F)
33540 {
33541         u32 adr, res;
33542         u32 src, dst;
33543
33544         adr = AREG(7);
33545         AREG(7) += 4;
33546         PRE_IO
33547         READ_LONG_F(adr, src)
33548         res = DREGu32((Opcode >> 9) & 7);
33549         res &= src;
33550         flag_C = 0;
33551         flag_V = 0;
33552         flag_NotZ = res;
33553         flag_N = res >> 24;
33554         DREGu32((Opcode >> 9) & 7) = res;
33555         POST_IO
33556 RET(14)
33557 }
33558
33559 // ANDaD
33560 OPCODE(0xC0A7)
33561 {
33562         u32 adr, res;
33563         u32 src, dst;
33564
33565         adr = AREG(7) - 4;
33566         AREG(7) = adr;
33567         PRE_IO
33568         READ_LONG_F(adr, src)
33569         res = DREGu32((Opcode >> 9) & 7);
33570         res &= src;
33571         flag_C = 0;
33572         flag_V = 0;
33573         flag_NotZ = res;
33574         flag_N = res >> 24;
33575         DREGu32((Opcode >> 9) & 7) = res;
33576         POST_IO
33577 RET(16)
33578 }
33579
33580 // ANDDa
33581 OPCODE(0xC110)
33582 {
33583         u32 adr, res;
33584         u32 src, dst;
33585
33586         src = DREGu8((Opcode >> 9) & 7);
33587         adr = AREG((Opcode >> 0) & 7);
33588         PRE_IO
33589         READ_BYTE_F(adr, res)
33590         res &= src;
33591         flag_C = 0;
33592         flag_V = 0;
33593         flag_NotZ = res;
33594         flag_N = res;
33595         WRITE_BYTE_F(adr, res)
33596         POST_IO
33597 RET(12)
33598 }
33599
33600 // ANDDa
33601 OPCODE(0xC118)
33602 {
33603         u32 adr, res;
33604         u32 src, dst;
33605
33606         src = DREGu8((Opcode >> 9) & 7);
33607         adr = AREG((Opcode >> 0) & 7);
33608         AREG((Opcode >> 0) & 7) += 1;
33609         PRE_IO
33610         READ_BYTE_F(adr, res)
33611         res &= src;
33612         flag_C = 0;
33613         flag_V = 0;
33614         flag_NotZ = res;
33615         flag_N = res;
33616         WRITE_BYTE_F(adr, res)
33617         POST_IO
33618 RET(12)
33619 }
33620
33621 // ANDDa
33622 OPCODE(0xC120)
33623 {
33624         u32 adr, res;
33625         u32 src, dst;
33626
33627         src = DREGu8((Opcode >> 9) & 7);
33628         adr = AREG((Opcode >> 0) & 7) - 1;
33629         AREG((Opcode >> 0) & 7) = adr;
33630         PRE_IO
33631         READ_BYTE_F(adr, res)
33632         res &= src;
33633         flag_C = 0;
33634         flag_V = 0;
33635         flag_NotZ = res;
33636         flag_N = res;
33637         WRITE_BYTE_F(adr, res)
33638         POST_IO
33639 RET(14)
33640 }
33641
33642 // ANDDa
33643 OPCODE(0xC128)
33644 {
33645         u32 adr, res;
33646         u32 src, dst;
33647
33648         src = DREGu8((Opcode >> 9) & 7);
33649         FETCH_SWORD(adr);
33650         adr += AREG((Opcode >> 0) & 7);
33651         PRE_IO
33652         READ_BYTE_F(adr, res)
33653         res &= src;
33654         flag_C = 0;
33655         flag_V = 0;
33656         flag_NotZ = res;
33657         flag_N = res;
33658         WRITE_BYTE_F(adr, res)
33659         POST_IO
33660 RET(16)
33661 }
33662
33663 // ANDDa
33664 OPCODE(0xC130)
33665 {
33666         u32 adr, res;
33667         u32 src, dst;
33668
33669         src = DREGu8((Opcode >> 9) & 7);
33670         adr = AREG((Opcode >> 0) & 7);
33671         DECODE_EXT_WORD
33672         PRE_IO
33673         READ_BYTE_F(adr, res)
33674         res &= src;
33675         flag_C = 0;
33676         flag_V = 0;
33677         flag_NotZ = res;
33678         flag_N = res;
33679         WRITE_BYTE_F(adr, res)
33680         POST_IO
33681 RET(18)
33682 }
33683
33684 // ANDDa
33685 OPCODE(0xC138)
33686 {
33687         u32 adr, res;
33688         u32 src, dst;
33689
33690         src = DREGu8((Opcode >> 9) & 7);
33691         FETCH_SWORD(adr);
33692         PRE_IO
33693         READ_BYTE_F(adr, res)
33694         res &= src;
33695         flag_C = 0;
33696         flag_V = 0;
33697         flag_NotZ = res;
33698         flag_N = res;
33699         WRITE_BYTE_F(adr, res)
33700         POST_IO
33701 RET(16)
33702 }
33703
33704 // ANDDa
33705 OPCODE(0xC139)
33706 {
33707         u32 adr, res;
33708         u32 src, dst;
33709
33710         src = DREGu8((Opcode >> 9) & 7);
33711         FETCH_LONG(adr);
33712         PRE_IO
33713         READ_BYTE_F(adr, res)
33714         res &= src;
33715         flag_C = 0;
33716         flag_V = 0;
33717         flag_NotZ = res;
33718         flag_N = res;
33719         WRITE_BYTE_F(adr, res)
33720         POST_IO
33721 RET(20)
33722 }
33723
33724 // ANDDa
33725 OPCODE(0xC11F)
33726 {
33727         u32 adr, res;
33728         u32 src, dst;
33729
33730         src = DREGu8((Opcode >> 9) & 7);
33731         adr = AREG(7);
33732         AREG(7) += 2;
33733         PRE_IO
33734         READ_BYTE_F(adr, res)
33735         res &= src;
33736         flag_C = 0;
33737         flag_V = 0;
33738         flag_NotZ = res;
33739         flag_N = res;
33740         WRITE_BYTE_F(adr, res)
33741         POST_IO
33742 RET(12)
33743 }
33744
33745 // ANDDa
33746 OPCODE(0xC127)
33747 {
33748         u32 adr, res;
33749         u32 src, dst;
33750
33751         src = DREGu8((Opcode >> 9) & 7);
33752         adr = AREG(7) - 2;
33753         AREG(7) = adr;
33754         PRE_IO
33755         READ_BYTE_F(adr, res)
33756         res &= src;
33757         flag_C = 0;
33758         flag_V = 0;
33759         flag_NotZ = res;
33760         flag_N = res;
33761         WRITE_BYTE_F(adr, res)
33762         POST_IO
33763 RET(14)
33764 }
33765
33766 // ANDDa
33767 OPCODE(0xC150)
33768 {
33769         u32 adr, res;
33770         u32 src, dst;
33771
33772         src = DREGu16((Opcode >> 9) & 7);
33773         adr = AREG((Opcode >> 0) & 7);
33774         PRE_IO
33775         READ_WORD_F(adr, res)
33776         res &= src;
33777         flag_C = 0;
33778         flag_V = 0;
33779         flag_NotZ = res;
33780         flag_N = res >> 8;
33781         WRITE_WORD_F(adr, res)
33782         POST_IO
33783 RET(12)
33784 }
33785
33786 // ANDDa
33787 OPCODE(0xC158)
33788 {
33789         u32 adr, res;
33790         u32 src, dst;
33791
33792         src = DREGu16((Opcode >> 9) & 7);
33793         adr = AREG((Opcode >> 0) & 7);
33794         AREG((Opcode >> 0) & 7) += 2;
33795         PRE_IO
33796         READ_WORD_F(adr, res)
33797         res &= src;
33798         flag_C = 0;
33799         flag_V = 0;
33800         flag_NotZ = res;
33801         flag_N = res >> 8;
33802         WRITE_WORD_F(adr, res)
33803         POST_IO
33804 RET(12)
33805 }
33806
33807 // ANDDa
33808 OPCODE(0xC160)
33809 {
33810         u32 adr, res;
33811         u32 src, dst;
33812
33813         src = DREGu16((Opcode >> 9) & 7);
33814         adr = AREG((Opcode >> 0) & 7) - 2;
33815         AREG((Opcode >> 0) & 7) = adr;
33816         PRE_IO
33817         READ_WORD_F(adr, res)
33818         res &= src;
33819         flag_C = 0;
33820         flag_V = 0;
33821         flag_NotZ = res;
33822         flag_N = res >> 8;
33823         WRITE_WORD_F(adr, res)
33824         POST_IO
33825 RET(14)
33826 }
33827
33828 // ANDDa
33829 OPCODE(0xC168)
33830 {
33831         u32 adr, res;
33832         u32 src, dst;
33833
33834         src = DREGu16((Opcode >> 9) & 7);
33835         FETCH_SWORD(adr);
33836         adr += AREG((Opcode >> 0) & 7);
33837         PRE_IO
33838         READ_WORD_F(adr, res)
33839         res &= src;
33840         flag_C = 0;
33841         flag_V = 0;
33842         flag_NotZ = res;
33843         flag_N = res >> 8;
33844         WRITE_WORD_F(adr, res)
33845         POST_IO
33846 RET(16)
33847 }
33848
33849 // ANDDa
33850 OPCODE(0xC170)
33851 {
33852         u32 adr, res;
33853         u32 src, dst;
33854
33855         src = DREGu16((Opcode >> 9) & 7);
33856         adr = AREG((Opcode >> 0) & 7);
33857         DECODE_EXT_WORD
33858         PRE_IO
33859         READ_WORD_F(adr, res)
33860         res &= src;
33861         flag_C = 0;
33862         flag_V = 0;
33863         flag_NotZ = res;
33864         flag_N = res >> 8;
33865         WRITE_WORD_F(adr, res)
33866         POST_IO
33867 RET(18)
33868 }
33869
33870 // ANDDa
33871 OPCODE(0xC178)
33872 {
33873         u32 adr, res;
33874         u32 src, dst;
33875
33876         src = DREGu16((Opcode >> 9) & 7);
33877         FETCH_SWORD(adr);
33878         PRE_IO
33879         READ_WORD_F(adr, res)
33880         res &= src;
33881         flag_C = 0;
33882         flag_V = 0;
33883         flag_NotZ = res;
33884         flag_N = res >> 8;
33885         WRITE_WORD_F(adr, res)
33886         POST_IO
33887 RET(16)
33888 }
33889
33890 // ANDDa
33891 OPCODE(0xC179)
33892 {
33893         u32 adr, res;
33894         u32 src, dst;
33895
33896         src = DREGu16((Opcode >> 9) & 7);
33897         FETCH_LONG(adr);
33898         PRE_IO
33899         READ_WORD_F(adr, res)
33900         res &= src;
33901         flag_C = 0;
33902         flag_V = 0;
33903         flag_NotZ = res;
33904         flag_N = res >> 8;
33905         WRITE_WORD_F(adr, res)
33906         POST_IO
33907 RET(20)
33908 }
33909
33910 // ANDDa
33911 OPCODE(0xC15F)
33912 {
33913         u32 adr, res;
33914         u32 src, dst;
33915
33916         src = DREGu16((Opcode >> 9) & 7);
33917         adr = AREG(7);
33918         AREG(7) += 2;
33919         PRE_IO
33920         READ_WORD_F(adr, res)
33921         res &= src;
33922         flag_C = 0;
33923         flag_V = 0;
33924         flag_NotZ = res;
33925         flag_N = res >> 8;
33926         WRITE_WORD_F(adr, res)
33927         POST_IO
33928 RET(12)
33929 }
33930
33931 // ANDDa
33932 OPCODE(0xC167)
33933 {
33934         u32 adr, res;
33935         u32 src, dst;
33936
33937         src = DREGu16((Opcode >> 9) & 7);
33938         adr = AREG(7) - 2;
33939         AREG(7) = adr;
33940         PRE_IO
33941         READ_WORD_F(adr, res)
33942         res &= src;
33943         flag_C = 0;
33944         flag_V = 0;
33945         flag_NotZ = res;
33946         flag_N = res >> 8;
33947         WRITE_WORD_F(adr, res)
33948         POST_IO
33949 RET(14)
33950 }
33951
33952 // ANDDa
33953 OPCODE(0xC190)
33954 {
33955         u32 adr, res;
33956         u32 src, dst;
33957
33958         src = DREGu32((Opcode >> 9) & 7);
33959         adr = AREG((Opcode >> 0) & 7);
33960         PRE_IO
33961         READ_LONG_F(adr, res)
33962         res &= src;
33963         flag_C = 0;
33964         flag_V = 0;
33965         flag_NotZ = res;
33966         flag_N = res >> 24;
33967         WRITE_LONG_F(adr, res)
33968         POST_IO
33969 RET(20)
33970 }
33971
33972 // ANDDa
33973 OPCODE(0xC198)
33974 {
33975         u32 adr, res;
33976         u32 src, dst;
33977
33978         src = DREGu32((Opcode >> 9) & 7);
33979         adr = AREG((Opcode >> 0) & 7);
33980         AREG((Opcode >> 0) & 7) += 4;
33981         PRE_IO
33982         READ_LONG_F(adr, res)
33983         res &= src;
33984         flag_C = 0;
33985         flag_V = 0;
33986         flag_NotZ = res;
33987         flag_N = res >> 24;
33988         WRITE_LONG_F(adr, res)
33989         POST_IO
33990 RET(20)
33991 }
33992
33993 // ANDDa
33994 OPCODE(0xC1A0)
33995 {
33996         u32 adr, res;
33997         u32 src, dst;
33998
33999         src = DREGu32((Opcode >> 9) & 7);
34000         adr = AREG((Opcode >> 0) & 7) - 4;
34001         AREG((Opcode >> 0) & 7) = adr;
34002         PRE_IO
34003         READ_LONG_F(adr, res)
34004         res &= src;
34005         flag_C = 0;
34006         flag_V = 0;
34007         flag_NotZ = res;
34008         flag_N = res >> 24;
34009         WRITE_LONG_F(adr, res)
34010         POST_IO
34011 RET(22)
34012 }
34013
34014 // ANDDa
34015 OPCODE(0xC1A8)
34016 {
34017         u32 adr, res;
34018         u32 src, dst;
34019
34020         src = DREGu32((Opcode >> 9) & 7);
34021         FETCH_SWORD(adr);
34022         adr += AREG((Opcode >> 0) & 7);
34023         PRE_IO
34024         READ_LONG_F(adr, res)
34025         res &= src;
34026         flag_C = 0;
34027         flag_V = 0;
34028         flag_NotZ = res;
34029         flag_N = res >> 24;
34030         WRITE_LONG_F(adr, res)
34031         POST_IO
34032 RET(24)
34033 }
34034
34035 // ANDDa
34036 OPCODE(0xC1B0)
34037 {
34038         u32 adr, res;
34039         u32 src, dst;
34040
34041         src = DREGu32((Opcode >> 9) & 7);
34042         adr = AREG((Opcode >> 0) & 7);
34043         DECODE_EXT_WORD
34044         PRE_IO
34045         READ_LONG_F(adr, res)
34046         res &= src;
34047         flag_C = 0;
34048         flag_V = 0;
34049         flag_NotZ = res;
34050         flag_N = res >> 24;
34051         WRITE_LONG_F(adr, res)
34052         POST_IO
34053 RET(26)
34054 }
34055
34056 // ANDDa
34057 OPCODE(0xC1B8)
34058 {
34059         u32 adr, res;
34060         u32 src, dst;
34061
34062         src = DREGu32((Opcode >> 9) & 7);
34063         FETCH_SWORD(adr);
34064         PRE_IO
34065         READ_LONG_F(adr, res)
34066         res &= src;
34067         flag_C = 0;
34068         flag_V = 0;
34069         flag_NotZ = res;
34070         flag_N = res >> 24;
34071         WRITE_LONG_F(adr, res)
34072         POST_IO
34073 RET(24)
34074 }
34075
34076 // ANDDa
34077 OPCODE(0xC1B9)
34078 {
34079         u32 adr, res;
34080         u32 src, dst;
34081
34082         src = DREGu32((Opcode >> 9) & 7);
34083         FETCH_LONG(adr);
34084         PRE_IO
34085         READ_LONG_F(adr, res)
34086         res &= src;
34087         flag_C = 0;
34088         flag_V = 0;
34089         flag_NotZ = res;
34090         flag_N = res >> 24;
34091         WRITE_LONG_F(adr, res)
34092         POST_IO
34093 RET(28)
34094 }
34095
34096 // ANDDa
34097 OPCODE(0xC19F)
34098 {
34099         u32 adr, res;
34100         u32 src, dst;
34101
34102         src = DREGu32((Opcode >> 9) & 7);
34103         adr = AREG(7);
34104         AREG(7) += 4;
34105         PRE_IO
34106         READ_LONG_F(adr, res)
34107         res &= src;
34108         flag_C = 0;
34109         flag_V = 0;
34110         flag_NotZ = res;
34111         flag_N = res >> 24;
34112         WRITE_LONG_F(adr, res)
34113         POST_IO
34114 RET(20)
34115 }
34116
34117 // ANDDa
34118 OPCODE(0xC1A7)
34119 {
34120         u32 adr, res;
34121         u32 src, dst;
34122
34123         src = DREGu32((Opcode >> 9) & 7);
34124         adr = AREG(7) - 4;
34125         AREG(7) = adr;
34126         PRE_IO
34127         READ_LONG_F(adr, res)
34128         res &= src;
34129         flag_C = 0;
34130         flag_V = 0;
34131         flag_NotZ = res;
34132         flag_N = res >> 24;
34133         WRITE_LONG_F(adr, res)
34134         POST_IO
34135 RET(22)
34136 }
34137
34138 // ABCD
34139 OPCODE(0xC100)
34140 {
34141         u32 adr, res;
34142         u32 src, dst;
34143         u32 corf = 0;
34144
34145         src = DREGu8((Opcode >> 0) & 7);
34146         dst = DREGu8((Opcode >> 9) & 7);
34147         res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34148         if (res > 9) corf = 6;
34149         res += (dst & 0xF0) + (src & 0xF0);
34150         flag_V = ~res;
34151         res += corf;
34152         if (res > 0x9F)
34153         {
34154                 res -= 0xA0;
34155                 flag_X = flag_C = M68K_SR_C;
34156         }
34157         else flag_X = flag_C = 0;
34158         flag_V &= res;
34159         flag_NotZ |= res & 0xFF;
34160         flag_N = res;
34161         DREGu8((Opcode >> 9) & 7) = res;
34162 RET(6)
34163 }
34164
34165 // ABCDM
34166 OPCODE(0xC108)
34167 {
34168         u32 adr, res;
34169         u32 src, dst;
34170         u32 corf = 0;
34171
34172         adr = AREG((Opcode >> 0) & 7) - 1;
34173         AREG((Opcode >> 0) & 7) = adr;
34174         PRE_IO
34175         READ_BYTE_F(adr, src)
34176         adr = AREG((Opcode >> 9) & 7) - 1;
34177         AREG((Opcode >> 9) & 7) = adr;
34178         READ_BYTE_F(adr, dst)
34179         res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34180         if (res > 9) corf = 6;
34181         res += (dst & 0xF0) + (src & 0xF0);
34182         flag_V = ~res;
34183         res += corf;
34184         if (res > 0x9F)
34185         {
34186                 res -= 0xA0;
34187                 flag_X = flag_C = M68K_SR_C;
34188         }
34189         else flag_X = flag_C = 0;
34190         flag_V &= res;
34191         flag_NotZ |= res & 0xFF;
34192         flag_N = res;
34193         WRITE_BYTE_F(adr, res)
34194         POST_IO
34195 RET(18)
34196 }
34197
34198 // ABCD7M
34199 OPCODE(0xC10F)
34200 {
34201         u32 adr, res;
34202         u32 src, dst;
34203         u32 corf = 0;
34204
34205         adr = AREG(7) - 2;
34206         AREG(7) = adr;
34207         PRE_IO
34208         READ_BYTE_F(adr, src)
34209         adr = AREG((Opcode >> 9) & 7) - 1;
34210         AREG((Opcode >> 9) & 7) = adr;
34211         READ_BYTE_F(adr, dst)
34212         res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34213         if (res > 9) corf = 6;
34214         res += (dst & 0xF0) + (src & 0xF0);
34215         flag_V = ~res;
34216         res += corf;
34217         if (res > 0x9F)
34218         {
34219                 res -= 0xA0;
34220                 flag_X = flag_C = M68K_SR_C;
34221         }
34222         else flag_X = flag_C = 0;
34223         flag_V &= res;
34224         flag_NotZ |= res & 0xFF;
34225         flag_N = res;
34226         WRITE_BYTE_F(adr, res)
34227         POST_IO
34228 RET(18)
34229 }
34230
34231 // ABCDM7
34232 OPCODE(0xCF08)
34233 {
34234         u32 adr, res;
34235         u32 src, dst;
34236         u32 corf = 0;
34237
34238         adr = AREG((Opcode >> 0) & 7) - 1;
34239         AREG((Opcode >> 0) & 7) = adr;
34240         PRE_IO
34241         READ_BYTE_F(adr, src)
34242         adr = AREG(7) - 2;
34243         AREG(7) = adr;
34244         READ_BYTE_F(adr, dst)
34245         res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34246         if (res > 9) corf = 6;
34247         res += (dst & 0xF0) + (src & 0xF0);
34248         flag_V = ~res;
34249         res += corf;
34250         if (res > 0x9F)
34251         {
34252                 res -= 0xA0;
34253                 flag_X = flag_C = M68K_SR_C;
34254         }
34255         else flag_X = flag_C = 0;
34256         flag_V &= res;
34257         flag_NotZ |= res & 0xFF;
34258         flag_N = res;
34259         WRITE_BYTE_F(adr, res)
34260         POST_IO
34261 RET(18)
34262 }
34263
34264 // ABCD7M7
34265 OPCODE(0xCF0F)
34266 {
34267         u32 adr, res;
34268         u32 src, dst;
34269         u32 corf = 0;
34270
34271         adr = AREG(7) - 2;
34272         AREG(7) = adr;
34273         PRE_IO
34274         READ_BYTE_F(adr, src)
34275         adr = AREG(7) - 2;
34276         AREG(7) = adr;
34277         READ_BYTE_F(adr, dst)
34278         res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34279         if (res > 9) corf = 6;
34280         res += (dst & 0xF0) + (src & 0xF0);
34281         flag_V = ~res;
34282         res += corf;
34283         if (res > 0x9F)
34284         {
34285                 res -= 0xA0;
34286                 flag_X = flag_C = M68K_SR_C;
34287         }
34288         else flag_X = flag_C = 0;
34289         flag_V &= res;
34290         flag_NotZ |= res & 0xFF;
34291         flag_N = res;
34292         WRITE_BYTE_F(adr, res)
34293         POST_IO
34294 RET(18)
34295 }
34296
34297 // MULU
34298 OPCODE(0xC0C0)
34299 {
34300         u32 adr, res;
34301         u32 src, dst;
34302
34303         src = DREGu16((Opcode >> 0) & 7);
34304         res = DREGu16((Opcode >> 9) & 7);
34305         res *= src;
34306         flag_N = res >> 24;
34307         flag_NotZ = res;
34308         flag_V = flag_C = 0;
34309         DREGu32((Opcode >> 9) & 7) = res;
34310 #ifdef USE_CYCLONE_TIMING
34311 RET(54)
34312 #else
34313 RET(50)
34314 #endif
34315 }
34316
34317 // MULU
34318 OPCODE(0xC0D0)
34319 {
34320         u32 adr, res;
34321         u32 src, dst;
34322
34323         adr = AREG((Opcode >> 0) & 7);
34324         PRE_IO
34325         READ_WORD_F(adr, src)
34326         res = DREGu16((Opcode >> 9) & 7);
34327         res *= src;
34328         flag_N = res >> 24;
34329         flag_NotZ = res;
34330         flag_V = flag_C = 0;
34331         DREGu32((Opcode >> 9) & 7) = res;
34332         POST_IO
34333 #ifdef USE_CYCLONE_TIMING
34334 RET(58)
34335 #else
34336 RET(54)
34337 #endif
34338 }
34339
34340 // MULU
34341 OPCODE(0xC0D8)
34342 {
34343         u32 adr, res;
34344         u32 src, dst;
34345
34346         adr = AREG((Opcode >> 0) & 7);
34347         AREG((Opcode >> 0) & 7) += 2;
34348         PRE_IO
34349         READ_WORD_F(adr, src)
34350         res = DREGu16((Opcode >> 9) & 7);
34351         res *= src;
34352         flag_N = res >> 24;
34353         flag_NotZ = res;
34354         flag_V = flag_C = 0;
34355         DREGu32((Opcode >> 9) & 7) = res;
34356         POST_IO
34357 #ifdef USE_CYCLONE_TIMING
34358 RET(58)
34359 #else
34360 RET(54)
34361 #endif
34362 }
34363
34364 // MULU
34365 OPCODE(0xC0E0)
34366 {
34367         u32 adr, res;
34368         u32 src, dst;
34369
34370         adr = AREG((Opcode >> 0) & 7) - 2;
34371         AREG((Opcode >> 0) & 7) = adr;
34372         PRE_IO
34373         READ_WORD_F(adr, src)
34374         res = DREGu16((Opcode >> 9) & 7);
34375         res *= src;
34376         flag_N = res >> 24;
34377         flag_NotZ = res;
34378         flag_V = flag_C = 0;
34379         DREGu32((Opcode >> 9) & 7) = res;
34380         POST_IO
34381 #ifdef USE_CYCLONE_TIMING
34382 RET(60)
34383 #else
34384 RET(56)
34385 #endif
34386 }
34387
34388 // MULU
34389 OPCODE(0xC0E8)
34390 {
34391         u32 adr, res;
34392         u32 src, dst;
34393
34394         FETCH_SWORD(adr);
34395         adr += AREG((Opcode >> 0) & 7);
34396         PRE_IO
34397         READ_WORD_F(adr, src)
34398         res = DREGu16((Opcode >> 9) & 7);
34399         res *= src;
34400         flag_N = res >> 24;
34401         flag_NotZ = res;
34402         flag_V = flag_C = 0;
34403         DREGu32((Opcode >> 9) & 7) = res;
34404         POST_IO
34405 #ifdef USE_CYCLONE_TIMING
34406 RET(62)
34407 #else
34408 RET(58)
34409 #endif
34410 }
34411
34412 // MULU
34413 OPCODE(0xC0F0)
34414 {
34415         u32 adr, res;
34416         u32 src, dst;
34417
34418         adr = AREG((Opcode >> 0) & 7);
34419         DECODE_EXT_WORD
34420         PRE_IO
34421         READ_WORD_F(adr, src)
34422         res = DREGu16((Opcode >> 9) & 7);
34423         res *= src;
34424         flag_N = res >> 24;
34425         flag_NotZ = res;
34426         flag_V = flag_C = 0;
34427         DREGu32((Opcode >> 9) & 7) = res;
34428         POST_IO
34429 #ifdef USE_CYCLONE_TIMING
34430 RET(64)
34431 #else
34432 RET(60)
34433 #endif
34434 }
34435
34436 // MULU
34437 OPCODE(0xC0F8)
34438 {
34439         u32 adr, res;
34440         u32 src, dst;
34441
34442         FETCH_SWORD(adr);
34443         PRE_IO
34444         READ_WORD_F(adr, src)
34445         res = DREGu16((Opcode >> 9) & 7);
34446         res *= src;
34447         flag_N = res >> 24;
34448         flag_NotZ = res;
34449         flag_V = flag_C = 0;
34450         DREGu32((Opcode >> 9) & 7) = res;
34451         POST_IO
34452 #ifdef USE_CYCLONE_TIMING
34453 RET(62)
34454 #else
34455 RET(58)
34456 #endif
34457 }
34458
34459 // MULU
34460 OPCODE(0xC0F9)
34461 {
34462         u32 adr, res;
34463         u32 src, dst;
34464
34465         FETCH_LONG(adr);
34466         PRE_IO
34467         READ_WORD_F(adr, src)
34468         res = DREGu16((Opcode >> 9) & 7);
34469         res *= src;
34470         flag_N = res >> 24;
34471         flag_NotZ = res;
34472         flag_V = flag_C = 0;
34473         DREGu32((Opcode >> 9) & 7) = res;
34474         POST_IO
34475 #ifdef USE_CYCLONE_TIMING
34476 RET(66)
34477 #else
34478 RET(62)
34479 #endif
34480 }
34481
34482 // MULU
34483 OPCODE(0xC0FA)
34484 {
34485         u32 adr, res;
34486         u32 src, dst;
34487
34488         adr = GET_SWORD + GET_PC;
34489         PC++;
34490         PRE_IO
34491         READ_WORD_F(adr, src)
34492         res = DREGu16((Opcode >> 9) & 7);
34493         res *= src;
34494         flag_N = res >> 24;
34495         flag_NotZ = res;
34496         flag_V = flag_C = 0;
34497         DREGu32((Opcode >> 9) & 7) = res;
34498         POST_IO
34499 #ifdef USE_CYCLONE_TIMING
34500 RET(62)
34501 #else
34502 RET(58)
34503 #endif
34504 }
34505
34506 // MULU
34507 OPCODE(0xC0FB)
34508 {
34509         u32 adr, res;
34510         u32 src, dst;
34511
34512         adr = GET_PC;
34513         DECODE_EXT_WORD
34514         PRE_IO
34515         READ_WORD_F(adr, src)
34516         res = DREGu16((Opcode >> 9) & 7);
34517         res *= src;
34518         flag_N = res >> 24;
34519         flag_NotZ = res;
34520         flag_V = flag_C = 0;
34521         DREGu32((Opcode >> 9) & 7) = res;
34522         POST_IO
34523 #ifdef USE_CYCLONE_TIMING
34524 RET(64)
34525 #else
34526 RET(60)
34527 #endif
34528 }
34529
34530 // MULU
34531 OPCODE(0xC0FC)
34532 {
34533         u32 adr, res;
34534         u32 src, dst;
34535
34536         FETCH_WORD(src);
34537         res = DREGu16((Opcode >> 9) & 7);
34538         res *= src;
34539         flag_N = res >> 24;
34540         flag_NotZ = res;
34541         flag_V = flag_C = 0;
34542         DREGu32((Opcode >> 9) & 7) = res;
34543 #ifdef USE_CYCLONE_TIMING
34544 RET(58)
34545 #else
34546 RET(54)
34547 #endif
34548 }
34549
34550 // MULU
34551 OPCODE(0xC0DF)
34552 {
34553         u32 adr, res;
34554         u32 src, dst;
34555
34556         adr = AREG(7);
34557         AREG(7) += 2;
34558         PRE_IO
34559         READ_WORD_F(adr, src)
34560         res = DREGu16((Opcode >> 9) & 7);
34561         res *= src;
34562         flag_N = res >> 24;
34563         flag_NotZ = res;
34564         flag_V = flag_C = 0;
34565         DREGu32((Opcode >> 9) & 7) = res;
34566         POST_IO
34567 #ifdef USE_CYCLONE_TIMING
34568 RET(58)
34569 #else
34570 RET(54)
34571 #endif
34572 }
34573
34574 // MULU
34575 OPCODE(0xC0E7)
34576 {
34577         u32 adr, res;
34578         u32 src, dst;
34579
34580         adr = AREG(7) - 2;
34581         AREG(7) = adr;
34582         PRE_IO
34583         READ_WORD_F(adr, src)
34584         res = DREGu16((Opcode >> 9) & 7);
34585         res *= src;
34586         flag_N = res >> 24;
34587         flag_NotZ = res;
34588         flag_V = flag_C = 0;
34589         DREGu32((Opcode >> 9) & 7) = res;
34590         POST_IO
34591 #ifdef USE_CYCLONE_TIMING
34592 RET(60)
34593 #else
34594 RET(56)
34595 #endif
34596 }
34597
34598 // MULS
34599 OPCODE(0xC1C0)
34600 {
34601         u32 adr, res;
34602         u32 src, dst;
34603
34604         src = (s32)DREGs16((Opcode >> 0) & 7);
34605         res = (s32)DREGs16((Opcode >> 9) & 7);
34606         res = ((s32)res) * ((s32)src);
34607         flag_N = res >> 24;
34608         flag_NotZ = res;
34609         flag_V = flag_C = 0;
34610         DREGu32((Opcode >> 9) & 7) = res;
34611 #ifdef USE_CYCLONE_TIMING
34612 RET(54)
34613 #else
34614 RET(50)
34615 #endif
34616 }
34617
34618 // MULS
34619 OPCODE(0xC1D0)
34620 {
34621         u32 adr, res;
34622         u32 src, dst;
34623
34624         adr = AREG((Opcode >> 0) & 7);
34625         PRE_IO
34626         READSX_WORD_F(adr, src)
34627         res = (s32)DREGs16((Opcode >> 9) & 7);
34628         res = ((s32)res) * ((s32)src);
34629         flag_N = res >> 24;
34630         flag_NotZ = res;
34631         flag_V = flag_C = 0;
34632         DREGu32((Opcode >> 9) & 7) = res;
34633         POST_IO
34634 #ifdef USE_CYCLONE_TIMING
34635 RET(58)
34636 #else
34637 RET(54)
34638 #endif
34639 }
34640
34641 // MULS
34642 OPCODE(0xC1D8)
34643 {
34644         u32 adr, res;
34645         u32 src, dst;
34646
34647         adr = AREG((Opcode >> 0) & 7);
34648         AREG((Opcode >> 0) & 7) += 2;
34649         PRE_IO
34650         READSX_WORD_F(adr, src)
34651         res = (s32)DREGs16((Opcode >> 9) & 7);
34652         res = ((s32)res) * ((s32)src);
34653         flag_N = res >> 24;
34654         flag_NotZ = res;
34655         flag_V = flag_C = 0;
34656         DREGu32((Opcode >> 9) & 7) = res;
34657         POST_IO
34658 #ifdef USE_CYCLONE_TIMING
34659 RET(58)
34660 #else
34661 RET(54)
34662 #endif
34663 }
34664
34665 // MULS
34666 OPCODE(0xC1E0)
34667 {
34668         u32 adr, res;
34669         u32 src, dst;
34670
34671         adr = AREG((Opcode >> 0) & 7) - 2;
34672         AREG((Opcode >> 0) & 7) = adr;
34673         PRE_IO
34674         READSX_WORD_F(adr, src)
34675         res = (s32)DREGs16((Opcode >> 9) & 7);
34676         res = ((s32)res) * ((s32)src);
34677         flag_N = res >> 24;
34678         flag_NotZ = res;
34679         flag_V = flag_C = 0;
34680         DREGu32((Opcode >> 9) & 7) = res;
34681         POST_IO
34682 #ifdef USE_CYCLONE_TIMING
34683 RET(60)
34684 #else
34685 RET(56)
34686 #endif
34687 }
34688
34689 // MULS
34690 OPCODE(0xC1E8)
34691 {
34692         u32 adr, res;
34693         u32 src, dst;
34694
34695         FETCH_SWORD(adr);
34696         adr += AREG((Opcode >> 0) & 7);
34697         PRE_IO
34698         READSX_WORD_F(adr, src)
34699         res = (s32)DREGs16((Opcode >> 9) & 7);
34700         res = ((s32)res) * ((s32)src);
34701         flag_N = res >> 24;
34702         flag_NotZ = res;
34703         flag_V = flag_C = 0;
34704         DREGu32((Opcode >> 9) & 7) = res;
34705         POST_IO
34706 #ifdef USE_CYCLONE_TIMING
34707 RET(62)
34708 #else
34709 RET(58)
34710 #endif
34711 }
34712
34713 // MULS
34714 OPCODE(0xC1F0)
34715 {
34716         u32 adr, res;
34717         u32 src, dst;
34718
34719         adr = AREG((Opcode >> 0) & 7);
34720         DECODE_EXT_WORD
34721         PRE_IO
34722         READSX_WORD_F(adr, src)
34723         res = (s32)DREGs16((Opcode >> 9) & 7);
34724         res = ((s32)res) * ((s32)src);
34725         flag_N = res >> 24;
34726         flag_NotZ = res;
34727         flag_V = flag_C = 0;
34728         DREGu32((Opcode >> 9) & 7) = res;
34729         POST_IO
34730 #ifdef USE_CYCLONE_TIMING
34731 RET(64)
34732 #else
34733 RET(60)
34734 #endif
34735 }
34736
34737 // MULS
34738 OPCODE(0xC1F8)
34739 {
34740         u32 adr, res;
34741         u32 src, dst;
34742
34743         FETCH_SWORD(adr);
34744         PRE_IO
34745         READSX_WORD_F(adr, src)
34746         res = (s32)DREGs16((Opcode >> 9) & 7);
34747         res = ((s32)res) * ((s32)src);
34748         flag_N = res >> 24;
34749         flag_NotZ = res;
34750         flag_V = flag_C = 0;
34751         DREGu32((Opcode >> 9) & 7) = res;
34752         POST_IO
34753 #ifdef USE_CYCLONE_TIMING
34754 RET(62)
34755 #else
34756 RET(58)
34757 #endif
34758 }
34759
34760 // MULS
34761 OPCODE(0xC1F9)
34762 {
34763         u32 adr, res;
34764         u32 src, dst;
34765
34766         FETCH_LONG(adr);
34767         PRE_IO
34768         READSX_WORD_F(adr, src)
34769         res = (s32)DREGs16((Opcode >> 9) & 7);
34770         res = ((s32)res) * ((s32)src);
34771         flag_N = res >> 24;
34772         flag_NotZ = res;
34773         flag_V = flag_C = 0;
34774         DREGu32((Opcode >> 9) & 7) = res;
34775         POST_IO
34776 #ifdef USE_CYCLONE_TIMING
34777 RET(66)
34778 #else
34779 RET(62)
34780 #endif
34781 }
34782
34783 // MULS
34784 OPCODE(0xC1FA)
34785 {
34786         u32 adr, res;
34787         u32 src, dst;
34788
34789         adr = GET_SWORD + GET_PC;
34790         PC++;
34791         PRE_IO
34792         READSX_WORD_F(adr, src)
34793         res = (s32)DREGs16((Opcode >> 9) & 7);
34794         res = ((s32)res) * ((s32)src);
34795         flag_N = res >> 24;
34796         flag_NotZ = res;
34797         flag_V = flag_C = 0;
34798         DREGu32((Opcode >> 9) & 7) = res;
34799         POST_IO
34800 #ifdef USE_CYCLONE_TIMING
34801 RET(62)
34802 #else
34803 RET(58)
34804 #endif
34805 }
34806
34807 // MULS
34808 OPCODE(0xC1FB)
34809 {
34810         u32 adr, res;
34811         u32 src, dst;
34812
34813         adr = GET_PC;
34814         DECODE_EXT_WORD
34815         PRE_IO
34816         READSX_WORD_F(adr, src)
34817         res = (s32)DREGs16((Opcode >> 9) & 7);
34818         res = ((s32)res) * ((s32)src);
34819         flag_N = res >> 24;
34820         flag_NotZ = res;
34821         flag_V = flag_C = 0;
34822         DREGu32((Opcode >> 9) & 7) = res;
34823         POST_IO
34824 #ifdef USE_CYCLONE_TIMING
34825 RET(64)
34826 #else
34827 RET(60)
34828 #endif
34829 }
34830
34831 // MULS
34832 OPCODE(0xC1FC)
34833 {
34834         u32 adr, res;
34835         u32 src, dst;
34836
34837         FETCH_SWORD(src);
34838         res = (s32)DREGs16((Opcode >> 9) & 7);
34839         res = ((s32)res) * ((s32)src);
34840         flag_N = res >> 24;
34841         flag_NotZ = res;
34842         flag_V = flag_C = 0;
34843         DREGu32((Opcode >> 9) & 7) = res;
34844 #ifdef USE_CYCLONE_TIMING
34845 RET(58)
34846 #else
34847 RET(54)
34848 #endif
34849 }
34850
34851 // MULS
34852 OPCODE(0xC1DF)
34853 {
34854         u32 adr, res;
34855         u32 src, dst;
34856
34857         adr = AREG(7);
34858         AREG(7) += 2;
34859         PRE_IO
34860         READSX_WORD_F(adr, src)
34861         res = (s32)DREGs16((Opcode >> 9) & 7);
34862         res = ((s32)res) * ((s32)src);
34863         flag_N = res >> 24;
34864         flag_NotZ = res;
34865         flag_V = flag_C = 0;
34866         DREGu32((Opcode >> 9) & 7) = res;
34867         POST_IO
34868 #ifdef USE_CYCLONE_TIMING
34869 RET(58)
34870 #else
34871 RET(54)
34872 #endif
34873 }
34874
34875 // MULS
34876 OPCODE(0xC1E7)
34877 {
34878         u32 adr, res;
34879         u32 src, dst;
34880
34881         adr = AREG(7) - 2;
34882         AREG(7) = adr;
34883         PRE_IO
34884         READSX_WORD_F(adr, src)
34885         res = (s32)DREGs16((Opcode >> 9) & 7);
34886         res = ((s32)res) * ((s32)src);
34887         flag_N = res >> 24;
34888         flag_NotZ = res;
34889         flag_V = flag_C = 0;
34890         DREGu32((Opcode >> 9) & 7) = res;
34891         POST_IO
34892 #ifdef USE_CYCLONE_TIMING
34893 RET(60)
34894 #else
34895 RET(56)
34896 #endif
34897 }
34898
34899 // EXGDD
34900 OPCODE(0xC140)
34901 {
34902         u32 adr, res;
34903         u32 src, dst;
34904
34905         res = DREGu32((Opcode >> 0) & 7);
34906         src = DREGu32((Opcode >> 9) & 7);
34907         DREGu32((Opcode >> 9) & 7) = res;
34908         res = src;
34909         DREGu32((Opcode >> 0) & 7) = res;
34910 RET(6)
34911 }
34912
34913 // EXGAA
34914 OPCODE(0xC148)
34915 {
34916         u32 adr, res;
34917         u32 src, dst;
34918
34919         res = AREGu32((Opcode >> 0) & 7);
34920         src = AREGu32((Opcode >> 9) & 7);
34921         AREG((Opcode >> 9) & 7) = res;
34922         res = src;
34923         AREG((Opcode >> 0) & 7) = res;
34924 RET(6)
34925 }
34926
34927 // EXGAD
34928 OPCODE(0xC188)
34929 {
34930         u32 adr, res;
34931         u32 src, dst;
34932
34933         res = AREGu32((Opcode >> 0) & 7);
34934         src = DREGu32((Opcode >> 9) & 7);
34935         DREGu32((Opcode >> 9) & 7) = res;
34936         res = src;
34937         AREG((Opcode >> 0) & 7) = res;
34938 RET(6)
34939 }
34940
34941 // ADDaD
34942 OPCODE(0xD000)
34943 {
34944         u32 adr, res;
34945         u32 src, dst;
34946
34947         src = DREGu8((Opcode >> 0) & 7);
34948         dst = DREGu8((Opcode >> 9) & 7);
34949         res = dst + src;
34950         flag_N = flag_X = flag_C = res;
34951         flag_V = (src ^ res) & (dst ^ res);
34952         flag_NotZ = res & 0xFF;
34953         DREGu8((Opcode >> 9) & 7) = res;
34954 RET(4)
34955 }
34956
34957 // ADDaD
34958 #if 0
34959 OPCODE(0xD008)
34960 {
34961         u32 adr, res;
34962         u32 src, dst;
34963
34964         // can't read byte from Ax registers !
34965         m68kcontext.execinfo |= M68K_FAULTED;
34966         m68kcontext.io_cycle_counter = 0;
34967 /*
34968         goto famec_Exec_End;
34969         dst = DREGu8((Opcode >> 9) & 7);
34970         res = dst + src;
34971         flag_N = flag_X = flag_C = res;
34972         flag_V = (src ^ res) & (dst ^ res);
34973         flag_NotZ = res & 0xFF;
34974         DREGu8((Opcode >> 9) & 7) = res;
34975 */
34976 RET(4)
34977 }
34978 #endif
34979
34980 // ADDaD
34981 OPCODE(0xD010)
34982 {
34983         u32 adr, res;
34984         u32 src, dst;
34985
34986         adr = AREG((Opcode >> 0) & 7);
34987         PRE_IO
34988         READ_BYTE_F(adr, src)
34989         dst = DREGu8((Opcode >> 9) & 7);
34990         res = dst + src;
34991         flag_N = flag_X = flag_C = res;
34992         flag_V = (src ^ res) & (dst ^ res);
34993         flag_NotZ = res & 0xFF;
34994         DREGu8((Opcode >> 9) & 7) = res;
34995         POST_IO
34996 RET(8)
34997 }
34998
34999 // ADDaD
35000 OPCODE(0xD018)
35001 {
35002         u32 adr, res;
35003         u32 src, dst;
35004
35005         adr = AREG((Opcode >> 0) & 7);
35006         AREG((Opcode >> 0) & 7) += 1;
35007         PRE_IO
35008         READ_BYTE_F(adr, src)
35009         dst = DREGu8((Opcode >> 9) & 7);
35010         res = dst + src;
35011         flag_N = flag_X = flag_C = res;
35012         flag_V = (src ^ res) & (dst ^ res);
35013         flag_NotZ = res & 0xFF;
35014         DREGu8((Opcode >> 9) & 7) = res;
35015         POST_IO
35016 RET(8)
35017 }
35018
35019 // ADDaD
35020 OPCODE(0xD020)
35021 {
35022         u32 adr, res;
35023         u32 src, dst;
35024
35025         adr = AREG((Opcode >> 0) & 7) - 1;
35026         AREG((Opcode >> 0) & 7) = adr;
35027         PRE_IO
35028         READ_BYTE_F(adr, src)
35029         dst = DREGu8((Opcode >> 9) & 7);
35030         res = dst + src;
35031         flag_N = flag_X = flag_C = res;
35032         flag_V = (src ^ res) & (dst ^ res);
35033         flag_NotZ = res & 0xFF;
35034         DREGu8((Opcode >> 9) & 7) = res;
35035         POST_IO
35036 RET(10)
35037 }
35038
35039 // ADDaD
35040 OPCODE(0xD028)
35041 {
35042         u32 adr, res;
35043         u32 src, dst;
35044
35045         FETCH_SWORD(adr);
35046         adr += AREG((Opcode >> 0) & 7);
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(0xD030)
35061 {
35062         u32 adr, res;
35063         u32 src, dst;
35064
35065         adr = AREG((Opcode >> 0) & 7);
35066         DECODE_EXT_WORD
35067         PRE_IO
35068         READ_BYTE_F(adr, src)
35069         dst = DREGu8((Opcode >> 9) & 7);
35070         res = dst + src;
35071         flag_N = flag_X = flag_C = res;
35072         flag_V = (src ^ res) & (dst ^ res);
35073         flag_NotZ = res & 0xFF;
35074         DREGu8((Opcode >> 9) & 7) = res;
35075         POST_IO
35076 RET(14)
35077 }
35078
35079 // ADDaD
35080 OPCODE(0xD038)
35081 {
35082         u32 adr, res;
35083         u32 src, dst;
35084
35085         FETCH_SWORD(adr);
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(0xD039)
35100 {
35101         u32 adr, res;
35102         u32 src, dst;
35103
35104         FETCH_LONG(adr);
35105         PRE_IO
35106         READ_BYTE_F(adr, src)
35107         dst = DREGu8((Opcode >> 9) & 7);
35108         res = dst + src;
35109         flag_N = flag_X = flag_C = res;
35110         flag_V = (src ^ res) & (dst ^ res);
35111         flag_NotZ = res & 0xFF;
35112         DREGu8((Opcode >> 9) & 7) = res;
35113         POST_IO
35114 RET(16)
35115 }
35116
35117 // ADDaD
35118 OPCODE(0xD03A)
35119 {
35120         u32 adr, res;
35121         u32 src, dst;
35122
35123         adr = GET_SWORD + GET_PC;
35124         PC++;
35125         PRE_IO
35126         READ_BYTE_F(adr, src)
35127         dst = DREGu8((Opcode >> 9) & 7);
35128         res = dst + src;
35129         flag_N = flag_X = flag_C = res;
35130         flag_V = (src ^ res) & (dst ^ res);
35131         flag_NotZ = res & 0xFF;
35132         DREGu8((Opcode >> 9) & 7) = res;
35133         POST_IO
35134 RET(12)
35135 }
35136
35137 // ADDaD
35138 OPCODE(0xD03B)
35139 {
35140         u32 adr, res;
35141         u32 src, dst;
35142
35143         adr = GET_PC;
35144         DECODE_EXT_WORD
35145         PRE_IO
35146         READ_BYTE_F(adr, src)
35147         dst = DREGu8((Opcode >> 9) & 7);
35148         res = dst + src;
35149         flag_N = flag_X = flag_C = res;
35150         flag_V = (src ^ res) & (dst ^ res);
35151         flag_NotZ = res & 0xFF;
35152         DREGu8((Opcode >> 9) & 7) = res;
35153         POST_IO
35154 RET(14)
35155 }
35156
35157 // ADDaD
35158 OPCODE(0xD03C)
35159 {
35160         u32 adr, res;
35161         u32 src, dst;
35162
35163         FETCH_BYTE(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 RET(8)
35171 }
35172
35173 // ADDaD
35174 OPCODE(0xD01F)
35175 {
35176         u32 adr, res;
35177         u32 src, dst;
35178
35179         adr = AREG(7);
35180         AREG(7) += 2;
35181         PRE_IO
35182         READ_BYTE_F(adr, src)
35183         dst = DREGu8((Opcode >> 9) & 7);
35184         res = dst + src;
35185         flag_N = flag_X = flag_C = res;
35186         flag_V = (src ^ res) & (dst ^ res);
35187         flag_NotZ = res & 0xFF;
35188         DREGu8((Opcode >> 9) & 7) = res;
35189         POST_IO
35190 RET(8)
35191 }
35192
35193 // ADDaD
35194 OPCODE(0xD027)
35195 {
35196         u32 adr, res;
35197         u32 src, dst;
35198
35199         adr = AREG(7) - 2;
35200         AREG(7) = adr;
35201         PRE_IO
35202         READ_BYTE_F(adr, src)
35203         dst = DREGu8((Opcode >> 9) & 7);
35204         res = dst + src;
35205         flag_N = flag_X = flag_C = res;
35206         flag_V = (src ^ res) & (dst ^ res);
35207         flag_NotZ = res & 0xFF;
35208         DREGu8((Opcode >> 9) & 7) = res;
35209         POST_IO
35210 RET(10)
35211 }
35212
35213 // ADDaD
35214 OPCODE(0xD040)
35215 {
35216         u32 adr, res;
35217         u32 src, dst;
35218
35219         src = DREGu16((Opcode >> 0) & 7);
35220         dst = DREGu16((Opcode >> 9) & 7);
35221         res = dst + src;
35222         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35223         flag_N = flag_X = flag_C = res >> 8;
35224         flag_NotZ = res & 0xFFFF;
35225         DREGu16((Opcode >> 9) & 7) = res;
35226 RET(4)
35227 }
35228
35229 // ADDaD
35230 OPCODE(0xD048)
35231 {
35232         u32 adr, res;
35233         u32 src, dst;
35234
35235         src = AREGu16((Opcode >> 0) & 7);
35236         dst = DREGu16((Opcode >> 9) & 7);
35237         res = dst + src;
35238         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35239         flag_N = flag_X = flag_C = res >> 8;
35240         flag_NotZ = res & 0xFFFF;
35241         DREGu16((Opcode >> 9) & 7) = res;
35242 RET(4)
35243 }
35244
35245 // ADDaD
35246 OPCODE(0xD050)
35247 {
35248         u32 adr, res;
35249         u32 src, dst;
35250
35251         adr = AREG((Opcode >> 0) & 7);
35252         PRE_IO
35253         READ_WORD_F(adr, src)
35254         dst = DREGu16((Opcode >> 9) & 7);
35255         res = dst + src;
35256         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35257         flag_N = flag_X = flag_C = res >> 8;
35258         flag_NotZ = res & 0xFFFF;
35259         DREGu16((Opcode >> 9) & 7) = res;
35260         POST_IO
35261 RET(8)
35262 }
35263
35264 // ADDaD
35265 OPCODE(0xD058)
35266 {
35267         u32 adr, res;
35268         u32 src, dst;
35269
35270         adr = AREG((Opcode >> 0) & 7);
35271         AREG((Opcode >> 0) & 7) += 2;
35272         PRE_IO
35273         READ_WORD_F(adr, src)
35274         dst = DREGu16((Opcode >> 9) & 7);
35275         res = dst + src;
35276         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35277         flag_N = flag_X = flag_C = res >> 8;
35278         flag_NotZ = res & 0xFFFF;
35279         DREGu16((Opcode >> 9) & 7) = res;
35280         POST_IO
35281 RET(8)
35282 }
35283
35284 // ADDaD
35285 OPCODE(0xD060)
35286 {
35287         u32 adr, res;
35288         u32 src, dst;
35289
35290         adr = AREG((Opcode >> 0) & 7) - 2;
35291         AREG((Opcode >> 0) & 7) = adr;
35292         PRE_IO
35293         READ_WORD_F(adr, src)
35294         dst = DREGu16((Opcode >> 9) & 7);
35295         res = dst + src;
35296         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35297         flag_N = flag_X = flag_C = res >> 8;
35298         flag_NotZ = res & 0xFFFF;
35299         DREGu16((Opcode >> 9) & 7) = res;
35300         POST_IO
35301 RET(10)
35302 }
35303
35304 // ADDaD
35305 OPCODE(0xD068)
35306 {
35307         u32 adr, res;
35308         u32 src, dst;
35309
35310         FETCH_SWORD(adr);
35311         adr += AREG((Opcode >> 0) & 7);
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(0xD070)
35326 {
35327         u32 adr, res;
35328         u32 src, dst;
35329
35330         adr = AREG((Opcode >> 0) & 7);
35331         DECODE_EXT_WORD
35332         PRE_IO
35333         READ_WORD_F(adr, src)
35334         dst = DREGu16((Opcode >> 9) & 7);
35335         res = dst + src;
35336         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35337         flag_N = flag_X = flag_C = res >> 8;
35338         flag_NotZ = res & 0xFFFF;
35339         DREGu16((Opcode >> 9) & 7) = res;
35340         POST_IO
35341 RET(14)
35342 }
35343
35344 // ADDaD
35345 OPCODE(0xD078)
35346 {
35347         u32 adr, res;
35348         u32 src, dst;
35349
35350         FETCH_SWORD(adr);
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(0xD079)
35365 {
35366         u32 adr, res;
35367         u32 src, dst;
35368
35369         FETCH_LONG(adr);
35370         PRE_IO
35371         READ_WORD_F(adr, src)
35372         dst = DREGu16((Opcode >> 9) & 7);
35373         res = dst + src;
35374         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35375         flag_N = flag_X = flag_C = res >> 8;
35376         flag_NotZ = res & 0xFFFF;
35377         DREGu16((Opcode >> 9) & 7) = res;
35378         POST_IO
35379 RET(16)
35380 }
35381
35382 // ADDaD
35383 OPCODE(0xD07A)
35384 {
35385         u32 adr, res;
35386         u32 src, dst;
35387
35388         adr = GET_SWORD + GET_PC;
35389         PC++;
35390         PRE_IO
35391         READ_WORD_F(adr, src)
35392         dst = DREGu16((Opcode >> 9) & 7);
35393         res = dst + src;
35394         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35395         flag_N = flag_X = flag_C = res >> 8;
35396         flag_NotZ = res & 0xFFFF;
35397         DREGu16((Opcode >> 9) & 7) = res;
35398         POST_IO
35399 RET(12)
35400 }
35401
35402 // ADDaD
35403 OPCODE(0xD07B)
35404 {
35405         u32 adr, res;
35406         u32 src, dst;
35407
35408         adr = GET_PC;
35409         DECODE_EXT_WORD
35410         PRE_IO
35411         READ_WORD_F(adr, src)
35412         dst = DREGu16((Opcode >> 9) & 7);
35413         res = dst + src;
35414         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35415         flag_N = flag_X = flag_C = res >> 8;
35416         flag_NotZ = res & 0xFFFF;
35417         DREGu16((Opcode >> 9) & 7) = res;
35418         POST_IO
35419 RET(14)
35420 }
35421
35422 // ADDaD
35423 OPCODE(0xD07C)
35424 {
35425         u32 adr, res;
35426         u32 src, dst;
35427
35428         FETCH_WORD(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 RET(8)
35436 }
35437
35438 // ADDaD
35439 OPCODE(0xD05F)
35440 {
35441         u32 adr, res;
35442         u32 src, dst;
35443
35444         adr = AREG(7);
35445         AREG(7) += 2;
35446         PRE_IO
35447         READ_WORD_F(adr, src)
35448         dst = DREGu16((Opcode >> 9) & 7);
35449         res = dst + src;
35450         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35451         flag_N = flag_X = flag_C = res >> 8;
35452         flag_NotZ = res & 0xFFFF;
35453         DREGu16((Opcode >> 9) & 7) = res;
35454         POST_IO
35455 RET(8)
35456 }
35457
35458 // ADDaD
35459 OPCODE(0xD067)
35460 {
35461         u32 adr, res;
35462         u32 src, dst;
35463
35464         adr = AREG(7) - 2;
35465         AREG(7) = adr;
35466         PRE_IO
35467         READ_WORD_F(adr, src)
35468         dst = DREGu16((Opcode >> 9) & 7);
35469         res = dst + src;
35470         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35471         flag_N = flag_X = flag_C = res >> 8;
35472         flag_NotZ = res & 0xFFFF;
35473         DREGu16((Opcode >> 9) & 7) = res;
35474         POST_IO
35475 RET(10)
35476 }
35477
35478 // ADDaD
35479 OPCODE(0xD080)
35480 {
35481         u32 adr, res;
35482         u32 src, dst;
35483
35484         src = DREGu32((Opcode >> 0) & 7);
35485         dst = DREGu32((Opcode >> 9) & 7);
35486         res = dst + src;
35487         flag_NotZ = res;
35488         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35489         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35490         flag_N = res >> 24;
35491         DREGu32((Opcode >> 9) & 7) = res;
35492 RET(8)
35493 }
35494
35495 // ADDaD
35496 OPCODE(0xD088)
35497 {
35498         u32 adr, res;
35499         u32 src, dst;
35500
35501         src = AREGu32((Opcode >> 0) & 7);
35502         dst = DREGu32((Opcode >> 9) & 7);
35503         res = dst + src;
35504         flag_NotZ = res;
35505         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35506         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35507         flag_N = res >> 24;
35508         DREGu32((Opcode >> 9) & 7) = res;
35509 RET(8)
35510 }
35511
35512 // ADDaD
35513 OPCODE(0xD090)
35514 {
35515         u32 adr, res;
35516         u32 src, dst;
35517
35518         adr = AREG((Opcode >> 0) & 7);
35519         PRE_IO
35520         READ_LONG_F(adr, src)
35521         dst = DREGu32((Opcode >> 9) & 7);
35522         res = dst + src;
35523         flag_NotZ = res;
35524         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35525         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35526         flag_N = res >> 24;
35527         DREGu32((Opcode >> 9) & 7) = res;
35528         POST_IO
35529 RET(14)
35530 }
35531
35532 // ADDaD
35533 OPCODE(0xD098)
35534 {
35535         u32 adr, res;
35536         u32 src, dst;
35537
35538         adr = AREG((Opcode >> 0) & 7);
35539         AREG((Opcode >> 0) & 7) += 4;
35540         PRE_IO
35541         READ_LONG_F(adr, src)
35542         dst = DREGu32((Opcode >> 9) & 7);
35543         res = dst + src;
35544         flag_NotZ = res;
35545         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35546         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35547         flag_N = res >> 24;
35548         DREGu32((Opcode >> 9) & 7) = res;
35549         POST_IO
35550 RET(14)
35551 }
35552
35553 // ADDaD
35554 OPCODE(0xD0A0)
35555 {
35556         u32 adr, res;
35557         u32 src, dst;
35558
35559         adr = AREG((Opcode >> 0) & 7) - 4;
35560         AREG((Opcode >> 0) & 7) = adr;
35561         PRE_IO
35562         READ_LONG_F(adr, src)
35563         dst = DREGu32((Opcode >> 9) & 7);
35564         res = dst + src;
35565         flag_NotZ = res;
35566         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35567         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35568         flag_N = res >> 24;
35569         DREGu32((Opcode >> 9) & 7) = res;
35570         POST_IO
35571 RET(16)
35572 }
35573
35574 // ADDaD
35575 OPCODE(0xD0A8)
35576 {
35577         u32 adr, res;
35578         u32 src, dst;
35579
35580         FETCH_SWORD(adr);
35581         adr += AREG((Opcode >> 0) & 7);
35582         PRE_IO
35583         READ_LONG_F(adr, src)
35584         dst = DREGu32((Opcode >> 9) & 7);
35585         res = dst + src;
35586         flag_NotZ = res;
35587         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35588         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35589         flag_N = res >> 24;
35590         DREGu32((Opcode >> 9) & 7) = res;
35591         POST_IO
35592 RET(18)
35593 }
35594
35595 // ADDaD
35596 OPCODE(0xD0B0)
35597 {
35598         u32 adr, res;
35599         u32 src, dst;
35600
35601         adr = AREG((Opcode >> 0) & 7);
35602         DECODE_EXT_WORD
35603         PRE_IO
35604         READ_LONG_F(adr, src)
35605         dst = DREGu32((Opcode >> 9) & 7);
35606         res = dst + src;
35607         flag_NotZ = res;
35608         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35609         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35610         flag_N = res >> 24;
35611         DREGu32((Opcode >> 9) & 7) = res;
35612         POST_IO
35613 RET(20)
35614 }
35615
35616 // ADDaD
35617 OPCODE(0xD0B8)
35618 {
35619         u32 adr, res;
35620         u32 src, dst;
35621
35622         FETCH_SWORD(adr);
35623         PRE_IO
35624         READ_LONG_F(adr, src)
35625         dst = DREGu32((Opcode >> 9) & 7);
35626         res = dst + src;
35627         flag_NotZ = res;
35628         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35629         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35630         flag_N = res >> 24;
35631         DREGu32((Opcode >> 9) & 7) = res;
35632         POST_IO
35633 RET(18)
35634 }
35635
35636 // ADDaD
35637 OPCODE(0xD0B9)
35638 {
35639         u32 adr, res;
35640         u32 src, dst;
35641
35642         FETCH_LONG(adr);
35643         PRE_IO
35644         READ_LONG_F(adr, src)
35645         dst = DREGu32((Opcode >> 9) & 7);
35646         res = dst + src;
35647         flag_NotZ = res;
35648         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35649         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35650         flag_N = res >> 24;
35651         DREGu32((Opcode >> 9) & 7) = res;
35652         POST_IO
35653 RET(22)
35654 }
35655
35656 // ADDaD
35657 OPCODE(0xD0BA)
35658 {
35659         u32 adr, res;
35660         u32 src, dst;
35661
35662         adr = GET_SWORD + GET_PC;
35663         PC++;
35664         PRE_IO
35665         READ_LONG_F(adr, 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         POST_IO
35674 RET(18)
35675 }
35676
35677 // ADDaD
35678 OPCODE(0xD0BB)
35679 {
35680         u32 adr, res;
35681         u32 src, dst;
35682
35683         adr = GET_PC;
35684         DECODE_EXT_WORD
35685         PRE_IO
35686         READ_LONG_F(adr, src)
35687         dst = DREGu32((Opcode >> 9) & 7);
35688         res = dst + src;
35689         flag_NotZ = res;
35690         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35691         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35692         flag_N = res >> 24;
35693         DREGu32((Opcode >> 9) & 7) = res;
35694         POST_IO
35695 RET(20)
35696 }
35697
35698 // ADDaD
35699 OPCODE(0xD0BC)
35700 {
35701         u32 adr, res;
35702         u32 src, dst;
35703
35704         FETCH_LONG(src);
35705         dst = DREGu32((Opcode >> 9) & 7);
35706         res = dst + src;
35707         flag_NotZ = res;
35708         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35709         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35710         flag_N = res >> 24;
35711         DREGu32((Opcode >> 9) & 7) = res;
35712 RET(16)
35713 }
35714
35715 // ADDaD
35716 OPCODE(0xD09F)
35717 {
35718         u32 adr, res;
35719         u32 src, dst;
35720
35721         adr = AREG(7);
35722         AREG(7) += 4;
35723         PRE_IO
35724         READ_LONG_F(adr, src)
35725         dst = DREGu32((Opcode >> 9) & 7);
35726         res = dst + src;
35727         flag_NotZ = res;
35728         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35729         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35730         flag_N = res >> 24;
35731         DREGu32((Opcode >> 9) & 7) = res;
35732         POST_IO
35733 RET(14)
35734 }
35735
35736 // ADDaD
35737 OPCODE(0xD0A7)
35738 {
35739         u32 adr, res;
35740         u32 src, dst;
35741
35742         adr = AREG(7) - 4;
35743         AREG(7) = adr;
35744         PRE_IO
35745         READ_LONG_F(adr, src)
35746         dst = DREGu32((Opcode >> 9) & 7);
35747         res = dst + src;
35748         flag_NotZ = res;
35749         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35750         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35751         flag_N = res >> 24;
35752         DREGu32((Opcode >> 9) & 7) = res;
35753         POST_IO
35754 RET(16)
35755 }
35756
35757 // ADDDa
35758 OPCODE(0xD110)
35759 {
35760         u32 adr, res;
35761         u32 src, dst;
35762
35763         src = DREGu8((Opcode >> 9) & 7);
35764         adr = AREG((Opcode >> 0) & 7);
35765         PRE_IO
35766         READ_BYTE_F(adr, dst)
35767         res = dst + src;
35768         flag_N = flag_X = flag_C = res;
35769         flag_V = (src ^ res) & (dst ^ res);
35770         flag_NotZ = res & 0xFF;
35771         WRITE_BYTE_F(adr, res)
35772         POST_IO
35773 RET(12)
35774 }
35775
35776 // ADDDa
35777 OPCODE(0xD118)
35778 {
35779         u32 adr, res;
35780         u32 src, dst;
35781
35782         src = DREGu8((Opcode >> 9) & 7);
35783         adr = AREG((Opcode >> 0) & 7);
35784         AREG((Opcode >> 0) & 7) += 1;
35785         PRE_IO
35786         READ_BYTE_F(adr, dst)
35787         res = dst + src;
35788         flag_N = flag_X = flag_C = res;
35789         flag_V = (src ^ res) & (dst ^ res);
35790         flag_NotZ = res & 0xFF;
35791         WRITE_BYTE_F(adr, res)
35792         POST_IO
35793 RET(12)
35794 }
35795
35796 // ADDDa
35797 OPCODE(0xD120)
35798 {
35799         u32 adr, res;
35800         u32 src, dst;
35801
35802         src = DREGu8((Opcode >> 9) & 7);
35803         adr = AREG((Opcode >> 0) & 7) - 1;
35804         AREG((Opcode >> 0) & 7) = adr;
35805         PRE_IO
35806         READ_BYTE_F(adr, dst)
35807         res = dst + src;
35808         flag_N = flag_X = flag_C = res;
35809         flag_V = (src ^ res) & (dst ^ res);
35810         flag_NotZ = res & 0xFF;
35811         WRITE_BYTE_F(adr, res)
35812         POST_IO
35813 RET(14)
35814 }
35815
35816 // ADDDa
35817 OPCODE(0xD128)
35818 {
35819         u32 adr, res;
35820         u32 src, dst;
35821
35822         src = DREGu8((Opcode >> 9) & 7);
35823         FETCH_SWORD(adr);
35824         adr += AREG((Opcode >> 0) & 7);
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(0xD130)
35838 {
35839         u32 adr, res;
35840         u32 src, dst;
35841
35842         src = DREGu8((Opcode >> 9) & 7);
35843         adr = AREG((Opcode >> 0) & 7);
35844         DECODE_EXT_WORD
35845         PRE_IO
35846         READ_BYTE_F(adr, dst)
35847         res = dst + src;
35848         flag_N = flag_X = flag_C = res;
35849         flag_V = (src ^ res) & (dst ^ res);
35850         flag_NotZ = res & 0xFF;
35851         WRITE_BYTE_F(adr, res)
35852         POST_IO
35853 RET(18)
35854 }
35855
35856 // ADDDa
35857 OPCODE(0xD138)
35858 {
35859         u32 adr, res;
35860         u32 src, dst;
35861
35862         src = DREGu8((Opcode >> 9) & 7);
35863         FETCH_SWORD(adr);
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(16)
35873 }
35874
35875 // ADDDa
35876 OPCODE(0xD139)
35877 {
35878         u32 adr, res;
35879         u32 src, dst;
35880
35881         src = DREGu8((Opcode >> 9) & 7);
35882         FETCH_LONG(adr);
35883         PRE_IO
35884         READ_BYTE_F(adr, dst)
35885         res = dst + src;
35886         flag_N = flag_X = flag_C = res;
35887         flag_V = (src ^ res) & (dst ^ res);
35888         flag_NotZ = res & 0xFF;
35889         WRITE_BYTE_F(adr, res)
35890         POST_IO
35891 RET(20)
35892 }
35893
35894 // ADDDa
35895 OPCODE(0xD11F)
35896 {
35897         u32 adr, res;
35898         u32 src, dst;
35899
35900         src = DREGu8((Opcode >> 9) & 7);
35901         adr = AREG(7);
35902         AREG(7) += 2;
35903         PRE_IO
35904         READ_BYTE_F(adr, dst)
35905         res = dst + src;
35906         flag_N = flag_X = flag_C = res;
35907         flag_V = (src ^ res) & (dst ^ res);
35908         flag_NotZ = res & 0xFF;
35909         WRITE_BYTE_F(adr, res)
35910         POST_IO
35911 RET(12)
35912 }
35913
35914 // ADDDa
35915 OPCODE(0xD127)
35916 {
35917         u32 adr, res;
35918         u32 src, dst;
35919
35920         src = DREGu8((Opcode >> 9) & 7);
35921         adr = AREG(7) - 2;
35922         AREG(7) = adr;
35923         PRE_IO
35924         READ_BYTE_F(adr, dst)
35925         res = dst + src;
35926         flag_N = flag_X = flag_C = res;
35927         flag_V = (src ^ res) & (dst ^ res);
35928         flag_NotZ = res & 0xFF;
35929         WRITE_BYTE_F(adr, res)
35930         POST_IO
35931 RET(14)
35932 }
35933
35934 // ADDDa
35935 OPCODE(0xD150)
35936 {
35937         u32 adr, res;
35938         u32 src, dst;
35939
35940         src = DREGu16((Opcode >> 9) & 7);
35941         adr = AREG((Opcode >> 0) & 7);
35942         PRE_IO
35943         READ_WORD_F(adr, dst)
35944         res = dst + src;
35945         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35946         flag_N = flag_X = flag_C = res >> 8;
35947         flag_NotZ = res & 0xFFFF;
35948         WRITE_WORD_F(adr, res)
35949         POST_IO
35950 RET(12)
35951 }
35952
35953 // ADDDa
35954 OPCODE(0xD158)
35955 {
35956         u32 adr, res;
35957         u32 src, dst;
35958
35959         src = DREGu16((Opcode >> 9) & 7);
35960         adr = AREG((Opcode >> 0) & 7);
35961         AREG((Opcode >> 0) & 7) += 2;
35962         PRE_IO
35963         READ_WORD_F(adr, dst)
35964         res = dst + src;
35965         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35966         flag_N = flag_X = flag_C = res >> 8;
35967         flag_NotZ = res & 0xFFFF;
35968         WRITE_WORD_F(adr, res)
35969         POST_IO
35970 RET(12)
35971 }
35972
35973 // ADDDa
35974 OPCODE(0xD160)
35975 {
35976         u32 adr, res;
35977         u32 src, dst;
35978
35979         src = DREGu16((Opcode >> 9) & 7);
35980         adr = AREG((Opcode >> 0) & 7) - 2;
35981         AREG((Opcode >> 0) & 7) = adr;
35982         PRE_IO
35983         READ_WORD_F(adr, dst)
35984         res = dst + src;
35985         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35986         flag_N = flag_X = flag_C = res >> 8;
35987         flag_NotZ = res & 0xFFFF;
35988         WRITE_WORD_F(adr, res)
35989         POST_IO
35990 RET(14)
35991 }
35992
35993 // ADDDa
35994 OPCODE(0xD168)
35995 {
35996         u32 adr, res;
35997         u32 src, dst;
35998
35999         src = DREGu16((Opcode >> 9) & 7);
36000         FETCH_SWORD(adr);
36001         adr += AREG((Opcode >> 0) & 7);
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(0xD170)
36015 {
36016         u32 adr, res;
36017         u32 src, dst;
36018
36019         src = DREGu16((Opcode >> 9) & 7);
36020         adr = AREG((Opcode >> 0) & 7);
36021         DECODE_EXT_WORD
36022         PRE_IO
36023         READ_WORD_F(adr, dst)
36024         res = dst + src;
36025         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36026         flag_N = flag_X = flag_C = res >> 8;
36027         flag_NotZ = res & 0xFFFF;
36028         WRITE_WORD_F(adr, res)
36029         POST_IO
36030 RET(18)
36031 }
36032
36033 // ADDDa
36034 OPCODE(0xD178)
36035 {
36036         u32 adr, res;
36037         u32 src, dst;
36038
36039         src = DREGu16((Opcode >> 9) & 7);
36040         FETCH_SWORD(adr);
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(16)
36050 }
36051
36052 // ADDDa
36053 OPCODE(0xD179)
36054 {
36055         u32 adr, res;
36056         u32 src, dst;
36057
36058         src = DREGu16((Opcode >> 9) & 7);
36059         FETCH_LONG(adr);
36060         PRE_IO
36061         READ_WORD_F(adr, dst)
36062         res = dst + src;
36063         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36064         flag_N = flag_X = flag_C = res >> 8;
36065         flag_NotZ = res & 0xFFFF;
36066         WRITE_WORD_F(adr, res)
36067         POST_IO
36068 RET(20)
36069 }
36070
36071 // ADDDa
36072 OPCODE(0xD15F)
36073 {
36074         u32 adr, res;
36075         u32 src, dst;
36076
36077         src = DREGu16((Opcode >> 9) & 7);
36078         adr = AREG(7);
36079         AREG(7) += 2;
36080         PRE_IO
36081         READ_WORD_F(adr, dst)
36082         res = dst + src;
36083         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36084         flag_N = flag_X = flag_C = res >> 8;
36085         flag_NotZ = res & 0xFFFF;
36086         WRITE_WORD_F(adr, res)
36087         POST_IO
36088 RET(12)
36089 }
36090
36091 // ADDDa
36092 OPCODE(0xD167)
36093 {
36094         u32 adr, res;
36095         u32 src, dst;
36096
36097         src = DREGu16((Opcode >> 9) & 7);
36098         adr = AREG(7) - 2;
36099         AREG(7) = adr;
36100         PRE_IO
36101         READ_WORD_F(adr, dst)
36102         res = dst + src;
36103         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36104         flag_N = flag_X = flag_C = res >> 8;
36105         flag_NotZ = res & 0xFFFF;
36106         WRITE_WORD_F(adr, res)
36107         POST_IO
36108 RET(14)
36109 }
36110
36111 // ADDDa
36112 OPCODE(0xD190)
36113 {
36114         u32 adr, res;
36115         u32 src, dst;
36116
36117         src = DREGu32((Opcode >> 9) & 7);
36118         adr = AREG((Opcode >> 0) & 7);
36119         PRE_IO
36120         READ_LONG_F(adr, dst)
36121         res = dst + src;
36122         flag_NotZ = res;
36123         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36124         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36125         flag_N = res >> 24;
36126         WRITE_LONG_F(adr, res)
36127         POST_IO
36128 RET(20)
36129 }
36130
36131 // ADDDa
36132 OPCODE(0xD198)
36133 {
36134         u32 adr, res;
36135         u32 src, dst;
36136
36137         src = DREGu32((Opcode >> 9) & 7);
36138         adr = AREG((Opcode >> 0) & 7);
36139         AREG((Opcode >> 0) & 7) += 4;
36140         PRE_IO
36141         READ_LONG_F(adr, dst)
36142         res = dst + src;
36143         flag_NotZ = res;
36144         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36145         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36146         flag_N = res >> 24;
36147         WRITE_LONG_F(adr, res)
36148         POST_IO
36149 RET(20)
36150 }
36151
36152 // ADDDa
36153 OPCODE(0xD1A0)
36154 {
36155         u32 adr, res;
36156         u32 src, dst;
36157
36158         src = DREGu32((Opcode >> 9) & 7);
36159         adr = AREG((Opcode >> 0) & 7) - 4;
36160         AREG((Opcode >> 0) & 7) = adr;
36161         PRE_IO
36162         READ_LONG_F(adr, dst)
36163         res = dst + src;
36164         flag_NotZ = res;
36165         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36166         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36167         flag_N = res >> 24;
36168         WRITE_LONG_F(adr, res)
36169         POST_IO
36170 RET(22)
36171 }
36172
36173 // ADDDa
36174 OPCODE(0xD1A8)
36175 {
36176         u32 adr, res;
36177         u32 src, dst;
36178
36179         src = DREGu32((Opcode >> 9) & 7);
36180         FETCH_SWORD(adr);
36181         adr += AREG((Opcode >> 0) & 7);
36182         PRE_IO
36183         READ_LONG_F(adr, dst)
36184         res = dst + src;
36185         flag_NotZ = res;
36186         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36187         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36188         flag_N = res >> 24;
36189         WRITE_LONG_F(adr, res)
36190         POST_IO
36191 RET(24)
36192 }
36193
36194 // ADDDa
36195 OPCODE(0xD1B0)
36196 {
36197         u32 adr, res;
36198         u32 src, dst;
36199
36200         src = DREGu32((Opcode >> 9) & 7);
36201         adr = AREG((Opcode >> 0) & 7);
36202         DECODE_EXT_WORD
36203         PRE_IO
36204         READ_LONG_F(adr, dst)
36205         res = dst + src;
36206         flag_NotZ = res;
36207         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36208         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36209         flag_N = res >> 24;
36210         WRITE_LONG_F(adr, res)
36211         POST_IO
36212 RET(26)
36213 }
36214
36215 // ADDDa
36216 OPCODE(0xD1B8)
36217 {
36218         u32 adr, res;
36219         u32 src, dst;
36220
36221         src = DREGu32((Opcode >> 9) & 7);
36222         FETCH_SWORD(adr);
36223         PRE_IO
36224         READ_LONG_F(adr, dst)
36225         res = dst + src;
36226         flag_NotZ = res;
36227         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36228         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36229         flag_N = res >> 24;
36230         WRITE_LONG_F(adr, res)
36231         POST_IO
36232 RET(24)
36233 }
36234
36235 // ADDDa
36236 OPCODE(0xD1B9)
36237 {
36238         u32 adr, res;
36239         u32 src, dst;
36240
36241         src = DREGu32((Opcode >> 9) & 7);
36242         FETCH_LONG(adr);
36243         PRE_IO
36244         READ_LONG_F(adr, dst)
36245         res = dst + src;
36246         flag_NotZ = res;
36247         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36248         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36249         flag_N = res >> 24;
36250         WRITE_LONG_F(adr, res)
36251         POST_IO
36252 RET(28)
36253 }
36254
36255 // ADDDa
36256 OPCODE(0xD19F)
36257 {
36258         u32 adr, res;
36259         u32 src, dst;
36260
36261         src = DREGu32((Opcode >> 9) & 7);
36262         adr = AREG(7);
36263         AREG(7) += 4;
36264         PRE_IO
36265         READ_LONG_F(adr, dst)
36266         res = dst + src;
36267         flag_NotZ = res;
36268         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36269         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36270         flag_N = res >> 24;
36271         WRITE_LONG_F(adr, res)
36272         POST_IO
36273 RET(20)
36274 }
36275
36276 // ADDDa
36277 OPCODE(0xD1A7)
36278 {
36279         u32 adr, res;
36280         u32 src, dst;
36281
36282         src = DREGu32((Opcode >> 9) & 7);
36283         adr = AREG(7) - 4;
36284         AREG(7) = adr;
36285         PRE_IO
36286         READ_LONG_F(adr, dst)
36287         res = dst + src;
36288         flag_NotZ = res;
36289         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36290         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36291         flag_N = res >> 24;
36292         WRITE_LONG_F(adr, res)
36293         POST_IO
36294 RET(22)
36295 }
36296
36297 // ADDX
36298 OPCODE(0xD100)
36299 {
36300         u32 adr, res;
36301         u32 src, dst;
36302
36303         src = DREGu8((Opcode >> 0) & 7);
36304         dst = DREGu8((Opcode >> 9) & 7);
36305         res = dst + src + ((flag_X >> 8) & 1);
36306         flag_N = flag_X = flag_C = res;
36307         flag_V = (src ^ res) & (dst ^ res);
36308         flag_NotZ |= res & 0xFF;
36309         DREGu8((Opcode >> 9) & 7) = res;
36310 RET(4)
36311 }
36312
36313 // ADDX
36314 OPCODE(0xD140)
36315 {
36316         u32 adr, res;
36317         u32 src, dst;
36318
36319         src = DREGu16((Opcode >> 0) & 7);
36320         dst = DREGu16((Opcode >> 9) & 7);
36321         res = dst + src + ((flag_X >> 8) & 1);
36322         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36323         flag_N = flag_X = flag_C = res >> 8;
36324         flag_NotZ |= res & 0xFFFF;
36325         DREGu16((Opcode >> 9) & 7) = res;
36326 RET(4)
36327 }
36328
36329 // ADDX
36330 OPCODE(0xD180)
36331 {
36332         u32 adr, res;
36333         u32 src, dst;
36334
36335         src = DREGu32((Opcode >> 0) & 7);
36336         dst = DREGu32((Opcode >> 9) & 7);
36337         res = dst + src + ((flag_X >> 8) & 1);
36338         flag_NotZ |= res;
36339         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36340         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36341         flag_N = res >> 24;
36342         DREGu32((Opcode >> 9) & 7) = res;
36343 RET(8)
36344 }
36345
36346 // ADDXM
36347 OPCODE(0xD108)
36348 {
36349         u32 adr, res;
36350         u32 src, dst;
36351
36352         adr = AREG((Opcode >> 0) & 7) - 1;
36353         AREG((Opcode >> 0) & 7) = adr;
36354         PRE_IO
36355         READ_BYTE_F(adr, src)
36356         adr = AREG((Opcode >> 9) & 7) - 1;
36357         AREG((Opcode >> 9) & 7) = adr;
36358         READ_BYTE_F(adr, dst)
36359         res = dst + src + ((flag_X >> 8) & 1);
36360         flag_N = flag_X = flag_C = res;
36361         flag_V = (src ^ res) & (dst ^ res);
36362         flag_NotZ |= res & 0xFF;
36363         WRITE_BYTE_F(adr, res)
36364         POST_IO
36365 RET(18)
36366 }
36367
36368 // ADDXM
36369 OPCODE(0xD148)
36370 {
36371         u32 adr, res;
36372         u32 src, dst;
36373
36374         adr = AREG((Opcode >> 0) & 7) - 2;
36375         AREG((Opcode >> 0) & 7) = adr;
36376         PRE_IO
36377         READ_WORD_F(adr, src)
36378         adr = AREG((Opcode >> 9) & 7) - 2;
36379         AREG((Opcode >> 9) & 7) = adr;
36380         READ_WORD_F(adr, dst)
36381         res = dst + src + ((flag_X >> 8) & 1);
36382         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36383         flag_N = flag_X = flag_C = res >> 8;
36384         flag_NotZ |= res & 0xFFFF;
36385         WRITE_WORD_F(adr, res)
36386         POST_IO
36387 RET(18)
36388 }
36389
36390 // ADDXM
36391 OPCODE(0xD188)
36392 {
36393         u32 adr, res;
36394         u32 src, dst;
36395
36396         adr = AREG((Opcode >> 0) & 7) - 4;
36397         AREG((Opcode >> 0) & 7) = adr;
36398         PRE_IO
36399         READ_LONG_F(adr, src)
36400         adr = AREG((Opcode >> 9) & 7) - 4;
36401         AREG((Opcode >> 9) & 7) = adr;
36402         READ_LONG_F(adr, dst)
36403         res = dst + src + ((flag_X >> 8) & 1);
36404         flag_NotZ |= res;
36405         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36406         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36407         flag_N = res >> 24;
36408         WRITE_LONG_F(adr, res)
36409         POST_IO
36410 RET(30)
36411 }
36412
36413 // ADDX7M
36414 OPCODE(0xD10F)
36415 {
36416         u32 adr, res;
36417         u32 src, dst;
36418
36419         adr = AREG(7) - 2;
36420         AREG(7) = adr;
36421         PRE_IO
36422         READ_BYTE_F(adr, src)
36423         adr = AREG((Opcode >> 9) & 7) - 1;
36424         AREG((Opcode >> 9) & 7) = adr;
36425         READ_BYTE_F(adr, dst)
36426         res = dst + src + ((flag_X >> 8) & 1);
36427         flag_N = flag_X = flag_C = res;
36428         flag_V = (src ^ res) & (dst ^ res);
36429         flag_NotZ |= res & 0xFF;
36430         WRITE_BYTE_F(adr, res)
36431         POST_IO
36432 RET(18)
36433 }
36434
36435 // ADDX7M
36436 OPCODE(0xD14F)
36437 {
36438         u32 adr, res;
36439         u32 src, dst;
36440
36441         adr = AREG(7) - 2;
36442         AREG(7) = adr;
36443         PRE_IO
36444         READ_WORD_F(adr, src)
36445         adr = AREG((Opcode >> 9) & 7) - 2;
36446         AREG((Opcode >> 9) & 7) = adr;
36447         READ_WORD_F(adr, dst)
36448         res = dst + src + ((flag_X >> 8) & 1);
36449         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36450         flag_N = flag_X = flag_C = res >> 8;
36451         flag_NotZ |= res & 0xFFFF;
36452         WRITE_WORD_F(adr, res)
36453         POST_IO
36454 RET(18)
36455 }
36456
36457 // ADDX7M
36458 OPCODE(0xD18F)
36459 {
36460         u32 adr, res;
36461         u32 src, dst;
36462
36463         adr = AREG(7) - 4;
36464         AREG(7) = adr;
36465         PRE_IO
36466         READ_LONG_F(adr, src)
36467         adr = AREG((Opcode >> 9) & 7) - 4;
36468         AREG((Opcode >> 9) & 7) = adr;
36469         READ_LONG_F(adr, dst)
36470         res = dst + src + ((flag_X >> 8) & 1);
36471         flag_NotZ |= res;
36472         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36473         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36474         flag_N = res >> 24;
36475         WRITE_LONG_F(adr, res)
36476         POST_IO
36477 RET(30)
36478 }
36479
36480 // ADDXM7
36481 OPCODE(0xDF08)
36482 {
36483         u32 adr, res;
36484         u32 src, dst;
36485
36486         adr = AREG((Opcode >> 0) & 7) - 1;
36487         AREG((Opcode >> 0) & 7) = adr;
36488         PRE_IO
36489         READ_BYTE_F(adr, src)
36490         adr = AREG(7) - 2;
36491         AREG(7) = adr;
36492         READ_BYTE_F(adr, dst)
36493         res = dst + src + ((flag_X >> 8) & 1);
36494         flag_N = flag_X = flag_C = res;
36495         flag_V = (src ^ res) & (dst ^ res);
36496         flag_NotZ |= res & 0xFF;
36497         WRITE_BYTE_F(adr, res)
36498         POST_IO
36499 RET(18)
36500 }
36501
36502 // ADDXM7
36503 OPCODE(0xDF48)
36504 {
36505         u32 adr, res;
36506         u32 src, dst;
36507
36508         adr = AREG((Opcode >> 0) & 7) - 2;
36509         AREG((Opcode >> 0) & 7) = adr;
36510         PRE_IO
36511         READ_WORD_F(adr, src)
36512         adr = AREG(7) - 2;
36513         AREG(7) = adr;
36514         READ_WORD_F(adr, dst)
36515         res = dst + src + ((flag_X >> 8) & 1);
36516         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36517         flag_N = flag_X = flag_C = res >> 8;
36518         flag_NotZ |= res & 0xFFFF;
36519         WRITE_WORD_F(adr, res)
36520         POST_IO
36521 RET(18)
36522 }
36523
36524 // ADDXM7
36525 OPCODE(0xDF88)
36526 {
36527         u32 adr, res;
36528         u32 src, dst;
36529
36530         adr = AREG((Opcode >> 0) & 7) - 4;
36531         AREG((Opcode >> 0) & 7) = adr;
36532         PRE_IO
36533         READ_LONG_F(adr, src)
36534         adr = AREG(7) - 4;
36535         AREG(7) = adr;
36536         READ_LONG_F(adr, dst)
36537         res = dst + src + ((flag_X >> 8) & 1);
36538         flag_NotZ |= res;
36539         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36540         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36541         flag_N = res >> 24;
36542         WRITE_LONG_F(adr, res)
36543         POST_IO
36544 RET(30)
36545 }
36546
36547 // ADDX7M7
36548 OPCODE(0xDF0F)
36549 {
36550         u32 adr, res;
36551         u32 src, dst;
36552
36553         adr = AREG(7) - 2;
36554         AREG(7) = adr;
36555         PRE_IO
36556         READ_BYTE_F(adr, src)
36557         adr = AREG(7) - 2;
36558         AREG(7) = adr;
36559         READ_BYTE_F(adr, dst)
36560         res = dst + src + ((flag_X >> 8) & 1);
36561         flag_N = flag_X = flag_C = res;
36562         flag_V = (src ^ res) & (dst ^ res);
36563         flag_NotZ |= res & 0xFF;
36564         WRITE_BYTE_F(adr, res)
36565         POST_IO
36566 RET(18)
36567 }
36568
36569 // ADDX7M7
36570 OPCODE(0xDF4F)
36571 {
36572         u32 adr, res;
36573         u32 src, dst;
36574
36575         adr = AREG(7) - 2;
36576         AREG(7) = adr;
36577         PRE_IO
36578         READ_WORD_F(adr, src)
36579         adr = AREG(7) - 2;
36580         AREG(7) = adr;
36581         READ_WORD_F(adr, dst)
36582         res = dst + src + ((flag_X >> 8) & 1);
36583         flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36584         flag_N = flag_X = flag_C = res >> 8;
36585         flag_NotZ |= res & 0xFFFF;
36586         WRITE_WORD_F(adr, res)
36587         POST_IO
36588 RET(18)
36589 }
36590
36591 // ADDX7M7
36592 OPCODE(0xDF8F)
36593 {
36594         u32 adr, res;
36595         u32 src, dst;
36596
36597         adr = AREG(7) - 4;
36598         AREG(7) = adr;
36599         PRE_IO
36600         READ_LONG_F(adr, src)
36601         adr = AREG(7) - 4;
36602         AREG(7) = adr;
36603         READ_LONG_F(adr, dst)
36604         res = dst + src + ((flag_X >> 8) & 1);
36605         flag_NotZ |= res;
36606         flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36607         flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36608         flag_N = res >> 24;
36609         WRITE_LONG_F(adr, res)
36610         POST_IO
36611 RET(30)
36612 }
36613
36614 // ADDA
36615 OPCODE(0xD0C0)
36616 {
36617         u32 adr, res;
36618         u32 src, dst;
36619
36620         src = (s32)DREGs16((Opcode >> 0) & 7);
36621         dst = AREGu32((Opcode >> 9) & 7);
36622         res = dst + src;
36623         AREG((Opcode >> 9) & 7) = res;
36624 RET(8)
36625 }
36626
36627 // ADDA
36628 OPCODE(0xD0C8)
36629 {
36630         u32 adr, res;
36631         u32 src, dst;
36632
36633         src = (s32)AREGs16((Opcode >> 0) & 7);
36634         dst = AREGu32((Opcode >> 9) & 7);
36635         res = dst + src;
36636         AREG((Opcode >> 9) & 7) = res;
36637 RET(8)
36638 }
36639
36640 // ADDA
36641 OPCODE(0xD0D0)
36642 {
36643         u32 adr, res;
36644         u32 src, dst;
36645
36646         adr = AREG((Opcode >> 0) & 7);
36647         PRE_IO
36648         READSX_WORD_F(adr, src)
36649         dst = AREGu32((Opcode >> 9) & 7);
36650         res = dst + src;
36651         AREG((Opcode >> 9) & 7) = res;
36652         POST_IO
36653 #ifdef USE_CYCLONE_TIMING
36654 RET(12)
36655 #else
36656 RET(10)
36657 #endif
36658 }
36659
36660 // ADDA
36661 OPCODE(0xD0D8)
36662 {
36663         u32 adr, res;
36664         u32 src, dst;
36665
36666         adr = AREG((Opcode >> 0) & 7);
36667         AREG((Opcode >> 0) & 7) += 2;
36668         PRE_IO
36669         READSX_WORD_F(adr, src)
36670         dst = AREGu32((Opcode >> 9) & 7);
36671         res = dst + src;
36672         AREG((Opcode >> 9) & 7) = res;
36673         POST_IO
36674 #ifdef USE_CYCLONE_TIMING
36675 RET(12)
36676 #else
36677 RET(10)
36678 #endif
36679 }
36680
36681 // ADDA
36682 OPCODE(0xD0E0)
36683 {
36684         u32 adr, res;
36685         u32 src, dst;
36686
36687         adr = AREG((Opcode >> 0) & 7) - 2;
36688         AREG((Opcode >> 0) & 7) = adr;
36689         PRE_IO
36690         READSX_WORD_F(adr, src)
36691         dst = AREGu32((Opcode >> 9) & 7);
36692         res = dst + src;
36693         AREG((Opcode >> 9) & 7) = res;
36694         POST_IO
36695 #ifdef USE_CYCLONE_TIMING
36696 RET(14)
36697 #else
36698 RET(12)
36699 #endif
36700 }
36701
36702 // ADDA
36703 OPCODE(0xD0E8)
36704 {
36705         u32 adr, res;
36706         u32 src, dst;
36707
36708         FETCH_SWORD(adr);
36709         adr += AREG((Opcode >> 0) & 7);
36710         PRE_IO
36711         READSX_WORD_F(adr, src)
36712         dst = AREGu32((Opcode >> 9) & 7);
36713         res = dst + src;
36714         AREG((Opcode >> 9) & 7) = res;
36715         POST_IO
36716 #ifdef USE_CYCLONE_TIMING
36717 RET(16)
36718 #else
36719 RET(14)
36720 #endif
36721 }
36722
36723 // ADDA
36724 OPCODE(0xD0F0)
36725 {
36726         u32 adr, res;
36727         u32 src, dst;
36728
36729         adr = AREG((Opcode >> 0) & 7);
36730         DECODE_EXT_WORD
36731         PRE_IO
36732         READSX_WORD_F(adr, src)
36733         dst = AREGu32((Opcode >> 9) & 7);
36734         res = dst + src;
36735         AREG((Opcode >> 9) & 7) = res;
36736         POST_IO
36737 #ifdef USE_CYCLONE_TIMING
36738 RET(18)
36739 #else
36740 RET(16)
36741 #endif
36742 }
36743
36744 // ADDA
36745 OPCODE(0xD0F8)
36746 {
36747         u32 adr, res;
36748         u32 src, dst;
36749
36750         FETCH_SWORD(adr);
36751         PRE_IO
36752         READSX_WORD_F(adr, src)
36753         dst = AREGu32((Opcode >> 9) & 7);
36754         res = dst + src;
36755         AREG((Opcode >> 9) & 7) = res;
36756         POST_IO
36757 #ifdef USE_CYCLONE_TIMING
36758 RET(16)
36759 #else
36760 RET(14)
36761 #endif
36762 }
36763
36764 // ADDA
36765 OPCODE(0xD0F9)
36766 {
36767         u32 adr, res;
36768         u32 src, dst;
36769
36770         FETCH_LONG(adr);
36771         PRE_IO
36772         READSX_WORD_F(adr, src)
36773         dst = AREGu32((Opcode >> 9) & 7);
36774         res = dst + src;
36775         AREG((Opcode >> 9) & 7) = res;
36776         POST_IO
36777 #ifdef USE_CYCLONE_TIMING
36778 RET(20)
36779 #else
36780 RET(18)
36781 #endif
36782 }
36783
36784 // ADDA
36785 OPCODE(0xD0FA)
36786 {
36787         u32 adr, res;
36788         u32 src, dst;
36789
36790         adr = GET_SWORD + GET_PC;
36791         PC++;
36792         PRE_IO
36793         READSX_WORD_F(adr, src)
36794         dst = AREGu32((Opcode >> 9) & 7);
36795         res = dst + src;
36796         AREG((Opcode >> 9) & 7) = res;
36797         POST_IO
36798 #ifdef USE_CYCLONE_TIMING
36799 RET(16)
36800 #else
36801 RET(14)
36802 #endif
36803 }
36804
36805 // ADDA
36806 OPCODE(0xD0FB)
36807 {
36808         u32 adr, res;
36809         u32 src, dst;
36810
36811         adr = GET_PC;
36812         DECODE_EXT_WORD
36813         PRE_IO
36814         READSX_WORD_F(adr, src)
36815         dst = AREGu32((Opcode >> 9) & 7);
36816         res = dst + src;
36817         AREG((Opcode >> 9) & 7) = res;
36818         POST_IO
36819 #ifdef USE_CYCLONE_TIMING
36820 RET(18)
36821 #else
36822 RET(16)
36823 #endif
36824 }
36825
36826 // ADDA
36827 OPCODE(0xD0FC)
36828 {
36829         u32 adr, res;
36830         u32 src, dst;
36831
36832         FETCH_SWORD(src);
36833         dst = AREGu32((Opcode >> 9) & 7);
36834         res = dst + src;
36835         AREG((Opcode >> 9) & 7) = res;
36836 RET(12)
36837 }
36838
36839 // ADDA
36840 OPCODE(0xD0DF)
36841 {
36842         u32 adr, res;
36843         u32 src, dst;
36844
36845         adr = AREG(7);
36846         AREG(7) += 2;
36847         PRE_IO
36848         READSX_WORD_F(adr, src)
36849         dst = AREGu32((Opcode >> 9) & 7);
36850         res = dst + src;
36851         AREG((Opcode >> 9) & 7) = res;
36852         POST_IO
36853 #ifdef USE_CYCLONE_TIMING
36854 RET(12)
36855 #else
36856 RET(10)
36857 #endif
36858 }
36859
36860 // ADDA
36861 OPCODE(0xD0E7)
36862 {
36863         u32 adr, res;
36864         u32 src, dst;
36865
36866         adr = AREG(7) - 2;
36867         AREG(7) = adr;
36868         PRE_IO
36869         READSX_WORD_F(adr, src)
36870         dst = AREGu32((Opcode >> 9) & 7);
36871         res = dst + src;
36872         AREG((Opcode >> 9) & 7) = res;
36873         POST_IO
36874 #ifdef USE_CYCLONE_TIMING
36875 RET(14)
36876 #else
36877 RET(12)
36878 #endif
36879 }
36880
36881 // ADDA
36882 OPCODE(0xD1C0)
36883 {
36884         u32 adr, res;
36885         u32 src, dst;
36886
36887         src = (s32)DREGs32((Opcode >> 0) & 7);
36888         dst = AREGu32((Opcode >> 9) & 7);
36889         res = dst + src;
36890         AREG((Opcode >> 9) & 7) = res;
36891 #ifdef USE_CYCLONE_TIMING
36892 RET(8)
36893 #else
36894 RET(6)
36895 #endif
36896 }
36897
36898 // ADDA
36899 OPCODE(0xD1C8)
36900 {
36901         u32 adr, res;
36902         u32 src, dst;
36903
36904         src = (s32)AREGs32((Opcode >> 0) & 7);
36905         dst = AREGu32((Opcode >> 9) & 7);
36906         res = dst + src;
36907         AREG((Opcode >> 9) & 7) = res;
36908 #ifdef USE_CYCLONE_TIMING
36909 RET(8)
36910 #else
36911 RET(6)
36912 #endif
36913 }
36914
36915 // ADDA
36916 OPCODE(0xD1D0)
36917 {
36918         u32 adr, res;
36919         u32 src, dst;
36920
36921         adr = AREG((Opcode >> 0) & 7);
36922         PRE_IO
36923         READSX_LONG_F(adr, src)
36924         dst = AREGu32((Opcode >> 9) & 7);
36925         res = dst + src;
36926         AREG((Opcode >> 9) & 7) = res;
36927         POST_IO
36928 RET(14)
36929 }
36930
36931 // ADDA
36932 OPCODE(0xD1D8)
36933 {
36934         u32 adr, res;
36935         u32 src, dst;
36936
36937         adr = AREG((Opcode >> 0) & 7);
36938         AREG((Opcode >> 0) & 7) += 4;
36939         PRE_IO
36940         READSX_LONG_F(adr, src)
36941         dst = AREGu32((Opcode >> 9) & 7);
36942         res = dst + src;
36943         AREG((Opcode >> 9) & 7) = res;
36944         POST_IO
36945 RET(14)
36946 }
36947
36948 // ADDA
36949 OPCODE(0xD1E0)
36950 {
36951         u32 adr, res;
36952         u32 src, dst;
36953
36954         adr = AREG((Opcode >> 0) & 7) - 4;
36955         AREG((Opcode >> 0) & 7) = adr;
36956         PRE_IO
36957         READSX_LONG_F(adr, src)
36958         dst = AREGu32((Opcode >> 9) & 7);
36959         res = dst + src;
36960         AREG((Opcode >> 9) & 7) = res;
36961         POST_IO
36962 RET(16)
36963 }
36964
36965 // ADDA
36966 OPCODE(0xD1E8)
36967 {
36968         u32 adr, res;
36969         u32 src, dst;
36970
36971         FETCH_SWORD(adr);
36972         adr += AREG((Opcode >> 0) & 7);
36973         PRE_IO
36974         READSX_LONG_F(adr, src)
36975         dst = AREGu32((Opcode >> 9) & 7);
36976         res = dst + src;
36977         AREG((Opcode >> 9) & 7) = res;
36978         POST_IO
36979 RET(18)
36980 }
36981
36982 // ADDA
36983 OPCODE(0xD1F0)
36984 {
36985         u32 adr, res;
36986         u32 src, dst;
36987
36988         adr = AREG((Opcode >> 0) & 7);
36989         DECODE_EXT_WORD
36990         PRE_IO
36991         READSX_LONG_F(adr, src)
36992         dst = AREGu32((Opcode >> 9) & 7);
36993         res = dst + src;
36994         AREG((Opcode >> 9) & 7) = res;
36995         POST_IO
36996 RET(20)
36997 }
36998
36999 // ADDA
37000 OPCODE(0xD1F8)
37001 {
37002         u32 adr, res;
37003         u32 src, dst;
37004
37005         FETCH_SWORD(adr);
37006         PRE_IO
37007         READSX_LONG_F(adr, src)
37008         dst = AREGu32((Opcode >> 9) & 7);
37009         res = dst + src;
37010         AREG((Opcode >> 9) & 7) = res;
37011         POST_IO
37012 RET(18)
37013 }
37014
37015 // ADDA
37016 OPCODE(0xD1F9)
37017 {
37018         u32 adr, res;
37019         u32 src, dst;
37020
37021         FETCH_LONG(adr);
37022         PRE_IO
37023         READSX_LONG_F(adr, src)
37024         dst = AREGu32((Opcode >> 9) & 7);
37025         res = dst + src;
37026         AREG((Opcode >> 9) & 7) = res;
37027         POST_IO
37028 RET(22)
37029 }
37030
37031 // ADDA
37032 OPCODE(0xD1FA)
37033 {
37034         u32 adr, res;
37035         u32 src, dst;
37036
37037         adr = GET_SWORD + GET_PC;
37038         PC++;
37039         PRE_IO
37040         READSX_LONG_F(adr, src)
37041         dst = AREGu32((Opcode >> 9) & 7);
37042         res = dst + src;
37043         AREG((Opcode >> 9) & 7) = res;
37044         POST_IO
37045 RET(18)
37046 }
37047
37048 // ADDA
37049 OPCODE(0xD1FB)
37050 {
37051         u32 adr, res;
37052         u32 src, dst;
37053
37054         adr = GET_PC;
37055         DECODE_EXT_WORD
37056         PRE_IO
37057         READSX_LONG_F(adr, src)
37058         dst = AREGu32((Opcode >> 9) & 7);
37059         res = dst + src;
37060         AREG((Opcode >> 9) & 7) = res;
37061         POST_IO
37062 RET(20)
37063 }
37064
37065 // ADDA
37066 OPCODE(0xD1FC)
37067 {
37068         u32 adr, res;
37069         u32 src, dst;
37070
37071         FETCH_LONG(src);
37072         dst = AREGu32((Opcode >> 9) & 7);
37073         res = dst + src;
37074         AREG((Opcode >> 9) & 7) = res;
37075 #ifdef USE_CYCLONE_TIMING
37076 RET(16)
37077 #else
37078 RET(14)
37079 #endif
37080 }
37081
37082 // ADDA
37083 OPCODE(0xD1DF)
37084 {
37085         u32 adr, res;
37086         u32 src, dst;
37087
37088         adr = AREG(7);
37089         AREG(7) += 4;
37090         PRE_IO
37091         READSX_LONG_F(adr, src)
37092         dst = AREGu32((Opcode >> 9) & 7);
37093         res = dst + src;
37094         AREG((Opcode >> 9) & 7) = res;
37095         POST_IO
37096 RET(14)
37097 }
37098
37099 // ADDA
37100 OPCODE(0xD1E7)
37101 {
37102         u32 adr, res;
37103         u32 src, dst;
37104
37105         adr = AREG(7) - 4;
37106         AREG(7) = adr;
37107         PRE_IO
37108         READSX_LONG_F(adr, src)
37109         dst = AREGu32((Opcode >> 9) & 7);
37110         res = dst + src;
37111         AREG((Opcode >> 9) & 7) = res;
37112         POST_IO
37113 RET(16)
37114 }
37115
37116 // ASRk
37117 OPCODE(0xE000)
37118 {
37119         u32 adr, res;
37120         u32 src, dst;
37121
37122         u32 sft;
37123
37124         sft = (((Opcode >> 9) - 1) & 7) + 1;
37125         m68kcontext.io_cycle_counter -= sft * 2;
37126         src = (s32)DREGs8((Opcode >> 0) & 7);
37127         flag_V = 0;
37128         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37129         res = ((s32)src) >> sft;
37130         flag_N = res >> 0;
37131         flag_NotZ = res;
37132         DREGu8((Opcode >> 0) & 7) = res;
37133 RET(6)
37134 }
37135
37136 // ASRk
37137 OPCODE(0xE040)
37138 {
37139         u32 adr, res;
37140         u32 src, dst;
37141
37142         u32 sft;
37143
37144         sft = (((Opcode >> 9) - 1) & 7) + 1;
37145         m68kcontext.io_cycle_counter -= sft * 2;
37146         src = (s32)DREGs16((Opcode >> 0) & 7);
37147         flag_V = 0;
37148         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37149         res = ((s32)src) >> sft;
37150         flag_N = res >> 8;
37151         flag_NotZ = res;
37152         DREGu16((Opcode >> 0) & 7) = res;
37153 RET(6)
37154 }
37155
37156 // ASRk
37157 OPCODE(0xE080)
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 = (s32)DREGs32((Opcode >> 0) & 7);
37167         flag_V = 0;
37168         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37169         res = ((s32)src) >> sft;
37170         flag_N = res >> 24;
37171         flag_NotZ = res;
37172         DREGu32((Opcode >> 0) & 7) = res;
37173 RET(8)
37174 }
37175
37176 // LSRk
37177 OPCODE(0xE008)
37178 {
37179         u32 adr, res;
37180         u32 src, dst;
37181
37182         u32 sft;
37183
37184         sft = (((Opcode >> 9) - 1) & 7) + 1;
37185         m68kcontext.io_cycle_counter -= sft * 2;
37186         src = DREGu8((Opcode >> 0) & 7);
37187         flag_N = flag_V = 0;
37188         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37189         res = src >> sft;
37190         flag_NotZ = res;
37191         DREGu8((Opcode >> 0) & 7) = res;
37192 RET(6)
37193 }
37194
37195 // LSRk
37196 OPCODE(0xE048)
37197 {
37198         u32 adr, res;
37199         u32 src, dst;
37200
37201         u32 sft;
37202
37203         sft = (((Opcode >> 9) - 1) & 7) + 1;
37204         m68kcontext.io_cycle_counter -= sft * 2;
37205         src = DREGu16((Opcode >> 0) & 7);
37206         flag_N = flag_V = 0;
37207         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37208         res = src >> sft;
37209         flag_NotZ = res;
37210         DREGu16((Opcode >> 0) & 7) = res;
37211 RET(6)
37212 }
37213
37214 // LSRk
37215 OPCODE(0xE088)
37216 {
37217         u32 adr, res;
37218         u32 src, dst;
37219
37220         u32 sft;
37221
37222         sft = (((Opcode >> 9) - 1) & 7) + 1;
37223         m68kcontext.io_cycle_counter -= sft * 2;
37224         src = DREGu32((Opcode >> 0) & 7);
37225         flag_N = flag_V = 0;
37226         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37227         res = src >> sft;
37228         flag_NotZ = res;
37229         DREGu32((Opcode >> 0) & 7) = res;
37230 RET(8)
37231 }
37232
37233 // ROXRk
37234 OPCODE(0xE010)
37235 {
37236         u32 adr, res;
37237         u32 src, dst;
37238
37239         u32 sft;
37240
37241         sft = (((Opcode >> 9) - 1) & 7) + 1;
37242         m68kcontext.io_cycle_counter -= sft * 2;
37243         src = DREGu8((Opcode >> 0) & 7);
37244         src |= (flag_X & M68K_SR_X) << 0;
37245         res = (src >> sft) | (src << (9 - sft));
37246         flag_X = flag_C = res >> 0;
37247         flag_V = 0;
37248         flag_N = res >> 0;
37249         flag_NotZ = res & 0x000000FF;
37250         DREGu8((Opcode >> 0) & 7) = res;
37251 RET(6)
37252 }
37253
37254 // ROXRk
37255 OPCODE(0xE050)
37256 {
37257         u32 adr, res;
37258         u32 src, dst;
37259
37260         u32 sft;
37261
37262         sft = (((Opcode >> 9) - 1) & 7) + 1;
37263         m68kcontext.io_cycle_counter -= sft * 2;
37264         src = DREGu16((Opcode >> 0) & 7);
37265         src |= (flag_X & M68K_SR_X) << 8;
37266         res = (src >> sft) | (src << (17 - sft));
37267         flag_X = flag_C = res >> 8;
37268         flag_V = 0;
37269         flag_N = res >> 8;
37270         flag_NotZ = res & 0x0000FFFF;
37271         DREGu16((Opcode >> 0) & 7) = res;
37272 RET(6)
37273 }
37274
37275 // ROXRk
37276 OPCODE(0xE090)
37277 {
37278         u32 adr, res;
37279         u32 src, dst;
37280
37281         u32 sft;
37282
37283         sft = (((Opcode >> 9) - 1) & 7) + 1;
37284         m68kcontext.io_cycle_counter -= sft * 2;
37285         src = DREGu32((Opcode >> 0) & 7);
37286         flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37287         if (sft == 1) res = (src >> 1) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1)));
37288         else res = (src >> sft) | (src << (33 - sft)) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + sft)));
37289         flag_X = flag_C;
37290         flag_V = 0;
37291         flag_N = res >> 24;
37292         flag_NotZ = res;
37293         DREGu32((Opcode >> 0) & 7) = res;
37294 RET(8)
37295 }
37296
37297 // RORk
37298 OPCODE(0xE018)
37299 {
37300         u32 adr, res;
37301         u32 src, dst;
37302
37303         u32 sft;
37304
37305         sft = (((Opcode >> 9) - 1) & 7) + 1;
37306         m68kcontext.io_cycle_counter -= sft * 2;
37307         src = DREGu8((Opcode >> 0) & 7);
37308         flag_V = 0;
37309         flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37310         res = (src >> sft) | (src << (8 - sft));
37311         flag_N = res >> 0;
37312         flag_NotZ = res & 0x000000FF;
37313         DREGu8((Opcode >> 0) & 7) = res;
37314 RET(6)
37315 }
37316
37317 // RORk
37318 OPCODE(0xE058)
37319 {
37320         u32 adr, res;
37321         u32 src, dst;
37322
37323         u32 sft;
37324
37325         sft = (((Opcode >> 9) - 1) & 7) + 1;
37326         m68kcontext.io_cycle_counter -= sft * 2;
37327         src = DREGu16((Opcode >> 0) & 7);
37328         flag_V = 0;
37329         flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37330         res = (src >> sft) | (src << (16 - sft));
37331         flag_N = res >> 8;
37332         flag_NotZ = res & 0x0000FFFF;
37333         DREGu16((Opcode >> 0) & 7) = res;
37334 RET(6)
37335 }
37336
37337 // RORk
37338 OPCODE(0xE098)
37339 {
37340         u32 adr, res;
37341         u32 src, dst;
37342
37343         u32 sft;
37344
37345         sft = (((Opcode >> 9) - 1) & 7) + 1;
37346         m68kcontext.io_cycle_counter -= sft * 2;
37347         src = DREGu32((Opcode >> 0) & 7);
37348         flag_V = 0;
37349         flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37350         res = (src >> sft) | (src << (32 - sft));
37351         flag_N = res >> 24;
37352         flag_NotZ = res;
37353         DREGu32((Opcode >> 0) & 7) = res;
37354 RET(8)
37355 }
37356
37357 // ASLk
37358 OPCODE(0xE100)
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 = DREGu8((Opcode >> 0) & 7);
37368         if (sft < 8)
37369         {
37370                 flag_X = flag_C = src << (0 + sft);
37371                 res = src << sft;
37372                 flag_N = res >> 0;
37373                 flag_NotZ = res & 0x000000FF;
37374         DREGu8((Opcode >> 0) & 7) = res;
37375                 flag_V = 0;
37376                 if ((sft > 7) && (src)) flag_V = M68K_SR_V;
37377                 else
37378                 {
37379                         u32 msk = (((s32)0x80000000) >> (sft + 24)) & 0x000000FF;
37380                         src &= msk;
37381                         if ((src) && (src != msk)) flag_V = M68K_SR_V;
37382                 }
37383         RET(6)
37384         }
37385
37386         if (src) flag_V = M68K_SR_V;
37387         else flag_V = 0;
37388         flag_X = flag_C = src << M68K_SR_C_SFT;
37389         res = 0;
37390         DREGu8((Opcode >> 0) & 7) = res;
37391         flag_N = 0;
37392         flag_NotZ = 0;
37393 RET(6)
37394 }
37395
37396 // ASLk
37397 OPCODE(0xE140)
37398 {
37399         u32 adr, res;
37400         u32 src, dst;
37401
37402         u32 sft;
37403
37404         sft = (((Opcode >> 9) - 1) & 7) + 1;
37405         m68kcontext.io_cycle_counter -= sft * 2;
37406         src = DREGu16((Opcode >> 0) & 7);
37407                 flag_X = flag_C = src >> (8 - sft);
37408                 res = src << sft;
37409                 flag_N = res >> 8;
37410                 flag_NotZ = res & 0x0000FFFF;
37411         DREGu16((Opcode >> 0) & 7) = res;
37412                 flag_V = 0;
37413                 {
37414                         u32 msk = (((s32)0x80000000) >> (sft + 16)) & 0x0000FFFF;
37415                         src &= msk;
37416                         if ((src) && (src != msk)) flag_V = M68K_SR_V;
37417                 }
37418 RET(6)
37419 }
37420
37421 // ASLk
37422 OPCODE(0xE180)
37423 {
37424         u32 adr, res;
37425         u32 src, dst;
37426
37427         u32 sft;
37428
37429         sft = (((Opcode >> 9) - 1) & 7) + 1;
37430         m68kcontext.io_cycle_counter -= sft * 2;
37431         src = DREGu32((Opcode >> 0) & 7);
37432                 flag_X = flag_C = src >> (24 - sft);
37433                 res = src << sft;
37434                 flag_N = res >> 24;
37435                 flag_NotZ = res & 0xFFFFFFFF;
37436         DREGu32((Opcode >> 0) & 7) = res;
37437                 flag_V = 0;
37438                 {
37439                         u32 msk = (((s32)0x80000000) >> (sft + 0)) & 0xFFFFFFFF;
37440                         src &= msk;
37441                         if ((src) && (src != msk)) flag_V = M68K_SR_V;
37442                 }
37443 RET(8)
37444 }
37445
37446 // LSLk
37447 OPCODE(0xE108)
37448 {
37449         u32 adr, res;
37450         u32 src, dst;
37451
37452         u32 sft;
37453
37454         sft = (((Opcode >> 9) - 1) & 7) + 1;
37455         m68kcontext.io_cycle_counter -= sft * 2;
37456         src = DREGu8((Opcode >> 0) & 7);
37457         flag_V = 0;
37458         flag_X = flag_C = src << (0 + sft);
37459         res = src << sft;
37460         flag_N = res >> 0;
37461         flag_NotZ = res & 0x000000FF;
37462         DREGu8((Opcode >> 0) & 7) = res;
37463 RET(6)
37464 }
37465
37466 // LSLk
37467 OPCODE(0xE148)
37468 {
37469         u32 adr, res;
37470         u32 src, dst;
37471
37472         u32 sft;
37473
37474         sft = (((Opcode >> 9) - 1) & 7) + 1;
37475         m68kcontext.io_cycle_counter -= sft * 2;
37476         src = DREGu16((Opcode >> 0) & 7);
37477         flag_V = 0;
37478         flag_X = flag_C = src >> (8 - sft);
37479         res = src << sft;
37480         flag_N = res >> 8;
37481         flag_NotZ = res & 0x0000FFFF;
37482         DREGu16((Opcode >> 0) & 7) = res;
37483 RET(6)
37484 }
37485
37486 // LSLk
37487 OPCODE(0xE188)
37488 {
37489         u32 adr, res;
37490         u32 src, dst;
37491
37492         u32 sft;
37493
37494         sft = (((Opcode >> 9) - 1) & 7) + 1;
37495         m68kcontext.io_cycle_counter -= sft * 2;
37496         src = DREGu32((Opcode >> 0) & 7);
37497         flag_V = 0;
37498         flag_X = flag_C = src >> (24 - sft);
37499         res = src << sft;
37500         flag_N = res >> 24;
37501         flag_NotZ = res & 0xFFFFFFFF;
37502         DREGu32((Opcode >> 0) & 7) = res;
37503 RET(8)
37504 }
37505
37506 // ROXLk
37507 OPCODE(0xE110)
37508 {
37509         u32 adr, res;
37510         u32 src, dst;
37511
37512         u32 sft;
37513
37514         sft = (((Opcode >> 9) - 1) & 7) + 1;
37515         m68kcontext.io_cycle_counter -= sft * 2;
37516         src = DREGu8((Opcode >> 0) & 7);
37517         src |= (flag_X & M68K_SR_X) << 0;
37518         res = (src << sft) | (src >> (9 - sft));
37519         flag_X = flag_C = res >> 0;
37520         flag_V = 0;
37521         flag_N = res >> 0;
37522         flag_NotZ = res & 0x000000FF;
37523         DREGu8((Opcode >> 0) & 7) = res;
37524 RET(6)
37525 }
37526
37527 // ROXLk
37528 OPCODE(0xE150)
37529 {
37530         u32 adr, res;
37531         u32 src, dst;
37532
37533         u32 sft;
37534
37535         sft = (((Opcode >> 9) - 1) & 7) + 1;
37536         m68kcontext.io_cycle_counter -= sft * 2;
37537         src = DREGu16((Opcode >> 0) & 7);
37538         src |= (flag_X & M68K_SR_X) << 8;
37539         res = (src << sft) | (src >> (17 - sft));
37540         flag_X = flag_C = res >> 8;
37541         flag_V = 0;
37542         flag_N = res >> 8;
37543         flag_NotZ = res & 0x0000FFFF;
37544         DREGu16((Opcode >> 0) & 7) = res;
37545 RET(6)
37546 }
37547
37548 // ROXLk
37549 OPCODE(0xE190)
37550 {
37551         u32 adr, res;
37552         u32 src, dst;
37553
37554         u32 sft;
37555
37556         sft = (((Opcode >> 9) - 1) & 7) + 1;
37557         m68kcontext.io_cycle_counter -= sft * 2;
37558         src = DREGu32((Opcode >> 0) & 7);
37559         flag_C = src >> ((32 - M68K_SR_C_SFT) - sft);
37560         if (sft == 1) res = (src << 1) | ((flag_X & M68K_SR_X) >> ((M68K_SR_X_SFT + 1) - 1));
37561         else res = (src << sft) | (src >> (33 - sft)) | ((flag_X & M68K_SR_X) >> ((M68K_SR_X_SFT + 1) - sft));
37562         flag_X = flag_C;
37563         flag_V = 0;
37564         flag_N = res >> 24;
37565         flag_NotZ = res;
37566         DREGu32((Opcode >> 0) & 7) = res;
37567 RET(8)
37568 }
37569
37570 // ROLk
37571 OPCODE(0xE118)
37572 {
37573         u32 adr, res;
37574         u32 src, dst;
37575
37576         u32 sft;
37577
37578         sft = (((Opcode >> 9) - 1) & 7) + 1;
37579         m68kcontext.io_cycle_counter -= sft * 2;
37580         src = DREGu8((Opcode >> 0) & 7);
37581         flag_V = 0;
37582         flag_C = src << (0 + sft);
37583         res = (src << sft) | (src >> (8 - sft));
37584         flag_N = res >> 0;
37585         flag_NotZ = res & 0x000000FF;
37586         DREGu8((Opcode >> 0) & 7) = res;
37587 RET(6)
37588 }
37589
37590 // ROLk
37591 OPCODE(0xE158)
37592 {
37593         u32 adr, res;
37594         u32 src, dst;
37595
37596         u32 sft;
37597
37598         sft = (((Opcode >> 9) - 1) & 7) + 1;
37599         m68kcontext.io_cycle_counter -= sft * 2;
37600         src = DREGu16((Opcode >> 0) & 7);
37601         flag_V = 0;
37602         flag_C = src >> (8 - sft);
37603         res = (src << sft) | (src >> (16 - sft));
37604         flag_N = res >> 8;
37605         flag_NotZ = res & 0x0000FFFF;
37606         DREGu16((Opcode >> 0) & 7) = res;
37607 RET(6)
37608 }
37609
37610 // ROLk
37611 OPCODE(0xE198)
37612 {
37613         u32 adr, res;
37614         u32 src, dst;
37615
37616         u32 sft;
37617
37618         sft = (((Opcode >> 9) - 1) & 7) + 1;
37619         m68kcontext.io_cycle_counter -= sft * 2;
37620         src = DREGu32((Opcode >> 0) & 7);
37621         flag_V = 0;
37622         flag_C = src >> (24 - sft);
37623         res = (src << sft) | (src >> (32 - sft));
37624         flag_N = res >> 24;
37625         flag_NotZ = res;
37626         DREGu32((Opcode >> 0) & 7) = res;
37627 RET(8)
37628 }
37629
37630 // ASRD
37631 OPCODE(0xE020)
37632 {
37633         u32 adr, res;
37634         u32 src, dst;
37635
37636         u32 sft;
37637
37638         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37639         src = (s32)DREGs8((Opcode >> 0) & 7);
37640         if (sft)
37641         {
37642         m68kcontext.io_cycle_counter -= sft * 2;
37643                 if (sft < 8)
37644                 {
37645                         flag_V = 0;
37646                         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37647                         res = ((s32)src) >> sft;
37648                         flag_N = res >> 0;
37649                         flag_NotZ = res;
37650         DREGu8((Opcode >> 0) & 7) = res;
37651         RET(6)
37652                 }
37653
37654                 if (src & (1 << 7))
37655                 {
37656                         flag_N = M68K_SR_N;
37657                         flag_NotZ = 1;
37658                         flag_V = 0;
37659                         flag_C = M68K_SR_C;
37660                         flag_X = M68K_SR_X;
37661                         res = 0x000000FF;
37662         DREGu8((Opcode >> 0) & 7) = res;
37663         RET(6)
37664                 }
37665
37666                 flag_N = 0;
37667                 flag_NotZ = 0;
37668                 flag_V = 0;
37669                 flag_C = 0;
37670                 flag_X = 0;
37671                 res = 0;
37672         DREGu8((Opcode >> 0) & 7) = res;
37673         RET(6)
37674         }
37675
37676         flag_V = 0;
37677         flag_C = 0;
37678         flag_N = src >> 0;
37679         flag_NotZ = src;
37680 RET(6)
37681 }
37682
37683 // ASRD
37684 OPCODE(0xE060)
37685 {
37686         u32 adr, res;
37687         u32 src, dst;
37688
37689         u32 sft;
37690
37691         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37692         src = (s32)DREGs16((Opcode >> 0) & 7);
37693         if (sft)
37694         {
37695         m68kcontext.io_cycle_counter -= sft * 2;
37696                 if (sft < 16)
37697                 {
37698                         flag_V = 0;
37699                         flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37700                         res = ((s32)src) >> sft;
37701                         flag_N = res >> 8;
37702                         flag_NotZ = res;
37703         DREGu16((Opcode >> 0) & 7) = res;
37704         RET(6)
37705                 }
37706
37707                 if (src & (1 << 15))
37708                 {
37709                         flag_N = M68K_SR_N;
37710                         flag_NotZ = 1;
37711                         flag_V = 0;
37712                         flag_C = M68K_SR_C;
37713                         flag_X = M68K_SR_X;
37714                         res = 0x0000FFFF;
37715         DREGu16((Opcode >> 0) & 7) = res;
37716         RET(6)
37717                 }
37718
37719                 flag_N = 0;
37720                 flag_NotZ = 0;
37721                 flag_V = 0;
37722                 flag_C = 0;
37723                 flag_X = 0;
37724                 res = 0;
37725         DREGu16((Opcode >> 0) & 7) = res;
37726         RET(6)
37727         }
37728
37729         flag_V = 0;
37730         flag_C = 0;
37731         flag_N = src >> 8;
37732         flag_NotZ = src;
37733 RET(6)
37734 }
37735
37736 // ASRD
37737 OPCODE(0xE0A0)
37738 {
37739 #ifdef USE_CYCLONE_TIMING
37740 #define CYC 8
37741 #else
37742 #define CYC 6
37743 #endif
37744         u32 adr, res;
37745         u32 src, dst;
37746
37747         u32 sft;
37748
37749         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37750         src = (s32)DREGs32((Opcode >> 0) & 7);
37751         if (sft)
37752         {
37753         m68kcontext.io_cycle_counter -= sft * 2;
37754                 if (sft < 32)
37755                 {
37756                         flag_V = 0;
37757                         flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37758                         res = ((s32)src) >> sft;
37759                         flag_N = res >> 24;
37760                         flag_NotZ = res;
37761         DREGu32((Opcode >> 0) & 7) = res;
37762         RET(CYC)
37763                 }
37764
37765                 if (src & (1 << 31))
37766                 {
37767                         flag_N = M68K_SR_N;
37768                         flag_NotZ = 1;
37769                         flag_V = 0;
37770                         flag_C = M68K_SR_C;
37771                         flag_X = M68K_SR_X;
37772                         res = 0xFFFFFFFF;
37773         DREGu32((Opcode >> 0) & 7) = res;
37774         RET(CYC)
37775                 }
37776
37777                 flag_N = 0;
37778                 flag_NotZ = 0;
37779                 flag_V = 0;
37780                 flag_C = 0;
37781                 flag_X = 0;
37782                 res = 0;
37783         DREGu32((Opcode >> 0) & 7) = res;
37784         RET(CYC)
37785         }
37786
37787         flag_V = 0;
37788         flag_C = 0;
37789         flag_N = src >> 24;
37790         flag_NotZ = src;
37791 RET(CYC)
37792 #undef CYC
37793 }
37794
37795 // LSRD
37796 OPCODE(0xE028)
37797 {
37798         u32 adr, res;
37799         u32 src, dst;
37800
37801         u32 sft;
37802
37803         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37804         src = DREGu8((Opcode >> 0) & 7);
37805         if (sft)
37806         {
37807         m68kcontext.io_cycle_counter -= sft * 2;
37808                 if (sft <= 8)
37809                 {
37810                         flag_N = flag_V = 0;
37811                         flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37812                         res = src >> sft;
37813                         flag_NotZ = res;
37814         DREGu8((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         DREGu8((Opcode >> 0) & 7) = res;
37824         RET(6)
37825         }
37826
37827         flag_V = 0;
37828         flag_C = 0;
37829         flag_N = src >> 0;
37830         flag_NotZ = src;
37831 RET(6)
37832 }
37833
37834 // LSRD
37835 OPCODE(0xE068)
37836 {
37837         u32 adr, res;
37838         u32 src, dst;
37839
37840         u32 sft;
37841
37842         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37843         src = DREGu16((Opcode >> 0) & 7);
37844         if (sft)
37845         {
37846         m68kcontext.io_cycle_counter -= sft * 2;
37847                 if (sft <= 16)
37848                 {
37849                         flag_N = flag_V = 0;
37850                         flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37851                         res = src >> sft;
37852                         flag_NotZ = res;
37853         DREGu16((Opcode >> 0) & 7) = res;
37854         RET(6)
37855                 }
37856
37857                 flag_X = flag_C = 0;
37858                 flag_N = 0;
37859                 flag_NotZ = 0;
37860                 flag_V = 0;
37861                 res = 0;
37862         DREGu16((Opcode >> 0) & 7) = res;
37863         RET(6)
37864         }
37865
37866         flag_V = 0;
37867         flag_C = 0;
37868         flag_N = src >> 8;
37869         flag_NotZ = src;
37870 RET(6)
37871 }
37872
37873 // LSRD
37874 OPCODE(0xE0A8)
37875 {
37876 #ifdef USE_CYCLONE_TIMING
37877 #define CYC 8
37878 #else
37879 #define CYC 6
37880 #endif
37881         u32 adr, res;
37882         u32 src, dst;
37883
37884         u32 sft;
37885
37886         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37887         src = DREGu32((Opcode >> 0) & 7);
37888         if (sft)
37889         {
37890         m68kcontext.io_cycle_counter -= sft * 2;
37891                 if (sft < 32)
37892                 {
37893                         flag_N = flag_V = 0;
37894                         flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37895                         res = src >> sft;
37896                         flag_NotZ = res;
37897         DREGu32((Opcode >> 0) & 7) = res;
37898         RET(CYC)
37899                 }
37900
37901                 if (sft == 32) flag_C = src >> (31 - M68K_SR_C_SFT);
37902                 else flag_C = 0;
37903                 flag_X = flag_C;
37904                 flag_N = 0;
37905                 flag_NotZ = 0;
37906                 flag_V = 0;
37907                 res = 0;
37908         DREGu32((Opcode >> 0) & 7) = res;
37909         RET(CYC)
37910         }
37911
37912         flag_V = 0;
37913         flag_C = 0;
37914         flag_N = src >> 24;
37915         flag_NotZ = src;
37916 RET(CYC)
37917 #undef CYC
37918 }
37919
37920 // ROXRD
37921 OPCODE(0xE030)
37922 {
37923         u32 adr, res;
37924         u32 src, dst;
37925
37926         u32 sft;
37927
37928         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37929         src = DREGu8((Opcode >> 0) & 7);
37930         if (sft)
37931         {
37932         m68kcontext.io_cycle_counter -= sft * 2;
37933                 sft %= 9;
37934
37935                 src |= (flag_X & M68K_SR_X) << 0;
37936                 res = (src >> sft) | (src << (9 - sft));
37937                 flag_X = flag_C = res >> 0;
37938                 flag_V = 0;
37939                 flag_N = res >> 0;
37940                 flag_NotZ = res & 0x000000FF;
37941         DREGu8((Opcode >> 0) & 7) = res;
37942         RET(6)
37943         }
37944
37945         flag_V = 0;
37946         flag_C = flag_X;
37947         flag_N = src >> 0;
37948         flag_NotZ = src;
37949 RET(6)
37950 }
37951
37952 // ROXRD
37953 OPCODE(0xE070)
37954 {
37955         u32 adr, res;
37956         u32 src, dst;
37957
37958         u32 sft;
37959
37960         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37961         src = DREGu16((Opcode >> 0) & 7);
37962         if (sft)
37963         {
37964         m68kcontext.io_cycle_counter -= sft * 2;
37965                 sft %= 17;
37966
37967                 src |= (flag_X & M68K_SR_X) << 8;
37968                 res = (src >> sft) | (src << (17 - sft));
37969                 flag_X = flag_C = res >> 8;
37970                 flag_V = 0;
37971                 flag_N = res >> 8;
37972                 flag_NotZ = res & 0x0000FFFF;
37973         DREGu16((Opcode >> 0) & 7) = res;
37974         RET(6)
37975         }
37976
37977         flag_V = 0;
37978         flag_C = flag_X;
37979         flag_N = src >> 8;
37980         flag_NotZ = src;
37981 RET(6)
37982 }
37983
37984 // ROXRD
37985 OPCODE(0xE0B0)
37986 {
37987 #ifdef USE_CYCLONE_TIMING
37988 #define CYC 8
37989 #else
37990 #define CYC 6
37991 #endif
37992         u32 adr, res;
37993         u32 src, dst;
37994
37995         u32 sft;
37996
37997         sft = DREG((Opcode >> 9) & 7) & 0x3F;
37998         src = DREGu32((Opcode >> 0) & 7);
37999         if (sft)
38000         {
38001         m68kcontext.io_cycle_counter -= sft * 2;
38002                 sft %= 33;
38003
38004                 if (sft != 0)
38005                 {
38006                         if (sft == 1) res = (src >> 1) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1)));
38007                         else res = (src >> sft) | (src << (33 - sft)) | (((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1))) >> (sft - 1));
38008                         flag_X = (src >> (32 - sft)) << M68K_SR_X_SFT;
38009                 }
38010                 else res = src;
38011                 flag_C = flag_X;
38012                 flag_V = 0;
38013                 flag_N = res >> 24;
38014                 flag_NotZ = res;
38015         DREGu32((Opcode >> 0) & 7) = res;
38016         RET(CYC)
38017         }
38018
38019         flag_V = 0;
38020         flag_C = flag_X;
38021         flag_N = src >> 24;
38022         flag_NotZ = src;
38023 RET(CYC)
38024 #undef CYC
38025 }
38026
38027 // RORD
38028 OPCODE(0xE038)
38029 {
38030         u32 adr, res;
38031         u32 src, dst;
38032
38033         u32 sft;
38034
38035         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38036         src = DREGu8((Opcode >> 0) & 7);
38037         if (sft)
38038         {
38039         m68kcontext.io_cycle_counter -= sft * 2;
38040                 sft &= 0x07;
38041
38042                 flag_C = src << (M68K_SR_C_SFT - ((sft - 1) & 7));
38043                 res = (src >> sft) | (src << (8 - sft));
38044                 flag_V = 0;
38045                 flag_N = res >> 0;
38046                 flag_NotZ = res & 0x000000FF;
38047         DREGu8((Opcode >> 0) & 7) = res;
38048         RET(6)
38049         }
38050
38051         flag_V = 0;
38052         flag_C = 0;
38053         flag_N = src >> 0;
38054         flag_NotZ = src;
38055 RET(6)
38056 }
38057
38058 // RORD
38059 OPCODE(0xE078)
38060 {
38061         u32 adr, res;
38062         u32 src, dst;
38063
38064         u32 sft;
38065
38066         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38067         src = DREGu16((Opcode >> 0) & 7);
38068         if (sft)
38069         {
38070         m68kcontext.io_cycle_counter -= sft * 2;
38071                 sft &= 0x0F;
38072
38073                 flag_C = (src >> ((sft - 1) & 15)) << M68K_SR_C_SFT;
38074                 res = (src >> sft) | (src << (16 - sft));
38075                 flag_V = 0;
38076                 flag_N = res >> 8;
38077                 flag_NotZ = res & 0x0000FFFF;
38078         DREGu16((Opcode >> 0) & 7) = res;
38079         RET(6)
38080         }
38081
38082         flag_V = 0;
38083         flag_C = 0;
38084         flag_N = src >> 8;
38085         flag_NotZ = src;
38086 RET(6)
38087 }
38088
38089 // RORD
38090 OPCODE(0xE0B8)
38091 {
38092 #ifdef USE_CYCLONE_TIMING
38093 #define CYC 8
38094 #else
38095 #define CYC 6
38096 #endif
38097         u32 adr, res;
38098         u32 src, dst;
38099
38100         u32 sft;
38101
38102         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38103         src = DREGu32((Opcode >> 0) & 7);
38104         if (sft)
38105         {
38106         m68kcontext.io_cycle_counter -= sft * 2;
38107                 sft &= 0x1F;
38108
38109                 flag_C = (src >> ((sft - 1) & 31)) << M68K_SR_C_SFT;
38110                 res = (src >> sft) | (src << (32 - sft));
38111                 flag_V = 0;
38112                 flag_N = res >> 24;
38113                 flag_NotZ = res;
38114         DREGu32((Opcode >> 0) & 7) = res;
38115         RET(CYC)
38116         }
38117
38118         flag_V = 0;
38119         flag_C = 0;
38120         flag_N = src >> 24;
38121         flag_NotZ = src;
38122 RET(CYC)
38123 #undef CYC
38124 }
38125
38126 // ASLD
38127 OPCODE(0xE120)
38128 {
38129         u32 adr, res;
38130         u32 src, dst;
38131
38132         u32 sft;
38133
38134         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38135         src = DREGu8((Opcode >> 0) & 7);
38136         if (sft)
38137         {
38138         m68kcontext.io_cycle_counter -= sft * 2;
38139                 if (sft < 8)
38140                 {
38141                         flag_X = flag_C = (src << sft) >> 0;
38142                         res = (src << sft) & 0x000000FF;
38143                         flag_N = res >> 0;
38144                         flag_NotZ = res;
38145         DREGu8((Opcode >> 0) & 7) = res;
38146                         flag_V = 0;
38147                         {
38148                                 u32 msk = (((s32)0x80000000) >> (sft + 24)) & 0x000000FF;
38149                                 src &= msk;
38150                                 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38151                         }
38152         RET(6)
38153                 }
38154
38155                 if (sft == 256) flag_C = src << M68K_SR_C_SFT;
38156                 else flag_C = 0;
38157                 flag_X = flag_C;
38158                 if (src) flag_V = M68K_SR_V;
38159                 else flag_V = 0;
38160                 res = 0;
38161         DREGu8((Opcode >> 0) & 7) = res;
38162                 flag_N = 0;
38163                 flag_NotZ = 0;
38164         RET(6)
38165         }
38166
38167         flag_V = 0;
38168         flag_C = 0;
38169         flag_N = src >> 0;
38170         flag_NotZ = src;
38171 RET(6)
38172 }
38173
38174 // ASLD
38175 OPCODE(0xE160)
38176 {
38177         u32 adr, res;
38178         u32 src, dst;
38179
38180         u32 sft;
38181
38182         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38183         src = DREGu16((Opcode >> 0) & 7);
38184         if (sft)
38185         {
38186         m68kcontext.io_cycle_counter -= sft * 2;
38187                 if (sft < 16)
38188                 {
38189                         flag_X = flag_C = (src << sft) >> 8;
38190                         res = (src << sft) & 0x0000FFFF;
38191                         flag_N = res >> 8;
38192                         flag_NotZ = res;
38193         DREGu16((Opcode >> 0) & 7) = res;
38194                         flag_V = 0;
38195                         {
38196                                 u32 msk = (((s32)0x80000000) >> (sft + 16)) & 0x0000FFFF;
38197                                 src &= msk;
38198                                 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38199                         }
38200         RET(6)
38201                 }
38202
38203                 if (sft == 65536) flag_C = src << M68K_SR_C_SFT;
38204                 else flag_C = 0;
38205                 flag_X = flag_C;
38206                 if (src) flag_V = M68K_SR_V;
38207                 else flag_V = 0;
38208                 res = 0;
38209         DREGu16((Opcode >> 0) & 7) = res;
38210                 flag_N = 0;
38211                 flag_NotZ = 0;
38212         RET(6)
38213         }
38214
38215         flag_V = 0;
38216         flag_C = 0;
38217         flag_N = src >> 8;
38218         flag_NotZ = src;
38219 RET(6)
38220 }
38221
38222 // ASLD
38223 OPCODE(0xE1A0)
38224 {
38225 #ifdef USE_CYCLONE_TIMING
38226 #define CYC 8
38227 #else
38228 #define CYC 6
38229 #endif
38230         u32 adr, res;
38231         u32 src, dst;
38232
38233         u32 sft;
38234
38235         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38236         src = DREGu32((Opcode >> 0) & 7);
38237         if (sft)
38238         {
38239         m68kcontext.io_cycle_counter -= sft * 2;
38240                 if (sft < 32)
38241                 {
38242                         flag_X = flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38243                         res = src << sft;
38244                         flag_N = res >> 24;
38245                         flag_NotZ = res;
38246         DREGu32((Opcode >> 0) & 7) = res;
38247                         flag_V = 0;
38248                         {
38249                                 u32 msk = (((s32)0x80000000) >> (sft + 0)) & 0xFFFFFFFF;
38250                                 src &= msk;
38251                                 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38252                         }
38253         RET(CYC)
38254                 }
38255
38256                 if (sft == 0) flag_C = src << M68K_SR_C_SFT;
38257                 else flag_C = 0;
38258                 flag_X = flag_C;
38259                 if (src) flag_V = M68K_SR_V;
38260                 else flag_V = 0;
38261                 res = 0;
38262         DREGu32((Opcode >> 0) & 7) = res;
38263                 flag_N = 0;
38264                 flag_NotZ = 0;
38265         RET(CYC)
38266         }
38267
38268         flag_V = 0;
38269         flag_C = 0;
38270         flag_N = src >> 24;
38271         flag_NotZ = src;
38272 RET(CYC)
38273 #undef CYC
38274 }
38275
38276 // LSLD
38277 OPCODE(0xE128)
38278 {
38279         u32 adr, res;
38280         u32 src, dst;
38281
38282         u32 sft;
38283
38284         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38285         src = DREGu8((Opcode >> 0) & 7);
38286         if (sft)
38287         {
38288         m68kcontext.io_cycle_counter -= sft * 2;
38289                 if (sft <= 8)
38290                 {
38291                         flag_X = flag_C = (src << sft) >> 0;
38292                         res = (src << sft) & 0x000000FF;
38293                         flag_V = 0;
38294                         flag_N = res >> 0;
38295                         flag_NotZ = res;
38296         DREGu8((Opcode >> 0) & 7) = res;
38297         RET(6)
38298                 }
38299
38300                 flag_X = flag_C = 0;
38301                 flag_N = 0;
38302                 flag_NotZ = 0;
38303                 flag_V = 0;
38304                 res = 0;
38305         DREGu8((Opcode >> 0) & 7) = res;
38306         RET(6)
38307         }
38308
38309         flag_V = 0;
38310         flag_C = 0;
38311         flag_N = src >> 0;
38312         flag_NotZ = src;
38313 RET(6)
38314 }
38315
38316 // LSLD
38317 OPCODE(0xE168)
38318 {
38319         u32 adr, res;
38320         u32 src, dst;
38321
38322         u32 sft;
38323
38324         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38325         src = DREGu16((Opcode >> 0) & 7);
38326         if (sft)
38327         {
38328         m68kcontext.io_cycle_counter -= sft * 2;
38329                 if (sft <= 16)
38330                 {
38331                         flag_X = flag_C = (src << sft) >> 8;
38332                         res = (src << sft) & 0x0000FFFF;
38333                         flag_V = 0;
38334                         flag_N = res >> 8;
38335                         flag_NotZ = res;
38336         DREGu16((Opcode >> 0) & 7) = res;
38337         RET(6)
38338                 }
38339
38340                 flag_X = flag_C = 0;
38341                 flag_N = 0;
38342                 flag_NotZ = 0;
38343                 flag_V = 0;
38344                 res = 0;
38345         DREGu16((Opcode >> 0) & 7) = res;
38346         RET(6)
38347         }
38348
38349         flag_V = 0;
38350         flag_C = 0;
38351         flag_N = src >> 8;
38352         flag_NotZ = src;
38353 RET(6)
38354 }
38355
38356 // LSLD
38357 OPCODE(0xE1A8)
38358 {
38359 #ifdef USE_CYCLONE_TIMING
38360 #define CYC 8
38361 #else
38362 #define CYC 6
38363 #endif
38364         u32 adr, res;
38365         u32 src, dst;
38366
38367         u32 sft;
38368
38369         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38370         src = DREGu32((Opcode >> 0) & 7);
38371         if (sft)
38372         {
38373         m68kcontext.io_cycle_counter -= sft * 2;
38374                 if (sft < 32)
38375                 {
38376                         flag_X = flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38377                         res = src << sft;
38378                         flag_V = 0;
38379                         flag_N = res >> 24;
38380                         flag_NotZ = res;
38381         DREGu32((Opcode >> 0) & 7) = res;
38382         RET(CYC)
38383                 }
38384
38385                 if (sft == 32) flag_C = src << M68K_SR_C_SFT;
38386                 else flag_C = 0;
38387                 flag_X = flag_C;
38388                 flag_N = 0;
38389                 flag_NotZ = 0;
38390                 flag_V = 0;
38391                 res = 0;
38392         DREGu32((Opcode >> 0) & 7) = res;
38393         RET(CYC)
38394         }
38395
38396         flag_V = 0;
38397         flag_C = 0;
38398         flag_N = src >> 24;
38399         flag_NotZ = src;
38400 RET(CYC)
38401 #undef CYC
38402 }
38403
38404 // ROXLD
38405 OPCODE(0xE130)
38406 {
38407         u32 adr, res;
38408         u32 src, dst;
38409
38410         u32 sft;
38411
38412         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38413         src = DREGu8((Opcode >> 0) & 7);
38414         if (sft)
38415         {
38416         m68kcontext.io_cycle_counter -= sft * 2;
38417                 sft %= 9;
38418
38419                 src |= (flag_X & M68K_SR_X) << 0;
38420                 res = (src << sft) | (src >> (9 - sft));
38421                 flag_X = flag_C = res >> 0;
38422                 flag_V = 0;
38423                 flag_N = res >> 0;
38424                 flag_NotZ = res & 0x000000FF;
38425         DREGu8((Opcode >> 0) & 7) = res;
38426         RET(6)
38427         }
38428
38429         flag_V = 0;
38430         flag_C = flag_X;
38431         flag_N = src >> 0;
38432         flag_NotZ = src;
38433 RET(6)
38434 }
38435
38436 // ROXLD
38437 OPCODE(0xE170)
38438 {
38439         u32 adr, res;
38440         u32 src, dst;
38441
38442         u32 sft;
38443
38444         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38445         src = DREGu16((Opcode >> 0) & 7);
38446         if (sft)
38447         {
38448         m68kcontext.io_cycle_counter -= sft * 2;
38449                 sft %= 17;
38450
38451                 src |= (flag_X & M68K_SR_X) << 8;
38452                 res = (src << sft) | (src >> (17 - sft));
38453                 flag_X = flag_C = res >> 8;
38454                 flag_V = 0;
38455                 flag_N = res >> 8;
38456                 flag_NotZ = res & 0x0000FFFF;
38457         DREGu16((Opcode >> 0) & 7) = res;
38458         RET(6)
38459         }
38460
38461         flag_V = 0;
38462         flag_C = flag_X;
38463         flag_N = src >> 8;
38464         flag_NotZ = src;
38465 RET(6)
38466 }
38467
38468 // ROXLD
38469 OPCODE(0xE1B0)
38470 {
38471 #ifdef USE_CYCLONE_TIMING
38472 #define CYC 8
38473 #else
38474 #define CYC 6
38475 #endif
38476         u32 adr, res;
38477         u32 src, dst;
38478
38479         u32 sft;
38480
38481         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38482         src = DREGu32((Opcode >> 0) & 7);
38483         if (sft)
38484         {
38485         m68kcontext.io_cycle_counter -= sft * 2;
38486                 sft %= 33;
38487
38488                 if (sft != 0)
38489                 {
38490                         if (sft == 1) res = (src << 1) | ((flag_X >> ((M68K_SR_X_SFT + 1) - 1)) & 1);
38491                         else res = (src << sft) | (src >> (33 - sft)) | (((flag_X >> ((M68K_SR_X_SFT + 1) - 1)) & 1) << (sft - 1));
38492                         flag_X = (src >> (32 - sft)) << M68K_SR_X_SFT;
38493                 }
38494                 else res = src;
38495                 flag_C = flag_X;
38496                 flag_V = 0;
38497                 flag_N = res >> 24;
38498                 flag_NotZ = res;
38499         DREGu32((Opcode >> 0) & 7) = res;
38500         RET(CYC)
38501         }
38502
38503         flag_V = 0;
38504         flag_C = flag_X;
38505         flag_N = src >> 24;
38506         flag_NotZ = src;
38507 RET(CYC)
38508 #undef CYC
38509 }
38510
38511 // ROLD
38512 OPCODE(0xE138)
38513 {
38514         u32 adr, res;
38515         u32 src, dst;
38516
38517         u32 sft;
38518
38519         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38520         src = DREGu8((Opcode >> 0) & 7);
38521         if (sft)
38522         {
38523         m68kcontext.io_cycle_counter -= sft * 2;
38524                 if (sft &= 0x07)
38525                 {
38526                         flag_C = (src << sft) >> 0;
38527                         res = ((src << sft) | (src >> (8 - sft))) & 0x000000FF;
38528                         flag_V = 0;
38529                         flag_N = res >> 0;
38530                         flag_NotZ = res;
38531         DREGu8((Opcode >> 0) & 7) = res;
38532         RET(6)
38533                 }
38534
38535                 flag_V = 0;
38536                 flag_C = src << M68K_SR_C_SFT;
38537                 flag_N = src >> 0;
38538                 flag_NotZ = src;
38539         RET(6)
38540         }
38541
38542         flag_V = 0;
38543         flag_C = 0;
38544         flag_N = src >> 0;
38545         flag_NotZ = src;
38546 RET(6)
38547 }
38548
38549 // ROLD
38550 OPCODE(0xE178)
38551 {
38552         u32 adr, res;
38553         u32 src, dst;
38554
38555         u32 sft;
38556
38557         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38558         src = DREGu16((Opcode >> 0) & 7);
38559         if (sft)
38560         {
38561         m68kcontext.io_cycle_counter -= sft * 2;
38562                 if (sft &= 0x0F)
38563                 {
38564                         flag_C = (src << sft) >> 8;
38565                         res = ((src << sft) | (src >> (16 - sft))) & 0x0000FFFF;
38566                         flag_V = 0;
38567                         flag_N = res >> 8;
38568                         flag_NotZ = res;
38569         DREGu16((Opcode >> 0) & 7) = res;
38570         RET(6)
38571                 }
38572
38573                 flag_V = 0;
38574                 flag_C = src << M68K_SR_C_SFT;
38575                 flag_N = src >> 8;
38576                 flag_NotZ = src;
38577         RET(6)
38578         }
38579
38580         flag_V = 0;
38581         flag_C = 0;
38582         flag_N = src >> 8;
38583         flag_NotZ = src;
38584 RET(6)
38585 }
38586
38587 // ROLD
38588 OPCODE(0xE1B8)
38589 {
38590 #ifdef USE_CYCLONE_TIMING
38591 #define CYC 8
38592 #else
38593 #define CYC 6
38594 #endif
38595         u32 adr, res;
38596         u32 src, dst;
38597
38598         u32 sft;
38599
38600         sft = DREG((Opcode >> 9) & 7) & 0x3F;
38601         src = DREGu32((Opcode >> 0) & 7);
38602         if (sft)
38603         {
38604         m68kcontext.io_cycle_counter -= sft * 2;
38605                 if (sft &= 0x1F)
38606                 {
38607                         flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38608                         res = (src << sft) | (src >> (32 - sft));
38609                         flag_V = 0;
38610                         flag_N = res >> 24;
38611                         flag_NotZ = res;
38612         DREGu32((Opcode >> 0) & 7) = res;
38613         RET(CYC)
38614                 }
38615
38616                 flag_V = 0;
38617                 flag_C = src << M68K_SR_C_SFT;
38618                 flag_N = src >> 24;
38619                 flag_NotZ = src;
38620         RET(CYC)
38621         }
38622
38623         flag_V = 0;
38624         flag_C = 0;
38625         flag_N = src >> 24;
38626         flag_NotZ = src;
38627 RET(CYC)
38628 #undef CYC
38629 }
38630
38631 // ASR
38632 OPCODE(0xE0D0)
38633 {
38634         u32 adr, res;
38635         u32 src, dst;
38636
38637         adr = AREG((Opcode >> 0) & 7);
38638         PRE_IO
38639         READ_WORD_F(adr, src)
38640         flag_V = 0;
38641         flag_X = flag_C = src << M68K_SR_C_SFT;
38642         res = (src >> 1) | (src & (1 << 15));
38643         flag_N = res >> 8;
38644         flag_NotZ = res;
38645         WRITE_WORD_F(adr, res)
38646         POST_IO
38647 RET(12)
38648 }
38649
38650 // ASR
38651 OPCODE(0xE0D8)
38652 {
38653         u32 adr, res;
38654         u32 src, dst;
38655
38656         adr = AREG((Opcode >> 0) & 7);
38657         AREG((Opcode >> 0) & 7) += 2;
38658         PRE_IO
38659         READ_WORD_F(adr, src)
38660         flag_V = 0;
38661         flag_X = flag_C = src << M68K_SR_C_SFT;
38662         res = (src >> 1) | (src & (1 << 15));
38663         flag_N = res >> 8;
38664         flag_NotZ = res;
38665         WRITE_WORD_F(adr, res)
38666         POST_IO
38667 RET(12)
38668 }
38669
38670 // ASR
38671 OPCODE(0xE0E0)
38672 {
38673         u32 adr, res;
38674         u32 src, dst;
38675
38676         adr = AREG((Opcode >> 0) & 7) - 2;
38677         AREG((Opcode >> 0) & 7) = adr;
38678         PRE_IO
38679         READ_WORD_F(adr, src)
38680         flag_V = 0;
38681         flag_X = flag_C = src << M68K_SR_C_SFT;
38682         res = (src >> 1) | (src & (1 << 15));
38683         flag_N = res >> 8;
38684         flag_NotZ = res;
38685         WRITE_WORD_F(adr, res)
38686         POST_IO
38687 RET(14)
38688 }
38689
38690 // ASR
38691 OPCODE(0xE0E8)
38692 {
38693         u32 adr, res;
38694         u32 src, dst;
38695
38696         FETCH_SWORD(adr);
38697         adr += AREG((Opcode >> 0) & 7);
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(0xE0F0)
38712 {
38713         u32 adr, res;
38714         u32 src, dst;
38715
38716         adr = AREG((Opcode >> 0) & 7);
38717         DECODE_EXT_WORD
38718         PRE_IO
38719         READ_WORD_F(adr, src)
38720         flag_V = 0;
38721         flag_X = flag_C = src << M68K_SR_C_SFT;
38722         res = (src >> 1) | (src & (1 << 15));
38723         flag_N = res >> 8;
38724         flag_NotZ = res;
38725         WRITE_WORD_F(adr, res)
38726         POST_IO
38727 RET(18)
38728 }
38729
38730 // ASR
38731 OPCODE(0xE0F8)
38732 {
38733         u32 adr, res;
38734         u32 src, dst;
38735
38736         FETCH_SWORD(adr);
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(16)
38747 }
38748
38749 // ASR
38750 OPCODE(0xE0F9)
38751 {
38752         u32 adr, res;
38753         u32 src, dst;
38754
38755         FETCH_LONG(adr);
38756         PRE_IO
38757         READ_WORD_F(adr, src)
38758         flag_V = 0;
38759         flag_X = flag_C = src << M68K_SR_C_SFT;
38760         res = (src >> 1) | (src & (1 << 15));
38761         flag_N = res >> 8;
38762         flag_NotZ = res;
38763         WRITE_WORD_F(adr, res)
38764         POST_IO
38765 RET(20)
38766 }
38767
38768 // ASR
38769 OPCODE(0xE0DF)
38770 {
38771         u32 adr, res;
38772         u32 src, dst;
38773
38774         adr = AREG(7);
38775         AREG(7) += 2;
38776         PRE_IO
38777         READ_WORD_F(adr, src)
38778         flag_V = 0;
38779         flag_X = flag_C = src << M68K_SR_C_SFT;
38780         res = (src >> 1) | (src & (1 << 15));
38781         flag_N = res >> 8;
38782         flag_NotZ = res;
38783         WRITE_WORD_F(adr, res)
38784         POST_IO
38785 RET(12)
38786 }
38787
38788 // ASR
38789 OPCODE(0xE0E7)
38790 {
38791         u32 adr, res;
38792         u32 src, dst;
38793
38794         adr = AREG(7) - 2;
38795         AREG(7) = adr;
38796         PRE_IO
38797         READ_WORD_F(adr, src)
38798         flag_V = 0;
38799         flag_X = flag_C = src << M68K_SR_C_SFT;
38800         res = (src >> 1) | (src & (1 << 15));
38801         flag_N = res >> 8;
38802         flag_NotZ = res;
38803         WRITE_WORD_F(adr, res)
38804         POST_IO
38805 RET(14)
38806 }
38807
38808 // LSR
38809 OPCODE(0xE2D0)
38810 {
38811         u32 adr, res;
38812         u32 src, dst;
38813
38814         adr = AREG((Opcode >> 0) & 7);
38815         PRE_IO
38816         READ_WORD_F(adr, src)
38817         flag_N = flag_V = 0;
38818         flag_X = flag_C = src << M68K_SR_C_SFT;
38819         res = src >> 1;
38820         flag_NotZ = res;
38821         WRITE_WORD_F(adr, res)
38822         POST_IO
38823 RET(12)
38824 }
38825
38826 // LSR
38827 OPCODE(0xE2D8)
38828 {
38829         u32 adr, res;
38830         u32 src, dst;
38831
38832         adr = AREG((Opcode >> 0) & 7);
38833         AREG((Opcode >> 0) & 7) += 2;
38834         PRE_IO
38835         READ_WORD_F(adr, src)
38836         flag_N = flag_V = 0;
38837         flag_X = flag_C = src << M68K_SR_C_SFT;
38838         res = src >> 1;
38839         flag_NotZ = res;
38840         WRITE_WORD_F(adr, res)
38841         POST_IO
38842 RET(12)
38843 }
38844
38845 // LSR
38846 OPCODE(0xE2E0)
38847 {
38848         u32 adr, res;
38849         u32 src, dst;
38850
38851         adr = AREG((Opcode >> 0) & 7) - 2;
38852         AREG((Opcode >> 0) & 7) = adr;
38853         PRE_IO
38854         READ_WORD_F(adr, src)
38855         flag_N = flag_V = 0;
38856         flag_X = flag_C = src << M68K_SR_C_SFT;
38857         res = src >> 1;
38858         flag_NotZ = res;
38859         WRITE_WORD_F(adr, res)
38860         POST_IO
38861 RET(14)
38862 }
38863
38864 // LSR
38865 OPCODE(0xE2E8)
38866 {
38867         u32 adr, res;
38868         u32 src, dst;
38869
38870         FETCH_SWORD(adr);
38871         adr += AREG((Opcode >> 0) & 7);
38872         PRE_IO
38873         READ_WORD_F(adr, src)
38874         flag_N = flag_V = 0;
38875         flag_X = flag_C = src << M68K_SR_C_SFT;
38876         res = src >> 1;
38877         flag_NotZ = res;
38878         WRITE_WORD_F(adr, res)
38879         POST_IO
38880 RET(16)
38881 }
38882
38883 // LSR
38884 OPCODE(0xE2F0)
38885 {
38886         u32 adr, res;
38887         u32 src, dst;
38888
38889         adr = AREG((Opcode >> 0) & 7);
38890         DECODE_EXT_WORD
38891         PRE_IO
38892         READ_WORD_F(adr, src)
38893         flag_N = flag_V = 0;
38894         flag_X = flag_C = src << M68K_SR_C_SFT;
38895         res = src >> 1;
38896         flag_NotZ = res;
38897         WRITE_WORD_F(adr, res)
38898         POST_IO
38899 RET(18)
38900 }
38901
38902 // LSR
38903 OPCODE(0xE2F8)
38904 {
38905         u32 adr, res;
38906         u32 src, dst;
38907
38908         FETCH_SWORD(adr);
38909         PRE_IO
38910         READ_WORD_F(adr, src)
38911         flag_N = flag_V = 0;
38912         flag_X = flag_C = src << M68K_SR_C_SFT;
38913         res = src >> 1;
38914         flag_NotZ = res;
38915         WRITE_WORD_F(adr, res)
38916         POST_IO
38917 RET(16)
38918 }
38919
38920 // LSR
38921 OPCODE(0xE2F9)
38922 {
38923         u32 adr, res;
38924         u32 src, dst;
38925
38926         FETCH_LONG(adr);
38927         PRE_IO
38928         READ_WORD_F(adr, src)
38929         flag_N = flag_V = 0;
38930         flag_X = flag_C = src << M68K_SR_C_SFT;
38931         res = src >> 1;
38932         flag_NotZ = res;
38933         WRITE_WORD_F(adr, res)
38934         POST_IO
38935 RET(20)
38936 }
38937
38938 // LSR
38939 OPCODE(0xE2DF)
38940 {
38941         u32 adr, res;
38942         u32 src, dst;
38943
38944         adr = AREG(7);
38945         AREG(7) += 2;
38946         PRE_IO
38947         READ_WORD_F(adr, src)
38948         flag_N = flag_V = 0;
38949         flag_X = flag_C = src << M68K_SR_C_SFT;
38950         res = src >> 1;
38951         flag_NotZ = res;
38952         WRITE_WORD_F(adr, res)
38953         POST_IO
38954 RET(12)
38955 }
38956
38957 // LSR
38958 OPCODE(0xE2E7)
38959 {
38960         u32 adr, res;
38961         u32 src, dst;
38962
38963         adr = AREG(7) - 2;
38964         AREG(7) = adr;
38965         PRE_IO
38966         READ_WORD_F(adr, src)
38967         flag_N = flag_V = 0;
38968         flag_X = flag_C = src << M68K_SR_C_SFT;
38969         res = src >> 1;
38970         flag_NotZ = res;
38971         WRITE_WORD_F(adr, res)
38972         POST_IO
38973 RET(14)
38974 }
38975
38976 // ROXR
38977 OPCODE(0xE4D0)
38978 {
38979         u32 adr, res;
38980         u32 src, dst;
38981
38982         adr = AREG((Opcode >> 0) & 7);
38983         PRE_IO
38984         READ_WORD_F(adr, src)
38985         flag_V = 0;
38986         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
38987         flag_C = flag_X = src << M68K_SR_C_SFT;
38988         flag_N = res >> 8;
38989         flag_NotZ = res;
38990         WRITE_WORD_F(adr, res)
38991         POST_IO
38992 RET(12)
38993 }
38994
38995 // ROXR
38996 OPCODE(0xE4D8)
38997 {
38998         u32 adr, res;
38999         u32 src, dst;
39000
39001         adr = AREG((Opcode >> 0) & 7);
39002         AREG((Opcode >> 0) & 7) += 2;
39003         PRE_IO
39004         READ_WORD_F(adr, src)
39005         flag_V = 0;
39006         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39007         flag_C = flag_X = src << M68K_SR_C_SFT;
39008         flag_N = res >> 8;
39009         flag_NotZ = res;
39010         WRITE_WORD_F(adr, res)
39011         POST_IO
39012 RET(12)
39013 }
39014
39015 // ROXR
39016 OPCODE(0xE4E0)
39017 {
39018         u32 adr, res;
39019         u32 src, dst;
39020
39021         adr = AREG((Opcode >> 0) & 7) - 2;
39022         AREG((Opcode >> 0) & 7) = adr;
39023         PRE_IO
39024         READ_WORD_F(adr, src)
39025         flag_V = 0;
39026         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39027         flag_C = flag_X = src << M68K_SR_C_SFT;
39028         flag_N = res >> 8;
39029         flag_NotZ = res;
39030         WRITE_WORD_F(adr, res)
39031         POST_IO
39032 RET(14)
39033 }
39034
39035 // ROXR
39036 OPCODE(0xE4E8)
39037 {
39038         u32 adr, res;
39039         u32 src, dst;
39040
39041         FETCH_SWORD(adr);
39042         adr += AREG((Opcode >> 0) & 7);
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(0xE4F0)
39057 {
39058         u32 adr, res;
39059         u32 src, dst;
39060
39061         adr = AREG((Opcode >> 0) & 7);
39062         DECODE_EXT_WORD
39063         PRE_IO
39064         READ_WORD_F(adr, src)
39065         flag_V = 0;
39066         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39067         flag_C = flag_X = src << M68K_SR_C_SFT;
39068         flag_N = res >> 8;
39069         flag_NotZ = res;
39070         WRITE_WORD_F(adr, res)
39071         POST_IO
39072 RET(18)
39073 }
39074
39075 // ROXR
39076 OPCODE(0xE4F8)
39077 {
39078         u32 adr, res;
39079         u32 src, dst;
39080
39081         FETCH_SWORD(adr);
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(16)
39092 }
39093
39094 // ROXR
39095 OPCODE(0xE4F9)
39096 {
39097         u32 adr, res;
39098         u32 src, dst;
39099
39100         FETCH_LONG(adr);
39101         PRE_IO
39102         READ_WORD_F(adr, src)
39103         flag_V = 0;
39104         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39105         flag_C = flag_X = src << M68K_SR_C_SFT;
39106         flag_N = res >> 8;
39107         flag_NotZ = res;
39108         WRITE_WORD_F(adr, res)
39109         POST_IO
39110 RET(20)
39111 }
39112
39113 // ROXR
39114 OPCODE(0xE4DF)
39115 {
39116         u32 adr, res;
39117         u32 src, dst;
39118
39119         adr = AREG(7);
39120         AREG(7) += 2;
39121         PRE_IO
39122         READ_WORD_F(adr, src)
39123         flag_V = 0;
39124         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39125         flag_C = flag_X = src << M68K_SR_C_SFT;
39126         flag_N = res >> 8;
39127         flag_NotZ = res;
39128         WRITE_WORD_F(adr, res)
39129         POST_IO
39130 RET(12)
39131 }
39132
39133 // ROXR
39134 OPCODE(0xE4E7)
39135 {
39136         u32 adr, res;
39137         u32 src, dst;
39138
39139         adr = AREG(7) - 2;
39140         AREG(7) = adr;
39141         PRE_IO
39142         READ_WORD_F(adr, src)
39143         flag_V = 0;
39144         res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39145         flag_C = flag_X = src << M68K_SR_C_SFT;
39146         flag_N = res >> 8;
39147         flag_NotZ = res;
39148         WRITE_WORD_F(adr, res)
39149         POST_IO
39150 RET(14)
39151 }
39152
39153 // ROR
39154 OPCODE(0xE6D0)
39155 {
39156         u32 adr, res;
39157         u32 src, dst;
39158
39159         adr = AREG((Opcode >> 0) & 7);
39160         PRE_IO
39161         READ_WORD_F(adr, src)
39162         flag_V = 0;
39163         flag_C = src << M68K_SR_C_SFT;
39164         res = (src >> 1) | (src << 15);
39165         flag_N = res >> 8;
39166         flag_NotZ = res & 0x0000FFFF;
39167         WRITE_WORD_F(adr, res)
39168         POST_IO
39169 RET(12)
39170 }
39171
39172 // ROR
39173 OPCODE(0xE6D8)
39174 {
39175         u32 adr, res;
39176         u32 src, dst;
39177
39178         adr = AREG((Opcode >> 0) & 7);
39179         AREG((Opcode >> 0) & 7) += 2;
39180         PRE_IO
39181         READ_WORD_F(adr, src)
39182         flag_V = 0;
39183         flag_C = src << M68K_SR_C_SFT;
39184         res = (src >> 1) | (src << 15);
39185         flag_N = res >> 8;
39186         flag_NotZ = res & 0x0000FFFF;
39187         WRITE_WORD_F(adr, res)
39188         POST_IO
39189 RET(12)
39190 }
39191
39192 // ROR
39193 OPCODE(0xE6E0)
39194 {
39195         u32 adr, res;
39196         u32 src, dst;
39197
39198         adr = AREG((Opcode >> 0) & 7) - 2;
39199         AREG((Opcode >> 0) & 7) = adr;
39200         PRE_IO
39201         READ_WORD_F(adr, src)
39202         flag_V = 0;
39203         flag_C = src << M68K_SR_C_SFT;
39204         res = (src >> 1) | (src << 15);
39205         flag_N = res >> 8;
39206         flag_NotZ = res & 0x0000FFFF;
39207         WRITE_WORD_F(adr, res)
39208         POST_IO
39209 RET(14)
39210 }
39211
39212 // ROR
39213 OPCODE(0xE6E8)
39214 {
39215         u32 adr, res;
39216         u32 src, dst;
39217
39218         FETCH_SWORD(adr);
39219         adr += AREG((Opcode >> 0) & 7);
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(0xE6F0)
39234 {
39235         u32 adr, res;
39236         u32 src, dst;
39237
39238         adr = AREG((Opcode >> 0) & 7);
39239         DECODE_EXT_WORD
39240         PRE_IO
39241         READ_WORD_F(adr, src)
39242         flag_V = 0;
39243         flag_C = src << M68K_SR_C_SFT;
39244         res = (src >> 1) | (src << 15);
39245         flag_N = res >> 8;
39246         flag_NotZ = res & 0x0000FFFF;
39247         WRITE_WORD_F(adr, res)
39248         POST_IO
39249 RET(18)
39250 }
39251
39252 // ROR
39253 OPCODE(0xE6F8)
39254 {
39255         u32 adr, res;
39256         u32 src, dst;
39257
39258         FETCH_SWORD(adr);
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(16)
39269 }
39270
39271 // ROR
39272 OPCODE(0xE6F9)
39273 {
39274         u32 adr, res;
39275         u32 src, dst;
39276
39277         FETCH_LONG(adr);
39278         PRE_IO
39279         READ_WORD_F(adr, src)
39280         flag_V = 0;
39281         flag_C = src << M68K_SR_C_SFT;
39282         res = (src >> 1) | (src << 15);
39283         flag_N = res >> 8;
39284         flag_NotZ = res & 0x0000FFFF;
39285         WRITE_WORD_F(adr, res)
39286         POST_IO
39287 RET(20)
39288 }
39289
39290 // ROR
39291 OPCODE(0xE6DF)
39292 {
39293         u32 adr, res;
39294         u32 src, dst;
39295
39296         adr = AREG(7);
39297         AREG(7) += 2;
39298         PRE_IO
39299         READ_WORD_F(adr, src)
39300         flag_V = 0;
39301         flag_C = src << M68K_SR_C_SFT;
39302         res = (src >> 1) | (src << 15);
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 // ROR
39311 OPCODE(0xE6E7)
39312 {
39313         u32 adr, res;
39314         u32 src, dst;
39315
39316         adr = AREG(7) - 2;
39317         AREG(7) = adr;
39318         PRE_IO
39319         READ_WORD_F(adr, src)
39320         flag_V = 0;
39321         flag_C = src << M68K_SR_C_SFT;
39322         res = (src >> 1) | (src << 15);
39323         flag_N = res >> 8;
39324         flag_NotZ = res & 0x0000FFFF;
39325         WRITE_WORD_F(adr, res)
39326         POST_IO
39327 RET(14)
39328 }
39329
39330 // ASL
39331 OPCODE(0xE1D0)
39332 {
39333         u32 adr, res;
39334         u32 src, dst;
39335
39336         adr = AREG((Opcode >> 0) & 7);
39337         PRE_IO
39338         READ_WORD_F(adr, src)
39339         flag_X = flag_C = src >> 7;
39340         res = src << 1;
39341         flag_V = (src ^ res) >> 8;
39342         flag_N = res >> 8;
39343         flag_NotZ = res & 0x0000FFFF;
39344         WRITE_WORD_F(adr, res)
39345         POST_IO
39346 RET(12)
39347 }
39348
39349 // ASL
39350 OPCODE(0xE1D8)
39351 {
39352         u32 adr, res;
39353         u32 src, dst;
39354
39355         adr = AREG((Opcode >> 0) & 7);
39356         AREG((Opcode >> 0) & 7) += 2;
39357         PRE_IO
39358         READ_WORD_F(adr, src)
39359         flag_X = flag_C = src >> 7;
39360         res = src << 1;
39361         flag_V = (src ^ res) >> 8;
39362         flag_N = res >> 8;
39363         flag_NotZ = res & 0x0000FFFF;
39364         WRITE_WORD_F(adr, res)
39365         POST_IO
39366 RET(12)
39367 }
39368
39369 // ASL
39370 OPCODE(0xE1E0)
39371 {
39372         u32 adr, res;
39373         u32 src, dst;
39374
39375         adr = AREG((Opcode >> 0) & 7) - 2;
39376         AREG((Opcode >> 0) & 7) = adr;
39377         PRE_IO
39378         READ_WORD_F(adr, src)
39379         flag_X = flag_C = src >> 7;
39380         res = src << 1;
39381         flag_V = (src ^ res) >> 8;
39382         flag_N = res >> 8;
39383         flag_NotZ = res & 0x0000FFFF;
39384         WRITE_WORD_F(adr, res)
39385         POST_IO
39386 RET(14)
39387 }
39388
39389 // ASL
39390 OPCODE(0xE1E8)
39391 {
39392         u32 adr, res;
39393         u32 src, dst;
39394
39395         FETCH_SWORD(adr);
39396         adr += AREG((Opcode >> 0) & 7);
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(0xE1F0)
39411 {
39412         u32 adr, res;
39413         u32 src, dst;
39414
39415         adr = AREG((Opcode >> 0) & 7);
39416         DECODE_EXT_WORD
39417         PRE_IO
39418         READ_WORD_F(adr, src)
39419         flag_X = flag_C = src >> 7;
39420         res = src << 1;
39421         flag_V = (src ^ res) >> 8;
39422         flag_N = res >> 8;
39423         flag_NotZ = res & 0x0000FFFF;
39424         WRITE_WORD_F(adr, res)
39425         POST_IO
39426 RET(18)
39427 }
39428
39429 // ASL
39430 OPCODE(0xE1F8)
39431 {
39432         u32 adr, res;
39433         u32 src, dst;
39434
39435         FETCH_SWORD(adr);
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(16)
39446 }
39447
39448 // ASL
39449 OPCODE(0xE1F9)
39450 {
39451         u32 adr, res;
39452         u32 src, dst;
39453
39454         FETCH_LONG(adr);
39455         PRE_IO
39456         READ_WORD_F(adr, src)
39457         flag_X = flag_C = src >> 7;
39458         res = src << 1;
39459         flag_V = (src ^ res) >> 8;
39460         flag_N = res >> 8;
39461         flag_NotZ = res & 0x0000FFFF;
39462         WRITE_WORD_F(adr, res)
39463         POST_IO
39464 RET(20)
39465 }
39466
39467 // ASL
39468 OPCODE(0xE1DF)
39469 {
39470         u32 adr, res;
39471         u32 src, dst;
39472
39473         adr = AREG(7);
39474         AREG(7) += 2;
39475         PRE_IO
39476         READ_WORD_F(adr, src)
39477         flag_X = flag_C = src >> 7;
39478         res = src << 1;
39479         flag_V = (src ^ res) >> 8;
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 // ASL
39488 OPCODE(0xE1E7)
39489 {
39490         u32 adr, res;
39491         u32 src, dst;
39492
39493         adr = AREG(7) - 2;
39494         AREG(7) = adr;
39495         PRE_IO
39496         READ_WORD_F(adr, src)
39497         flag_X = flag_C = src >> 7;
39498         res = src << 1;
39499         flag_V = (src ^ res) >> 8;
39500         flag_N = res >> 8;
39501         flag_NotZ = res & 0x0000FFFF;
39502         WRITE_WORD_F(adr, res)
39503         POST_IO
39504 RET(14)
39505 }
39506
39507 // LSL
39508 OPCODE(0xE3D0)
39509 {
39510         u32 adr, res;
39511         u32 src, dst;
39512
39513         adr = AREG((Opcode >> 0) & 7);
39514         PRE_IO
39515         READ_WORD_F(adr, src)
39516         flag_V = 0;
39517         flag_X = flag_C = src >> 7;
39518         res = src << 1;
39519         flag_N = res >> 8;
39520         flag_NotZ = res & 0x0000FFFF;
39521         WRITE_WORD_F(adr, res)
39522         POST_IO
39523 RET(12)
39524 }
39525
39526 // LSL
39527 OPCODE(0xE3D8)
39528 {
39529         u32 adr, res;
39530         u32 src, dst;
39531
39532         adr = AREG((Opcode >> 0) & 7);
39533         AREG((Opcode >> 0) & 7) += 2;
39534         PRE_IO
39535         READ_WORD_F(adr, src)
39536         flag_V = 0;
39537         flag_X = flag_C = src >> 7;
39538         res = src << 1;
39539         flag_N = res >> 8;
39540         flag_NotZ = res & 0x0000FFFF;
39541         WRITE_WORD_F(adr, res)
39542         POST_IO
39543 RET(12)
39544 }
39545
39546 // LSL
39547 OPCODE(0xE3E0)
39548 {
39549         u32 adr, res;
39550         u32 src, dst;
39551
39552         adr = AREG((Opcode >> 0) & 7) - 2;
39553         AREG((Opcode >> 0) & 7) = adr;
39554         PRE_IO
39555         READ_WORD_F(adr, src)
39556         flag_V = 0;
39557         flag_X = flag_C = src >> 7;
39558         res = src << 1;
39559         flag_N = res >> 8;
39560         flag_NotZ = res & 0x0000FFFF;
39561         WRITE_WORD_F(adr, res)
39562         POST_IO
39563 RET(14)
39564 }
39565
39566 // LSL
39567 OPCODE(0xE3E8)
39568 {
39569         u32 adr, res;
39570         u32 src, dst;
39571
39572         FETCH_SWORD(adr);
39573         adr += AREG((Opcode >> 0) & 7);
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(0xE3F0)
39588 {
39589         u32 adr, res;
39590         u32 src, dst;
39591
39592         adr = AREG((Opcode >> 0) & 7);
39593         DECODE_EXT_WORD
39594         PRE_IO
39595         READ_WORD_F(adr, src)
39596         flag_V = 0;
39597         flag_X = flag_C = src >> 7;
39598         res = src << 1;
39599         flag_N = res >> 8;
39600         flag_NotZ = res & 0x0000FFFF;
39601         WRITE_WORD_F(adr, res)
39602         POST_IO
39603 RET(18)
39604 }
39605
39606 // LSL
39607 OPCODE(0xE3F8)
39608 {
39609         u32 adr, res;
39610         u32 src, dst;
39611
39612         FETCH_SWORD(adr);
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(16)
39623 }
39624
39625 // LSL
39626 OPCODE(0xE3F9)
39627 {
39628         u32 adr, res;
39629         u32 src, dst;
39630
39631         FETCH_LONG(adr);
39632         PRE_IO
39633         READ_WORD_F(adr, src)
39634         flag_V = 0;
39635         flag_X = flag_C = src >> 7;
39636         res = src << 1;
39637         flag_N = res >> 8;
39638         flag_NotZ = res & 0x0000FFFF;
39639         WRITE_WORD_F(adr, res)
39640         POST_IO
39641 RET(20)
39642 }
39643
39644 // LSL
39645 OPCODE(0xE3DF)
39646 {
39647         u32 adr, res;
39648         u32 src, dst;
39649
39650         adr = AREG(7);
39651         AREG(7) += 2;
39652         PRE_IO
39653         READ_WORD_F(adr, src)
39654         flag_V = 0;
39655         flag_X = flag_C = src >> 7;
39656         res = src << 1;
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 // LSL
39665 OPCODE(0xE3E7)
39666 {
39667         u32 adr, res;
39668         u32 src, dst;
39669
39670         adr = AREG(7) - 2;
39671         AREG(7) = adr;
39672         PRE_IO
39673         READ_WORD_F(adr, src)
39674         flag_V = 0;
39675         flag_X = flag_C = src >> 7;
39676         res = src << 1;
39677         flag_N = res >> 8;
39678         flag_NotZ = res & 0x0000FFFF;
39679         WRITE_WORD_F(adr, res)
39680         POST_IO
39681 RET(14)
39682 }
39683
39684 // ROXL
39685 OPCODE(0xE5D0)
39686 {
39687         u32 adr, res;
39688         u32 src, dst;
39689
39690         adr = AREG((Opcode >> 0) & 7);
39691         PRE_IO
39692         READ_WORD_F(adr, src)
39693         flag_V = 0;
39694         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39695         flag_X = flag_C = src >> 7;
39696         flag_N = res >> 8;
39697         flag_NotZ = res & 0x0000FFFF;
39698         WRITE_WORD_F(adr, res)
39699         POST_IO
39700 RET(12)
39701 }
39702
39703 // ROXL
39704 OPCODE(0xE5D8)
39705 {
39706         u32 adr, res;
39707         u32 src, dst;
39708
39709         adr = AREG((Opcode >> 0) & 7);
39710         AREG((Opcode >> 0) & 7) += 2;
39711         PRE_IO
39712         READ_WORD_F(adr, src)
39713         flag_V = 0;
39714         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39715         flag_X = flag_C = src >> 7;
39716         flag_N = res >> 8;
39717         flag_NotZ = res & 0x0000FFFF;
39718         WRITE_WORD_F(adr, res)
39719         POST_IO
39720 RET(12)
39721 }
39722
39723 // ROXL
39724 OPCODE(0xE5E0)
39725 {
39726         u32 adr, res;
39727         u32 src, dst;
39728
39729         adr = AREG((Opcode >> 0) & 7) - 2;
39730         AREG((Opcode >> 0) & 7) = adr;
39731         PRE_IO
39732         READ_WORD_F(adr, src)
39733         flag_V = 0;
39734         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39735         flag_X = flag_C = src >> 7;
39736         flag_N = res >> 8;
39737         flag_NotZ = res & 0x0000FFFF;
39738         WRITE_WORD_F(adr, res)
39739         POST_IO
39740 RET(14)
39741 }
39742
39743 // ROXL
39744 OPCODE(0xE5E8)
39745 {
39746         u32 adr, res;
39747         u32 src, dst;
39748
39749         FETCH_SWORD(adr);
39750         adr += AREG((Opcode >> 0) & 7);
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(0xE5F0)
39765 {
39766         u32 adr, res;
39767         u32 src, dst;
39768
39769         adr = AREG((Opcode >> 0) & 7);
39770         DECODE_EXT_WORD
39771         PRE_IO
39772         READ_WORD_F(adr, src)
39773         flag_V = 0;
39774         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39775         flag_X = flag_C = src >> 7;
39776         flag_N = res >> 8;
39777         flag_NotZ = res & 0x0000FFFF;
39778         WRITE_WORD_F(adr, res)
39779         POST_IO
39780 RET(18)
39781 }
39782
39783 // ROXL
39784 OPCODE(0xE5F8)
39785 {
39786         u32 adr, res;
39787         u32 src, dst;
39788
39789         FETCH_SWORD(adr);
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(16)
39800 }
39801
39802 // ROXL
39803 OPCODE(0xE5F9)
39804 {
39805         u32 adr, res;
39806         u32 src, dst;
39807
39808         FETCH_LONG(adr);
39809         PRE_IO
39810         READ_WORD_F(adr, src)
39811         flag_V = 0;
39812         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39813         flag_X = flag_C = src >> 7;
39814         flag_N = res >> 8;
39815         flag_NotZ = res & 0x0000FFFF;
39816         WRITE_WORD_F(adr, res)
39817         POST_IO
39818 RET(20)
39819 }
39820
39821 // ROXL
39822 OPCODE(0xE5DF)
39823 {
39824         u32 adr, res;
39825         u32 src, dst;
39826
39827         adr = AREG(7);
39828         AREG(7) += 2;
39829         PRE_IO
39830         READ_WORD_F(adr, src)
39831         flag_V = 0;
39832         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39833         flag_X = flag_C = src >> 7;
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 // ROXL
39842 OPCODE(0xE5E7)
39843 {
39844         u32 adr, res;
39845         u32 src, dst;
39846
39847         adr = AREG(7) - 2;
39848         AREG(7) = adr;
39849         PRE_IO
39850         READ_WORD_F(adr, src)
39851         flag_V = 0;
39852         res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39853         flag_X = flag_C = src >> 7;
39854         flag_N = res >> 8;
39855         flag_NotZ = res & 0x0000FFFF;
39856         WRITE_WORD_F(adr, res)
39857         POST_IO
39858 RET(14)
39859 }
39860
39861 // ROL
39862 OPCODE(0xE7D0)
39863 {
39864         u32 adr, res;
39865         u32 src, dst;
39866
39867         adr = AREG((Opcode >> 0) & 7);
39868         PRE_IO
39869         READ_WORD_F(adr, src)
39870         flag_V = 0;
39871         flag_C = src >> 7;
39872         res = (src << 1) | (src >> 15);
39873         flag_N = res >> 8;
39874         flag_NotZ = res & 0x0000FFFF;
39875         WRITE_WORD_F(adr, res)
39876         POST_IO
39877 RET(12)
39878 }
39879
39880 // ROL
39881 OPCODE(0xE7D8)
39882 {
39883         u32 adr, res;
39884         u32 src, dst;
39885
39886         adr = AREG((Opcode >> 0) & 7);
39887         AREG((Opcode >> 0) & 7) += 2;
39888         PRE_IO
39889         READ_WORD_F(adr, src)
39890         flag_V = 0;
39891         flag_C = src >> 7;
39892         res = (src << 1) | (src >> 15);
39893         flag_N = res >> 8;
39894         flag_NotZ = res & 0x0000FFFF;
39895         WRITE_WORD_F(adr, res)
39896         POST_IO
39897 RET(12)
39898 }
39899
39900 // ROL
39901 OPCODE(0xE7E0)
39902 {
39903         u32 adr, res;
39904         u32 src, dst;
39905
39906         adr = AREG((Opcode >> 0) & 7) - 2;
39907         AREG((Opcode >> 0) & 7) = adr;
39908         PRE_IO
39909         READ_WORD_F(adr, src)
39910         flag_V = 0;
39911         flag_C = src >> 7;
39912         res = (src << 1) | (src >> 15);
39913         flag_N = res >> 8;
39914         flag_NotZ = res & 0x0000FFFF;
39915         WRITE_WORD_F(adr, res)
39916         POST_IO
39917 RET(14)
39918 }
39919
39920 // ROL
39921 OPCODE(0xE7E8)
39922 {
39923         u32 adr, res;
39924         u32 src, dst;
39925
39926         FETCH_SWORD(adr);
39927         adr += AREG((Opcode >> 0) & 7);
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(0xE7F0)
39942 {
39943         u32 adr, res;
39944         u32 src, dst;
39945
39946         adr = AREG((Opcode >> 0) & 7);
39947         DECODE_EXT_WORD
39948         PRE_IO
39949         READ_WORD_F(adr, src)
39950         flag_V = 0;
39951         flag_C = src >> 7;
39952         res = (src << 1) | (src >> 15);
39953         flag_N = res >> 8;
39954         flag_NotZ = res & 0x0000FFFF;
39955         WRITE_WORD_F(adr, res)
39956         POST_IO
39957 RET(18)
39958 }
39959
39960 // ROL
39961 OPCODE(0xE7F8)
39962 {
39963         u32 adr, res;
39964         u32 src, dst;
39965
39966         FETCH_SWORD(adr);
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(16)
39977 }
39978
39979 // ROL
39980 OPCODE(0xE7F9)
39981 {
39982         u32 adr, res;
39983         u32 src, dst;
39984
39985         FETCH_LONG(adr);
39986         PRE_IO
39987         READ_WORD_F(adr, src)
39988         flag_V = 0;
39989         flag_C = src >> 7;
39990         res = (src << 1) | (src >> 15);
39991         flag_N = res >> 8;
39992         flag_NotZ = res & 0x0000FFFF;
39993         WRITE_WORD_F(adr, res)
39994         POST_IO
39995 RET(20)
39996 }
39997
39998 // ROL
39999 OPCODE(0xE7DF)
40000 {
40001         u32 adr, res;
40002         u32 src, dst;
40003
40004         adr = AREG(7);
40005         AREG(7) += 2;
40006         PRE_IO
40007         READ_WORD_F(adr, src)
40008         flag_V = 0;
40009         flag_C = src >> 7;
40010         res = (src << 1) | (src >> 15);
40011         flag_N = res >> 8;
40012         flag_NotZ = res & 0x0000FFFF;
40013         WRITE_WORD_F(adr, res)
40014         POST_IO
40015 RET(12)
40016 }
40017
40018 // ROL
40019 OPCODE(0xE7E7)
40020 {
40021         u32 adr, res;
40022         u32 src, dst;
40023
40024         adr = AREG(7) - 2;
40025         AREG(7) = adr;
40026         PRE_IO
40027         READ_WORD_F(adr, src)
40028         flag_V = 0;
40029         flag_C = src >> 7;
40030         res = (src << 1) | (src >> 15);
40031         flag_N = res >> 8;
40032         flag_NotZ = res & 0x0000FFFF;
40033         WRITE_WORD_F(adr, res)
40034         POST_IO
40035 RET(14)
40036 }
40037
40038 #ifdef PICODRIVE_HACK
40039 #if 0
40040 #define UPDATE_IDLE_COUNT { \
40041         extern int idle_hit_counter; \
40042         idle_hit_counter++; \
40043 }
40044 #else
40045 #define UPDATE_IDLE_COUNT
40046 #endif
40047
40048 // BRA
40049 OPCODE(0x6001_idle)
40050 {
40051 #ifdef FAMEC_CHECK_BRANCHES
40052         u32 newPC = GET_PC;
40053         s8 offs=Opcode;
40054         newPC += offs;
40055         SET_PC(newPC);
40056         CHECK_BRANCH_EXCEPTION(offs)
40057 #else
40058         PC += ((s8)(Opcode & 0xFE)) >> 1;
40059 #endif
40060         UPDATE_IDLE_COUNT
40061 RET0()
40062 }
40063
40064 // BCC
40065 OPCODE(0x6601_idle)
40066 {
40067         if (flag_NotZ)
40068         {
40069                 UPDATE_IDLE_COUNT
40070                 PC += ((s8)(Opcode & 0xFE)) >> 1;
40071                 //if (idle_hit)
40072                 RET0()
40073         }
40074 RET(8)
40075 }
40076
40077 OPCODE(0x6701_idle)
40078 {
40079         if (!flag_NotZ)
40080         {
40081                 UPDATE_IDLE_COUNT
40082                 PC += ((s8)(Opcode & 0xFE)) >> 1;
40083                 //if (idle_hit)
40084                 RET0()
40085         }
40086 RET(8)
40087 }
40088
40089
40090 extern int SekIsIdleReady(void);
40091 extern int SekIsIdleCode(unsigned short *dst, int bytes);
40092 extern int SekRegisterIdlePatch(unsigned int pc, int oldop, int newop, void *ctx);
40093
40094 OPCODE(idle_detector_bcc8)
40095 {
40096         int frame_count, cond_true, bytes, ret, newop;
40097         u16 *dest_pc;
40098
40099         dest_pc = PC + (((s8)(Opcode & 0xFE)) >> 1);
40100
40101         if (!SekIsIdleReady())
40102                 goto end;
40103
40104         bytes = 0 - (s8)(Opcode & 0xFE) - 2;
40105         ret = SekIsIdleCode(dest_pc, bytes);
40106         newop = (Opcode & 0xfe) | 0x7100;
40107         if (!ret) newop |= 0x200;
40108         if (  Opcode & 0x0100)  newop |= 0x400; // beq
40109         if (!(Opcode & 0x0f00)) newop |= 0xc00; // bra
40110
40111         ret = SekRegisterIdlePatch(GET_PC - 2, Opcode, newop, &m68kcontext);
40112         switch (ret)
40113         {
40114                 case 0: PC[-1] = newop; break;
40115                 case 1: break;
40116                 case 2: JumpTable[Opcode] = (Opcode & 0x0f00) ?
40117                                 ((Opcode & 0x0100) ? CAST_OP(0x6701) : CAST_OP(0x6601)) :
40118                                 CAST_OP(0x6001); break;
40119         }
40120
40121 end:
40122         if ((Opcode & 0xff00) == 0x6000) cond_true = 1;
40123         else cond_true = (Opcode & 0x0100) ? !flag_NotZ : flag_NotZ; // beq?
40124         if (cond_true)
40125         {
40126                 PC = dest_pc;
40127                 m68kcontext.io_cycle_counter -= 2;
40128         }
40129 RET(8)
40130 }
40131
40132 #endif // PICODRIVE_HACK