# Mutants for video/c_mv16t16bt.c, checked by test/difftest_t16bt.c.
# The pixel writers it shares with the 8x8 form live in test/mutants_btpx.txt.
# Format: name<TAB>old<TAB>new   (\n for a newline)
loop left	    tileleft16b = 33;\n    edx	    tileleft16b = 32;\n    edx
loop dl init	    edx = (edx & 0xFFFFFF00u) | temp;	    edx = (edx & 0xFFFFFF00u) | bshifter;
loop dl width	    edx = (edx & 0xFFFFFF00u) | temp;	    edx = temp;
loop ax word	        eax = (eax & 0xFFFF0000u) | *edi;	        eax = *edi;
loop toggle	        a16x16xinc ^= 1;	        a16x16xinc ^= 0;
loop toggle after	        a16x16xinc ^= 1;\n        if (!(dh & 0x40u)) {	        if (!(dh & 0x40u)) {
loop xflip bit	        if (!(dh & 0x40u)) {\n            /* Not flipped	        if (!(dh & 0x80u)) {\n            /* Not flipped
loop xflip sense	        if (!(dh & 0x40u)) {\n            /* Not flipped	        if ((dh & 0x40u)) {\n            /* Not flipped
loop plain inc	            if (!(a16x16xinc & 1u)) {\n                eax = (eax & 0xFFFF0000u) | (u2)(eax + 1u);\n                edi++;\n            }	            if (!(a16x16xinc & 1u)) {\n                edi++;\n            }
loop plain map	            if (!(a16x16xinc & 1u)) {\n                eax = (eax & 0xFFFF0000u) | (u2)(eax + 1u);\n                edi++;\n            }	            if (!(a16x16xinc & 1u)) {\n                eax = (eax & 0xFFFF0000u) | (u2)(eax + 1u);\n            }
loop plain sense	            if (!(a16x16xinc & 1u)) {\n                eax = (eax & 0xFFFF0000u) | (u2)(eax + 1u);\n                edi++;\n            }	            if ((a16x16xinc & 1u)) {\n                eax = (eax & 0xFFFF0000u) | (u2)(eax + 1u);\n                edi++;\n            }
loop flip arms	        } else if (!(a16x16xinc & 1u)) {\n            edi++;\n        } else {\n            eax = (eax & 0xFFFF0000u) | (u2)(eax + 1u);\n        }	        } else if (!(a16x16xinc & 1u)) {\n            eax = (eax & 0xFFFF0000u) | (u2)(eax + 1u);\n        } else {\n            edi++;\n        }
loop flip both	        } else if (!(a16x16xinc & 1u)) {\n            edi++;\n        } else {	        } else if (!(a16x16xinc & 1u)) {\n            edi++;\n            eax = (eax & 0xFFFF0000u) | (u2)(eax + 1u);\n        } else {
loop inc width	        } else {\n            eax = (eax & 0xFFFF0000u) | (u2)(eax + 1u);\n        }	        } else {\n            eax = eax + 1u;\n        }
loop bgpr	        dh = (u1)(dh ^ curbgpr);	        dh = (u1)dh;
loop dh out	        edx = (edx & 0xFFFF00FFu) | (u4)dh << 8;\n        if (!(dh & 0x20u)) {	        if (!(dh & 0x20u)) {
loop prio bit	        if (!(dh & 0x20u)) {	        if (!(dh & 0x10u)) {
loop prio sense	        if (!(dh & 0x20u)) {	        if ((dh & 0x20u)) {
loop drawn	            drawn++;\n            /* The row within	            /* The row within
loop yadd bit	                | (u2)(eax + ((dh & 0x80u) ? yflipadd : yadd));	                | (u2)(eax + ((dh & 0x40u) ? yflipadd : yadd));
loop yadd swap	                | (u2)(eax + ((dh & 0x80u) ? yflipadd : yadd));	                | (u2)(eax + ((dh & 0x80u) ? yadd : yflipadd));
loop yadd none	            eax = (eax & 0xFFFF0000u)\n                | (u2)(eax + ((dh & 0x80u) ? yflipadd : yadd));\n            /* filter out tile #	            /* filter out tile #
loop yadd width	                | (u2)(eax + ((dh & 0x80u) ? yflipadd : yadd));	                | (u4)(eax + ((dh & 0x80u) ? yflipadd : yadd));
loop tile mask	            eax = (eax & 0xFFFF0000u) | (eax & 0x03FFu);	            eax = (eax & 0xFFFF0000u) | (eax & 0x07FFu);
loop tile mask wide	            eax = (eax & 0xFFFF0000u) | (eax & 0x03FFu);	            eax = eax & 0x03FFu;
loop tile shift	            eax = (eax & 0xFFFF0000u) | (u2)(eax << 6);	            eax = (eax & 0xFFFF0000u) | (u2)(eax << 5);
loop tile shift wide	            eax = (eax & 0xFFFF0000u) | (u2)(eax << 6);	            eax = (eax & 0xFFFF0000u) | (u4)(eax << 6);
loop clip test	            if (tile >= bgofwptr) {	            if (tile > bgofwptr) {
loop clip none	            if (tile >= bgofwptr) {\n                tile -= bgsubby;\n            }	            /* mutant: never clips */
loop yadder bit	            tile += (dh & 0x80u) ? yrevadder : yadder;	            tile += (dh & 0x40u) ? yrevadder : yadder;
loop yadder swap	            tile += (dh & 0x80u) ? yrevadder : yadder;	            tile += (dh & 0x80u) ? yadder : yrevadder;
loop bx out	            r->bx = (u4)(uintptr_t)tile;\n            if (!winon_) {	            if (!winon_) {
loop cx shifter	            if (!winon_) {\n                r->cx = (r->cx & 0xFFFFFF00u) | bshifter;\n            }	            if (winon_) {\n                r->cx = (r->cx & 0xFFFFFF00u) | bshifter;\n            }
loop cx width	                r->cx = (r->cx & 0xFFFFFF00u) | bshifter;	                r->cx = bshifter;
loop pal mask	            pal = (u1)((((u4)dh & 0x1Cu) << (bshifter & 31u)) + bgcoloradder);	            pal = (u1)((((u4)dh & 0x0Cu) << (bshifter & 31u)) + bgcoloradder);
loop pal shift	            pal = (u1)((((u4)dh & 0x1Cu) << (bshifter & 31u)) + bgcoloradder);	            pal = (u1)((((u4)dh & 0x1Cu) << (bshifter & 7u)) + bgcoloradder);
loop pal adder	            pal = (u1)((((u4)dh & 0x1Cu) << (bshifter & 31u)) + bgcoloradder);	            pal = (u1)(((u4)dh & 0x1Cu) << (bshifter & 31u));
loop pal dh	            edx = (edx & 0xFFFF00FFu) | (u4)pal << 8;\n            r->ax = 0;	            r->ax = 0;
loop ax back	            bt_row(r, tile, winon_ ? win : 0, pal, esi, ebp,\n                (dh & 0x40u) != 0, 1);\n            eax = r->ax;	            bt_row(r, tile, winon_ ? win : 0, pal, esi, ebp,\n                (dh & 0x40u) != 0, 1);
loop flipx bit	                (dh & 0x40u) != 0, 1);	                (dh & 0x80u) != 0, 1);
loop flipx sense	                (dh & 0x40u) != 0, 1);	                (dh & 0x40u) == 0, 1);
loop winbyk	                (dh & 0x40u) != 0, 1);	                (dh & 0x40u) != 0, 0);
loop win arg	            bt_row(r, tile, winon_ ? win : 0, pal, esi, ebp,	            bt_row(r, tile, win, pal, esi, ebp,
loop esi step	        esi += 16;\n        ebp += 16;	        esi += 8;\n        ebp += 16;
loop ebp step	        esi += 16;\n        ebp += 16;	        esi += 16;\n        ebp += 8;
loop win step	        win += 8;	        win += 16;
loop dl gate	        if (!(a16x16xinc & 1u)) {\n            edx = (edx & 0xFFFFFF00u) | (u1)(edx + 1);\n        }	        edx = (edx & 0xFFFFFF00u) | (u1)(edx + 1);
loop dl gate sense	        if (!(a16x16xinc & 1u)) {\n            edx = (edx & 0xFFFFFF00u) | (u1)(edx + 1);\n        }	        if ((a16x16xinc & 1u)) {\n            edx = (edx & 0xFFFFFF00u) | (u1)(edx + 1);\n        }
loop dl width2	            edx = (edx & 0xFFFFFF00u) | (u1)(edx + 1);	            edx = edx + 1;
loop wrap value	        if ((u1)edx == 0x20) {	        if ((u1)edx == 0x21) {
loop wrap none	        if ((u1)edx == 0x20) {\n            edx &= 0xFFFFFF00u;\n            edi = temptile;\n        }	        /* mutant: no column wrap */
loop wrap reset	        if ((u1)edx == 0x20) {\n            edx &= 0xFFFFFF00u;\n            edi = temptile;\n        }	        if ((u1)edx == 0x20) {\n            edi = temptile;\n        }
loop wrap map	        if ((u1)edx == 0x20) {\n            edx &= 0xFFFFFF00u;\n            edi = temptile;\n        }	        if ((u1)edx == 0x20) {\n            edx &= 0xFFFFFF00u;\n        }
loop ax out	    r->ax = eax;\n    r->dx = edx;	    r->dx = edx;
loop dx out	    r->ax = eax;\n    r->dx = edx;	    r->ax = eax;
loop si out	    r->si = (u4)(uintptr_t)esi;\n    r->di	    r->di
loop di out	    r->di = (u4)(uintptr_t)edi;\n    r->bp	    r->bp
loop bp out	    r->bp = (u4)(uintptr_t)ebp;\n    if (winon_) {	    if (winon_) {
loop cx out	    if (winon_) {\n        r->cx = (u4)(uintptr_t)win;\n    }	    r->cx = (u4)(uintptr_t)win;
loop cx out none	    if (winon_) {\n        r->cx = (u4)(uintptr_t)win;\n    }	    /* mutant: windowed ecx not returned */
pro drawn	    T16Tail = 0;\n    drawn = 0;	    T16Tail = 0;
pro temp	    temp = (u1)r.ax;\n    bshifter = (u1)(r.ax >> 8);	    temp = (u1)(r.ax >> 8);\n    bshifter = (u1)r.ax;
pro xinc	    a16x16xinc = (u1)(r.ax >> 16);\n    a16x16yinc = (u1)(r.ax >> 24);	    a16x16yinc = (u1)(r.ax >> 24);
pro yinc	    a16x16xinc = (u1)(r.ax >> 16);\n    a16x16yinc = (u1)(r.ax >> 24);	    a16x16xinc = (u1)(r.ax >> 16);
pro inc swap	    a16x16xinc = (u1)(r.ax >> 16);\n    a16x16yinc = (u1)(r.ax >> 24);	    a16x16xinc = (u1)(r.ax >> 24);\n    a16x16yinc = (u1)(r.ax >> 16);
pro ax out	    r.ax = hofs;\n    yadder = r.cx;	    yadder = r.cx;
pro yadder	    yadder = r.cx;\n    tempcach	    yadder = r.bx;\n    tempcach
pro yrev	    yrevadder = 56u - r.cx;	    yrevadder = 56u + r.cx;
pro bx out	    r.bx = curypos & 0xFFu;	    r.bx = 56u - r.cx;
pro bx width	    r.bx = curypos & 0xFFu;	    r.bx = curypos;
pro temptile	    temptile = (u2*)(uintptr_t)r.dx;	    temptile = (u2*)(uintptr_t)r.di;
pro yadd bit	    if (a16x16yinc & 1u) {	    if (a16x16yinc & 2u) {
pro yadd swap	    if (a16x16yinc & 1u) {\n        yadd = 16;\n        yflipadd = 0;\n    } else {\n        yadd = 0;\n        yflipadd = 16;\n    }	    if (a16x16yinc & 1u) {\n        yadd = 0;\n        yflipadd = 16;\n    } else {\n        yadd = 16;\n        yflipadd = 0;\n    }
pro yadd size	        yadd = 16;\n        yflipadd = 0;	        yadd = 8;\n        yflipadd = 0;
pro winptr	    winptrref = cwinptr - hofs;	    winptrref = cwinptr - hofs * 2u;
pro vid bias	    esi = curvidoffset - hofs * 2u;	    esi = curvidoffset - hofs;
pro mosaic test	    if (curmosaicsz != 1) {	    if (curmosaicsz == 1) {
pro mosaic size	        memset(xtravbuf + 32, 0, 512);	        memset(xtravbuf + 32, 0, 256);
pro mosaic base	        memset(xtravbuf + 32, 0, 512);	        memset(xtravbuf, 0, 512);
pro mosaic cx	        r.cx = 0;\n        esi = xtravbuf + 32 - hofs * 2u;	        esi = xtravbuf + 32 - hofs * 2u;
pro mosaic esi	        r.cx = 0;\n        esi = xtravbuf + 32 - hofs * 2u;	        r.cx = 0;
pro cache first	    bgofwptr = vcache2b + 262144u;	    bgofwptr = vcache2b + 131072u;
pro cache sub	    bgsubby = 262144u;\n    bgofwptr = vcache2b + 262144u;	    bgsubby = 131072u;\n    bgofwptr = vcache2b + 262144u;
pro cache chain	    if (tempcach >= bgofwptr) {\n        bgsubby = 131072u;	    if (tempcach > bgofwptr) {\n        bgsubby = 131072u;
pro cache second	        bgofwptr = vcache4b + 131072u;\n        if (tempcach >= bgofwptr) {	        bgofwptr = vcache4b + 65536u;\n        if (tempcach >= bgofwptr) {
pro cache third	            bgofwptr = vcache8b + 65536u;\n            bgsubby = 65536u;	            bgofwptr = vcache8b + 131072u;\n            bgsubby = 65536u;
top winon mosaic	    if (curmosaicsz == 1 && winon != 0) {	    if (winon != 0) {
top winon flag	    if (curmosaicsz == 1 && winon != 0) {	    if (curmosaicsz == 1) {
top tail drawn	        r.dx = (r.dx & 0xFFFF00FFu) | (u4)curmosaicsz << 8;\n        T16Tail	        if (drawn == 0) {\n            return;\n        }\n        r.dx = (r.dx & 0xFFFF00FFu) | (u4)curmosaicsz << 8;\n        T16Tail
top tail dh	        r.dx = (r.dx & 0xFFFF00FFu) | (u4)curmosaicsz << 8;\n        T16Tail	        T16Tail
top tail flag	        T16Tail = curmosaicsz != 1;	        T16Tail = 1;
top tail sense	        T16Tail = curmosaicsz != 1;	        T16Tail = curmosaicsz == 1;
top tail winon	    if (curmosaicsz == 1 && winon != 0) {\n        tiles(&r, hofs, esi, 1);\n    } else {	    if (0) {\n        tiles(&r, hofs, esi, 1);\n    } else {
#
# Four survive, all equivalent:
#
#   loop ax word        the top half of eax is the horizontal offset until the
#   loop tile mask wide first tile draws, and an offset that fits the pointers
#   loop tile shift wide it biases fits 16 bits - so masking or not masking it
#                       cannot be seen, and 0x3FF << 6 fits 16 bits anyway.
#   loop tile mask      0x3FF vs 0x7FF: bit 10 shifts to bit 16 and the 16-bit
#                       `shl ax,6` drops it. Same equivalence as in mv16tms.
