Return to cpuD.c CVS log

Up to [UNIX Amiga Emulator] / uae / CPU Sources

Annotation of uae/CPU Sources/cpuD.c, revision 1.1

1.1     ! root        1: #include "config.h"
        !             2: #include "amiga.h"
        !             3: #include "options.h"
        !             4: #include <stdlib.h>
        !             5: #include "memory.h"
        !             6: #include "custom.h"
        !             7: #include "newcpu.h"
        !             8: #include "cputbl.h"
        !             9: void op_d000(UWORD opcode)
        !            10: {
        !            11:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !            12:        ULONG dstreg = (opcode & 3584) >> 9;
        !            13: {{     BYTE src = regs.d[srcreg];
        !            14: {      BYTE dst = regs.d[dstreg];
        !            15: {      ULONG newv = dst + src;
        !            16: {      bool flgs = ((BYTE)(src)) < 0;
        !            17:        bool flgo = ((BYTE)(dst)) < 0;
        !            18:        bool flgn = ((BYTE)(newv)) < 0;
        !            19:        regs.z = ((BYTE)(newv)) == 0;
        !            20:        regs.v = (flgs == flgo) && (flgn != flgo);
        !            21:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !            22:        regs.n = flgn != 0;
        !            23:        regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
        !            24: }}}}}}
        !            25: void op_d010(UWORD opcode)
        !            26: {
        !            27:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !            28:        ULONG dstreg = (opcode & 3584) >> 9;
        !            29: {{     CPTR srca = regs.a[srcreg];
        !            30:        BYTE src = get_byte(srca);
        !            31: {      BYTE dst = regs.d[dstreg];
        !            32: {      ULONG newv = dst + src;
        !            33: {      bool flgs = ((BYTE)(src)) < 0;
        !            34:        bool flgo = ((BYTE)(dst)) < 0;
        !            35:        bool flgn = ((BYTE)(newv)) < 0;
        !            36:        regs.z = ((BYTE)(newv)) == 0;
        !            37:        regs.v = (flgs == flgo) && (flgn != flgo);
        !            38:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !            39:        regs.n = flgn != 0;
        !            40:        regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
        !            41: }}}}}}
        !            42: void op_d018(UWORD opcode)
        !            43: {
        !            44:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !            45:        ULONG dstreg = (opcode & 3584) >> 9;
        !            46: {{     CPTR srca = regs.a[srcreg];
        !            47:        BYTE src = get_byte(srca);
        !            48: {      regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
        !            49: {      BYTE dst = regs.d[dstreg];
        !            50: {      ULONG newv = dst + src;
        !            51: {      bool flgs = ((BYTE)(src)) < 0;
        !            52:        bool flgo = ((BYTE)(dst)) < 0;
        !            53:        bool flgn = ((BYTE)(newv)) < 0;
        !            54:        regs.z = ((BYTE)(newv)) == 0;
        !            55:        regs.v = (flgs == flgo) && (flgn != flgo);
        !            56:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !            57:        regs.n = flgn != 0;
        !            58:        regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
        !            59: }}}}}}}
        !            60: void op_d020(UWORD opcode)
        !            61: {
        !            62:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !            63:        ULONG dstreg = (opcode & 3584) >> 9;
        !            64: {{     regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
        !            65: {      CPTR srca = regs.a[srcreg];
        !            66:        BYTE src = get_byte(srca);
        !            67: {      BYTE dst = regs.d[dstreg];
        !            68: {      ULONG newv = dst + src;
        !            69: {      bool flgs = ((BYTE)(src)) < 0;
        !            70:        bool flgo = ((BYTE)(dst)) < 0;
        !            71:        bool flgn = ((BYTE)(newv)) < 0;
        !            72:        regs.z = ((BYTE)(newv)) == 0;
        !            73:        regs.v = (flgs == flgo) && (flgn != flgo);
        !            74:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !            75:        regs.n = flgn != 0;
        !            76:        regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
        !            77: }}}}}}}
        !            78: void op_d028(UWORD opcode)
        !            79: {
        !            80:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !            81:        ULONG dstreg = (opcode & 3584) >> 9;
        !            82: {{     CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
        !            83:        BYTE src = get_byte(srca);
        !            84: {      BYTE dst = regs.d[dstreg];
        !            85: {      ULONG newv = dst + src;
        !            86: {      bool flgs = ((BYTE)(src)) < 0;
        !            87:        bool flgo = ((BYTE)(dst)) < 0;
        !            88:        bool flgn = ((BYTE)(newv)) < 0;
        !            89:        regs.z = ((BYTE)(newv)) == 0;
        !            90:        regs.v = (flgs == flgo) && (flgn != flgo);
        !            91:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !            92:        regs.n = flgn != 0;
        !            93:        regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
        !            94: }}}}}}
        !            95: void op_d030(UWORD opcode)
        !            96: {
        !            97:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !            98:        ULONG dstreg = (opcode & 3584) >> 9;
        !            99: {{     CPTR srca = regs.a[srcreg];
        !           100:        UWORD srcdp = nextiword();
        !           101:        srca += (LONG)(BYTE)(srcdp & 0xFF);
        !           102: {      ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
        !           103:        if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
        !           104:        srca += srcdpr;
        !           105: {      BYTE src = get_byte(srca);
        !           106: {      BYTE dst = regs.d[dstreg];
        !           107: {      ULONG newv = dst + src;
        !           108: {      bool flgs = ((BYTE)(src)) < 0;
        !           109:        bool flgo = ((BYTE)(dst)) < 0;
        !           110:        bool flgn = ((BYTE)(newv)) < 0;
        !           111:        regs.z = ((BYTE)(newv)) == 0;
        !           112:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           113:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           114:        regs.n = flgn != 0;
        !           115:        regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
        !           116: }}}}}}}}
        !           117: void op_d038(UWORD opcode)
        !           118: {
        !           119:        ULONG dstreg = (opcode & 3584) >> 9;
        !           120: {{     CPTR srca = (LONG)(WORD)nextiword();
        !           121:        BYTE src = get_byte(srca);
        !           122: {      BYTE dst = regs.d[dstreg];
        !           123: {      ULONG newv = dst + src;
        !           124: {      bool flgs = ((BYTE)(src)) < 0;
        !           125:        bool flgo = ((BYTE)(dst)) < 0;
        !           126:        bool flgn = ((BYTE)(newv)) < 0;
        !           127:        regs.z = ((BYTE)(newv)) == 0;
        !           128:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           129:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           130:        regs.n = flgn != 0;
        !           131:        regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
        !           132: }}}}}}
        !           133: void op_d039(UWORD opcode)
        !           134: {
        !           135:        ULONG dstreg = (opcode & 3584) >> 9;
        !           136: {{     CPTR srca = nextilong();
        !           137:        BYTE src = get_byte(srca);
        !           138: {      BYTE dst = regs.d[dstreg];
        !           139: {      ULONG newv = dst + src;
        !           140: {      bool flgs = ((BYTE)(src)) < 0;
        !           141:        bool flgo = ((BYTE)(dst)) < 0;
        !           142:        bool flgn = ((BYTE)(newv)) < 0;
        !           143:        regs.z = ((BYTE)(newv)) == 0;
        !           144:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           145:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           146:        regs.n = flgn != 0;
        !           147:        regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
        !           148: }}}}}}
        !           149: void op_d03a(UWORD opcode)
        !           150: {
        !           151:        ULONG dstreg = (opcode & 3584) >> 9;
        !           152: {{     CPTR srca = m68k_getpc();
        !           153:        srca += (LONG)(WORD)nextiword();
        !           154: {      BYTE src = get_byte(srca);
        !           155: {      BYTE dst = regs.d[dstreg];
        !           156: {      ULONG newv = dst + src;
        !           157: {      bool flgs = ((BYTE)(src)) < 0;
        !           158:        bool flgo = ((BYTE)(dst)) < 0;
        !           159:        bool flgn = ((BYTE)(newv)) < 0;
        !           160:        regs.z = ((BYTE)(newv)) == 0;
        !           161:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           162:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           163:        regs.n = flgn != 0;
        !           164:        regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
        !           165: }}}}}}}
        !           166: void op_d03b(UWORD opcode)
        !           167: {
        !           168:        ULONG dstreg = (opcode & 3584) >> 9;
        !           169: {{     CPTR srca = m68k_getpc();
        !           170:        UWORD srcdp = nextiword();
        !           171:        srca += (LONG)(BYTE)(srcdp & 0xFF);
        !           172: {      ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
        !           173:        if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
        !           174:        srca += srcdpr;
        !           175: {      BYTE src = get_byte(srca);
        !           176: {      BYTE dst = regs.d[dstreg];
        !           177: {      ULONG newv = dst + src;
        !           178: {      bool flgs = ((BYTE)(src)) < 0;
        !           179:        bool flgo = ((BYTE)(dst)) < 0;
        !           180:        bool flgn = ((BYTE)(newv)) < 0;
        !           181:        regs.z = ((BYTE)(newv)) == 0;
        !           182:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           183:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           184:        regs.n = flgn != 0;
        !           185:        regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
        !           186: }}}}}}}}
        !           187: void op_d03c(UWORD opcode)
        !           188: {
        !           189:        ULONG dstreg = (opcode & 3584) >> 9;
        !           190: {{     BYTE src = nextiword();
        !           191: {      BYTE dst = regs.d[dstreg];
        !           192: {      ULONG newv = dst + src;
        !           193: {      bool flgs = ((BYTE)(src)) < 0;
        !           194:        bool flgo = ((BYTE)(dst)) < 0;
        !           195:        bool flgn = ((BYTE)(newv)) < 0;
        !           196:        regs.z = ((BYTE)(newv)) == 0;
        !           197:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           198:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           199:        regs.n = flgn != 0;
        !           200:        regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
        !           201: }}}}}}
        !           202: void op_d040(UWORD opcode)
        !           203: {
        !           204:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           205:        ULONG dstreg = (opcode & 3584) >> 9;
        !           206: {{     WORD src = regs.d[srcreg];
        !           207: {      WORD dst = regs.d[dstreg];
        !           208: {      ULONG newv = dst + src;
        !           209: {      bool flgs = ((WORD)(src)) < 0;
        !           210:        bool flgo = ((WORD)(dst)) < 0;
        !           211:        bool flgn = ((WORD)(newv)) < 0;
        !           212:        regs.z = ((WORD)(newv)) == 0;
        !           213:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           214:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           215:        regs.n = flgn != 0;
        !           216:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           217: }}}}}}
        !           218: void op_d048(UWORD opcode)
        !           219: {
        !           220:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           221:        ULONG dstreg = (opcode & 3584) >> 9;
        !           222: {{     WORD src = regs.a[srcreg];
        !           223: {      WORD dst = regs.d[dstreg];
        !           224: {      ULONG newv = dst + src;
        !           225: {      bool flgs = ((WORD)(src)) < 0;
        !           226:        bool flgo = ((WORD)(dst)) < 0;
        !           227:        bool flgn = ((WORD)(newv)) < 0;
        !           228:        regs.z = ((WORD)(newv)) == 0;
        !           229:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           230:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           231:        regs.n = flgn != 0;
        !           232:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           233: }}}}}}
        !           234: void op_d050(UWORD opcode)
        !           235: {
        !           236:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           237:        ULONG dstreg = (opcode & 3584) >> 9;
        !           238: {{     CPTR srca = regs.a[srcreg];
        !           239:        WORD src = get_word(srca);
        !           240: {      WORD dst = regs.d[dstreg];
        !           241: {      ULONG newv = dst + src;
        !           242: {      bool flgs = ((WORD)(src)) < 0;
        !           243:        bool flgo = ((WORD)(dst)) < 0;
        !           244:        bool flgn = ((WORD)(newv)) < 0;
        !           245:        regs.z = ((WORD)(newv)) == 0;
        !           246:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           247:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           248:        regs.n = flgn != 0;
        !           249:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           250: }}}}}}
        !           251: void op_d058(UWORD opcode)
        !           252: {
        !           253:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           254:        ULONG dstreg = (opcode & 3584) >> 9;
        !           255: {{     CPTR srca = regs.a[srcreg];
        !           256:        WORD src = get_word(srca);
        !           257: {      regs.a[srcreg] += 2;
        !           258: {      WORD dst = regs.d[dstreg];
        !           259: {      ULONG newv = dst + src;
        !           260: {      bool flgs = ((WORD)(src)) < 0;
        !           261:        bool flgo = ((WORD)(dst)) < 0;
        !           262:        bool flgn = ((WORD)(newv)) < 0;
        !           263:        regs.z = ((WORD)(newv)) == 0;
        !           264:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           265:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           266:        regs.n = flgn != 0;
        !           267:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           268: }}}}}}}
        !           269: void op_d060(UWORD opcode)
        !           270: {
        !           271:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           272:        ULONG dstreg = (opcode & 3584) >> 9;
        !           273: {{     regs.a[srcreg] -= 2;
        !           274: {      CPTR srca = regs.a[srcreg];
        !           275:        WORD src = get_word(srca);
        !           276: {      WORD dst = regs.d[dstreg];
        !           277: {      ULONG newv = dst + src;
        !           278: {      bool flgs = ((WORD)(src)) < 0;
        !           279:        bool flgo = ((WORD)(dst)) < 0;
        !           280:        bool flgn = ((WORD)(newv)) < 0;
        !           281:        regs.z = ((WORD)(newv)) == 0;
        !           282:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           283:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           284:        regs.n = flgn != 0;
        !           285:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           286: }}}}}}}
        !           287: void op_d068(UWORD opcode)
        !           288: {
        !           289:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           290:        ULONG dstreg = (opcode & 3584) >> 9;
        !           291: {{     CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
        !           292:        WORD src = get_word(srca);
        !           293: {      WORD dst = regs.d[dstreg];
        !           294: {      ULONG newv = dst + src;
        !           295: {      bool flgs = ((WORD)(src)) < 0;
        !           296:        bool flgo = ((WORD)(dst)) < 0;
        !           297:        bool flgn = ((WORD)(newv)) < 0;
        !           298:        regs.z = ((WORD)(newv)) == 0;
        !           299:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           300:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           301:        regs.n = flgn != 0;
        !           302:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           303: }}}}}}
        !           304: void op_d070(UWORD opcode)
        !           305: {
        !           306:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           307:        ULONG dstreg = (opcode & 3584) >> 9;
        !           308: {{     CPTR srca = regs.a[srcreg];
        !           309:        UWORD srcdp = nextiword();
        !           310:        srca += (LONG)(BYTE)(srcdp & 0xFF);
        !           311: {      ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
        !           312:        if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
        !           313:        srca += srcdpr;
        !           314: {      WORD src = get_word(srca);
        !           315: {      WORD dst = regs.d[dstreg];
        !           316: {      ULONG newv = dst + src;
        !           317: {      bool flgs = ((WORD)(src)) < 0;
        !           318:        bool flgo = ((WORD)(dst)) < 0;
        !           319:        bool flgn = ((WORD)(newv)) < 0;
        !           320:        regs.z = ((WORD)(newv)) == 0;
        !           321:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           322:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           323:        regs.n = flgn != 0;
        !           324:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           325: }}}}}}}}
        !           326: void op_d078(UWORD opcode)
        !           327: {
        !           328:        ULONG dstreg = (opcode & 3584) >> 9;
        !           329: {{     CPTR srca = (LONG)(WORD)nextiword();
        !           330:        WORD src = get_word(srca);
        !           331: {      WORD dst = regs.d[dstreg];
        !           332: {      ULONG newv = dst + src;
        !           333: {      bool flgs = ((WORD)(src)) < 0;
        !           334:        bool flgo = ((WORD)(dst)) < 0;
        !           335:        bool flgn = ((WORD)(newv)) < 0;
        !           336:        regs.z = ((WORD)(newv)) == 0;
        !           337:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           338:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           339:        regs.n = flgn != 0;
        !           340:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           341: }}}}}}
        !           342: void op_d079(UWORD opcode)
        !           343: {
        !           344:        ULONG dstreg = (opcode & 3584) >> 9;
        !           345: {{     CPTR srca = nextilong();
        !           346:        WORD src = get_word(srca);
        !           347: {      WORD dst = regs.d[dstreg];
        !           348: {      ULONG newv = dst + src;
        !           349: {      bool flgs = ((WORD)(src)) < 0;
        !           350:        bool flgo = ((WORD)(dst)) < 0;
        !           351:        bool flgn = ((WORD)(newv)) < 0;
        !           352:        regs.z = ((WORD)(newv)) == 0;
        !           353:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           354:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           355:        regs.n = flgn != 0;
        !           356:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           357: }}}}}}
        !           358: void op_d07a(UWORD opcode)
        !           359: {
        !           360:        ULONG dstreg = (opcode & 3584) >> 9;
        !           361: {{     CPTR srca = m68k_getpc();
        !           362:        srca += (LONG)(WORD)nextiword();
        !           363: {      WORD src = get_word(srca);
        !           364: {      WORD dst = regs.d[dstreg];
        !           365: {      ULONG newv = dst + src;
        !           366: {      bool flgs = ((WORD)(src)) < 0;
        !           367:        bool flgo = ((WORD)(dst)) < 0;
        !           368:        bool flgn = ((WORD)(newv)) < 0;
        !           369:        regs.z = ((WORD)(newv)) == 0;
        !           370:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           371:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           372:        regs.n = flgn != 0;
        !           373:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           374: }}}}}}}
        !           375: void op_d07b(UWORD opcode)
        !           376: {
        !           377:        ULONG dstreg = (opcode & 3584) >> 9;
        !           378: {{     CPTR srca = m68k_getpc();
        !           379:        UWORD srcdp = nextiword();
        !           380:        srca += (LONG)(BYTE)(srcdp & 0xFF);
        !           381: {      ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
        !           382:        if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
        !           383:        srca += srcdpr;
        !           384: {      WORD src = get_word(srca);
        !           385: {      WORD dst = regs.d[dstreg];
        !           386: {      ULONG newv = dst + src;
        !           387: {      bool flgs = ((WORD)(src)) < 0;
        !           388:        bool flgo = ((WORD)(dst)) < 0;
        !           389:        bool flgn = ((WORD)(newv)) < 0;
        !           390:        regs.z = ((WORD)(newv)) == 0;
        !           391:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           392:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           393:        regs.n = flgn != 0;
        !           394:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           395: }}}}}}}}
        !           396: void op_d07c(UWORD opcode)
        !           397: {
        !           398:        ULONG dstreg = (opcode & 3584) >> 9;
        !           399: {{     WORD src = nextiword();
        !           400: {      WORD dst = regs.d[dstreg];
        !           401: {      ULONG newv = dst + src;
        !           402: {      bool flgs = ((WORD)(src)) < 0;
        !           403:        bool flgo = ((WORD)(dst)) < 0;
        !           404:        bool flgn = ((WORD)(newv)) < 0;
        !           405:        regs.z = ((WORD)(newv)) == 0;
        !           406:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           407:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           408:        regs.n = flgn != 0;
        !           409:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           410: }}}}}}
        !           411: void op_d080(UWORD opcode)
        !           412: {
        !           413:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           414:        ULONG dstreg = (opcode & 3584) >> 9;
        !           415: {{     LONG src = regs.d[srcreg];
        !           416: {      LONG dst = regs.d[dstreg];
        !           417: {      ULONG newv = dst + src;
        !           418: {      bool flgs = ((LONG)(src)) < 0;
        !           419:        bool flgo = ((LONG)(dst)) < 0;
        !           420:        bool flgn = ((LONG)(newv)) < 0;
        !           421:        regs.z = ((LONG)(newv)) == 0;
        !           422:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           423:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !           424:        regs.n = flgn != 0;
        !           425:        regs.d[dstreg] = (newv);
        !           426: }}}}}}
        !           427: void op_d088(UWORD opcode)
        !           428: {
        !           429:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           430:        ULONG dstreg = (opcode & 3584) >> 9;
        !           431: {{     LONG src = regs.a[srcreg];
        !           432: {      LONG dst = regs.d[dstreg];
        !           433: {      ULONG newv = dst + src;
        !           434: {      bool flgs = ((LONG)(src)) < 0;
        !           435:        bool flgo = ((LONG)(dst)) < 0;
        !           436:        bool flgn = ((LONG)(newv)) < 0;
        !           437:        regs.z = ((LONG)(newv)) == 0;
        !           438:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           439:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !           440:        regs.n = flgn != 0;
        !           441:        regs.d[dstreg] = (newv);
        !           442: }}}}}}
        !           443: void op_d090(UWORD opcode)
        !           444: {
        !           445:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           446:        ULONG dstreg = (opcode & 3584) >> 9;
        !           447: {{     CPTR srca = regs.a[srcreg];
        !           448:        LONG src = get_long(srca);
        !           449: {      LONG dst = regs.d[dstreg];
        !           450: {      ULONG newv = dst + src;
        !           451: {      bool flgs = ((LONG)(src)) < 0;
        !           452:        bool flgo = ((LONG)(dst)) < 0;
        !           453:        bool flgn = ((LONG)(newv)) < 0;
        !           454:        regs.z = ((LONG)(newv)) == 0;
        !           455:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           456:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !           457:        regs.n = flgn != 0;
        !           458:        regs.d[dstreg] = (newv);
        !           459: }}}}}}
        !           460: void op_d098(UWORD opcode)
        !           461: {
        !           462:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           463:        ULONG dstreg = (opcode & 3584) >> 9;
        !           464: {{     CPTR srca = regs.a[srcreg];
        !           465:        LONG src = get_long(srca);
        !           466: {      regs.a[srcreg] += 4;
        !           467: {      LONG dst = regs.d[dstreg];
        !           468: {      ULONG newv = dst + src;
        !           469: {      bool flgs = ((LONG)(src)) < 0;
        !           470:        bool flgo = ((LONG)(dst)) < 0;
        !           471:        bool flgn = ((LONG)(newv)) < 0;
        !           472:        regs.z = ((LONG)(newv)) == 0;
        !           473:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           474:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !           475:        regs.n = flgn != 0;
        !           476:        regs.d[dstreg] = (newv);
        !           477: }}}}}}}
        !           478: void op_d0a0(UWORD opcode)
        !           479: {
        !           480:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           481:        ULONG dstreg = (opcode & 3584) >> 9;
        !           482: {{     regs.a[srcreg] -= 4;
        !           483: {      CPTR srca = regs.a[srcreg];
        !           484:        LONG src = get_long(srca);
        !           485: {      LONG dst = regs.d[dstreg];
        !           486: {      ULONG newv = dst + src;
        !           487: {      bool flgs = ((LONG)(src)) < 0;
        !           488:        bool flgo = ((LONG)(dst)) < 0;
        !           489:        bool flgn = ((LONG)(newv)) < 0;
        !           490:        regs.z = ((LONG)(newv)) == 0;
        !           491:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           492:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !           493:        regs.n = flgn != 0;
        !           494:        regs.d[dstreg] = (newv);
        !           495: }}}}}}}
        !           496: void op_d0a8(UWORD opcode)
        !           497: {
        !           498:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           499:        ULONG dstreg = (opcode & 3584) >> 9;
        !           500: {{     CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
        !           501:        LONG src = get_long(srca);
        !           502: {      LONG dst = regs.d[dstreg];
        !           503: {      ULONG newv = dst + src;
        !           504: {      bool flgs = ((LONG)(src)) < 0;
        !           505:        bool flgo = ((LONG)(dst)) < 0;
        !           506:        bool flgn = ((LONG)(newv)) < 0;
        !           507:        regs.z = ((LONG)(newv)) == 0;
        !           508:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           509:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !           510:        regs.n = flgn != 0;
        !           511:        regs.d[dstreg] = (newv);
        !           512: }}}}}}
        !           513: void op_d0b0(UWORD opcode)
        !           514: {
        !           515:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           516:        ULONG dstreg = (opcode & 3584) >> 9;
        !           517: {{     CPTR srca = regs.a[srcreg];
        !           518:        UWORD srcdp = nextiword();
        !           519:        srca += (LONG)(BYTE)(srcdp & 0xFF);
        !           520: {      ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
        !           521:        if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
        !           522:        srca += srcdpr;
        !           523: {      LONG src = get_long(srca);
        !           524: {      LONG dst = regs.d[dstreg];
        !           525: {      ULONG newv = dst + src;
        !           526: {      bool flgs = ((LONG)(src)) < 0;
        !           527:        bool flgo = ((LONG)(dst)) < 0;
        !           528:        bool flgn = ((LONG)(newv)) < 0;
        !           529:        regs.z = ((LONG)(newv)) == 0;
        !           530:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           531:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !           532:        regs.n = flgn != 0;
        !           533:        regs.d[dstreg] = (newv);
        !           534: }}}}}}}}
        !           535: void op_d0b8(UWORD opcode)
        !           536: {
        !           537:        ULONG dstreg = (opcode & 3584) >> 9;
        !           538: {{     CPTR srca = (LONG)(WORD)nextiword();
        !           539:        LONG src = get_long(srca);
        !           540: {      LONG dst = regs.d[dstreg];
        !           541: {      ULONG newv = dst + src;
        !           542: {      bool flgs = ((LONG)(src)) < 0;
        !           543:        bool flgo = ((LONG)(dst)) < 0;
        !           544:        bool flgn = ((LONG)(newv)) < 0;
        !           545:        regs.z = ((LONG)(newv)) == 0;
        !           546:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           547:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !           548:        regs.n = flgn != 0;
        !           549:        regs.d[dstreg] = (newv);
        !           550: }}}}}}
        !           551: void op_d0b9(UWORD opcode)
        !           552: {
        !           553:        ULONG dstreg = (opcode & 3584) >> 9;
        !           554: {{     CPTR srca = nextilong();
        !           555:        LONG src = get_long(srca);
        !           556: {      LONG dst = regs.d[dstreg];
        !           557: {      ULONG newv = dst + src;
        !           558: {      bool flgs = ((LONG)(src)) < 0;
        !           559:        bool flgo = ((LONG)(dst)) < 0;
        !           560:        bool flgn = ((LONG)(newv)) < 0;
        !           561:        regs.z = ((LONG)(newv)) == 0;
        !           562:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           563:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !           564:        regs.n = flgn != 0;
        !           565:        regs.d[dstreg] = (newv);
        !           566: }}}}}}
        !           567: void op_d0ba(UWORD opcode)
        !           568: {
        !           569:        ULONG dstreg = (opcode & 3584) >> 9;
        !           570: {{     CPTR srca = m68k_getpc();
        !           571:        srca += (LONG)(WORD)nextiword();
        !           572: {      LONG src = get_long(srca);
        !           573: {      LONG dst = regs.d[dstreg];
        !           574: {      ULONG newv = dst + src;
        !           575: {      bool flgs = ((LONG)(src)) < 0;
        !           576:        bool flgo = ((LONG)(dst)) < 0;
        !           577:        bool flgn = ((LONG)(newv)) < 0;
        !           578:        regs.z = ((LONG)(newv)) == 0;
        !           579:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           580:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !           581:        regs.n = flgn != 0;
        !           582:        regs.d[dstreg] = (newv);
        !           583: }}}}}}}
        !           584: void op_d0bb(UWORD opcode)
        !           585: {
        !           586:        ULONG dstreg = (opcode & 3584) >> 9;
        !           587: {{     CPTR srca = m68k_getpc();
        !           588:        UWORD srcdp = nextiword();
        !           589:        srca += (LONG)(BYTE)(srcdp & 0xFF);
        !           590: {      ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
        !           591:        if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
        !           592:        srca += srcdpr;
        !           593: {      LONG src = get_long(srca);
        !           594: {      LONG dst = regs.d[dstreg];
        !           595: {      ULONG newv = dst + src;
        !           596: {      bool flgs = ((LONG)(src)) < 0;
        !           597:        bool flgo = ((LONG)(dst)) < 0;
        !           598:        bool flgn = ((LONG)(newv)) < 0;
        !           599:        regs.z = ((LONG)(newv)) == 0;
        !           600:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           601:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !           602:        regs.n = flgn != 0;
        !           603:        regs.d[dstreg] = (newv);
        !           604: }}}}}}}}
        !           605: void op_d0bc(UWORD opcode)
        !           606: {
        !           607:        ULONG dstreg = (opcode & 3584) >> 9;
        !           608: {{     LONG src = nextilong();
        !           609: {      LONG dst = regs.d[dstreg];
        !           610: {      ULONG newv = dst + src;
        !           611: {      bool flgs = ((LONG)(src)) < 0;
        !           612:        bool flgo = ((LONG)(dst)) < 0;
        !           613:        bool flgn = ((LONG)(newv)) < 0;
        !           614:        regs.z = ((LONG)(newv)) == 0;
        !           615:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           616:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !           617:        regs.n = flgn != 0;
        !           618:        regs.d[dstreg] = (newv);
        !           619: }}}}}}
        !           620: void op_d0c0(UWORD opcode)
        !           621: {
        !           622:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           623:        ULONG dstreg = (opcode & 3584) >> 9;
        !           624: {{     WORD src = regs.d[srcreg];
        !           625: {      LONG dst = regs.a[dstreg];
        !           626: {      ULONG newv = dst + src;
        !           627:        regs.a[dstreg] = (newv);
        !           628: }}}}}
        !           629: void op_d0c8(UWORD opcode)
        !           630: {
        !           631:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           632:        ULONG dstreg = (opcode & 3584) >> 9;
        !           633: {{     WORD src = regs.a[srcreg];
        !           634: {      LONG dst = regs.a[dstreg];
        !           635: {      ULONG newv = dst + src;
        !           636:        regs.a[dstreg] = (newv);
        !           637: }}}}}
        !           638: void op_d0d0(UWORD opcode)
        !           639: {
        !           640:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           641:        ULONG dstreg = (opcode & 3584) >> 9;
        !           642: {{     CPTR srca = regs.a[srcreg];
        !           643:        WORD src = get_word(srca);
        !           644: {      LONG dst = regs.a[dstreg];
        !           645: {      ULONG newv = dst + src;
        !           646:        regs.a[dstreg] = (newv);
        !           647: }}}}}
        !           648: void op_d0d8(UWORD opcode)
        !           649: {
        !           650:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           651:        ULONG dstreg = (opcode & 3584) >> 9;
        !           652: {{     CPTR srca = regs.a[srcreg];
        !           653:        WORD src = get_word(srca);
        !           654: {      regs.a[srcreg] += 2;
        !           655: {      LONG dst = regs.a[dstreg];
        !           656: {      ULONG newv = dst + src;
        !           657:        regs.a[dstreg] = (newv);
        !           658: }}}}}}
        !           659: void op_d0e0(UWORD opcode)
        !           660: {
        !           661:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           662:        ULONG dstreg = (opcode & 3584) >> 9;
        !           663: {{     regs.a[srcreg] -= 2;
        !           664: {      CPTR srca = regs.a[srcreg];
        !           665:        WORD src = get_word(srca);
        !           666: {      LONG dst = regs.a[dstreg];
        !           667: {      ULONG newv = dst + src;
        !           668:        regs.a[dstreg] = (newv);
        !           669: }}}}}}
        !           670: void op_d0e8(UWORD opcode)
        !           671: {
        !           672:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           673:        ULONG dstreg = (opcode & 3584) >> 9;
        !           674: {{     CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
        !           675:        WORD src = get_word(srca);
        !           676: {      LONG dst = regs.a[dstreg];
        !           677: {      ULONG newv = dst + src;
        !           678:        regs.a[dstreg] = (newv);
        !           679: }}}}}
        !           680: void op_d0f0(UWORD opcode)
        !           681: {
        !           682:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           683:        ULONG dstreg = (opcode & 3584) >> 9;
        !           684: {{     CPTR srca = regs.a[srcreg];
        !           685:        UWORD srcdp = nextiword();
        !           686:        srca += (LONG)(BYTE)(srcdp & 0xFF);
        !           687: {      ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
        !           688:        if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
        !           689:        srca += srcdpr;
        !           690: {      WORD src = get_word(srca);
        !           691: {      LONG dst = regs.a[dstreg];
        !           692: {      ULONG newv = dst + src;
        !           693:        regs.a[dstreg] = (newv);
        !           694: }}}}}}}
        !           695: void op_d0f8(UWORD opcode)
        !           696: {
        !           697:        ULONG dstreg = (opcode & 3584) >> 9;
        !           698: {{     CPTR srca = (LONG)(WORD)nextiword();
        !           699:        WORD src = get_word(srca);
        !           700: {      LONG dst = regs.a[dstreg];
        !           701: {      ULONG newv = dst + src;
        !           702:        regs.a[dstreg] = (newv);
        !           703: }}}}}
        !           704: void op_d0f9(UWORD opcode)
        !           705: {
        !           706:        ULONG dstreg = (opcode & 3584) >> 9;
        !           707: {{     CPTR srca = nextilong();
        !           708:        WORD src = get_word(srca);
        !           709: {      LONG dst = regs.a[dstreg];
        !           710: {      ULONG newv = dst + src;
        !           711:        regs.a[dstreg] = (newv);
        !           712: }}}}}
        !           713: void op_d0fa(UWORD opcode)
        !           714: {
        !           715:        ULONG dstreg = (opcode & 3584) >> 9;
        !           716: {{     CPTR srca = m68k_getpc();
        !           717:        srca += (LONG)(WORD)nextiword();
        !           718: {      WORD src = get_word(srca);
        !           719: {      LONG dst = regs.a[dstreg];
        !           720: {      ULONG newv = dst + src;
        !           721:        regs.a[dstreg] = (newv);
        !           722: }}}}}}
        !           723: void op_d0fb(UWORD opcode)
        !           724: {
        !           725:        ULONG dstreg = (opcode & 3584) >> 9;
        !           726: {{     CPTR srca = m68k_getpc();
        !           727:        UWORD srcdp = nextiword();
        !           728:        srca += (LONG)(BYTE)(srcdp & 0xFF);
        !           729: {      ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
        !           730:        if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
        !           731:        srca += srcdpr;
        !           732: {      WORD src = get_word(srca);
        !           733: {      LONG dst = regs.a[dstreg];
        !           734: {      ULONG newv = dst + src;
        !           735:        regs.a[dstreg] = (newv);
        !           736: }}}}}}}
        !           737: void op_d0fc(UWORD opcode)
        !           738: {
        !           739:        ULONG dstreg = (opcode & 3584) >> 9;
        !           740: {{     WORD src = nextiword();
        !           741: {      LONG dst = regs.a[dstreg];
        !           742: {      ULONG newv = dst + src;
        !           743:        regs.a[dstreg] = (newv);
        !           744: }}}}}
        !           745: void op_d100(UWORD opcode)
        !           746: {
        !           747:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           748:        ULONG dstreg = (opcode & 3584) >> 9;
        !           749: {{     BYTE src = regs.d[srcreg];
        !           750: {      BYTE dst = regs.d[dstreg];
        !           751: {      bool xflg = regs.x;
        !           752:        regs.v = regs.c = regs.x = 0;
        !           753: {      ULONG newv = dst + src;
        !           754: {      bool flgs = ((BYTE)(src)) < 0;
        !           755:        bool flgo = ((BYTE)(dst)) < 0;
        !           756:        bool flgn = ((BYTE)(newv)) < 0;
        !           757:        if ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;
        !           758:        if ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;
        !           759:        if (xflg)
        !           760: {{     bool flgs = ((BYTE)(newv)) < 0;
        !           761:        bool flgo = ((BYTE)(1)) < 0;
        !           762:        bool flgn = ((BYTE)((newv+1))) < 0;
        !           763:        if ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;
        !           764:        if ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;
        !           765:        newv++;
        !           766: }}     regs.z = ((BYTE)(newv)) == 0;
        !           767:        regs.n = ((BYTE)(newv)) < 0;
        !           768:        regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
        !           769: }}}}}}}
        !           770: void op_d108(UWORD opcode)
        !           771: {
        !           772:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           773:        ULONG dstreg = (opcode & 3584) >> 9;
        !           774: {{     regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
        !           775: {      CPTR srca = regs.a[srcreg];
        !           776:        BYTE src = get_byte(srca);
        !           777: {      regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
        !           778: {      CPTR dsta = regs.a[dstreg];
        !           779:        BYTE dst = get_byte(dsta);
        !           780: {      bool xflg = regs.x;
        !           781:        regs.v = regs.c = regs.x = 0;
        !           782: {      ULONG newv = dst + src;
        !           783: {      bool flgs = ((BYTE)(src)) < 0;
        !           784:        bool flgo = ((BYTE)(dst)) < 0;
        !           785:        bool flgn = ((BYTE)(newv)) < 0;
        !           786:        if ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;
        !           787:        if ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;
        !           788:        if (xflg)
        !           789: {{     bool flgs = ((BYTE)(newv)) < 0;
        !           790:        bool flgo = ((BYTE)(1)) < 0;
        !           791:        bool flgn = ((BYTE)((newv+1))) < 0;
        !           792:        if ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;
        !           793:        if ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;
        !           794:        newv++;
        !           795: }}     regs.z = ((BYTE)(newv)) == 0;
        !           796:        regs.n = ((BYTE)(newv)) < 0;
        !           797:        put_byte(dsta,newv);
        !           798: }}}}}}}}}
        !           799: void op_d110(UWORD opcode)
        !           800: {
        !           801:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !           802:        ULONG dstreg = (opcode & 7) >> 0;
        !           803: {{     BYTE src = regs.d[srcreg];
        !           804: {      CPTR dsta = regs.a[dstreg];
        !           805:        BYTE dst = get_byte(dsta);
        !           806: {      ULONG newv = dst + src;
        !           807: {      bool flgs = ((BYTE)(src)) < 0;
        !           808:        bool flgo = ((BYTE)(dst)) < 0;
        !           809:        bool flgn = ((BYTE)(newv)) < 0;
        !           810:        regs.z = ((BYTE)(newv)) == 0;
        !           811:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           812:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           813:        regs.n = flgn != 0;
        !           814:        put_byte(dsta,newv);
        !           815: }}}}}}
        !           816: void op_d118(UWORD opcode)
        !           817: {
        !           818:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !           819:        ULONG dstreg = (opcode & 7) >> 0;
        !           820: {{     BYTE src = regs.d[srcreg];
        !           821: {      CPTR dsta = regs.a[dstreg];
        !           822:        BYTE dst = get_byte(dsta);
        !           823: {      regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
        !           824: {      ULONG newv = dst + src;
        !           825: {      bool flgs = ((BYTE)(src)) < 0;
        !           826:        bool flgo = ((BYTE)(dst)) < 0;
        !           827:        bool flgn = ((BYTE)(newv)) < 0;
        !           828:        regs.z = ((BYTE)(newv)) == 0;
        !           829:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           830:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           831:        regs.n = flgn != 0;
        !           832:        put_byte(dsta,newv);
        !           833: }}}}}}}
        !           834: void op_d120(UWORD opcode)
        !           835: {
        !           836:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !           837:        ULONG dstreg = (opcode & 7) >> 0;
        !           838: {{     BYTE src = regs.d[srcreg];
        !           839: {      regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
        !           840: {      CPTR dsta = regs.a[dstreg];
        !           841:        BYTE dst = get_byte(dsta);
        !           842: {      ULONG newv = dst + src;
        !           843: {      bool flgs = ((BYTE)(src)) < 0;
        !           844:        bool flgo = ((BYTE)(dst)) < 0;
        !           845:        bool flgn = ((BYTE)(newv)) < 0;
        !           846:        regs.z = ((BYTE)(newv)) == 0;
        !           847:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           848:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           849:        regs.n = flgn != 0;
        !           850:        put_byte(dsta,newv);
        !           851: }}}}}}}
        !           852: void op_d128(UWORD opcode)
        !           853: {
        !           854:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !           855:        ULONG dstreg = (opcode & 7) >> 0;
        !           856: {{     BYTE src = regs.d[srcreg];
        !           857: {      CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
        !           858:        BYTE dst = get_byte(dsta);
        !           859: {      ULONG newv = dst + src;
        !           860: {      bool flgs = ((BYTE)(src)) < 0;
        !           861:        bool flgo = ((BYTE)(dst)) < 0;
        !           862:        bool flgn = ((BYTE)(newv)) < 0;
        !           863:        regs.z = ((BYTE)(newv)) == 0;
        !           864:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           865:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           866:        regs.n = flgn != 0;
        !           867:        put_byte(dsta,newv);
        !           868: }}}}}}
        !           869: void op_d130(UWORD opcode)
        !           870: {
        !           871:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !           872:        ULONG dstreg = (opcode & 7) >> 0;
        !           873: {{     BYTE src = regs.d[srcreg];
        !           874: {      CPTR dsta = regs.a[dstreg];
        !           875:        UWORD dstdp = nextiword();
        !           876:        dsta += (LONG)(BYTE)(dstdp & 0xFF);
        !           877: {      ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
        !           878:        if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
        !           879:        dsta += dstdpr;
        !           880: {      BYTE dst = get_byte(dsta);
        !           881: {      ULONG newv = dst + src;
        !           882: {      bool flgs = ((BYTE)(src)) < 0;
        !           883:        bool flgo = ((BYTE)(dst)) < 0;
        !           884:        bool flgn = ((BYTE)(newv)) < 0;
        !           885:        regs.z = ((BYTE)(newv)) == 0;
        !           886:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           887:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           888:        regs.n = flgn != 0;
        !           889:        put_byte(dsta,newv);
        !           890: }}}}}}}}
        !           891: void op_d138(UWORD opcode)
        !           892: {
        !           893:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !           894: {{     BYTE src = regs.d[srcreg];
        !           895: {      CPTR dsta = (LONG)(WORD)nextiword();
        !           896:        BYTE dst = get_byte(dsta);
        !           897: {      ULONG newv = dst + src;
        !           898: {      bool flgs = ((BYTE)(src)) < 0;
        !           899:        bool flgo = ((BYTE)(dst)) < 0;
        !           900:        bool flgn = ((BYTE)(newv)) < 0;
        !           901:        regs.z = ((BYTE)(newv)) == 0;
        !           902:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           903:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           904:        regs.n = flgn != 0;
        !           905:        put_byte(dsta,newv);
        !           906: }}}}}}
        !           907: void op_d139(UWORD opcode)
        !           908: {
        !           909:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !           910: {{     BYTE src = regs.d[srcreg];
        !           911: {      CPTR dsta = nextilong();
        !           912:        BYTE dst = get_byte(dsta);
        !           913: {      ULONG newv = dst + src;
        !           914: {      bool flgs = ((BYTE)(src)) < 0;
        !           915:        bool flgo = ((BYTE)(dst)) < 0;
        !           916:        bool flgn = ((BYTE)(newv)) < 0;
        !           917:        regs.z = ((BYTE)(newv)) == 0;
        !           918:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           919:        regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
        !           920:        regs.n = flgn != 0;
        !           921:        put_byte(dsta,newv);
        !           922: }}}}}}
        !           923: void op_d140(UWORD opcode)
        !           924: {
        !           925:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           926:        ULONG dstreg = (opcode & 3584) >> 9;
        !           927: {{     WORD src = regs.d[srcreg];
        !           928: {      WORD dst = regs.d[dstreg];
        !           929: {      bool xflg = regs.x;
        !           930:        regs.v = regs.c = regs.x = 0;
        !           931: {      ULONG newv = dst + src;
        !           932: {      bool flgs = ((WORD)(src)) < 0;
        !           933:        bool flgo = ((WORD)(dst)) < 0;
        !           934:        bool flgn = ((WORD)(newv)) < 0;
        !           935:        if ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;
        !           936:        if ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;
        !           937:        if (xflg)
        !           938: {{     bool flgs = ((WORD)(newv)) < 0;
        !           939:        bool flgo = ((WORD)(1)) < 0;
        !           940:        bool flgn = ((WORD)((newv+1))) < 0;
        !           941:        if ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;
        !           942:        if ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;
        !           943:        newv++;
        !           944: }}     regs.z = ((WORD)(newv)) == 0;
        !           945:        regs.n = ((WORD)(newv)) < 0;
        !           946:        regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
        !           947: }}}}}}}
        !           948: void op_d148(UWORD opcode)
        !           949: {
        !           950:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !           951:        ULONG dstreg = (opcode & 3584) >> 9;
        !           952: {{     regs.a[srcreg] -= 2;
        !           953: {      CPTR srca = regs.a[srcreg];
        !           954:        WORD src = get_word(srca);
        !           955: {      regs.a[dstreg] -= 2;
        !           956: {      CPTR dsta = regs.a[dstreg];
        !           957:        WORD dst = get_word(dsta);
        !           958: {      bool xflg = regs.x;
        !           959:        regs.v = regs.c = regs.x = 0;
        !           960: {      ULONG newv = dst + src;
        !           961: {      bool flgs = ((WORD)(src)) < 0;
        !           962:        bool flgo = ((WORD)(dst)) < 0;
        !           963:        bool flgn = ((WORD)(newv)) < 0;
        !           964:        if ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;
        !           965:        if ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;
        !           966:        if (xflg)
        !           967: {{     bool flgs = ((WORD)(newv)) < 0;
        !           968:        bool flgo = ((WORD)(1)) < 0;
        !           969:        bool flgn = ((WORD)((newv+1))) < 0;
        !           970:        if ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;
        !           971:        if ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;
        !           972:        newv++;
        !           973: }}     regs.z = ((WORD)(newv)) == 0;
        !           974:        regs.n = ((WORD)(newv)) < 0;
        !           975:        put_word(dsta,newv);
        !           976: }}}}}}}}}
        !           977: void op_d150(UWORD opcode)
        !           978: {
        !           979:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !           980:        ULONG dstreg = (opcode & 7) >> 0;
        !           981: {{     WORD src = regs.d[srcreg];
        !           982: {      CPTR dsta = regs.a[dstreg];
        !           983:        WORD dst = get_word(dsta);
        !           984: {      ULONG newv = dst + src;
        !           985: {      bool flgs = ((WORD)(src)) < 0;
        !           986:        bool flgo = ((WORD)(dst)) < 0;
        !           987:        bool flgn = ((WORD)(newv)) < 0;
        !           988:        regs.z = ((WORD)(newv)) == 0;
        !           989:        regs.v = (flgs == flgo) && (flgn != flgo);
        !           990:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !           991:        regs.n = flgn != 0;
        !           992:        put_word(dsta,newv);
        !           993: }}}}}}
        !           994: void op_d158(UWORD opcode)
        !           995: {
        !           996:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !           997:        ULONG dstreg = (opcode & 7) >> 0;
        !           998: {{     WORD src = regs.d[srcreg];
        !           999: {      CPTR dsta = regs.a[dstreg];
        !          1000:        WORD dst = get_word(dsta);
        !          1001: {      regs.a[dstreg] += 2;
        !          1002: {      ULONG newv = dst + src;
        !          1003: {      bool flgs = ((WORD)(src)) < 0;
        !          1004:        bool flgo = ((WORD)(dst)) < 0;
        !          1005:        bool flgn = ((WORD)(newv)) < 0;
        !          1006:        regs.z = ((WORD)(newv)) == 0;
        !          1007:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1008:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !          1009:        regs.n = flgn != 0;
        !          1010:        put_word(dsta,newv);
        !          1011: }}}}}}}
        !          1012: void op_d160(UWORD opcode)
        !          1013: {
        !          1014:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !          1015:        ULONG dstreg = (opcode & 7) >> 0;
        !          1016: {{     WORD src = regs.d[srcreg];
        !          1017: {      regs.a[dstreg] -= 2;
        !          1018: {      CPTR dsta = regs.a[dstreg];
        !          1019:        WORD dst = get_word(dsta);
        !          1020: {      ULONG newv = dst + src;
        !          1021: {      bool flgs = ((WORD)(src)) < 0;
        !          1022:        bool flgo = ((WORD)(dst)) < 0;
        !          1023:        bool flgn = ((WORD)(newv)) < 0;
        !          1024:        regs.z = ((WORD)(newv)) == 0;
        !          1025:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1026:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !          1027:        regs.n = flgn != 0;
        !          1028:        put_word(dsta,newv);
        !          1029: }}}}}}}
        !          1030: void op_d168(UWORD opcode)
        !          1031: {
        !          1032:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !          1033:        ULONG dstreg = (opcode & 7) >> 0;
        !          1034: {{     WORD src = regs.d[srcreg];
        !          1035: {      CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
        !          1036:        WORD dst = get_word(dsta);
        !          1037: {      ULONG newv = dst + src;
        !          1038: {      bool flgs = ((WORD)(src)) < 0;
        !          1039:        bool flgo = ((WORD)(dst)) < 0;
        !          1040:        bool flgn = ((WORD)(newv)) < 0;
        !          1041:        regs.z = ((WORD)(newv)) == 0;
        !          1042:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1043:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !          1044:        regs.n = flgn != 0;
        !          1045:        put_word(dsta,newv);
        !          1046: }}}}}}
        !          1047: void op_d170(UWORD opcode)
        !          1048: {
        !          1049:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !          1050:        ULONG dstreg = (opcode & 7) >> 0;
        !          1051: {{     WORD src = regs.d[srcreg];
        !          1052: {      CPTR dsta = regs.a[dstreg];
        !          1053:        UWORD dstdp = nextiword();
        !          1054:        dsta += (LONG)(BYTE)(dstdp & 0xFF);
        !          1055: {      ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
        !          1056:        if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
        !          1057:        dsta += dstdpr;
        !          1058: {      WORD dst = get_word(dsta);
        !          1059: {      ULONG newv = dst + src;
        !          1060: {      bool flgs = ((WORD)(src)) < 0;
        !          1061:        bool flgo = ((WORD)(dst)) < 0;
        !          1062:        bool flgn = ((WORD)(newv)) < 0;
        !          1063:        regs.z = ((WORD)(newv)) == 0;
        !          1064:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1065:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !          1066:        regs.n = flgn != 0;
        !          1067:        put_word(dsta,newv);
        !          1068: }}}}}}}}
        !          1069: void op_d178(UWORD opcode)
        !          1070: {
        !          1071:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !          1072: {{     WORD src = regs.d[srcreg];
        !          1073: {      CPTR dsta = (LONG)(WORD)nextiword();
        !          1074:        WORD dst = get_word(dsta);
        !          1075: {      ULONG newv = dst + src;
        !          1076: {      bool flgs = ((WORD)(src)) < 0;
        !          1077:        bool flgo = ((WORD)(dst)) < 0;
        !          1078:        bool flgn = ((WORD)(newv)) < 0;
        !          1079:        regs.z = ((WORD)(newv)) == 0;
        !          1080:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1081:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !          1082:        regs.n = flgn != 0;
        !          1083:        put_word(dsta,newv);
        !          1084: }}}}}}
        !          1085: void op_d179(UWORD opcode)
        !          1086: {
        !          1087:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !          1088: {{     WORD src = regs.d[srcreg];
        !          1089: {      CPTR dsta = nextilong();
        !          1090:        WORD dst = get_word(dsta);
        !          1091: {      ULONG newv = dst + src;
        !          1092: {      bool flgs = ((WORD)(src)) < 0;
        !          1093:        bool flgo = ((WORD)(dst)) < 0;
        !          1094:        bool flgn = ((WORD)(newv)) < 0;
        !          1095:        regs.z = ((WORD)(newv)) == 0;
        !          1096:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1097:        regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
        !          1098:        regs.n = flgn != 0;
        !          1099:        put_word(dsta,newv);
        !          1100: }}}}}}
        !          1101: void op_d180(UWORD opcode)
        !          1102: {
        !          1103:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !          1104:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1105: {{     LONG src = regs.d[srcreg];
        !          1106: {      LONG dst = regs.d[dstreg];
        !          1107: {      bool xflg = regs.x;
        !          1108:        regs.v = regs.c = regs.x = 0;
        !          1109: {      ULONG newv = dst + src;
        !          1110: {      bool flgs = ((LONG)(src)) < 0;
        !          1111:        bool flgo = ((LONG)(dst)) < 0;
        !          1112:        bool flgn = ((LONG)(newv)) < 0;
        !          1113:        if ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;
        !          1114:        if ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;
        !          1115:        if (xflg)
        !          1116: {{     bool flgs = ((LONG)(newv)) < 0;
        !          1117:        bool flgo = ((LONG)(1)) < 0;
        !          1118:        bool flgn = ((LONG)((newv+1))) < 0;
        !          1119:        if ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;
        !          1120:        if ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;
        !          1121:        newv++;
        !          1122: }}     regs.z = ((LONG)(newv)) == 0;
        !          1123:        regs.n = ((LONG)(newv)) < 0;
        !          1124:        regs.d[dstreg] = (newv);
        !          1125: }}}}}}}
        !          1126: void op_d188(UWORD opcode)
        !          1127: {
        !          1128:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !          1129:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1130: {{     regs.a[srcreg] -= 4;
        !          1131: {      CPTR srca = regs.a[srcreg];
        !          1132:        LONG src = get_long(srca);
        !          1133: {      regs.a[dstreg] -= 4;
        !          1134: {      CPTR dsta = regs.a[dstreg];
        !          1135:        LONG dst = get_long(dsta);
        !          1136: {      bool xflg = regs.x;
        !          1137:        regs.v = regs.c = regs.x = 0;
        !          1138: {      ULONG newv = dst + src;
        !          1139: {      bool flgs = ((LONG)(src)) < 0;
        !          1140:        bool flgo = ((LONG)(dst)) < 0;
        !          1141:        bool flgn = ((LONG)(newv)) < 0;
        !          1142:        if ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;
        !          1143:        if ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;
        !          1144:        if (xflg)
        !          1145: {{     bool flgs = ((LONG)(newv)) < 0;
        !          1146:        bool flgo = ((LONG)(1)) < 0;
        !          1147:        bool flgn = ((LONG)((newv+1))) < 0;
        !          1148:        if ((flgs && flgo && !flgn) || (!flgs && !flgo && flgn)) regs.v = 1;
        !          1149:        if ((flgs && flgo) || (!flgn && (flgo || flgs))) regs.c = regs.x = 1;
        !          1150:        newv++;
        !          1151: }}     regs.z = ((LONG)(newv)) == 0;
        !          1152:        regs.n = ((LONG)(newv)) < 0;
        !          1153:        put_long(dsta,newv);
        !          1154: }}}}}}}}}
        !          1155: void op_d190(UWORD opcode)
        !          1156: {
        !          1157:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !          1158:        ULONG dstreg = (opcode & 7) >> 0;
        !          1159: {{     LONG src = regs.d[srcreg];
        !          1160: {      CPTR dsta = regs.a[dstreg];
        !          1161:        LONG dst = get_long(dsta);
        !          1162: {      ULONG newv = dst + src;
        !          1163: {      bool flgs = ((LONG)(src)) < 0;
        !          1164:        bool flgo = ((LONG)(dst)) < 0;
        !          1165:        bool flgn = ((LONG)(newv)) < 0;
        !          1166:        regs.z = ((LONG)(newv)) == 0;
        !          1167:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1168:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !          1169:        regs.n = flgn != 0;
        !          1170:        put_long(dsta,newv);
        !          1171: }}}}}}
        !          1172: void op_d198(UWORD opcode)
        !          1173: {
        !          1174:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !          1175:        ULONG dstreg = (opcode & 7) >> 0;
        !          1176: {{     LONG src = regs.d[srcreg];
        !          1177: {      CPTR dsta = regs.a[dstreg];
        !          1178:        LONG dst = get_long(dsta);
        !          1179: {      regs.a[dstreg] += 4;
        !          1180: {      ULONG newv = dst + src;
        !          1181: {      bool flgs = ((LONG)(src)) < 0;
        !          1182:        bool flgo = ((LONG)(dst)) < 0;
        !          1183:        bool flgn = ((LONG)(newv)) < 0;
        !          1184:        regs.z = ((LONG)(newv)) == 0;
        !          1185:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1186:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !          1187:        regs.n = flgn != 0;
        !          1188:        put_long(dsta,newv);
        !          1189: }}}}}}}
        !          1190: void op_d1a0(UWORD opcode)
        !          1191: {
        !          1192:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !          1193:        ULONG dstreg = (opcode & 7) >> 0;
        !          1194: {{     LONG src = regs.d[srcreg];
        !          1195: {      regs.a[dstreg] -= 4;
        !          1196: {      CPTR dsta = regs.a[dstreg];
        !          1197:        LONG dst = get_long(dsta);
        !          1198: {      ULONG newv = dst + src;
        !          1199: {      bool flgs = ((LONG)(src)) < 0;
        !          1200:        bool flgo = ((LONG)(dst)) < 0;
        !          1201:        bool flgn = ((LONG)(newv)) < 0;
        !          1202:        regs.z = ((LONG)(newv)) == 0;
        !          1203:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1204:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !          1205:        regs.n = flgn != 0;
        !          1206:        put_long(dsta,newv);
        !          1207: }}}}}}}
        !          1208: void op_d1a8(UWORD opcode)
        !          1209: {
        !          1210:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !          1211:        ULONG dstreg = (opcode & 7) >> 0;
        !          1212: {{     LONG src = regs.d[srcreg];
        !          1213: {      CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
        !          1214:        LONG dst = get_long(dsta);
        !          1215: {      ULONG newv = dst + src;
        !          1216: {      bool flgs = ((LONG)(src)) < 0;
        !          1217:        bool flgo = ((LONG)(dst)) < 0;
        !          1218:        bool flgn = ((LONG)(newv)) < 0;
        !          1219:        regs.z = ((LONG)(newv)) == 0;
        !          1220:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1221:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !          1222:        regs.n = flgn != 0;
        !          1223:        put_long(dsta,newv);
        !          1224: }}}}}}
        !          1225: void op_d1b0(UWORD opcode)
        !          1226: {
        !          1227:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !          1228:        ULONG dstreg = (opcode & 7) >> 0;
        !          1229: {{     LONG src = regs.d[srcreg];
        !          1230: {      CPTR dsta = regs.a[dstreg];
        !          1231:        UWORD dstdp = nextiword();
        !          1232:        dsta += (LONG)(BYTE)(dstdp & 0xFF);
        !          1233: {      ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
        !          1234:        if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
        !          1235:        dsta += dstdpr;
        !          1236: {      LONG dst = get_long(dsta);
        !          1237: {      ULONG newv = dst + src;
        !          1238: {      bool flgs = ((LONG)(src)) < 0;
        !          1239:        bool flgo = ((LONG)(dst)) < 0;
        !          1240:        bool flgn = ((LONG)(newv)) < 0;
        !          1241:        regs.z = ((LONG)(newv)) == 0;
        !          1242:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1243:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !          1244:        regs.n = flgn != 0;
        !          1245:        put_long(dsta,newv);
        !          1246: }}}}}}}}
        !          1247: void op_d1b8(UWORD opcode)
        !          1248: {
        !          1249:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !          1250: {{     LONG src = regs.d[srcreg];
        !          1251: {      CPTR dsta = (LONG)(WORD)nextiword();
        !          1252:        LONG dst = get_long(dsta);
        !          1253: {      ULONG newv = dst + src;
        !          1254: {      bool flgs = ((LONG)(src)) < 0;
        !          1255:        bool flgo = ((LONG)(dst)) < 0;
        !          1256:        bool flgn = ((LONG)(newv)) < 0;
        !          1257:        regs.z = ((LONG)(newv)) == 0;
        !          1258:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1259:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !          1260:        regs.n = flgn != 0;
        !          1261:        put_long(dsta,newv);
        !          1262: }}}}}}
        !          1263: void op_d1b9(UWORD opcode)
        !          1264: {
        !          1265:        ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
        !          1266: {{     LONG src = regs.d[srcreg];
        !          1267: {      CPTR dsta = nextilong();
        !          1268:        LONG dst = get_long(dsta);
        !          1269: {      ULONG newv = dst + src;
        !          1270: {      bool flgs = ((LONG)(src)) < 0;
        !          1271:        bool flgo = ((LONG)(dst)) < 0;
        !          1272:        bool flgn = ((LONG)(newv)) < 0;
        !          1273:        regs.z = ((LONG)(newv)) == 0;
        !          1274:        regs.v = (flgs == flgo) && (flgn != flgo);
        !          1275:        regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
        !          1276:        regs.n = flgn != 0;
        !          1277:        put_long(dsta,newv);
        !          1278: }}}}}}
        !          1279: void op_d1c0(UWORD opcode)
        !          1280: {
        !          1281:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !          1282:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1283: {{     LONG src = regs.d[srcreg];
        !          1284: {      LONG dst = regs.a[dstreg];
        !          1285: {      ULONG newv = dst + src;
        !          1286:        regs.a[dstreg] = (newv);
        !          1287: }}}}}
        !          1288: void op_d1c8(UWORD opcode)
        !          1289: {
        !          1290:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !          1291:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1292: {{     LONG src = regs.a[srcreg];
        !          1293: {      LONG dst = regs.a[dstreg];
        !          1294: {      ULONG newv = dst + src;
        !          1295:        regs.a[dstreg] = (newv);
        !          1296: }}}}}
        !          1297: void op_d1d0(UWORD opcode)
        !          1298: {
        !          1299:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !          1300:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1301: {{     CPTR srca = regs.a[srcreg];
        !          1302:        LONG src = get_long(srca);
        !          1303: {      LONG dst = regs.a[dstreg];
        !          1304: {      ULONG newv = dst + src;
        !          1305:        regs.a[dstreg] = (newv);
        !          1306: }}}}}
        !          1307: void op_d1d8(UWORD opcode)
        !          1308: {
        !          1309:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !          1310:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1311: {{     CPTR srca = regs.a[srcreg];
        !          1312:        LONG src = get_long(srca);
        !          1313: {      regs.a[srcreg] += 4;
        !          1314: {      LONG dst = regs.a[dstreg];
        !          1315: {      ULONG newv = dst + src;
        !          1316:        regs.a[dstreg] = (newv);
        !          1317: }}}}}}
        !          1318: void op_d1e0(UWORD opcode)
        !          1319: {
        !          1320:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !          1321:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1322: {{     regs.a[srcreg] -= 4;
        !          1323: {      CPTR srca = regs.a[srcreg];
        !          1324:        LONG src = get_long(srca);
        !          1325: {      LONG dst = regs.a[dstreg];
        !          1326: {      ULONG newv = dst + src;
        !          1327:        regs.a[dstreg] = (newv);
        !          1328: }}}}}}
        !          1329: void op_d1e8(UWORD opcode)
        !          1330: {
        !          1331:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !          1332:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1333: {{     CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
        !          1334:        LONG src = get_long(srca);
        !          1335: {      LONG dst = regs.a[dstreg];
        !          1336: {      ULONG newv = dst + src;
        !          1337:        regs.a[dstreg] = (newv);
        !          1338: }}}}}
        !          1339: void op_d1f0(UWORD opcode)
        !          1340: {
        !          1341:        ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
        !          1342:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1343: {{     CPTR srca = regs.a[srcreg];
        !          1344:        UWORD srcdp = nextiword();
        !          1345:        srca += (LONG)(BYTE)(srcdp & 0xFF);
        !          1346: {      ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
        !          1347:        if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
        !          1348:        srca += srcdpr;
        !          1349: {      LONG src = get_long(srca);
        !          1350: {      LONG dst = regs.a[dstreg];
        !          1351: {      ULONG newv = dst + src;
        !          1352:        regs.a[dstreg] = (newv);
        !          1353: }}}}}}}
        !          1354: void op_d1f8(UWORD opcode)
        !          1355: {
        !          1356:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1357: {{     CPTR srca = (LONG)(WORD)nextiword();
        !          1358:        LONG src = get_long(srca);
        !          1359: {      LONG dst = regs.a[dstreg];
        !          1360: {      ULONG newv = dst + src;
        !          1361:        regs.a[dstreg] = (newv);
        !          1362: }}}}}
        !          1363: void op_d1f9(UWORD opcode)
        !          1364: {
        !          1365:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1366: {{     CPTR srca = nextilong();
        !          1367:        LONG src = get_long(srca);
        !          1368: {      LONG dst = regs.a[dstreg];
        !          1369: {      ULONG newv = dst + src;
        !          1370:        regs.a[dstreg] = (newv);
        !          1371: }}}}}
        !          1372: void op_d1fa(UWORD opcode)
        !          1373: {
        !          1374:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1375: {{     CPTR srca = m68k_getpc();
        !          1376:        srca += (LONG)(WORD)nextiword();
        !          1377: {      LONG src = get_long(srca);
        !          1378: {      LONG dst = regs.a[dstreg];
        !          1379: {      ULONG newv = dst + src;
        !          1380:        regs.a[dstreg] = (newv);
        !          1381: }}}}}}
        !          1382: void op_d1fb(UWORD opcode)
        !          1383: {
        !          1384:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1385: {{     CPTR srca = m68k_getpc();
        !          1386:        UWORD srcdp = nextiword();
        !          1387:        srca += (LONG)(BYTE)(srcdp & 0xFF);
        !          1388: {      ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
        !          1389:        if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
        !          1390:        srca += srcdpr;
        !          1391: {      LONG src = get_long(srca);
        !          1392: {      LONG dst = regs.a[dstreg];
        !          1393: {      ULONG newv = dst + src;
        !          1394:        regs.a[dstreg] = (newv);
        !          1395: }}}}}}}
        !          1396: void op_d1fc(UWORD opcode)
        !          1397: {
        !          1398:        ULONG dstreg = (opcode & 3584) >> 9;
        !          1399: {{     LONG src = nextilong();
        !          1400: {      LONG dst = regs.a[dstreg];
        !          1401: {      ULONG newv = dst + src;
        !          1402:        regs.a[dstreg] = (newv);
        !          1403: }}}}}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.