# Mutants for video/c_mv16t8t.c and video/c_mv16tt.h, both checked by
# test/difftest_t8t.c. The header is swept with --source video/c_mv16tt.h and a
# build that compiles the .c files out of the mirror.
# Format: name<TAB>old<TAB>new   (\n for a newline)
loop left	    tileleft16b = 33;\n    drawn = 0;	    tileleft16b = 32;\n    drawn = 0;
loop drawn init	    tileleft16b = 33;\n    drawn = 0;	    tileleft16b = 33;
loop dl init none	       pointer in the windowed ones and overwritten below either way. */\n    edx = (edx & 0xFFFFFF00u) | temp;	       pointer in the windowed ones and overwritten below either way. */
loop dl width	    edx = (edx & 0xFFFFFF00u) | temp;\n    do {	    edx = temp;\n    do {
loop ax word	        eax = (eax & 0xFFFF0000u) | *edi++;	        eax = *edi++;
loop bgpr	        attr = (u1)((eax >> 8) ^ curbgpr);	        attr = (u1)(eax >> 8);
loop attr reg	        if (winon_) {\n            ecx = (ecx & 0xFFFFFF00u) | attr;\n        } else {\n            edx = (edx & 0xFFFF00FFu) | (u4)attr << 8;\n        }	        if (!winon_) {\n            ecx = (ecx & 0xFFFFFF00u) | attr;\n        } else {\n            edx = (edx & 0xFFFF00FFu) | (u4)attr << 8;\n        }
loop attr cx	            ecx = (ecx & 0xFFFFFF00u) | attr;	            ecx = attr;
loop attr dh	            edx = (edx & 0xFFFF00FFu) | (u4)attr << 8;\n        }	            edx = (edx & 0xFFFF0000u) | (u4)attr << 8;\n        }
loop prio bit	        if (!(attr & 0x20u)) {	        if (!(attr & 0x10u)) {
loop prio sense	        if (!(attr & 0x20u)) {	        if ((attr & 0x20u)) {
loop drawn inc	            drawn++;\n            eax &= 0x03FFu;	            eax &= 0x03FFu;
loop tile mask	            eax &= 0x03FFu; /* filter out tile # */	            eax &= 0x07FFu; /* filter out tile # */
loop tile mask word	            eax &= 0x03FFu; /* filter out tile # */	            eax = (eax & 0xFFFF0000u) | (eax & 0x03FFu); /* filter out tile # */
loop tile scale	            tile = tempcach + eax * 64u;	            tile = tempcach + eax * 32u;
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 += (attr & 0x80u) ? yrevadder : yadder;	            tile += (attr & 0x40u) ? yrevadder : yadder;
loop yadder swap	            tile += (attr & 0x80u) ? yrevadder : yadder;	            tile += (attr & 0x80u) ? yadder : yrevadder;
loop bx half	            if (mode == T_HALF) {\n                r->bx = (u4)(uintptr_t)tile;\n            }	            r->bx = (u4)(uintptr_t)tile;
loop bx none	            if (mode == T_HALF) {\n                r->bx = (u4)(uintptr_t)tile;\n            }	            /* mutant: ebx never holds the tile pointer */
loop pal mask	            adder = (u1)((u1)((attr & 0x1Cu) << (bshifter & 31u))\n                + bgcoloradder);	            adder = (u1)((u1)((attr & 0x0Cu) << (bshifter & 31u))\n                + bgcoloradder);
loop pal shift	            adder = (u1)((u1)((attr & 0x1Cu) << (bshifter & 31u))\n                + bgcoloradder);	            adder = (u1)((u1)((attr & 0x1Cu) << (bshifter & 7u))\n                + bgcoloradder);
loop pal adder	            adder = (u1)((u1)((attr & 0x1Cu) << (bshifter & 31u))\n                + bgcoloradder);	            adder = (u1)((u1)((attr & 0x1Cu) << (bshifter & 31u)));
loop coadder	            if (winon_) {\n                coadder16 = adder;\n            } else {	            if (0) {\n                coadder16 = adder;\n            } else {
loop coadder always	            if (winon_) {\n                coadder16 = adder;\n            } else {\n                edx = (edx & 0xFFFF00FFu) | (u4)adder << 8;\n            }	            coadder16 = adder;\n            {\n                edx = (edx & 0xFFFF00FFu) | (u4)adder << 8;\n            }
loop pal dh	                edx = (edx & 0xFFFF00FFu) | (u4)adder << 8;\n            }\n            r->ax = 0;	            }\n            r->ax = 0;
loop cx zero	            r->ax = 0;\n            r->cx = 0;	            r->ax = 0;
loop flipx bit	                (attr & 0x40u) != 0, mode);	                (attr & 0x80u) != 0, mode);
loop flipx sense	                (attr & 0x40u) != 0, mode);	                (attr & 0x40u) == 0, mode);
loop win arg	            tt_row(r, tile, winon_ ? win : 0, adder, esi, ebp,	            tt_row(r, tile, win, adder, esi, ebp,
loop win none	            tt_row(r, tile, winon_ ? win : 0, adder, esi, ebp,	            tt_row(r, tile, 0, adder, 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 temp count	            temp = (u1)(temp + 1);	            temp = (u1)(temp + 2);
loop temp wrap	            if (temp == 0x20) {\n                edi = temptile;\n            }	            /* mutant: windowed column never wraps */
loop dl count	            edx = (edx & 0xFFFFFF00u) | (u1)(edx + 1);	            edx = edx + 1;
loop dl wrap	            if ((u1)edx == 0x20) {\n                edi = temptile;\n            }	            /* mutant: plain column never wraps */
loop wrap value	            if ((u1)edx == 0x20) {	            if ((u1)edx == 0x21) {
loop counters swapped	        if (winon_) {\n            temp = (u1)(temp + 1);	        if (!winon_) {\n            temp = (u1)(temp + 1);
loop ax out	    r->ax = eax;\n    r->cx = ecx;	    r->cx = ecx;
loop cx out	    r->ax = eax;\n    r->cx = ecx;	    r->ax = eax;
loop dx out	    r->dx = winon_ ? (u4)(uintptr_t)win : edx;	    r->dx = edx;
loop dx win	    r->dx = winon_ ? (u4)(uintptr_t)win : edx;	    r->dx = (u4)(uintptr_t)win;
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}	}
pro temp	    temp = (u1)r.ax;\n    bshifter = (u1)(r.ax >> 8);	    temp = (u1)(r.ax >> 8);\n    bshifter = (u1)r.ax;
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;\n    r.bx = 56u - r.cx;	    yrevadder = 56u + r.cx;\n    r.bx = 56u - r.cx;
pro bx out	    yrevadder = 56u - r.cx;\n    r.bx = 56u - r.cx;	    yrevadder = 56u - r.cx;
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 temptile	    temptile = (u2*)(uintptr_t)r.dx;	    temptile = (u2*)(uintptr_t)r.di;
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 win mosaic	    win = curmosaicsz == 1 && winon != 0;	    win = winon != 0;
top win flag	    win = curmosaicsz == 1 && winon != 0;	    win = curmosaicsz == 1;
top sub bit	    if (scaddtype & 0x80u) {	    if (scaddtype & 0x40u) {
top half bit	    } else if (!(scaddtype & 0x40u) || (scrnon >> 8) == 0) {	    } else if (!(scaddtype & 0x20u) || (scrnon >> 8) == 0) {
top half scrnon	    } else if (!(scaddtype & 0x40u) || (scrnon >> 8) == 0) {	    } else if (!(scaddtype & 0x40u) || (scrnon & 0xFFu) == 0) {
top half only	    } else if (!(scaddtype & 0x40u) || (scrnon >> 8) == 0) {	    } else if (!(scaddtype & 0x40u)) {
top mode swap	        mode = T_SUB;\n    } else if (!(scaddtype & 0x40u) || (scrnon >> 8) == 0) {\n        mode = T_ADD;	        mode = T_ADD;\n    } else if (!(scaddtype & 0x40u) || (scrnon >> 8) == 0) {\n        mode = T_SUB;
top tail win	    if (!win && mode != T_SUB && drawn != 0) {	    if (mode != T_SUB && drawn != 0) {
top tail sub	    if (!win && mode != T_SUB && drawn != 0) {	    if (!win && drawn != 0) {
top tail drawn	    if (!win && mode != T_SUB && drawn != 0) {	    if (!win && mode != T_SUB) {
top tail dh	        r.dx = (r.dx & 0xFFFF00FFu) | (u4)curmosaicsz << 8;\n        TTTail	        TTTail
top tail flag	        TTTail = curmosaicsz != 1;	        TTTail = 1;
top tail sense	        TTTail = curmosaicsz != 1;	        TTTail = curmosaicsz == 1;
top tail reset	    TTTail = 0;\n    temp	    temp
#
# Two survive, both the same equivalence:
#
#   loop ax word        `mov ax,[edi]` keeps the top half of eax, which is the
#   loop tile mask word horizontal offset until the first tile draws. An offset
#                       that fits the pointers it biases fits 16 bits, so the
#                       top half is always zero and masking it or not cannot
#                       be seen.
