* Code cleanup:

[people/ms/u-boot.git] / board / MAI / bios_emulator / scitech / src / x86emu / ops.c

diff --git a/board/MAI/bios_emulator/scitech/src/x86emu/ops.c b/board/MAI/bios_emulator/scitech/src/x86emu/ops.c
index 0d797766b0a20e8085ce37e9973c7779da13e36c..2d4f93eee43731a941bdb8336f8218bee0806355 100644 (file)
--- a/board/MAI/bios_emulator/scitech/src/x86emu/ops.c
+++ b/board/MAI/bios_emulator/scitech/src/x86emu/ops.c
@@ -88,7 +88,7 @@ void x86emuOp_illegal_op(
     DECODE_PRINTF("ILLEGAL X86 OPCODE\n");
     TRACE_REGS();
     printk("%04x:%04x: %02X ILLEGAL X86 OPCODE!\n",
-        M.x86.R_CS, M.x86.R_IP-1,op1);
+       M.x86.R_CS, M.x86.R_IP-1,op1);
     HALT_SYS();
     END_OF_INSTR();
 }
@@ -109,43 +109,43 @@ void x86emuOp_add_byte_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = add_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = add_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = add_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = add_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = add_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = add_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = add_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = add_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -165,107 +165,107 @@ void x86emuOp_add_word_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = add_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = add_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = add_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = add_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = add_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = add_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = add_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = add_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = add_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = add_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = add_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = add_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = add_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = add_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = add_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = add_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -287,40 +287,40 @@ void x86emuOp_add_byte_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm00_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = add_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm00_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = add_byte(*destreg, srcval);
+       break;
     case 1:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm01_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = add_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm01_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = add_byte(*destreg, srcval);
+       break;
     case 2:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm10_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = add_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm10_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = add_byte(*destreg, srcval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = add_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = add_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -340,101 +340,101 @@ void x86emuOp_add_word_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = add_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = add_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = add_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = add_word(*destreg, srcval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = add_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = add_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = add_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = add_word(*destreg, srcval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = add_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = add_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = add_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = add_word(*destreg, srcval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = add_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = add_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = add_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = add_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -468,18 +468,18 @@ void x86emuOp_add_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("ADD\tEAX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("ADD\tEAX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("ADD\tAX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("ADD\tAX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = add_long(M.x86.R_EAX, srcval);
+       M.x86.R_EAX = add_long(M.x86.R_EAX, srcval);
     } else {
-        M.x86.R_AX = add_word(M.x86.R_AX, (u16)srcval);
+       M.x86.R_AX = add_word(M.x86.R_AX, (u16)srcval);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -529,43 +529,43 @@ void x86emuOp_or_byte_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = or_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = or_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = or_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = or_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = or_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = or_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = or_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = or_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -585,107 +585,107 @@ void x86emuOp_or_word_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = or_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = or_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = or_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = or_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = or_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = or_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = or_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = or_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = or_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = or_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = or_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = or_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = or_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = or_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = or_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = or_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -707,40 +707,40 @@ void x86emuOp_or_byte_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm00_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = or_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm00_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = or_byte(*destreg, srcval);
+       break;
     case 1:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm01_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = or_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm01_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = or_byte(*destreg, srcval);
+       break;
     case 2:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm10_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = or_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm10_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = or_byte(*destreg, srcval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = or_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = or_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -760,101 +760,101 @@ void x86emuOp_or_word_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = or_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = or_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = or_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = or_word(*destreg, srcval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = or_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = or_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = or_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = or_word(*destreg, srcval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = or_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = or_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = or_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = or_word(*destreg, srcval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = or_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = or_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = or_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = or_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -888,18 +888,18 @@ void x86emuOp_or_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("OR\tEAX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("OR\tEAX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("OR\tAX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("OR\tAX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = or_long(M.x86.R_EAX, srcval);
+       M.x86.R_EAX = or_long(M.x86.R_EAX, srcval);
     } else {
-        M.x86.R_AX = or_word(M.x86.R_AX, (u16)srcval);
+       M.x86.R_AX = or_word(M.x86.R_AX, (u16)srcval);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -946,43 +946,43 @@ void x86emuOp_adc_byte_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = adc_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = adc_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = adc_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = adc_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = adc_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = adc_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = adc_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = adc_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1002,107 +1002,107 @@ void x86emuOp_adc_word_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = adc_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = adc_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = adc_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = adc_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = adc_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = adc_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = adc_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = adc_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = adc_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = adc_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = adc_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = adc_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = adc_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = adc_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = adc_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = adc_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1124,40 +1124,40 @@ void x86emuOp_adc_byte_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm00_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = adc_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm00_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = adc_byte(*destreg, srcval);
+       break;
     case 1:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm01_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = adc_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm01_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = adc_byte(*destreg, srcval);
+       break;
     case 2:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm10_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = adc_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm10_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = adc_byte(*destreg, srcval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = adc_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = adc_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1177,101 +1177,101 @@ void x86emuOp_adc_word_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = adc_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = adc_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = adc_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = adc_word(*destreg, srcval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = adc_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = adc_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = adc_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = adc_word(*destreg, srcval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = adc_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = adc_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = adc_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = adc_word(*destreg, srcval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = adc_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = adc_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = adc_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = adc_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1305,18 +1305,18 @@ void x86emuOp_adc_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("ADC\tEAX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("ADC\tEAX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("ADC\tAX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("ADC\tAX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = adc_long(M.x86.R_EAX, srcval);
+       M.x86.R_EAX = adc_long(M.x86.R_EAX, srcval);
     } else {
-        M.x86.R_AX = adc_word(M.x86.R_AX, (u16)srcval);
+       M.x86.R_AX = adc_word(M.x86.R_AX, (u16)srcval);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1366,43 +1366,43 @@ void x86emuOp_sbb_byte_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = sbb_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = sbb_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = sbb_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = sbb_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = sbb_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = sbb_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = sbb_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = sbb_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1422,107 +1422,107 @@ void x86emuOp_sbb_word_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = sbb_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = sbb_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = sbb_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = sbb_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = sbb_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = sbb_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = sbb_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = sbb_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = sbb_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = sbb_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = sbb_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = sbb_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sbb_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sbb_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sbb_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sbb_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1544,40 +1544,40 @@ void x86emuOp_sbb_byte_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm00_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = sbb_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm00_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = sbb_byte(*destreg, srcval);
+       break;
     case 1:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm01_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = sbb_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm01_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = sbb_byte(*destreg, srcval);
+       break;
     case 2:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm10_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = sbb_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm10_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = sbb_byte(*destreg, srcval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = sbb_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = sbb_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1597,101 +1597,101 @@ void x86emuOp_sbb_word_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sbb_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sbb_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sbb_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sbb_word(*destreg, srcval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sbb_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sbb_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sbb_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sbb_word(*destreg, srcval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sbb_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sbb_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sbb_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sbb_word(*destreg, srcval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sbb_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sbb_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sbb_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sbb_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1725,18 +1725,18 @@ void x86emuOp_sbb_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("SBB\tEAX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("SBB\tEAX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("SBB\tAX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("SBB\tAX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = sbb_long(M.x86.R_EAX, srcval);
+       M.x86.R_EAX = sbb_long(M.x86.R_EAX, srcval);
     } else {
-        M.x86.R_AX = sbb_word(M.x86.R_AX, (u16)srcval);
+       M.x86.R_AX = sbb_word(M.x86.R_AX, (u16)srcval);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1787,46 +1787,46 @@ void x86emuOp_and_byte_RM_R(u8 X86EMU_UNUSED(op1))
 
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = and_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = and_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
 
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = and_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = and_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
 
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = and_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = and_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
 
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = and_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = and_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1846,107 +1846,107 @@ void x86emuOp_and_word_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = and_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = and_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = and_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = and_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = and_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = and_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = and_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = and_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = and_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = and_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = and_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = and_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = and_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = and_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = and_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = and_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1968,40 +1968,40 @@ void x86emuOp_and_byte_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm00_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = and_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm00_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = and_byte(*destreg, srcval);
+       break;
     case 1:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm01_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = and_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm01_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = and_byte(*destreg, srcval);
+       break;
     case 2:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm10_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = and_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm10_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = and_byte(*destreg, srcval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = and_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = and_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2021,102 +2021,102 @@ void x86emuOp_and_word_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = and_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = and_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = and_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = and_word(*destreg, srcval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = and_long(*destreg, srcval);
-            break;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = and_word(*destreg, srcval);
-            break;
-        }
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = and_long(*destreg, srcval);
+           break;
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = and_word(*destreg, srcval);
+           break;
+       }
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = and_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = and_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = and_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = and_word(*destreg, srcval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = and_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = and_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = and_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = and_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2150,18 +2150,18 @@ void x86emuOp_and_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("AND\tEAX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("AND\tEAX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("AND\tAX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("AND\tAX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = and_long(M.x86.R_EAX, srcval);
+       M.x86.R_EAX = and_long(M.x86.R_EAX, srcval);
     } else {
-        M.x86.R_AX = and_word(M.x86.R_AX, (u16)srcval);
+       M.x86.R_AX = and_word(M.x86.R_AX, (u16)srcval);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2214,43 +2214,43 @@ void x86emuOp_sub_byte_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = sub_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = sub_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = sub_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = sub_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = sub_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = sub_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = sub_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = sub_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2270,107 +2270,107 @@ void x86emuOp_sub_word_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = sub_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = sub_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = sub_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = sub_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = sub_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = sub_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = sub_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = sub_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = sub_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = sub_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = sub_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = sub_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sub_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sub_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sub_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sub_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2392,40 +2392,40 @@ void x86emuOp_sub_byte_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm00_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = sub_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm00_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = sub_byte(*destreg, srcval);
+       break;
     case 1:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm01_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = sub_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm01_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = sub_byte(*destreg, srcval);
+       break;
     case 2:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm10_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = sub_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm10_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = sub_byte(*destreg, srcval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = sub_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = sub_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2445,101 +2445,101 @@ void x86emuOp_sub_word_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sub_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sub_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sub_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sub_word(*destreg, srcval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sub_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sub_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sub_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sub_word(*destreg, srcval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sub_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sub_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sub_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sub_word(*destreg, srcval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sub_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sub_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = sub_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = sub_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2573,18 +2573,18 @@ void x86emuOp_sub_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("SUB\tEAX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("SUB\tEAX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("SUB\tAX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("SUB\tAX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = sub_long(M.x86.R_EAX, srcval);
+       M.x86.R_EAX = sub_long(M.x86.R_EAX, srcval);
     } else {
-        M.x86.R_AX = sub_word(M.x86.R_AX, (u16)srcval);
+       M.x86.R_AX = sub_word(M.x86.R_AX, (u16)srcval);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2634,43 +2634,43 @@ void x86emuOp_xor_byte_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = xor_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = xor_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = xor_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = xor_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = xor_byte(destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = xor_byte(destval, *srcreg);
+       store_data_byte(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = xor_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = xor_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2690,107 +2690,107 @@ void x86emuOp_xor_word_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = xor_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = xor_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = xor_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = xor_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = xor_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = xor_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = xor_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = xor_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = xor_long(destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = xor_word(destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = xor_long(destval, *srcreg);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = xor_word(destval, *srcreg);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = xor_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = xor_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = xor_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = xor_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2812,40 +2812,40 @@ void x86emuOp_xor_byte_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm00_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = xor_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm00_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = xor_byte(*destreg, srcval);
+       break;
     case 1:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm01_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = xor_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm01_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = xor_byte(*destreg, srcval);
+       break;
     case 2:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm10_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = xor_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm10_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = xor_byte(*destreg, srcval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = xor_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = xor_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2865,101 +2865,101 @@ void x86emuOp_xor_word_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = xor_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = xor_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = xor_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = xor_word(*destreg, srcval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = xor_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = xor_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = xor_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = xor_word(*destreg, srcval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = xor_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = xor_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = xor_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = xor_word(*destreg, srcval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = xor_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = xor_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = xor_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = xor_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2993,18 +2993,18 @@ void x86emuOp_xor_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("XOR\tEAX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("XOR\tEAX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("XOR\tAX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("XOR\tAX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = xor_long(M.x86.R_EAX, srcval);
+       M.x86.R_EAX = xor_long(M.x86.R_EAX, srcval);
     } else {
-        M.x86.R_AX = xor_word(M.x86.R_AX, (u16)srcval);
+       M.x86.R_AX = xor_word(M.x86.R_AX, (u16)srcval);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3054,40 +3054,40 @@ void x86emuOp_cmp_byte_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        cmp_byte(destval, *srcreg);
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       cmp_byte(destval, *srcreg);
+       break;
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        cmp_byte(destval, *srcreg);
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       cmp_byte(destval, *srcreg);
+       break;
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        cmp_byte(destval, *srcreg);
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       cmp_byte(destval, *srcreg);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        cmp_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       cmp_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3107,101 +3107,101 @@ void x86emuOp_cmp_word_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_long(destval, *srcreg);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_word(destval, *srcreg);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_long(destval, *srcreg);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_word(destval, *srcreg);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_long(destval, *srcreg);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_word(destval, *srcreg);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_long(destval, *srcreg);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_word(destval, *srcreg);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_long(destval, *srcreg);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_word(destval, *srcreg);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_long(destval, *srcreg);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_word(destval, *srcreg);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3223,40 +3223,40 @@ void x86emuOp_cmp_byte_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm00_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        cmp_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm00_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       cmp_byte(*destreg, srcval);
+       break;
     case 1:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm01_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        cmp_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm01_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       cmp_byte(*destreg, srcval);
+       break;
     case 2:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm10_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        cmp_byte(*destreg, srcval);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm10_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       cmp_byte(*destreg, srcval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        cmp_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       cmp_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3276,101 +3276,101 @@ void x86emuOp_cmp_word_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_word(*destreg, srcval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_word(*destreg, srcval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_long(*destreg, srcval);
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_word(*destreg, srcval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_long(*destreg, srcval);
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_word(*destreg, srcval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            cmp_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           cmp_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3404,18 +3404,18 @@ void x86emuOp_cmp_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("CMP\tEAX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("CMP\tEAX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("CMP\tAX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("CMP\tAX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        cmp_long(M.x86.R_EAX, srcval);
+       cmp_long(M.x86.R_EAX, srcval);
     } else {
-        cmp_word(M.x86.R_AX, (u16)srcval);
+       cmp_word(M.x86.R_AX, (u16)srcval);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3457,15 +3457,15 @@ void x86emuOp_inc_AX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("INC\tEAX\n");
+       DECODE_PRINTF("INC\tEAX\n");
     } else {
-        DECODE_PRINTF("INC\tAX\n");
+       DECODE_PRINTF("INC\tAX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = inc_long(M.x86.R_EAX);
+       M.x86.R_EAX = inc_long(M.x86.R_EAX);
     } else {
-        M.x86.R_AX = inc_word(M.x86.R_AX);
+       M.x86.R_AX = inc_word(M.x86.R_AX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3479,15 +3479,15 @@ void x86emuOp_inc_CX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("INC\tECX\n");
+       DECODE_PRINTF("INC\tECX\n");
     } else {
-        DECODE_PRINTF("INC\tCX\n");
+       DECODE_PRINTF("INC\tCX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_ECX = inc_long(M.x86.R_ECX);
+       M.x86.R_ECX = inc_long(M.x86.R_ECX);
     } else {
-        M.x86.R_CX = inc_word(M.x86.R_CX);
+       M.x86.R_CX = inc_word(M.x86.R_CX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3501,15 +3501,15 @@ void x86emuOp_inc_DX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("INC\tEDX\n");
+       DECODE_PRINTF("INC\tEDX\n");
     } else {
-        DECODE_PRINTF("INC\tDX\n");
+       DECODE_PRINTF("INC\tDX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EDX = inc_long(M.x86.R_EDX);
+       M.x86.R_EDX = inc_long(M.x86.R_EDX);
     } else {
-        M.x86.R_DX = inc_word(M.x86.R_DX);
+       M.x86.R_DX = inc_word(M.x86.R_DX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3523,15 +3523,15 @@ void x86emuOp_inc_BX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("INC\tEBX\n");
+       DECODE_PRINTF("INC\tEBX\n");
     } else {
-        DECODE_PRINTF("INC\tBX\n");
+       DECODE_PRINTF("INC\tBX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EBX = inc_long(M.x86.R_EBX);
+       M.x86.R_EBX = inc_long(M.x86.R_EBX);
     } else {
-        M.x86.R_BX = inc_word(M.x86.R_BX);
+       M.x86.R_BX = inc_word(M.x86.R_BX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3545,15 +3545,15 @@ void x86emuOp_inc_SP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("INC\tESP\n");
+       DECODE_PRINTF("INC\tESP\n");
     } else {
-        DECODE_PRINTF("INC\tSP\n");
+       DECODE_PRINTF("INC\tSP\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_ESP = inc_long(M.x86.R_ESP);
+       M.x86.R_ESP = inc_long(M.x86.R_ESP);
     } else {
-        M.x86.R_SP = inc_word(M.x86.R_SP);
+       M.x86.R_SP = inc_word(M.x86.R_SP);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3567,15 +3567,15 @@ void x86emuOp_inc_BP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("INC\tEBP\n");
+       DECODE_PRINTF("INC\tEBP\n");
     } else {
-        DECODE_PRINTF("INC\tBP\n");
+       DECODE_PRINTF("INC\tBP\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EBP = inc_long(M.x86.R_EBP);
+       M.x86.R_EBP = inc_long(M.x86.R_EBP);
     } else {
-        M.x86.R_BP = inc_word(M.x86.R_BP);
+       M.x86.R_BP = inc_word(M.x86.R_BP);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3589,15 +3589,15 @@ void x86emuOp_inc_SI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("INC\tESI\n");
+       DECODE_PRINTF("INC\tESI\n");
     } else {
-        DECODE_PRINTF("INC\tSI\n");
+       DECODE_PRINTF("INC\tSI\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_ESI = inc_long(M.x86.R_ESI);
+       M.x86.R_ESI = inc_long(M.x86.R_ESI);
     } else {
-        M.x86.R_SI = inc_word(M.x86.R_SI);
+       M.x86.R_SI = inc_word(M.x86.R_SI);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3611,15 +3611,15 @@ void x86emuOp_inc_DI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("INC\tEDI\n");
+       DECODE_PRINTF("INC\tEDI\n");
     } else {
-        DECODE_PRINTF("INC\tDI\n");
+       DECODE_PRINTF("INC\tDI\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EDI = inc_long(M.x86.R_EDI);
+       M.x86.R_EDI = inc_long(M.x86.R_EDI);
     } else {
-        M.x86.R_DI = inc_word(M.x86.R_DI);
+       M.x86.R_DI = inc_word(M.x86.R_DI);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3633,15 +3633,15 @@ void x86emuOp_dec_AX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("DEC\tEAX\n");
+       DECODE_PRINTF("DEC\tEAX\n");
     } else {
-        DECODE_PRINTF("DEC\tAX\n");
+       DECODE_PRINTF("DEC\tAX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = dec_long(M.x86.R_EAX);
+       M.x86.R_EAX = dec_long(M.x86.R_EAX);
     } else {
-        M.x86.R_AX = dec_word(M.x86.R_AX);
+       M.x86.R_AX = dec_word(M.x86.R_AX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3655,15 +3655,15 @@ void x86emuOp_dec_CX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("DEC\tECX\n");
+       DECODE_PRINTF("DEC\tECX\n");
     } else {
-        DECODE_PRINTF("DEC\tCX\n");
+       DECODE_PRINTF("DEC\tCX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_ECX = dec_long(M.x86.R_ECX);
+       M.x86.R_ECX = dec_long(M.x86.R_ECX);
     } else {
-        M.x86.R_CX = dec_word(M.x86.R_CX);
+       M.x86.R_CX = dec_word(M.x86.R_CX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3677,15 +3677,15 @@ void x86emuOp_dec_DX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("DEC\tEDX\n");
+       DECODE_PRINTF("DEC\tEDX\n");
     } else {
-        DECODE_PRINTF("DEC\tDX\n");
+       DECODE_PRINTF("DEC\tDX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EDX = dec_long(M.x86.R_EDX);
+       M.x86.R_EDX = dec_long(M.x86.R_EDX);
     } else {
-        M.x86.R_DX = dec_word(M.x86.R_DX);
+       M.x86.R_DX = dec_word(M.x86.R_DX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3699,15 +3699,15 @@ void x86emuOp_dec_BX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("DEC\tEBX\n");
+       DECODE_PRINTF("DEC\tEBX\n");
     } else {
-        DECODE_PRINTF("DEC\tBX\n");
+       DECODE_PRINTF("DEC\tBX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EBX = dec_long(M.x86.R_EBX);
+       M.x86.R_EBX = dec_long(M.x86.R_EBX);
     } else {
-        M.x86.R_BX = dec_word(M.x86.R_BX);
+       M.x86.R_BX = dec_word(M.x86.R_BX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3721,15 +3721,15 @@ void x86emuOp_dec_SP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("DEC\tESP\n");
+       DECODE_PRINTF("DEC\tESP\n");
     } else {
-        DECODE_PRINTF("DEC\tSP\n");
+       DECODE_PRINTF("DEC\tSP\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_ESP = dec_long(M.x86.R_ESP);
+       M.x86.R_ESP = dec_long(M.x86.R_ESP);
     } else {
-        M.x86.R_SP = dec_word(M.x86.R_SP);
+       M.x86.R_SP = dec_word(M.x86.R_SP);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3743,15 +3743,15 @@ void x86emuOp_dec_BP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("DEC\tEBP\n");
+       DECODE_PRINTF("DEC\tEBP\n");
     } else {
-        DECODE_PRINTF("DEC\tBP\n");
+       DECODE_PRINTF("DEC\tBP\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EBP = dec_long(M.x86.R_EBP);
+       M.x86.R_EBP = dec_long(M.x86.R_EBP);
     } else {
-        M.x86.R_BP = dec_word(M.x86.R_BP);
+       M.x86.R_BP = dec_word(M.x86.R_BP);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3765,15 +3765,15 @@ void x86emuOp_dec_SI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("DEC\tESI\n");
+       DECODE_PRINTF("DEC\tESI\n");
     } else {
-        DECODE_PRINTF("DEC\tSI\n");
+       DECODE_PRINTF("DEC\tSI\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_ESI = dec_long(M.x86.R_ESI);
+       M.x86.R_ESI = dec_long(M.x86.R_ESI);
     } else {
-        M.x86.R_SI = dec_word(M.x86.R_SI);
+       M.x86.R_SI = dec_word(M.x86.R_SI);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3787,15 +3787,15 @@ void x86emuOp_dec_DI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("DEC\tEDI\n");
+       DECODE_PRINTF("DEC\tEDI\n");
     } else {
-        DECODE_PRINTF("DEC\tDI\n");
+       DECODE_PRINTF("DEC\tDI\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EDI = dec_long(M.x86.R_EDI);
+       M.x86.R_EDI = dec_long(M.x86.R_EDI);
     } else {
-        M.x86.R_DI = dec_word(M.x86.R_DI);
+       M.x86.R_DI = dec_word(M.x86.R_DI);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3809,15 +3809,15 @@ void x86emuOp_push_AX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("PUSH\tEAX\n");
+       DECODE_PRINTF("PUSH\tEAX\n");
     } else {
-        DECODE_PRINTF("PUSH\tAX\n");
+       DECODE_PRINTF("PUSH\tAX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        push_long(M.x86.R_EAX);
+       push_long(M.x86.R_EAX);
     } else {
-        push_word(M.x86.R_AX);
+       push_word(M.x86.R_AX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3831,15 +3831,15 @@ void x86emuOp_push_CX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("PUSH\tECX\n");
+       DECODE_PRINTF("PUSH\tECX\n");
     } else {
-        DECODE_PRINTF("PUSH\tCX\n");
+       DECODE_PRINTF("PUSH\tCX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        push_long(M.x86.R_ECX);
+       push_long(M.x86.R_ECX);
     } else {
-        push_word(M.x86.R_CX);
+       push_word(M.x86.R_CX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3853,15 +3853,15 @@ void x86emuOp_push_DX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("PUSH\tEDX\n");
+       DECODE_PRINTF("PUSH\tEDX\n");
     } else {
-        DECODE_PRINTF("PUSH\tDX\n");
+       DECODE_PRINTF("PUSH\tDX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        push_long(M.x86.R_EDX);
+       push_long(M.x86.R_EDX);
     } else {
-        push_word(M.x86.R_DX);
+       push_word(M.x86.R_DX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3875,15 +3875,15 @@ void x86emuOp_push_BX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("PUSH\tEBX\n");
+       DECODE_PRINTF("PUSH\tEBX\n");
     } else {
-        DECODE_PRINTF("PUSH\tBX\n");
+       DECODE_PRINTF("PUSH\tBX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        push_long(M.x86.R_EBX);
+       push_long(M.x86.R_EBX);
     } else {
-        push_word(M.x86.R_BX);
+       push_word(M.x86.R_BX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3897,9 +3897,9 @@ void x86emuOp_push_SP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("PUSH\tESP\n");
+       DECODE_PRINTF("PUSH\tESP\n");
     } else {
-        DECODE_PRINTF("PUSH\tSP\n");
+       DECODE_PRINTF("PUSH\tSP\n");
     }
     TRACE_AND_STEP();
        /* Always push (E)SP, since we are emulating an i386 and above
@@ -3923,15 +3923,15 @@ void x86emuOp_push_BP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("PUSH\tEBP\n");
+       DECODE_PRINTF("PUSH\tEBP\n");
     } else {
-        DECODE_PRINTF("PUSH\tBP\n");
+       DECODE_PRINTF("PUSH\tBP\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        push_long(M.x86.R_EBP);
+       push_long(M.x86.R_EBP);
     } else {
-        push_word(M.x86.R_BP);
+       push_word(M.x86.R_BP);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3945,15 +3945,15 @@ void x86emuOp_push_SI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("PUSH\tESI\n");
+       DECODE_PRINTF("PUSH\tESI\n");
     } else {
-        DECODE_PRINTF("PUSH\tSI\n");
+       DECODE_PRINTF("PUSH\tSI\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        push_long(M.x86.R_ESI);
+       push_long(M.x86.R_ESI);
     } else {
-        push_word(M.x86.R_SI);
+       push_word(M.x86.R_SI);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3967,15 +3967,15 @@ void x86emuOp_push_DI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("PUSH\tEDI\n");
+       DECODE_PRINTF("PUSH\tEDI\n");
     } else {
-        DECODE_PRINTF("PUSH\tDI\n");
+       DECODE_PRINTF("PUSH\tDI\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        push_long(M.x86.R_EDI);
+       push_long(M.x86.R_EDI);
     } else {
-        push_word(M.x86.R_DI);
+       push_word(M.x86.R_DI);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3989,15 +3989,15 @@ void x86emuOp_pop_AX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("POP\tEAX\n");
+       DECODE_PRINTF("POP\tEAX\n");
     } else {
-        DECODE_PRINTF("POP\tAX\n");
+       DECODE_PRINTF("POP\tAX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = pop_long();
+       M.x86.R_EAX = pop_long();
     } else {
-        M.x86.R_AX = pop_word();
+       M.x86.R_AX = pop_word();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4011,15 +4011,15 @@ void x86emuOp_pop_CX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("POP\tECX\n");
+       DECODE_PRINTF("POP\tECX\n");
     } else {
-        DECODE_PRINTF("POP\tCX\n");
+       DECODE_PRINTF("POP\tCX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_ECX = pop_long();
+       M.x86.R_ECX = pop_long();
     } else {
-        M.x86.R_CX = pop_word();
+       M.x86.R_CX = pop_word();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4033,15 +4033,15 @@ void x86emuOp_pop_DX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("POP\tEDX\n");
+       DECODE_PRINTF("POP\tEDX\n");
     } else {
-        DECODE_PRINTF("POP\tDX\n");
+       DECODE_PRINTF("POP\tDX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EDX = pop_long();
+       M.x86.R_EDX = pop_long();
     } else {
-        M.x86.R_DX = pop_word();
+       M.x86.R_DX = pop_word();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4055,15 +4055,15 @@ void x86emuOp_pop_BX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("POP\tEBX\n");
+       DECODE_PRINTF("POP\tEBX\n");
     } else {
-        DECODE_PRINTF("POP\tBX\n");
+       DECODE_PRINTF("POP\tBX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EBX = pop_long();
+       M.x86.R_EBX = pop_long();
     } else {
-        M.x86.R_BX = pop_word();
+       M.x86.R_BX = pop_word();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4077,15 +4077,15 @@ void x86emuOp_pop_SP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("POP\tESP\n");
+       DECODE_PRINTF("POP\tESP\n");
     } else {
-        DECODE_PRINTF("POP\tSP\n");
+       DECODE_PRINTF("POP\tSP\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_ESP = pop_long();
+       M.x86.R_ESP = pop_long();
     } else {
-        M.x86.R_SP = pop_word();
+       M.x86.R_SP = pop_word();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4099,15 +4099,15 @@ void x86emuOp_pop_BP(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("POP\tEBP\n");
+       DECODE_PRINTF("POP\tEBP\n");
     } else {
-        DECODE_PRINTF("POP\tBP\n");
+       DECODE_PRINTF("POP\tBP\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EBP = pop_long();
+       M.x86.R_EBP = pop_long();
     } else {
-        M.x86.R_BP = pop_word();
+       M.x86.R_BP = pop_word();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4121,15 +4121,15 @@ void x86emuOp_pop_SI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("POP\tESI\n");
+       DECODE_PRINTF("POP\tESI\n");
     } else {
-        DECODE_PRINTF("POP\tSI\n");
+       DECODE_PRINTF("POP\tSI\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_ESI = pop_long();
+       M.x86.R_ESI = pop_long();
     } else {
-        M.x86.R_SI = pop_word();
+       M.x86.R_SI = pop_word();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4143,15 +4143,15 @@ void x86emuOp_pop_DI(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("POP\tEDI\n");
+       DECODE_PRINTF("POP\tEDI\n");
     } else {
-        DECODE_PRINTF("POP\tDI\n");
+       DECODE_PRINTF("POP\tDI\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EDI = pop_long();
+       M.x86.R_EDI = pop_long();
     } else {
-        M.x86.R_DI = pop_word();
+       M.x86.R_DI = pop_word();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4165,33 +4165,33 @@ void x86emuOp_push_all(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("PUSHAD\n");
+       DECODE_PRINTF("PUSHAD\n");
     } else {
-        DECODE_PRINTF("PUSHA\n");
+       DECODE_PRINTF("PUSHA\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        u32 old_sp = M.x86.R_ESP;
+       u32 old_sp = M.x86.R_ESP;
 
-        push_long(M.x86.R_EAX);
-        push_long(M.x86.R_ECX);
-        push_long(M.x86.R_EDX);
-        push_long(M.x86.R_EBX);
-        push_long(old_sp);
-        push_long(M.x86.R_EBP);
-        push_long(M.x86.R_ESI);
-        push_long(M.x86.R_EDI);
+       push_long(M.x86.R_EAX);
+       push_long(M.x86.R_ECX);
+       push_long(M.x86.R_EDX);
+       push_long(M.x86.R_EBX);
+       push_long(old_sp);
+       push_long(M.x86.R_EBP);
+       push_long(M.x86.R_ESI);
+       push_long(M.x86.R_EDI);
     } else {
-        u16 old_sp = M.x86.R_SP;
+       u16 old_sp = M.x86.R_SP;
 
-        push_word(M.x86.R_AX);
-        push_word(M.x86.R_CX);
-        push_word(M.x86.R_DX);
-        push_word(M.x86.R_BX);
-        push_word(old_sp);
-        push_word(M.x86.R_BP);
-        push_word(M.x86.R_SI);
-        push_word(M.x86.R_DI);
+       push_word(M.x86.R_AX);
+       push_word(M.x86.R_CX);
+       push_word(M.x86.R_DX);
+       push_word(M.x86.R_BX);
+       push_word(old_sp);
+       push_word(M.x86.R_BP);
+       push_word(M.x86.R_SI);
+       push_word(M.x86.R_DI);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4205,29 +4205,29 @@ void x86emuOp_pop_all(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("POPAD\n");
+       DECODE_PRINTF("POPAD\n");
     } else {
-        DECODE_PRINTF("POPA\n");
+       DECODE_PRINTF("POPA\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EDI = pop_long();
-        M.x86.R_ESI = pop_long();
-        M.x86.R_EBP = pop_long();
-        M.x86.R_ESP += 4;              /* skip ESP */
-        M.x86.R_EBX = pop_long();
-        M.x86.R_EDX = pop_long();
-        M.x86.R_ECX = pop_long();
-        M.x86.R_EAX = pop_long();
+       M.x86.R_EDI = pop_long();
+       M.x86.R_ESI = pop_long();
+       M.x86.R_EBP = pop_long();
+       M.x86.R_ESP += 4;              /* skip ESP */
+       M.x86.R_EBX = pop_long();
+       M.x86.R_EDX = pop_long();
+       M.x86.R_ECX = pop_long();
+       M.x86.R_EAX = pop_long();
     } else {
-        M.x86.R_DI = pop_word();
-        M.x86.R_SI = pop_word();
-        M.x86.R_BP = pop_word();
-        M.x86.R_SP += 2;               /* skip SP */
-        M.x86.R_BX = pop_word();
-        M.x86.R_DX = pop_word();
-        M.x86.R_CX = pop_word();
-        M.x86.R_AX = pop_word();
+       M.x86.R_DI = pop_word();
+       M.x86.R_SI = pop_word();
+       M.x86.R_BP = pop_word();
+       M.x86.R_SP += 2;               /* skip SP */
+       M.x86.R_BX = pop_word();
+       M.x86.R_DX = pop_word();
+       M.x86.R_CX = pop_word();
+       M.x86.R_AX = pop_word();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4308,16 +4308,16 @@ void x86emuOp_push_word_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        imm = fetch_long_imm();
+       imm = fetch_long_imm();
     } else {
-        imm = fetch_word_imm();
+       imm = fetch_word_imm();
     }
     DECODE_PRINTF2("PUSH\t%x\n", imm);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        push_long(imm);
+       push_long(imm);
     } else {
-        push_word((u16)imm);
+       push_word((u16)imm);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4337,188 +4337,188 @@ void x86emuOp_imul_word_IMM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-            u32 res_lo,res_hi;
-            s32 imm;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            imm = fetch_long_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
-            if (res_hi != 0) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u32)res_lo;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-            u32 res;
-            s16 imm;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            res = (s16)srcval * (s16)imm;
-            if (res > 0xFFFF) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+           u32 res_lo,res_hi;
+           s32 imm;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           imm = fetch_long_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
+           if (res_hi != 0) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u32)res_lo;
+       } else {
+           u16 *destreg;
+           u16 srcval;
+           u32 res;
+           s16 imm;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           imm = fetch_word_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           res = (s16)srcval * (s16)imm;
+           if (res > 0xFFFF) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u16)res;
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-            u32 res_lo,res_hi;
-            s32 imm;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            imm = fetch_long_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
-            if (res_hi != 0) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u32)res_lo;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-            u32 res;
-            s16 imm;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            res = (s16)srcval * (s16)imm;
-            if (res > 0xFFFF) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+           u32 res_lo,res_hi;
+           s32 imm;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           imm = fetch_long_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
+           if (res_hi != 0) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u32)res_lo;
+       } else {
+           u16 *destreg;
+           u16 srcval;
+           u32 res;
+           s16 imm;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           imm = fetch_word_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           res = (s16)srcval * (s16)imm;
+           if (res > 0xFFFF) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u16)res;
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-            u32 res_lo,res_hi;
-            s32 imm;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            imm = fetch_long_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
-            if (res_hi != 0) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u32)res_lo;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-            u32 res;
-            s16 imm;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            res = (s16)srcval * (s16)imm;
-            if (res > 0xFFFF) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+           u32 res_lo,res_hi;
+           s32 imm;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           imm = fetch_long_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
+           if (res_hi != 0) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u32)res_lo;
+       } else {
+           u16 *destreg;
+           u16 srcval;
+           u32 res;
+           s16 imm;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           imm = fetch_word_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           res = (s16)srcval * (s16)imm;
+           if (res > 0xFFFF) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u16)res;
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-            u32 res_lo,res_hi;
-            s32 imm;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            imm = fetch_long_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            imul_long_direct(&res_lo,&res_hi,(s32)*srcreg,(s32)imm);
-            if (res_hi != 0) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u32)res_lo;
-        } else {
-            u16 *destreg,*srcreg;
-            u32 res;
-            s16 imm;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            res = (s16)*srcreg * (s16)imm;
-            if (res > 0xFFFF) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+           u32 res_lo,res_hi;
+           s32 imm;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rl);
+           imm = fetch_long_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           imul_long_direct(&res_lo,&res_hi,(s32)*srcreg,(s32)imm);
+           if (res_hi != 0) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u32)res_lo;
+       } else {
+           u16 *destreg,*srcreg;
+           u32 res;
+           s16 imm;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rl);
+           imm = fetch_word_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           res = (s16)*srcreg * (s16)imm;
+           if (res > 0xFFFF) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u16)res;
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4556,180 +4556,180 @@ void x86emuOp_imul_byte_IMM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-            u32 res_lo,res_hi;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            imm = fetch_byte_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
-            if (res_hi != 0) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u32)res_lo;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-            u32 res;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            imm = fetch_byte_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            res = (s16)srcval * (s16)imm;
-            if (res > 0xFFFF) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+           u32 res_lo,res_hi;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           imm = fetch_byte_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
+           if (res_hi != 0) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u32)res_lo;
+       } else {
+           u16 *destreg;
+           u16 srcval;
+           u32 res;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           imm = fetch_byte_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           res = (s16)srcval * (s16)imm;
+           if (res > 0xFFFF) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u16)res;
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-            u32 res_lo,res_hi;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            imm = fetch_byte_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
-            if (res_hi != 0) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u32)res_lo;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-            u32 res;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            imm = fetch_byte_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            res = (s16)srcval * (s16)imm;
-            if (res > 0xFFFF) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+           u32 res_lo,res_hi;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           imm = fetch_byte_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
+           if (res_hi != 0) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u32)res_lo;
+       } else {
+           u16 *destreg;
+           u16 srcval;
+           u32 res;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           imm = fetch_byte_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           res = (s16)srcval * (s16)imm;
+           if (res > 0xFFFF) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u16)res;
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-            u32 res_lo,res_hi;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            imm = fetch_byte_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
-            if (res_hi != 0) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u32)res_lo;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-            u32 res;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            imm = fetch_byte_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            res = (s16)srcval * (s16)imm;
-            if (res > 0xFFFF) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+           u32 res_lo,res_hi;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           imm = fetch_byte_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           imul_long_direct(&res_lo,&res_hi,(s32)srcval,(s32)imm);
+           if (res_hi != 0) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u32)res_lo;
+       } else {
+           u16 *destreg;
+           u16 srcval;
+           u32 res;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           imm = fetch_byte_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           res = (s16)srcval * (s16)imm;
+           if (res > 0xFFFF) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u16)res;
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-            u32 res_lo,res_hi;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            imm = fetch_byte_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            TRACE_AND_STEP();
-            imul_long_direct(&res_lo,&res_hi,(s32)*srcreg,(s32)imm);
-            if (res_hi != 0) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u32)res_lo;
-        } else {
-            u16 *destreg,*srcreg;
-            u32 res;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            imm = fetch_byte_imm();
-            DECODE_PRINTF2(",%d\n", (s32)imm);
-            res = (s16)*srcreg * (s16)imm;
-            if (res > 0xFFFF) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+           u32 res_lo,res_hi;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rl);
+           imm = fetch_byte_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           TRACE_AND_STEP();
+           imul_long_direct(&res_lo,&res_hi,(s32)*srcreg,(s32)imm);
+           if (res_hi != 0) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u32)res_lo;
+       } else {
+           u16 *destreg,*srcreg;
+           u32 res;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rl);
+           imm = fetch_byte_imm();
+           DECODE_PRINTF2(",%d\n", (s32)imm);
+           res = (s16)*srcreg * (s16)imm;
+           if (res > 0xFFFF) {
+               SET_FLAG(F_CF);
+               SET_FLAG(F_OF);
+           } else {
+               CLEAR_FLAG(F_CF);
+               CLEAR_FLAG(F_OF);
+           }
+           *destreg = (u16)res;
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4757,11 +4757,11 @@ void x86emuOp_ins_word(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("INSD\n");
-        ins(4);
+       DECODE_PRINTF("INSD\n");
+       ins(4);
     } else {
-        DECODE_PRINTF("INSW\n");
-        ins(2);
+       DECODE_PRINTF("INSW\n");
+       ins(2);
     }
     TRACE_AND_STEP();
     DECODE_CLEAR_SEGOVR();
@@ -4790,11 +4790,11 @@ void x86emuOp_outs_word(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("OUTSD\n");
-        outs(4);
+       DECODE_PRINTF("OUTSD\n");
+       outs(4);
     } else {
-        DECODE_PRINTF("OUTSW\n");
-        outs(2);
+       DECODE_PRINTF("OUTSW\n");
+       outs(2);
     }
     TRACE_AND_STEP();
     DECODE_CLEAR_SEGOVR();
@@ -4818,7 +4818,7 @@ void x86emuOp_jump_near_O(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (ACCESS_FLAG(F_OF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -4840,7 +4840,7 @@ void x86emuOp_jump_near_NO(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (!ACCESS_FLAG(F_OF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -4862,7 +4862,7 @@ void x86emuOp_jump_near_B(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (ACCESS_FLAG(F_CF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -4884,7 +4884,7 @@ void x86emuOp_jump_near_NB(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (!ACCESS_FLAG(F_CF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -4906,7 +4906,7 @@ void x86emuOp_jump_near_Z(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (ACCESS_FLAG(F_ZF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -4928,7 +4928,7 @@ void x86emuOp_jump_near_NZ(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (!ACCESS_FLAG(F_ZF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -4951,7 +4951,7 @@ void x86emuOp_jump_near_BE(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -4974,7 +4974,7 @@ void x86emuOp_jump_near_NBE(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (!(ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF)))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -4996,7 +4996,7 @@ void x86emuOp_jump_near_S(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (ACCESS_FLAG(F_SF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -5018,7 +5018,7 @@ void x86emuOp_jump_near_NS(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (!ACCESS_FLAG(F_SF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -5040,7 +5040,7 @@ void x86emuOp_jump_near_P(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (ACCESS_FLAG(F_PF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -5062,7 +5062,7 @@ void x86emuOp_jump_near_NP(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (!ACCESS_FLAG(F_PF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -5087,7 +5087,7 @@ void x86emuOp_jump_near_L(u8 X86EMU_UNUSED(op1))
     sf = ACCESS_FLAG(F_SF) != 0;
     of = ACCESS_FLAG(F_OF) != 0;
     if (sf ^ of)
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -5113,7 +5113,7 @@ void x86emuOp_jump_near_NL(u8 X86EMU_UNUSED(op1))
     of = ACCESS_FLAG(F_OF) != 0;
     /* note: inverse of above, but using == instead of xor. */
     if (sf == of)
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -5139,7 +5139,7 @@ void x86emuOp_jump_near_LE(u8 X86EMU_UNUSED(op1))
     sf = ACCESS_FLAG(F_SF) != 0;
     of = ACCESS_FLAG(F_OF) != 0;
     if ((sf ^ of) || ACCESS_FLAG(F_ZF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -5165,7 +5165,7 @@ void x86emuOp_jump_near_NLE(u8 X86EMU_UNUSED(op1))
     sf = ACCESS_FLAG(F_SF) != 0;
     of = ACCESS_FLAG(F_OF) != 0;
     if ((sf == of) && !ACCESS_FLAG(F_ZF))
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -5203,88 +5203,88 @@ void x86emuOp_opc80_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
 #ifdef DEBUG
     if (DEBUG_DECODE()) {
-        /* XXX DECODE_PRINTF may be changed to something more
-           general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
-           above test is done twice. */
-
-        switch (rh) {
-        case 0:
-            DECODE_PRINTF("ADD\t");
-            break;
-        case 1:
-            DECODE_PRINTF("OR\t");
-            break;
-        case 2:
-            DECODE_PRINTF("ADC\t");
-            break;
-        case 3:
-            DECODE_PRINTF("SBB\t");
-            break;
-        case 4:
-            DECODE_PRINTF("AND\t");
-            break;
-        case 5:
-            DECODE_PRINTF("SUB\t");
-            break;
-        case 6:
-            DECODE_PRINTF("XOR\t");
-            break;
-        case 7:
-            DECODE_PRINTF("CMP\t");
-            break;
-        }
+       /* XXX DECODE_PRINTF may be changed to something more
+          general, so that it is important to leave the strings
+          in the same format, even though the result is that the
+          above test is done twice. */
+
+       switch (rh) {
+       case 0:
+           DECODE_PRINTF("ADD\t");
+           break;
+       case 1:
+           DECODE_PRINTF("OR\t");
+           break;
+       case 2:
+           DECODE_PRINTF("ADC\t");
+           break;
+       case 3:
+           DECODE_PRINTF("SBB\t");
+           break;
+       case 4:
+           DECODE_PRINTF("AND\t");
+           break;
+       case 5:
+           DECODE_PRINTF("SUB\t");
+           break;
+       case 6:
+           DECODE_PRINTF("XOR\t");
+           break;
+       case 7:
+           DECODE_PRINTF("CMP\t");
+           break;
+       }
     }
 #endif
     /* know operation, decode the mod byte to find the addressing
        mode. */
     switch (mod) {
     case 0:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2("%x\n", imm);
-        TRACE_AND_STEP();
-        destval = (*opc80_byte_operation[rh]) (destval, imm);
-        if (rh != 7)
-            store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       imm = fetch_byte_imm();
+       DECODE_PRINTF2("%x\n", imm);
+       TRACE_AND_STEP();
+       destval = (*opc80_byte_operation[rh]) (destval, imm);
+       if (rh != 7)
+           store_data_byte(destoffset, destval);
+       break;
     case 1:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2("%x\n", imm);
-        TRACE_AND_STEP();
-        destval = (*opc80_byte_operation[rh]) (destval, imm);
-        if (rh != 7)
-            store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       imm = fetch_byte_imm();
+       DECODE_PRINTF2("%x\n", imm);
+       TRACE_AND_STEP();
+       destval = (*opc80_byte_operation[rh]) (destval, imm);
+       if (rh != 7)
+           store_data_byte(destoffset, destval);
+       break;
     case 2:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2("%x\n", imm);
-        TRACE_AND_STEP();
-        destval = (*opc80_byte_operation[rh]) (destval, imm);
-        if (rh != 7)
-            store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       imm = fetch_byte_imm();
+       DECODE_PRINTF2("%x\n", imm);
+       TRACE_AND_STEP();
+       destval = (*opc80_byte_operation[rh]) (destval, imm);
+       if (rh != 7)
+           store_data_byte(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2("%x\n", imm);
-        TRACE_AND_STEP();
-        destval = (*opc80_byte_operation[rh]) (*destreg, imm);
-        if (rh != 7)
-            *destreg = destval;
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",");
+       imm = fetch_byte_imm();
+       DECODE_PRINTF2("%x\n", imm);
+       TRACE_AND_STEP();
+       destval = (*opc80_byte_operation[rh]) (*destreg, imm);
+       if (rh != 7)
+           *destreg = destval;
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -5332,158 +5332,158 @@ void x86emuOp_opc81_word_RM_IMM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
 #ifdef DEBUG
     if (DEBUG_DECODE()) {
-        /* XXX DECODE_PRINTF may be changed to something more
-           general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
-           above test is done twice. */
-
-        switch (rh) {
-        case 0:
-            DECODE_PRINTF("ADD\t");
-            break;
-        case 1:
-            DECODE_PRINTF("OR\t");
-            break;
-        case 2:
-            DECODE_PRINTF("ADC\t");
-            break;
-        case 3:
-            DECODE_PRINTF("SBB\t");
-            break;
-        case 4:
-            DECODE_PRINTF("AND\t");
-            break;
-        case 5:
-            DECODE_PRINTF("SUB\t");
-            break;
-        case 6:
-            DECODE_PRINTF("XOR\t");
-            break;
-        case 7:
-            DECODE_PRINTF("CMP\t");
-            break;
-        }
+       /* XXX DECODE_PRINTF may be changed to something more
+          general, so that it is important to leave the strings
+          in the same format, even though the result is that the
+          above test is done twice. */
+
+       switch (rh) {
+       case 0:
+           DECODE_PRINTF("ADD\t");
+           break;
+       case 1:
+           DECODE_PRINTF("OR\t");
+           break;
+       case 2:
+           DECODE_PRINTF("ADC\t");
+           break;
+       case 3:
+           DECODE_PRINTF("SBB\t");
+           break;
+       case 4:
+           DECODE_PRINTF("AND\t");
+           break;
+       case 5:
+           DECODE_PRINTF("SUB\t");
+           break;
+       case 6:
+           DECODE_PRINTF("XOR\t");
+           break;
+       case 7:
+           DECODE_PRINTF("CMP\t");
+           break;
+       }
     }
 #endif
     /*
-     * Know operation, decode the mod byte to find the addressing 
+     * Know operation, decode the mod byte to find the addressing
      * mode.
      */
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval,imm;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            imm = fetch_long_imm();
-            DECODE_PRINTF2("%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc81_long_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_long(destoffset, destval);
-        } else {
-            u16 destval,imm;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2("%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc81_word_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval,imm;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           imm = fetch_long_imm();
+           DECODE_PRINTF2("%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc81_long_operation[rh]) (destval, imm);
+           if (rh != 7)
+               store_data_long(destoffset, destval);
+       } else {
+           u16 destval,imm;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           imm = fetch_word_imm();
+           DECODE_PRINTF2("%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc81_word_operation[rh]) (destval, imm);
+           if (rh != 7)
+               store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval,imm;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            imm = fetch_long_imm();
-            DECODE_PRINTF2("%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc81_long_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_long(destoffset, destval);
-        } else {
-            u16 destval,imm;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2("%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc81_word_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval,imm;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           imm = fetch_long_imm();
+           DECODE_PRINTF2("%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc81_long_operation[rh]) (destval, imm);
+           if (rh != 7)
+               store_data_long(destoffset, destval);
+       } else {
+           u16 destval,imm;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           imm = fetch_word_imm();
+           DECODE_PRINTF2("%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc81_word_operation[rh]) (destval, imm);
+           if (rh != 7)
+               store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval,imm;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            imm = fetch_long_imm();
-            DECODE_PRINTF2("%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc81_long_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_long(destoffset, destval);
-        } else {
-            u16 destval,imm;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2("%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc81_word_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval,imm;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           imm = fetch_long_imm();
+           DECODE_PRINTF2("%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc81_long_operation[rh]) (destval, imm);
+           if (rh != 7)
+               store_data_long(destoffset, destval);
+       } else {
+           u16 destval,imm;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           imm = fetch_word_imm();
+           DECODE_PRINTF2("%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc81_word_operation[rh]) (destval, imm);
+           if (rh != 7)
+               store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 destval,imm;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            imm = fetch_long_imm();
-            DECODE_PRINTF2("%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc81_long_operation[rh]) (*destreg, imm);
-            if (rh != 7)
-                *destreg = destval;
-        } else {
-            u16 *destreg;
-            u16 destval,imm;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 destval,imm;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",");
+           imm = fetch_long_imm();
+           DECODE_PRINTF2("%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc81_long_operation[rh]) (*destreg, imm);
+           if (rh != 7)
+               *destreg = destval;
+       } else {
+           u16 *destreg;
+           u16 destval,imm;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            imm = fetch_word_imm();
-            DECODE_PRINTF2("%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc81_word_operation[rh]) (*destreg, imm);
-            if (rh != 7)
-                *destreg = destval;
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",");
+           imm = fetch_word_imm();
+           DECODE_PRINTF2("%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc81_word_operation[rh]) (*destreg, imm);
+           if (rh != 7)
+               *destreg = destval;
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -5492,12 +5492,12 @@ void x86emuOp_opc81_word_RM_IMM(u8 X86EMU_UNUSED(op1))
 static u8 (*opc82_byte_operation[])(u8 s, u8 d) =
 {
     add_byte,           /*00 */
-    or_byte,            /*01 *//*YYY UNUSED ???? */
+    or_byte,            /*01 */ /*YYY UNUSED ???? */
     adc_byte,           /*02 */
     sbb_byte,           /*03 */
-    and_byte,           /*04 *//*YYY UNUSED ???? */
+    and_byte,           /*04 */ /*YYY UNUSED ???? */
     sub_byte,           /*05 */
-    xor_byte,           /*06 *//*YYY UNUSED ???? */
+    xor_byte,           /*06 */ /*YYY UNUSED ???? */
     cmp_byte,           /*07 */
 };
 
@@ -5523,83 +5523,83 @@ void x86emuOp_opc82_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
 #ifdef DEBUG
     if (DEBUG_DECODE()) {
-        /* XXX DECODE_PRINTF may be changed to something more
-           general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
-           above test is done twice. */
-        switch (rh) {
-        case 0:
-            DECODE_PRINTF("ADD\t");
-            break;
-        case 1:
-            DECODE_PRINTF("OR\t");
-            break;
-        case 2:
-            DECODE_PRINTF("ADC\t");
-            break;
-        case 3:
-            DECODE_PRINTF("SBB\t");
-            break;
-        case 4:
-            DECODE_PRINTF("AND\t");
-            break;
-        case 5:
-            DECODE_PRINTF("SUB\t");
-            break;
-        case 6:
-            DECODE_PRINTF("XOR\t");
-            break;
-        case 7:
-            DECODE_PRINTF("CMP\t");
-            break;
-        }
+       /* XXX DECODE_PRINTF may be changed to something more
+          general, so that it is important to leave the strings
+          in the same format, even though the result is that the
+          above test is done twice. */
+       switch (rh) {
+       case 0:
+           DECODE_PRINTF("ADD\t");
+           break;
+       case 1:
+           DECODE_PRINTF("OR\t");
+           break;
+       case 2:
+           DECODE_PRINTF("ADC\t");
+           break;
+       case 3:
+           DECODE_PRINTF("SBB\t");
+           break;
+       case 4:
+           DECODE_PRINTF("AND\t");
+           break;
+       case 5:
+           DECODE_PRINTF("SUB\t");
+           break;
+       case 6:
+           DECODE_PRINTF("XOR\t");
+           break;
+       case 7:
+           DECODE_PRINTF("CMP\t");
+           break;
+       }
     }
 #endif
     /* know operation, decode the mod byte to find the addressing
        mode. */
     switch (mod) {
     case 0:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm00_address(rl);
-        destval = fetch_data_byte(destoffset);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2(",%x\n", imm);
-        TRACE_AND_STEP();
-        destval = (*opc82_byte_operation[rh]) (destval, imm);
-        if (rh != 7)
-            store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm00_address(rl);
+       destval = fetch_data_byte(destoffset);
+       imm = fetch_byte_imm();
+       DECODE_PRINTF2(",%x\n", imm);
+       TRACE_AND_STEP();
+       destval = (*opc82_byte_operation[rh]) (destval, imm);
+       if (rh != 7)
+           store_data_byte(destoffset, destval);
+       break;
     case 1:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm01_address(rl);
-        destval = fetch_data_byte(destoffset);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2(",%x\n", imm);
-        TRACE_AND_STEP();
-        destval = (*opc82_byte_operation[rh]) (destval, imm);
-        if (rh != 7)
-            store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm01_address(rl);
+       destval = fetch_data_byte(destoffset);
+       imm = fetch_byte_imm();
+       DECODE_PRINTF2(",%x\n", imm);
+       TRACE_AND_STEP();
+       destval = (*opc82_byte_operation[rh]) (destval, imm);
+       if (rh != 7)
+           store_data_byte(destoffset, destval);
+       break;
     case 2:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm10_address(rl);
-        destval = fetch_data_byte(destoffset);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2(",%x\n", imm);
-        TRACE_AND_STEP();
-        destval = (*opc82_byte_operation[rh]) (destval, imm);
-        if (rh != 7)
-            store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm10_address(rl);
+       destval = fetch_data_byte(destoffset);
+       imm = fetch_byte_imm();
+       DECODE_PRINTF2(",%x\n", imm);
+       TRACE_AND_STEP();
+       destval = (*opc82_byte_operation[rh]) (destval, imm);
+       if (rh != 7)
+           store_data_byte(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2(",%x\n", imm);
-        TRACE_AND_STEP();
-        destval = (*opc82_byte_operation[rh]) (*destreg, imm);
-        if (rh != 7)
-            *destreg = destval;
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       imm = fetch_byte_imm();
+       DECODE_PRINTF2(",%x\n", imm);
+       TRACE_AND_STEP();
+       destval = (*opc82_byte_operation[rh]) (*destreg, imm);
+       if (rh != 7)
+           *destreg = destval;
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -5608,24 +5608,24 @@ void x86emuOp_opc82_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
 static u16 (*opc83_word_operation[])(u16 s, u16 d) =
 {
     add_word,           /*00 */
-    or_word,            /*01 *//*YYY UNUSED ???? */
+    or_word,            /*01 */ /*YYY UNUSED ???? */
     adc_word,           /*02 */
     sbb_word,           /*03 */
-    and_word,           /*04 *//*YYY UNUSED ???? */
+    and_word,           /*04 */ /*YYY UNUSED ???? */
     sub_word,           /*05 */
-    xor_word,           /*06 *//*YYY UNUSED ???? */
+    xor_word,           /*06 */ /*YYY UNUSED ???? */
     cmp_word,           /*07 */
 };
 
 static u32 (*opc83_long_operation[])(u32 s, u32 d) =
 {
     add_long,           /*00 */
-    or_long,            /*01 *//*YYY UNUSED ???? */
+    or_long,            /*01 */ /*YYY UNUSED ???? */
     adc_long,           /*02 */
     sbb_long,           /*03 */
-    and_long,           /*04 *//*YYY UNUSED ???? */
+    and_long,           /*04 */ /*YYY UNUSED ???? */
     sub_long,           /*05 */
-    xor_long,           /*06 *//*YYY UNUSED ???? */
+    xor_long,           /*06 */ /*YYY UNUSED ???? */
     cmp_long,           /*07 */
 };
 
@@ -5648,147 +5648,147 @@ void x86emuOp_opc83_word_RM_IMM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
 #ifdef DEBUG
     if (DEBUG_DECODE()) {
-        /* XXX DECODE_PRINTF may be changed to something more
-           general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
-           above test is done twice. */
+       /* XXX DECODE_PRINTF may be changed to something more
+          general, so that it is important to leave the strings
+          in the same format, even though the result is that the
+          above test is done twice. */
        switch (rh) {
-        case 0:
-            DECODE_PRINTF("ADD\t");
-            break;
-        case 1:
-            DECODE_PRINTF("OR\t");
-            break;
-        case 2:
-            DECODE_PRINTF("ADC\t");
-            break;
-        case 3:
-            DECODE_PRINTF("SBB\t");
-            break;
-        case 4:
-            DECODE_PRINTF("AND\t");
-            break;
-        case 5:
-            DECODE_PRINTF("SUB\t");
-            break;
-        case 6:
-            DECODE_PRINTF("XOR\t");
-            break;
-        case 7:
-            DECODE_PRINTF("CMP\t");
-            break;
-        }
+       case 0:
+           DECODE_PRINTF("ADD\t");
+           break;
+       case 1:
+           DECODE_PRINTF("OR\t");
+           break;
+       case 2:
+           DECODE_PRINTF("ADC\t");
+           break;
+       case 3:
+           DECODE_PRINTF("SBB\t");
+           break;
+       case 4:
+           DECODE_PRINTF("AND\t");
+           break;
+       case 5:
+           DECODE_PRINTF("SUB\t");
+           break;
+       case 6:
+           DECODE_PRINTF("XOR\t");
+           break;
+       case 7:
+           DECODE_PRINTF("CMP\t");
+           break;
+       }
     }
 #endif
     /* know operation, decode the mod byte to find the addressing
        mode. */
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval,imm;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm00_address(rl);
-            destval = fetch_data_long(destoffset);
-            imm = (s8) fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc83_long_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_long(destoffset, destval);
-        } else {
-            u16 destval,imm;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm00_address(rl);
-            destval = fetch_data_word(destoffset);
-            imm = (s8) fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc83_word_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval,imm;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm00_address(rl);
+           destval = fetch_data_long(destoffset);
+           imm = (s8) fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc83_long_operation[rh]) (destval, imm);
+           if (rh != 7)
+               store_data_long(destoffset, destval);
+       } else {
+           u16 destval,imm;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm00_address(rl);
+           destval = fetch_data_word(destoffset);
+           imm = (s8) fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc83_word_operation[rh]) (destval, imm);
+           if (rh != 7)
+               store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval,imm;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm01_address(rl);
-            destval = fetch_data_long(destoffset);
-            imm = (s8) fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc83_long_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_long(destoffset, destval);
-        } else {
-            u16 destval,imm;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm01_address(rl);
-            destval = fetch_data_word(destoffset);
-            imm = (s8) fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc83_word_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval,imm;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm01_address(rl);
+           destval = fetch_data_long(destoffset);
+           imm = (s8) fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc83_long_operation[rh]) (destval, imm);
+           if (rh != 7)
+               store_data_long(destoffset, destval);
+       } else {
+           u16 destval,imm;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm01_address(rl);
+           destval = fetch_data_word(destoffset);
+           imm = (s8) fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc83_word_operation[rh]) (destval, imm);
+           if (rh != 7)
+               store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval,imm;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm10_address(rl);
-            destval = fetch_data_long(destoffset);
-            imm = (s8) fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc83_long_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_long(destoffset, destval);
-        } else {
-            u16 destval,imm;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm10_address(rl);
-            destval = fetch_data_word(destoffset);
-            imm = (s8) fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc83_word_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval,imm;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm10_address(rl);
+           destval = fetch_data_long(destoffset);
+           imm = (s8) fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc83_long_operation[rh]) (destval, imm);
+           if (rh != 7)
+               store_data_long(destoffset, destval);
+       } else {
+           u16 destval,imm;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm10_address(rl);
+           destval = fetch_data_word(destoffset);
+           imm = (s8) fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc83_word_operation[rh]) (destval, imm);
+           if (rh != 7)
+               store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 destval,imm;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            imm = (s8) fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc83_long_operation[rh]) (*destreg, imm);
-            if (rh != 7)
-                *destreg = destval;
-        } else {
-            u16 *destreg;
-            u16 destval,imm;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 destval,imm;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           imm = (s8) fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc83_long_operation[rh]) (*destreg, imm);
+           if (rh != 7)
+               *destreg = destval;
+       } else {
+           u16 *destreg;
+           u16 destval,imm;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            imm = (s8) fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*opc83_word_operation[rh]) (*destreg, imm);
-            if (rh != 7)
-                *destreg = destval;
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           imm = (s8) fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           destval = (*opc83_word_operation[rh]) (*destreg, imm);
+           if (rh != 7)
+               *destreg = destval;
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -5810,40 +5810,40 @@ void x86emuOp_test_byte_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        test_byte(destval, *srcreg);
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       test_byte(destval, *srcreg);
+       break;
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        test_byte(destval, *srcreg);
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       test_byte(destval, *srcreg);
+       break;
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        test_byte(destval, *srcreg);
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       test_byte(destval, *srcreg);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        test_byte(*destreg, *srcreg);
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       test_byte(*destreg, *srcreg);
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -5863,101 +5863,101 @@ void x86emuOp_test_word_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            test_long(destval, *srcreg);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            test_word(destval, *srcreg);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           test_long(destval, *srcreg);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           test_word(destval, *srcreg);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            test_long(destval, *srcreg);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            test_word(destval, *srcreg);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           test_long(destval, *srcreg);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           test_word(destval, *srcreg);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            test_long(destval, *srcreg);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            test_word(destval, *srcreg);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+           u32 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           test_long(destval, *srcreg);
+       } else {
+           u16 destval;
+           u16 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           test_word(destval, *srcreg);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            test_long(*destreg, *srcreg);
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           test_long(*destreg, *srcreg);
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            test_word(*destreg, *srcreg);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           test_word(*destreg, *srcreg);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -5980,51 +5980,51 @@ void x86emuOp_xchg_byte_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        tmp = *srcreg;
-        *srcreg = destval;
-        destval = tmp;
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       tmp = *srcreg;
+       *srcreg = destval;
+       destval = tmp;
+       store_data_byte(destoffset, destval);
+       break;
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        tmp = *srcreg;
-        *srcreg = destval;
-        destval = tmp;
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       tmp = *srcreg;
+       *srcreg = destval;
+       destval = tmp;
+       store_data_byte(destoffset, destval);
+       break;
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        tmp = *srcreg;
-        *srcreg = destval;
-        destval = tmp;
-        store_data_byte(destoffset, destval);
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       destval = fetch_data_byte(destoffset);
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       tmp = *srcreg;
+       *srcreg = destval;
+       destval = tmp;
+       store_data_byte(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        tmp = *srcreg;
-        *srcreg = *destreg;
-        *destreg = tmp;
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       tmp = *srcreg;
+       *srcreg = *destreg;
+       *destreg = tmp;
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6044,125 +6044,125 @@ void x86emuOp_xchg_word_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg;
-            u32 destval,tmp;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            tmp = *srcreg;
-            *srcreg = destval;
-            destval = tmp;
-            store_data_long(destoffset, destval);
-        } else {
-            u16 *srcreg;
-            u16 destval,tmp;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            tmp = *srcreg;
-            *srcreg = destval;
-            destval = tmp;
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *srcreg;
+           u32 destval,tmp;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           tmp = *srcreg;
+           *srcreg = destval;
+           destval = tmp;
+           store_data_long(destoffset, destval);
+       } else {
+           u16 *srcreg;
+           u16 destval,tmp;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           tmp = *srcreg;
+           *srcreg = destval;
+           destval = tmp;
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg;
-            u32 destval,tmp;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            tmp = *srcreg;
-            *srcreg = destval;
-            destval = tmp;
-            store_data_long(destoffset, destval);
-        } else {
-            u16 *srcreg;
-            u16 destval,tmp;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            tmp = *srcreg;
-            *srcreg = destval;
-            destval = tmp;
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *srcreg;
+           u32 destval,tmp;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           tmp = *srcreg;
+           *srcreg = destval;
+           destval = tmp;
+           store_data_long(destoffset, destval);
+       } else {
+           u16 *srcreg;
+           u16 destval,tmp;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           tmp = *srcreg;
+           *srcreg = destval;
+           destval = tmp;
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg;
-            u32 destval,tmp;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            tmp = *srcreg;
-            *srcreg = destval;
-            destval = tmp;
-            store_data_long(destoffset, destval);
-        } else {
-            u16 *srcreg;
-            u16 destval,tmp;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            tmp = *srcreg;
-            *srcreg = destval;
-            destval = tmp;
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *srcreg;
+           u32 destval,tmp;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_long(destoffset);
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           tmp = *srcreg;
+           *srcreg = destval;
+           destval = tmp;
+           store_data_long(destoffset, destval);
+       } else {
+           u16 *srcreg;
+           u16 destval,tmp;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           destval = fetch_data_word(destoffset);
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           tmp = *srcreg;
+           *srcreg = destval;
+           destval = tmp;
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-            u32 tmp;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            tmp = *srcreg;
-            *srcreg = *destreg;
-            *destreg = tmp;
-        } else {
-            u16 *destreg,*srcreg;
-            u16 tmp;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+           u32 tmp;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           tmp = *srcreg;
+           *srcreg = *destreg;
+           *destreg = tmp;
+       } else {
+           u16 *destreg,*srcreg;
+           u16 tmp;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            tmp = *srcreg;
-            *srcreg = *destreg;
-            *destreg = tmp;
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           tmp = *srcreg;
+           *srcreg = *destreg;
+           *destreg = tmp;
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6183,37 +6183,37 @@ void x86emuOp_mov_byte_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        store_data_byte(destoffset, *srcreg);
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       store_data_byte(destoffset, *srcreg);
+       break;
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        store_data_byte(destoffset, *srcreg);
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       store_data_byte(destoffset, *srcreg);
+       break;
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        store_data_byte(destoffset, *srcreg);
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       store_data_byte(destoffset, *srcreg);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = *srcreg;
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = *srcreg;
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6233,89 +6233,89 @@ void x86emuOp_mov_word_RM_R(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            store_data_long(destoffset, *srcreg);
-        } else {
-            u16 *srcreg;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            store_data_word(destoffset, *srcreg);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           store_data_long(destoffset, *srcreg);
+       } else {
+           u16 *srcreg;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           store_data_word(destoffset, *srcreg);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            store_data_long(destoffset, *srcreg);
-        } else {
-            u16 *srcreg;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            store_data_word(destoffset, *srcreg);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           store_data_long(destoffset, *srcreg);
+       } else {
+           u16 *srcreg;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           store_data_word(destoffset, *srcreg);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            store_data_long(destoffset, *srcreg);
-        } else {
-            u16 *srcreg;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            store_data_word(destoffset, *srcreg);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           store_data_long(destoffset, *srcreg);
+       } else {
+           u16 *srcreg;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           store_data_word(destoffset, *srcreg);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = *srcreg;
-        } else {
-            u16 *destreg,*srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg,*srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = *srcreg;
+       } else {
+           u16 *destreg,*srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = *srcreg;
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = *srcreg;
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6337,40 +6337,40 @@ void x86emuOp_mov_byte_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm00_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = srcval;
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm00_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = srcval;
+       break;
     case 1:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm01_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = srcval;
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm01_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = srcval;
+       break;
     case 2:
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm10_address(rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = srcval;
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm10_address(rl);
+       srcval = fetch_data_byte(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = srcval;
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = *srcreg;
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = *srcreg;
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6390,101 +6390,101 @@ void x86emuOp_mov_word_R_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = srcval;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm00_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = srcval;
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = srcval;
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm00_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = srcval;
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = srcval;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm01_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = srcval;
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = srcval;
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm01_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = srcval;
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = srcval;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rm10_address(rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = srcval;
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
+           u32 srcval;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_long(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = srcval;
+       } else {
+           u16 *destreg;
+           u16 srcval;
+
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcoffset = decode_rm10_address(rl);
+           srcval = fetch_data_word(srcoffset);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = srcval;
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg, *srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = *srcreg;
-        } else {
-            u16 *destreg, *srcreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg, *srcreg;
+
+           destreg = DECODE_RM_LONG_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = *srcreg;
+       } else {
+           u16 *destreg, *srcreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = *srcreg;
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rh);
+           DECODE_PRINTF(",");
+           srcreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = *srcreg;
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6506,40 +6506,40 @@ void x86emuOp_mov_word_RM_SR(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",");
-        srcreg = decode_rm_seg_register(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = *srcreg;
-        store_data_word(destoffset, destval);
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",");
+       srcreg = decode_rm_seg_register(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = *srcreg;
+       store_data_word(destoffset, destval);
+       break;
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",");
-        srcreg = decode_rm_seg_register(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = *srcreg;
-        store_data_word(destoffset, destval);
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",");
+       srcreg = decode_rm_seg_register(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = *srcreg;
+       store_data_word(destoffset, destval);
+       break;
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",");
-        srcreg = decode_rm_seg_register(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = *srcreg;
-        store_data_word(destoffset, destval);
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",");
+       srcreg = decode_rm_seg_register(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       destval = *srcreg;
+       store_data_word(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_WORD_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = decode_rm_seg_register(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = *srcreg;
-        break;
+       destreg = DECODE_RM_WORD_REGISTER(rl);
+       DECODE_PRINTF(",");
+       srcreg = decode_rm_seg_register(rh);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = *srcreg;
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6560,38 +6560,38 @@ void x86emuOp_lea_word_R_M(u8 X86EMU_UNUSED(op1))
  *
  * lea  eax,[eax+ebx*2] ??
  */
-    
+
     START_OF_INSTR();
     DECODE_PRINTF("LEA\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        srcreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *srcreg = (u16)destoffset;
-        break;
+       srcreg = DECODE_RM_WORD_REGISTER(rh);
+       DECODE_PRINTF(",");
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *srcreg = (u16)destoffset;
+       break;
     case 1:
-        srcreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *srcreg = (u16)destoffset;
-        break;
+       srcreg = DECODE_RM_WORD_REGISTER(rh);
+       DECODE_PRINTF(",");
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *srcreg = (u16)destoffset;
+       break;
     case 2:
-        srcreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *srcreg = (u16)destoffset;
-        break;
+       srcreg = DECODE_RM_WORD_REGISTER(rh);
+       DECODE_PRINTF(",");
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *srcreg = (u16)destoffset;
+       break;
     case 3:                     /* register to register */
-        /* undefined.  Do nothing. */
-        break;
+       /* undefined.  Do nothing. */
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6613,40 +6613,40 @@ void x86emuOp_mov_word_SR_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        destreg = decode_rm_seg_register(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm00_address(rl);
-        srcval = fetch_data_word(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = srcval;
-        break;
+       destreg = decode_rm_seg_register(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm00_address(rl);
+       srcval = fetch_data_word(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = srcval;
+       break;
     case 1:
-        destreg = decode_rm_seg_register(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm01_address(rl);
-        srcval = fetch_data_word(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = srcval;
-        break;
+       destreg = decode_rm_seg_register(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm01_address(rl);
+       srcval = fetch_data_word(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = srcval;
+       break;
     case 2:
-        destreg = decode_rm_seg_register(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm10_address(rl);
-        srcval = fetch_data_word(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = srcval;
-        break;
+       destreg = decode_rm_seg_register(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm10_address(rl);
+       srcval = fetch_data_word(srcoffset);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = srcval;
+       break;
     case 3:                     /* register to register */
-        destreg = decode_rm_seg_register(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_WORD_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = *srcreg;
-        break;
+       destreg = decode_rm_seg_register(rh);
+       DECODE_PRINTF(",");
+       srcreg = DECODE_RM_WORD_REGISTER(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *destreg = *srcreg;
+       break;
     }
     /*
      * Clean up, and reset all the R_xSP pointers to the correct
@@ -6671,84 +6671,84 @@ void x86emuOp_pop_RM(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("POP\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (rh != 0) {
-        DECODE_PRINTF("ILLEGAL DECODE OF OPCODE 8F\n");
-        HALT_SYS();
+       DECODE_PRINTF("ILLEGAL DECODE OF OPCODE 8F\n");
+       HALT_SYS();
     }
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = pop_long();
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = pop_word();
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = pop_long();
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = pop_word();
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = pop_long();
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = pop_word();
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = pop_long();
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = pop_word();
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = pop_long();
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = pop_word();
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = pop_long();
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           destval = pop_word();
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
 
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = pop_long();
-        } else {
-            u16 *destreg;
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = pop_long();
+       } else {
+           u16 *destreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = pop_word();
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = pop_word();
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6777,19 +6777,19 @@ void x86emuOp_xchg_word_AX_CX(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("XCHG\tEAX,ECX\n");
+       DECODE_PRINTF("XCHG\tEAX,ECX\n");
     } else {
-        DECODE_PRINTF("XCHG\tAX,CX\n");
+       DECODE_PRINTF("XCHG\tAX,CX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        tmp = M.x86.R_EAX;
-        M.x86.R_EAX = M.x86.R_ECX;
-        M.x86.R_ECX = tmp;
+       tmp = M.x86.R_EAX;
+       M.x86.R_EAX = M.x86.R_ECX;
+       M.x86.R_ECX = tmp;
     } else {
-        tmp = M.x86.R_AX;
-        M.x86.R_AX = M.x86.R_CX;
-        M.x86.R_CX = (u16)tmp;
+       tmp = M.x86.R_AX;
+       M.x86.R_AX = M.x86.R_CX;
+       M.x86.R_CX = (u16)tmp;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6805,19 +6805,19 @@ void x86emuOp_xchg_word_AX_DX(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("XCHG\tEAX,EDX\n");
+       DECODE_PRINTF("XCHG\tEAX,EDX\n");
     } else {
-        DECODE_PRINTF("XCHG\tAX,DX\n");
+       DECODE_PRINTF("XCHG\tAX,DX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        tmp = M.x86.R_EAX;
-        M.x86.R_EAX = M.x86.R_EDX;
-        M.x86.R_EDX = tmp;
+       tmp = M.x86.R_EAX;
+       M.x86.R_EAX = M.x86.R_EDX;
+       M.x86.R_EDX = tmp;
     } else {
-        tmp = M.x86.R_AX;
-        M.x86.R_AX = M.x86.R_DX;
-        M.x86.R_DX = (u16)tmp;
+       tmp = M.x86.R_AX;
+       M.x86.R_AX = M.x86.R_DX;
+       M.x86.R_DX = (u16)tmp;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6833,19 +6833,19 @@ void x86emuOp_xchg_word_AX_BX(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("XCHG\tEAX,EBX\n");
+       DECODE_PRINTF("XCHG\tEAX,EBX\n");
     } else {
-        DECODE_PRINTF("XCHG\tAX,BX\n");
+       DECODE_PRINTF("XCHG\tAX,BX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        tmp = M.x86.R_EAX;
-        M.x86.R_EAX = M.x86.R_EBX;
-        M.x86.R_EBX = tmp;
+       tmp = M.x86.R_EAX;
+       M.x86.R_EAX = M.x86.R_EBX;
+       M.x86.R_EBX = tmp;
     } else {
-        tmp = M.x86.R_AX;
-        M.x86.R_AX = M.x86.R_BX;
-        M.x86.R_BX = (u16)tmp;
+       tmp = M.x86.R_AX;
+       M.x86.R_AX = M.x86.R_BX;
+       M.x86.R_BX = (u16)tmp;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6861,19 +6861,19 @@ void x86emuOp_xchg_word_AX_SP(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("XCHG\tEAX,ESP\n");
+       DECODE_PRINTF("XCHG\tEAX,ESP\n");
     } else {
-        DECODE_PRINTF("XCHG\tAX,SP\n");
+       DECODE_PRINTF("XCHG\tAX,SP\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        tmp = M.x86.R_EAX;
-        M.x86.R_EAX = M.x86.R_ESP;
-        M.x86.R_ESP = tmp;
+       tmp = M.x86.R_EAX;
+       M.x86.R_EAX = M.x86.R_ESP;
+       M.x86.R_ESP = tmp;
     } else {
-        tmp = M.x86.R_AX;
-        M.x86.R_AX = M.x86.R_SP;
-        M.x86.R_SP = (u16)tmp;
+       tmp = M.x86.R_AX;
+       M.x86.R_AX = M.x86.R_SP;
+       M.x86.R_SP = (u16)tmp;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6889,19 +6889,19 @@ void x86emuOp_xchg_word_AX_BP(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("XCHG\tEAX,EBP\n");
+       DECODE_PRINTF("XCHG\tEAX,EBP\n");
     } else {
-        DECODE_PRINTF("XCHG\tAX,BP\n");
+       DECODE_PRINTF("XCHG\tAX,BP\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        tmp = M.x86.R_EAX;
-        M.x86.R_EAX = M.x86.R_EBP;
-        M.x86.R_EBP = tmp;
+       tmp = M.x86.R_EAX;
+       M.x86.R_EAX = M.x86.R_EBP;
+       M.x86.R_EBP = tmp;
     } else {
-        tmp = M.x86.R_AX;
-        M.x86.R_AX = M.x86.R_BP;
-        M.x86.R_BP = (u16)tmp;
+       tmp = M.x86.R_AX;
+       M.x86.R_AX = M.x86.R_BP;
+       M.x86.R_BP = (u16)tmp;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6917,19 +6917,19 @@ void x86emuOp_xchg_word_AX_SI(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("XCHG\tEAX,ESI\n");
+       DECODE_PRINTF("XCHG\tEAX,ESI\n");
     } else {
-        DECODE_PRINTF("XCHG\tAX,SI\n");
+       DECODE_PRINTF("XCHG\tAX,SI\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        tmp = M.x86.R_EAX;
-        M.x86.R_EAX = M.x86.R_ESI;
-        M.x86.R_ESI = tmp;
+       tmp = M.x86.R_EAX;
+       M.x86.R_EAX = M.x86.R_ESI;
+       M.x86.R_ESI = tmp;
     } else {
-        tmp = M.x86.R_AX;
-        M.x86.R_AX = M.x86.R_SI;
-        M.x86.R_SI = (u16)tmp;
+       tmp = M.x86.R_AX;
+       M.x86.R_AX = M.x86.R_SI;
+       M.x86.R_SI = (u16)tmp;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6945,19 +6945,19 @@ void x86emuOp_xchg_word_AX_DI(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("XCHG\tEAX,EDI\n");
+       DECODE_PRINTF("XCHG\tEAX,EDI\n");
     } else {
-        DECODE_PRINTF("XCHG\tAX,DI\n");
+       DECODE_PRINTF("XCHG\tAX,DI\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        tmp = M.x86.R_EAX;
-        M.x86.R_EAX = M.x86.R_EDI;
-        M.x86.R_EDI = tmp;
+       tmp = M.x86.R_EAX;
+       M.x86.R_EAX = M.x86.R_EDI;
+       M.x86.R_EDI = tmp;
     } else {
-        tmp = M.x86.R_AX;
-        M.x86.R_AX = M.x86.R_DI;
-        M.x86.R_DI = (u16)tmp;
+       tmp = M.x86.R_AX;
+       M.x86.R_AX = M.x86.R_DI;
+       M.x86.R_DI = (u16)tmp;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -6971,23 +6971,23 @@ void x86emuOp_cbw(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("CWDE\n");
+       DECODE_PRINTF("CWDE\n");
     } else {
-        DECODE_PRINTF("CBW\n");
+       DECODE_PRINTF("CBW\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        if (M.x86.R_AX & 0x8000) {
-            M.x86.R_EAX |= 0xffff0000;
-        } else {
-            M.x86.R_EAX &= 0x0000ffff;
-        }
+       if (M.x86.R_AX & 0x8000) {
+           M.x86.R_EAX |= 0xffff0000;
+       } else {
+           M.x86.R_EAX &= 0x0000ffff;
+       }
     } else {
-        if (M.x86.R_AL & 0x80) {
-            M.x86.R_AH = 0xff;
-        } else {
-            M.x86.R_AH = 0x0;
-        }
+       if (M.x86.R_AL & 0x80) {
+           M.x86.R_AH = 0xff;
+       } else {
+           M.x86.R_AH = 0x0;
+       }
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7001,24 +7001,24 @@ void x86emuOp_cwd(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("CDQ\n");
+       DECODE_PRINTF("CDQ\n");
     } else {
-        DECODE_PRINTF("CWD\n");
+       DECODE_PRINTF("CWD\n");
     }
     DECODE_PRINTF("CWD\n");
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        if (M.x86.R_EAX & 0x80000000) {
-            M.x86.R_EDX = 0xffffffff;
-        } else {
-            M.x86.R_EDX = 0x0;
-        }
+       if (M.x86.R_EAX & 0x80000000) {
+           M.x86.R_EDX = 0xffffffff;
+       } else {
+           M.x86.R_EDX = 0x0;
+       }
     } else {
-        if (M.x86.R_AX & 0x8000) {
-            M.x86.R_DX = 0xffff;
-        } else {
-            M.x86.R_DX = 0x0;
-        }
+       if (M.x86.R_AX & 0x8000) {
+           M.x86.R_DX = 0xffff;
+       } else {
+           M.x86.R_DX = 0x0;
+       }
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7041,7 +7041,7 @@ void x86emuOp_call_far_IMM(u8 X86EMU_UNUSED(op1))
        CALL_TRACE(M.x86.saved_cs, M.x86.saved_ip, farseg, faroff, "FAR ");
 
     /* XXX
-     * 
+     *
      * Hooked interrupt vectors calling into our "BIOS" will cause
      * problems unless all intersegment stuff is checked for BIOS
      * access.  Check needed here.  For moment, let it alone.
@@ -7079,18 +7079,18 @@ void x86emuOp_pushf_word(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("PUSHFD\n");
+       DECODE_PRINTF("PUSHFD\n");
     } else {
-        DECODE_PRINTF("PUSHF\n");
+       DECODE_PRINTF("PUSHF\n");
     }
     TRACE_AND_STEP();
 
     /* clear out *all* bits not representing flags, and turn on real bits */
     flags = (M.x86.R_EFLG & F_MSK) | F_ALWAYS_ON;
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        push_long(flags);
+       push_long(flags);
     } else {
-        push_word((u16)flags);
+       push_word((u16)flags);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7104,15 +7104,15 @@ void x86emuOp_popf_word(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("POPFD\n");
+       DECODE_PRINTF("POPFD\n");
     } else {
-        DECODE_PRINTF("POPF\n");
+       DECODE_PRINTF("POPF\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EFLG = pop_long();
+       M.x86.R_EFLG = pop_long();
     } else {
-        M.x86.R_FLG = pop_word();
+       M.x86.R_FLG = pop_word();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7181,15 +7181,15 @@ void x86emuOp_mov_AX_M_IMM(u8 X86EMU_UNUSED(op1))
     START_OF_INSTR();
     offset = fetch_word_imm();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF2("MOV\tEAX,[%04x]\n", offset);
+       DECODE_PRINTF2("MOV\tEAX,[%04x]\n", offset);
     } else {
-        DECODE_PRINTF2("MOV\tAX,[%04x]\n", offset);
+       DECODE_PRINTF2("MOV\tAX,[%04x]\n", offset);
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = fetch_data_long(offset);
+       M.x86.R_EAX = fetch_data_long(offset);
     } else {
-        M.x86.R_AX = fetch_data_word(offset);
+       M.x86.R_AX = fetch_data_word(offset);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7224,15 +7224,15 @@ void x86emuOp_mov_M_AX_IMM(u8 X86EMU_UNUSED(op1))
     START_OF_INSTR();
     offset = fetch_word_imm();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF2("MOV\t[%04x],EAX\n", offset);
+       DECODE_PRINTF2("MOV\t[%04x],EAX\n", offset);
     } else {
-        DECODE_PRINTF2("MOV\t[%04x],AX\n", offset);
+       DECODE_PRINTF2("MOV\t[%04x],AX\n", offset);
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        store_data_long(offset, M.x86.R_EAX);
+       store_data_long(offset, M.x86.R_EAX);
     } else {
-        store_data_word(offset, M.x86.R_AX);
+       store_data_word(offset, M.x86.R_AX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7251,23 +7251,23 @@ void x86emuOp_movs_byte(u8 X86EMU_UNUSED(op1))
     START_OF_INSTR();
     DECODE_PRINTF("MOVS\tBYTE\n");
     if (ACCESS_FLAG(F_DF))   /* down */
-        inc = -1;
+       inc = -1;
     else
-        inc = 1;
+       inc = 1;
     TRACE_AND_STEP();
     count = 1;
     if (M.x86.mode & (SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE)) {
-        /* dont care whether REPE or REPNE */
-        /* move them until CX is ZERO. */
-        count = M.x86.R_CX;
-        M.x86.R_CX = 0;
-        M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
+       /* dont care whether REPE or REPNE */
+       /* move them until CX is ZERO. */
+       count = M.x86.R_CX;
+       M.x86.R_CX = 0;
+       M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
     }
     while (count--) {
-        val = fetch_data_byte(M.x86.R_SI);
-        store_data_byte_abs(M.x86.R_ES, M.x86.R_DI, val);
-        M.x86.R_SI += inc;
-        M.x86.R_DI += inc;
+       val = fetch_data_byte(M.x86.R_SI);
+       store_data_byte_abs(M.x86.R_ES, M.x86.R_DI, val);
+       M.x86.R_SI += inc;
+       M.x86.R_DI += inc;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7285,37 +7285,37 @@ void x86emuOp_movs_word(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("MOVS\tDWORD\n");
-        if (ACCESS_FLAG(F_DF))      /* down */
-            inc = -4;
-        else
-            inc = 4;
+       DECODE_PRINTF("MOVS\tDWORD\n");
+       if (ACCESS_FLAG(F_DF))      /* down */
+           inc = -4;
+       else
+           inc = 4;
     } else {
-        DECODE_PRINTF("MOVS\tWORD\n");
-        if (ACCESS_FLAG(F_DF))      /* down */
-            inc = -2;
-        else
-            inc = 2;
+       DECODE_PRINTF("MOVS\tWORD\n");
+       if (ACCESS_FLAG(F_DF))      /* down */
+           inc = -2;
+       else
+           inc = 2;
     }
     TRACE_AND_STEP();
     count = 1;
     if (M.x86.mode & (SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE)) {
-        /* dont care whether REPE or REPNE */
-        /* move them until CX is ZERO. */
-        count = M.x86.R_CX;
-        M.x86.R_CX = 0;
-        M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
+       /* dont care whether REPE or REPNE */
+       /* move them until CX is ZERO. */
+       count = M.x86.R_CX;
+       M.x86.R_CX = 0;
+       M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
     }
     while (count--) {
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            val = fetch_data_long(M.x86.R_SI);
-            store_data_long_abs(M.x86.R_ES, M.x86.R_DI, val);
-        } else {
-            val = fetch_data_word(M.x86.R_SI);
-            store_data_word_abs(M.x86.R_ES, M.x86.R_DI, (u16)val);
-        }
-        M.x86.R_SI += inc;
-        M.x86.R_DI += inc;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           val = fetch_data_long(M.x86.R_SI);
+           store_data_long_abs(M.x86.R_ES, M.x86.R_DI, val);
+       } else {
+           val = fetch_data_word(M.x86.R_SI);
+           store_data_word_abs(M.x86.R_ES, M.x86.R_DI, (u16)val);
+       }
+       M.x86.R_SI += inc;
+       M.x86.R_DI += inc;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7334,44 +7334,44 @@ void x86emuOp_cmps_byte(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("CMPS\tBYTE\n");
     TRACE_AND_STEP();
     if (ACCESS_FLAG(F_DF))   /* down */
-        inc = -1;
+       inc = -1;
     else
-        inc = 1;
+       inc = 1;
 
     if (M.x86.mode & SYSMODE_PREFIX_REPE) {
-        /* REPE  */
-        /* move them until CX is ZERO. */
-        while (M.x86.R_CX != 0) {
-            val1 = fetch_data_byte(M.x86.R_SI);
-            val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
-                     cmp_byte(val1, val2);
-            M.x86.R_CX -= 1;
-            M.x86.R_SI += inc;
-            M.x86.R_DI += inc;
-            if (ACCESS_FLAG(F_ZF) == 0)
-                break;
-        }
-        M.x86.mode &= ~SYSMODE_PREFIX_REPE;
+       /* REPE  */
+       /* move them until CX is ZERO. */
+       while (M.x86.R_CX != 0) {
+           val1 = fetch_data_byte(M.x86.R_SI);
+           val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
+                    cmp_byte(val1, val2);
+           M.x86.R_CX -= 1;
+           M.x86.R_SI += inc;
+           M.x86.R_DI += inc;
+           if (ACCESS_FLAG(F_ZF) == 0)
+               break;
+       }
+       M.x86.mode &= ~SYSMODE_PREFIX_REPE;
     } else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
-        /* REPNE  */
-        /* move them until CX is ZERO. */
-        while (M.x86.R_CX != 0) {
-            val1 = fetch_data_byte(M.x86.R_SI);
-            val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
-            cmp_byte(val1, val2);
-            M.x86.R_CX -= 1;
-            M.x86.R_SI += inc;
-            M.x86.R_DI += inc;
-            if (ACCESS_FLAG(F_ZF))
-                break;          /* zero flag set means equal */
-        }
-        M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
+       /* REPNE  */
+       /* move them until CX is ZERO. */
+       while (M.x86.R_CX != 0) {
+           val1 = fetch_data_byte(M.x86.R_SI);
+           val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
+           cmp_byte(val1, val2);
+           M.x86.R_CX -= 1;
+           M.x86.R_SI += inc;
+           M.x86.R_DI += inc;
+           if (ACCESS_FLAG(F_ZF))
+               break;          /* zero flag set means equal */
+       }
+       M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
     } else {
-        val1 = fetch_data_byte(M.x86.R_SI);
-        val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
-        cmp_byte(val1, val2);
-        M.x86.R_SI += inc;
-        M.x86.R_DI += inc;
+       val1 = fetch_data_byte(M.x86.R_SI);
+       val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
+       cmp_byte(val1, val2);
+       M.x86.R_SI += inc;
+       M.x86.R_DI += inc;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7388,71 +7388,71 @@ void x86emuOp_cmps_word(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("CMPS\tDWORD\n");
-        if (ACCESS_FLAG(F_DF))   /* down */
-            inc = -4;
-        else
-            inc = 4;
+       DECODE_PRINTF("CMPS\tDWORD\n");
+       if (ACCESS_FLAG(F_DF))   /* down */
+           inc = -4;
+       else
+           inc = 4;
     } else {
-        DECODE_PRINTF("CMPS\tWORD\n");
-        if (ACCESS_FLAG(F_DF))   /* down */
-            inc = -2;
-        else
-            inc = 2;
+       DECODE_PRINTF("CMPS\tWORD\n");
+       if (ACCESS_FLAG(F_DF))   /* down */
+           inc = -2;
+       else
+           inc = 2;
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_REPE) {
-        /* REPE  */
-        /* move them until CX is ZERO. */
-        while (M.x86.R_CX != 0) {
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                val1 = fetch_data_long(M.x86.R_SI);
-                val2 = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
-                cmp_long(val1, val2);
-            } else {
-                val1 = fetch_data_word(M.x86.R_SI);
-                val2 = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
-                cmp_word((u16)val1, (u16)val2);
-            }
-            M.x86.R_CX -= 1;
-            M.x86.R_SI += inc;
-            M.x86.R_DI += inc;
-            if (ACCESS_FLAG(F_ZF) == 0)
-                break;
-        }
-        M.x86.mode &= ~SYSMODE_PREFIX_REPE;
+       /* REPE  */
+       /* move them until CX is ZERO. */
+       while (M.x86.R_CX != 0) {
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               val1 = fetch_data_long(M.x86.R_SI);
+               val2 = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
+               cmp_long(val1, val2);
+           } else {
+               val1 = fetch_data_word(M.x86.R_SI);
+               val2 = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
+               cmp_word((u16)val1, (u16)val2);
+           }
+           M.x86.R_CX -= 1;
+           M.x86.R_SI += inc;
+           M.x86.R_DI += inc;
+           if (ACCESS_FLAG(F_ZF) == 0)
+               break;
+       }
+       M.x86.mode &= ~SYSMODE_PREFIX_REPE;
     } else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
-        /* REPNE  */
-        /* move them until CX is ZERO. */
-        while (M.x86.R_CX != 0) {
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                val1 = fetch_data_long(M.x86.R_SI);
-                val2 = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
-                cmp_long(val1, val2);
-            } else {
-                val1 = fetch_data_word(M.x86.R_SI);
-                val2 = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
-                cmp_word((u16)val1, (u16)val2);
-            }
-            M.x86.R_CX -= 1;
-            M.x86.R_SI += inc;
-            M.x86.R_DI += inc;
-            if (ACCESS_FLAG(F_ZF))
-                break;          /* zero flag set means equal */
-        }
-        M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
-    } else {
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            val1 = fetch_data_long(M.x86.R_SI);
-            val2 = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
-            cmp_long(val1, val2);
-        } else {
-            val1 = fetch_data_word(M.x86.R_SI);
-            val2 = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
-            cmp_word((u16)val1, (u16)val2);
-        }
-        M.x86.R_SI += inc;
-        M.x86.R_DI += inc;
+       /* REPNE  */
+       /* move them until CX is ZERO. */
+       while (M.x86.R_CX != 0) {
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               val1 = fetch_data_long(M.x86.R_SI);
+               val2 = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
+               cmp_long(val1, val2);
+           } else {
+               val1 = fetch_data_word(M.x86.R_SI);
+               val2 = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
+               cmp_word((u16)val1, (u16)val2);
+           }
+           M.x86.R_CX -= 1;
+           M.x86.R_SI += inc;
+           M.x86.R_DI += inc;
+           if (ACCESS_FLAG(F_ZF))
+               break;          /* zero flag set means equal */
+       }
+       M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
+    } else {
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           val1 = fetch_data_long(M.x86.R_SI);
+           val2 = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
+           cmp_long(val1, val2);
+       } else {
+           val1 = fetch_data_word(M.x86.R_SI);
+           val2 = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
+           cmp_word((u16)val1, (u16)val2);
+       }
+       M.x86.R_SI += inc;
+       M.x86.R_DI += inc;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7486,18 +7486,18 @@ void x86emuOp_test_AX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("TEST\tEAX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("TEST\tEAX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("TEST\tAX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("TEST\tAX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        test_long(M.x86.R_EAX, srcval);
+       test_long(M.x86.R_EAX, srcval);
     } else {
-        test_word(M.x86.R_AX, (u16)srcval);
+       test_word(M.x86.R_AX, (u16)srcval);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7514,22 +7514,22 @@ void x86emuOp_stos_byte(u8 X86EMU_UNUSED(op1))
     START_OF_INSTR();
     DECODE_PRINTF("STOS\tBYTE\n");
     if (ACCESS_FLAG(F_DF))   /* down */
-        inc = -1;
+       inc = -1;
     else
-        inc = 1;
+       inc = 1;
     TRACE_AND_STEP();
     if (M.x86.mode & (SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE)) {
-        /* dont care whether REPE or REPNE */
-        /* move them until CX is ZERO. */
-        while (M.x86.R_CX != 0) {
-            store_data_byte_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_AL);
-            M.x86.R_CX -= 1;
-            M.x86.R_DI += inc;
-        }
-        M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
+       /* dont care whether REPE or REPNE */
+       /* move them until CX is ZERO. */
+       while (M.x86.R_CX != 0) {
+           store_data_byte_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_AL);
+           M.x86.R_CX -= 1;
+           M.x86.R_DI += inc;
+       }
+       M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
     } else {
-        store_data_byte_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_AL);
-        M.x86.R_DI += inc;
+       store_data_byte_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_AL);
+       M.x86.R_DI += inc;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7546,34 +7546,34 @@ void x86emuOp_stos_word(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("STOS\tDWORD\n");
-        if (ACCESS_FLAG(F_DF))   /* down */
-            inc = -4;
-        else
-            inc = 4;
+       DECODE_PRINTF("STOS\tDWORD\n");
+       if (ACCESS_FLAG(F_DF))   /* down */
+           inc = -4;
+       else
+           inc = 4;
     } else {
-        DECODE_PRINTF("STOS\tWORD\n");
-        if (ACCESS_FLAG(F_DF))   /* down */
-            inc = -2;
-        else
-            inc = 2;
+       DECODE_PRINTF("STOS\tWORD\n");
+       if (ACCESS_FLAG(F_DF))   /* down */
+           inc = -2;
+       else
+           inc = 2;
     }
     TRACE_AND_STEP();
     count = 1;
     if (M.x86.mode & (SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE)) {
-        /* dont care whether REPE or REPNE */
-        /* move them until CX is ZERO. */
-        count = M.x86.R_CX;
-        M.x86.R_CX = 0;
-        M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
+       /* dont care whether REPE or REPNE */
+       /* move them until CX is ZERO. */
+       count = M.x86.R_CX;
+       M.x86.R_CX = 0;
+       M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
     }
     while (count--) {
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            store_data_long_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_EAX);
-        } else {
-            store_data_word_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_AX);
-        }
-        M.x86.R_DI += inc;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           store_data_long_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_EAX);
+       } else {
+           store_data_word_abs(M.x86.R_ES, M.x86.R_DI, M.x86.R_AX);
+       }
+       M.x86.R_DI += inc;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7591,21 +7591,21 @@ void x86emuOp_lods_byte(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("LODS\tBYTE\n");
     TRACE_AND_STEP();
     if (ACCESS_FLAG(F_DF))   /* down */
-        inc = -1;
+       inc = -1;
     else
-        inc = 1;
+       inc = 1;
     if (M.x86.mode & (SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE)) {
-        /* dont care whether REPE or REPNE */
-        /* move them until CX is ZERO. */
-        while (M.x86.R_CX != 0) {
-            M.x86.R_AL = fetch_data_byte(M.x86.R_SI);
-            M.x86.R_CX -= 1;
-            M.x86.R_SI += inc;
-        }
-        M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
+       /* dont care whether REPE or REPNE */
+       /* move them until CX is ZERO. */
+       while (M.x86.R_CX != 0) {
+           M.x86.R_AL = fetch_data_byte(M.x86.R_SI);
+           M.x86.R_CX -= 1;
+           M.x86.R_SI += inc;
+       }
+       M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
     } else {
-        M.x86.R_AL = fetch_data_byte(M.x86.R_SI);
-        M.x86.R_SI += inc;
+       M.x86.R_AL = fetch_data_byte(M.x86.R_SI);
+       M.x86.R_SI += inc;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7622,34 +7622,34 @@ void x86emuOp_lods_word(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("LODS\tDWORD\n");
-        if (ACCESS_FLAG(F_DF))   /* down */
-            inc = -4;
-        else
-            inc = 4;
+       DECODE_PRINTF("LODS\tDWORD\n");
+       if (ACCESS_FLAG(F_DF))   /* down */
+           inc = -4;
+       else
+           inc = 4;
     } else {
-        DECODE_PRINTF("LODS\tWORD\n");
-        if (ACCESS_FLAG(F_DF))   /* down */
-            inc = -2;
-        else
-            inc = 2;
+       DECODE_PRINTF("LODS\tWORD\n");
+       if (ACCESS_FLAG(F_DF))   /* down */
+           inc = -2;
+       else
+           inc = 2;
     }
     TRACE_AND_STEP();
     count = 1;
     if (M.x86.mode & (SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE)) {
-        /* dont care whether REPE or REPNE */
-        /* move them until CX is ZERO. */
-        count = M.x86.R_CX;
-        M.x86.R_CX = 0;
-        M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
+       /* dont care whether REPE or REPNE */
+       /* move them until CX is ZERO. */
+       count = M.x86.R_CX;
+       M.x86.R_CX = 0;
+       M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
     }
     while (count--) {
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            M.x86.R_EAX = fetch_data_long(M.x86.R_SI);
-        } else {
-            M.x86.R_AX = fetch_data_word(M.x86.R_SI);
-        }
-        M.x86.R_SI += inc;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           M.x86.R_EAX = fetch_data_long(M.x86.R_SI);
+       } else {
+           M.x86.R_AX = fetch_data_word(M.x86.R_SI);
+       }
+       M.x86.R_SI += inc;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7668,37 +7668,37 @@ void x86emuOp_scas_byte(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("SCAS\tBYTE\n");
     TRACE_AND_STEP();
     if (ACCESS_FLAG(F_DF))   /* down */
-        inc = -1;
+       inc = -1;
     else
-        inc = 1;
+       inc = 1;
     if (M.x86.mode & SYSMODE_PREFIX_REPE) {
-        /* REPE  */
-        /* move them until CX is ZERO. */
-        while (M.x86.R_CX != 0) {
-            val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
-            cmp_byte(M.x86.R_AL, val2);
-            M.x86.R_CX -= 1;
-            M.x86.R_DI += inc;
-            if (ACCESS_FLAG(F_ZF) == 0)
-                break;
-        }
-        M.x86.mode &= ~SYSMODE_PREFIX_REPE;
+       /* REPE  */
+       /* move them until CX is ZERO. */
+       while (M.x86.R_CX != 0) {
+           val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
+           cmp_byte(M.x86.R_AL, val2);
+           M.x86.R_CX -= 1;
+           M.x86.R_DI += inc;
+           if (ACCESS_FLAG(F_ZF) == 0)
+               break;
+       }
+       M.x86.mode &= ~SYSMODE_PREFIX_REPE;
     } else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
-        /* REPNE  */
-        /* move them until CX is ZERO. */
-        while (M.x86.R_CX != 0) {
-            val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
-            cmp_byte(M.x86.R_AL, val2);
-            M.x86.R_CX -= 1;
-            M.x86.R_DI += inc;
-            if (ACCESS_FLAG(F_ZF))
-                break;          /* zero flag set means equal */
-        }
-        M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
+       /* REPNE  */
+       /* move them until CX is ZERO. */
+       while (M.x86.R_CX != 0) {
+           val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
+           cmp_byte(M.x86.R_AL, val2);
+           M.x86.R_CX -= 1;
+           M.x86.R_DI += inc;
+           if (ACCESS_FLAG(F_ZF))
+               break;          /* zero flag set means equal */
+       }
+       M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
     } else {
-        val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
-        cmp_byte(M.x86.R_AL, val2);
-        M.x86.R_DI += inc;
+       val2 = fetch_data_byte_abs(M.x86.R_ES, M.x86.R_DI);
+       cmp_byte(M.x86.R_AL, val2);
+       M.x86.R_DI += inc;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7715,62 +7715,62 @@ void x86emuOp_scas_word(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("SCAS\tDWORD\n");
-        if (ACCESS_FLAG(F_DF))   /* down */
-            inc = -4;
-        else
-            inc = 4;
+       DECODE_PRINTF("SCAS\tDWORD\n");
+       if (ACCESS_FLAG(F_DF))   /* down */
+           inc = -4;
+       else
+           inc = 4;
     } else {
-        DECODE_PRINTF("SCAS\tWORD\n");
-        if (ACCESS_FLAG(F_DF))   /* down */
-            inc = -2;
-        else
-            inc = 2;
+       DECODE_PRINTF("SCAS\tWORD\n");
+       if (ACCESS_FLAG(F_DF))   /* down */
+           inc = -2;
+       else
+           inc = 2;
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_REPE) {
-        /* REPE  */
-        /* move them until CX is ZERO. */
-        while (M.x86.R_CX != 0) {
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                val = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
-                cmp_long(M.x86.R_EAX, val);
-            } else {
-                val = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
-                cmp_word(M.x86.R_AX, (u16)val);
-            }
-            M.x86.R_CX -= 1;
-            M.x86.R_DI += inc;
-            if (ACCESS_FLAG(F_ZF) == 0)
-                break;
-        }
-        M.x86.mode &= ~SYSMODE_PREFIX_REPE;
+       /* REPE  */
+       /* move them until CX is ZERO. */
+       while (M.x86.R_CX != 0) {
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               val = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
+               cmp_long(M.x86.R_EAX, val);
+           } else {
+               val = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
+               cmp_word(M.x86.R_AX, (u16)val);
+           }
+           M.x86.R_CX -= 1;
+           M.x86.R_DI += inc;
+           if (ACCESS_FLAG(F_ZF) == 0)
+               break;
+       }
+       M.x86.mode &= ~SYSMODE_PREFIX_REPE;
     } else if (M.x86.mode & SYSMODE_PREFIX_REPNE) {
-        /* REPNE  */
-        /* move them until CX is ZERO. */
-        while (M.x86.R_CX != 0) {
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                val = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
-                cmp_long(M.x86.R_EAX, val);
-            } else {
-                val = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
-                cmp_word(M.x86.R_AX, (u16)val);
-            }
-            M.x86.R_CX -= 1;
-            M.x86.R_DI += inc;
-            if (ACCESS_FLAG(F_ZF))
-                break;          /* zero flag set means equal */
-        }
-        M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
+       /* REPNE  */
+       /* move them until CX is ZERO. */
+       while (M.x86.R_CX != 0) {
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               val = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
+               cmp_long(M.x86.R_EAX, val);
+           } else {
+               val = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
+               cmp_word(M.x86.R_AX, (u16)val);
+           }
+           M.x86.R_CX -= 1;
+           M.x86.R_DI += inc;
+           if (ACCESS_FLAG(F_ZF))
+               break;          /* zero flag set means equal */
+       }
+       M.x86.mode &= ~SYSMODE_PREFIX_REPNE;
     } else {
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            val = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
-            cmp_long(M.x86.R_EAX, val);
-        } else {
-            val = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
-            cmp_word(M.x86.R_AX, (u16)val);
-        }
-        M.x86.R_DI += inc;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           val = fetch_data_long_abs(M.x86.R_ES, M.x86.R_DI);
+           cmp_long(M.x86.R_EAX, val);
+       } else {
+           val = fetch_data_word_abs(M.x86.R_ES, M.x86.R_DI);
+           cmp_word(M.x86.R_AX, (u16)val);
+       }
+       M.x86.R_DI += inc;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7930,18 +7930,18 @@ void x86emuOp_mov_word_AX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("MOV\tEAX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("MOV\tEAX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("MOV\tAX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("MOV\tAX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = srcval;
+       M.x86.R_EAX = srcval;
     } else {
-        M.x86.R_AX = (u16)srcval;
+       M.x86.R_AX = (u16)srcval;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7957,18 +7957,18 @@ void x86emuOp_mov_word_CX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("MOV\tECX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("MOV\tECX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("MOV\tCX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("MOV\tCX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_ECX = srcval;
+       M.x86.R_ECX = srcval;
     } else {
-        M.x86.R_CX = (u16)srcval;
+       M.x86.R_CX = (u16)srcval;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -7984,18 +7984,18 @@ void x86emuOp_mov_word_DX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("MOV\tEDX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("MOV\tEDX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("MOV\tDX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("MOV\tDX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EDX = srcval;
+       M.x86.R_EDX = srcval;
     } else {
-        M.x86.R_DX = (u16)srcval;
+       M.x86.R_DX = (u16)srcval;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8011,18 +8011,18 @@ void x86emuOp_mov_word_BX_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("MOV\tEBX,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("MOV\tEBX,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("MOV\tBX,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("MOV\tBX,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EBX = srcval;
+       M.x86.R_EBX = srcval;
     } else {
-        M.x86.R_BX = (u16)srcval;
+       M.x86.R_BX = (u16)srcval;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8038,18 +8038,18 @@ void x86emuOp_mov_word_SP_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("MOV\tESP,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("MOV\tESP,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("MOV\tSP,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("MOV\tSP,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_ESP = srcval;
+       M.x86.R_ESP = srcval;
     } else {
-        M.x86.R_SP = (u16)srcval;
+       M.x86.R_SP = (u16)srcval;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8065,18 +8065,18 @@ void x86emuOp_mov_word_BP_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("MOV\tEBP,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("MOV\tEBP,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("MOV\tBP,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("MOV\tBP,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EBP = srcval;
+       M.x86.R_EBP = srcval;
     } else {
-        M.x86.R_BP = (u16)srcval;
+       M.x86.R_BP = (u16)srcval;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8092,18 +8092,18 @@ void x86emuOp_mov_word_SI_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("MOV\tESI,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("MOV\tESI,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("MOV\tSI,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("MOV\tSI,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_ESI = srcval;
+       M.x86.R_ESI = srcval;
     } else {
-        M.x86.R_SI = (u16)srcval;
+       M.x86.R_SI = (u16)srcval;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8119,18 +8119,18 @@ void x86emuOp_mov_word_DI_IMM(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("MOV\tEDI,");
-        srcval = fetch_long_imm();
+       DECODE_PRINTF("MOV\tEDI,");
+       srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF("MOV\tDI,");
-        srcval = fetch_word_imm();
+       DECODE_PRINTF("MOV\tDI,");
+       srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EDI = srcval;
+       M.x86.R_EDI = srcval;
     } else {
-        M.x86.R_DI = (u16)srcval;
+       M.x86.R_DI = (u16)srcval;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8170,80 +8170,80 @@ void x86emuOp_opcC0_byte_RM_MEM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
 #ifdef DEBUG
     if (DEBUG_DECODE()) {
-        /* XXX DECODE_PRINTF may be changed to something more
-           general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
-           above test is done twice. */
-
-        switch (rh) {
-        case 0:
-            DECODE_PRINTF("ROL\t");
-            break;
-        case 1:
-            DECODE_PRINTF("ROR\t");
-            break;
-        case 2:
-            DECODE_PRINTF("RCL\t");
-            break;
-        case 3:
-            DECODE_PRINTF("RCR\t");
-            break;
-        case 4:
-            DECODE_PRINTF("SHL\t");
-            break;
-        case 5:
-            DECODE_PRINTF("SHR\t");
-            break;
-        case 6:
-            DECODE_PRINTF("SAL\t");
-            break;
-        case 7:
-            DECODE_PRINTF("SAR\t");
-            break;
-        }
+       /* XXX DECODE_PRINTF may be changed to something more
+          general, so that it is important to leave the strings
+          in the same format, even though the result is that the
+          above test is done twice. */
+
+       switch (rh) {
+       case 0:
+           DECODE_PRINTF("ROL\t");
+           break;
+       case 1:
+           DECODE_PRINTF("ROR\t");
+           break;
+       case 2:
+           DECODE_PRINTF("RCL\t");
+           break;
+       case 3:
+           DECODE_PRINTF("RCR\t");
+           break;
+       case 4:
+           DECODE_PRINTF("SHL\t");
+           break;
+       case 5:
+           DECODE_PRINTF("SHR\t");
+           break;
+       case 6:
+           DECODE_PRINTF("SAL\t");
+           break;
+       case 7:
+           DECODE_PRINTF("SAR\t");
+           break;
+       }
     }
 #endif
     /* know operation, decode the mod byte to find the addressing
        mode. */
     switch (mod) {
     case 0:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm00_address(rl);
-        amt = fetch_byte_imm();
-        DECODE_PRINTF2(",%x\n", amt);
-        destval = fetch_data_byte(destoffset);
-        TRACE_AND_STEP();
-        destval = (*opcD0_byte_operation[rh]) (destval, amt);
-        store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm00_address(rl);
+       amt = fetch_byte_imm();
+       DECODE_PRINTF2(",%x\n", amt);
+       destval = fetch_data_byte(destoffset);
+       TRACE_AND_STEP();
+       destval = (*opcD0_byte_operation[rh]) (destval, amt);
+       store_data_byte(destoffset, destval);
+       break;
     case 1:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm01_address(rl);
-        amt = fetch_byte_imm();
-        DECODE_PRINTF2(",%x\n", amt);
-        destval = fetch_data_byte(destoffset);
-        TRACE_AND_STEP();
-        destval = (*opcD0_byte_operation[rh]) (destval, amt);
-        store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm01_address(rl);
+       amt = fetch_byte_imm();
+       DECODE_PRINTF2(",%x\n", amt);
+       destval = fetch_data_byte(destoffset);
+       TRACE_AND_STEP();
+       destval = (*opcD0_byte_operation[rh]) (destval, amt);
+       store_data_byte(destoffset, destval);
+       break;
     case 2:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm10_address(rl);
-        amt = fetch_byte_imm();
-        DECODE_PRINTF2(",%x\n", amt);
-        destval = fetch_data_byte(destoffset);
-        TRACE_AND_STEP();
-        destval = (*opcD0_byte_operation[rh]) (destval, amt);
-        store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm10_address(rl);
+       amt = fetch_byte_imm();
+       DECODE_PRINTF2(",%x\n", amt);
+       destval = fetch_data_byte(destoffset);
+       TRACE_AND_STEP();
+       destval = (*opcD0_byte_operation[rh]) (destval, amt);
+       store_data_byte(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        amt = fetch_byte_imm();
-        DECODE_PRINTF2(",%x\n", amt);
-        TRACE_AND_STEP();
-        destval = (*opcD0_byte_operation[rh]) (*destreg, amt);
-        *destreg = destval;
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       amt = fetch_byte_imm();
+       DECODE_PRINTF2(",%x\n", amt);
+       TRACE_AND_STEP();
+       destval = (*opcD0_byte_operation[rh]) (*destreg, amt);
+       *destreg = destval;
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8294,136 +8294,136 @@ void x86emuOp_opcC1_word_RM_MEM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
 #ifdef DEBUG
     if (DEBUG_DECODE()) {
-        /* XXX DECODE_PRINTF may be changed to something more
-           general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
-           above test is done twice. */
-
-        switch (rh) {
-        case 0:
-            DECODE_PRINTF("ROL\t");
-            break;
-        case 1:
-            DECODE_PRINTF("ROR\t");
-            break;
-        case 2:
-            DECODE_PRINTF("RCL\t");
-            break;
-        case 3:
-            DECODE_PRINTF("RCR\t");
-            break;
-        case 4:
-            DECODE_PRINTF("SHL\t");
-            break;
-        case 5:
-            DECODE_PRINTF("SHR\t");
-            break;
-        case 6:
-            DECODE_PRINTF("SAL\t");
-            break;
-        case 7:
-            DECODE_PRINTF("SAR\t");
-            break;
-        }
+       /* XXX DECODE_PRINTF may be changed to something more
+          general, so that it is important to leave the strings
+          in the same format, even though the result is that the
+          above test is done twice. */
+
+       switch (rh) {
+       case 0:
+           DECODE_PRINTF("ROL\t");
+           break;
+       case 1:
+           DECODE_PRINTF("ROR\t");
+           break;
+       case 2:
+           DECODE_PRINTF("RCL\t");
+           break;
+       case 3:
+           DECODE_PRINTF("RCR\t");
+           break;
+       case 4:
+           DECODE_PRINTF("SHL\t");
+           break;
+       case 5:
+           DECODE_PRINTF("SHR\t");
+           break;
+       case 6:
+           DECODE_PRINTF("SAL\t");
+           break;
+       case 7:
+           DECODE_PRINTF("SAR\t");
+           break;
+       }
     }
 #endif
     /* know operation, decode the mod byte to find the addressing
        mode. */
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm00_address(rl);
-            amt = fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", amt);
-            destval = fetch_data_long(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_long_operation[rh]) (destval, amt);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm00_address(rl);
-            amt = fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", amt);
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_word_operation[rh]) (destval, amt);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm00_address(rl);
+           amt = fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", amt);
+           destval = fetch_data_long(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_long_operation[rh]) (destval, amt);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm00_address(rl);
+           amt = fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", amt);
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_word_operation[rh]) (destval, amt);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm01_address(rl);
-            amt = fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", amt);
-            destval = fetch_data_long(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_long_operation[rh]) (destval, amt);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm01_address(rl);
-            amt = fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", amt);
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_word_operation[rh]) (destval, amt);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm01_address(rl);
+           amt = fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", amt);
+           destval = fetch_data_long(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_long_operation[rh]) (destval, amt);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm01_address(rl);
+           amt = fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", amt);
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_word_operation[rh]) (destval, amt);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm10_address(rl);
-            amt = fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", amt);
-            destval = fetch_data_long(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_long_operation[rh]) (destval, amt);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm10_address(rl);
-            amt = fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", amt);
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_word_operation[rh]) (destval, amt);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm10_address(rl);
+           amt = fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", amt);
+           destval = fetch_data_long(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_long_operation[rh]) (destval, amt);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm10_address(rl);
+           amt = fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", amt);
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_word_operation[rh]) (destval, amt);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
 
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            amt = fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", amt);
-            TRACE_AND_STEP();
-            *destreg = (*opcD1_long_operation[rh]) (*destreg, amt);
-        } else {
-            u16 *destreg;
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           amt = fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", amt);
+           TRACE_AND_STEP();
+           *destreg = (*opcD1_long_operation[rh]) (*destreg, amt);
+       } else {
+           u16 *destreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            amt = fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", amt);
-            TRACE_AND_STEP();
-            *destreg = (*opcD1_word_operation[rh]) (*destreg, amt);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           amt = fetch_byte_imm();
+           DECODE_PRINTF2(",%x\n", amt);
+           TRACE_AND_STEP();
+           *destreg = (*opcD1_word_operation[rh]) (*destreg, amt);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8479,35 +8479,35 @@ void x86emuOp_les_R_IMM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        dstreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm00_address(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *dstreg = fetch_data_word(srcoffset);
-        M.x86.R_ES = fetch_data_word(srcoffset + 2);
-        break;
+       dstreg = DECODE_RM_WORD_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm00_address(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *dstreg = fetch_data_word(srcoffset);
+       M.x86.R_ES = fetch_data_word(srcoffset + 2);
+       break;
     case 1:
-        dstreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm01_address(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *dstreg = fetch_data_word(srcoffset);
-        M.x86.R_ES = fetch_data_word(srcoffset + 2);
-        break;
+       dstreg = DECODE_RM_WORD_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm01_address(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *dstreg = fetch_data_word(srcoffset);
+       M.x86.R_ES = fetch_data_word(srcoffset + 2);
+       break;
     case 2:
-        dstreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm10_address(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *dstreg = fetch_data_word(srcoffset);
-        M.x86.R_ES = fetch_data_word(srcoffset + 2);
-        break;
+       dstreg = DECODE_RM_WORD_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm10_address(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *dstreg = fetch_data_word(srcoffset);
+       M.x86.R_ES = fetch_data_word(srcoffset + 2);
+       break;
     case 3:                     /* register to register */
-        /* UNDEFINED! */
-        TRACE_AND_STEP();
+       /* UNDEFINED! */
+       TRACE_AND_STEP();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8528,35 +8528,35 @@ void x86emuOp_lds_R_IMM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:
-        dstreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm00_address(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *dstreg = fetch_data_word(srcoffset);
-        M.x86.R_DS = fetch_data_word(srcoffset + 2);
-        break;
+       dstreg = DECODE_RM_WORD_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm00_address(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *dstreg = fetch_data_word(srcoffset);
+       M.x86.R_DS = fetch_data_word(srcoffset + 2);
+       break;
     case 1:
-        dstreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm01_address(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *dstreg = fetch_data_word(srcoffset);
-        M.x86.R_DS = fetch_data_word(srcoffset + 2);
-        break;
+       dstreg = DECODE_RM_WORD_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm01_address(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *dstreg = fetch_data_word(srcoffset);
+       M.x86.R_DS = fetch_data_word(srcoffset + 2);
+       break;
     case 2:
-        dstreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rm10_address(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *dstreg = fetch_data_word(srcoffset);
-        M.x86.R_DS = fetch_data_word(srcoffset + 2);
-        break;
+       dstreg = DECODE_RM_WORD_REGISTER(rh);
+       DECODE_PRINTF(",");
+       srcoffset = decode_rm10_address(rl);
+       DECODE_PRINTF("\n");
+       TRACE_AND_STEP();
+       *dstreg = fetch_data_word(srcoffset);
+       M.x86.R_DS = fetch_data_word(srcoffset + 2);
+       break;
     case 3:                     /* register to register */
-        /* UNDEFINED! */
-        TRACE_AND_STEP();
+       /* UNDEFINED! */
+       TRACE_AND_STEP();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8577,41 +8577,41 @@ void x86emuOp_mov_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("MOV\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (rh != 0) {
-        DECODE_PRINTF("ILLEGAL DECODE OF OPCODE c6\n");
-        HALT_SYS();
+       DECODE_PRINTF("ILLEGAL DECODE OF OPCODE c6\n");
+       HALT_SYS();
     }
     switch (mod) {
     case 0:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm00_address(rl);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2(",%2x\n", imm);
-        TRACE_AND_STEP();
-        store_data_byte(destoffset, imm);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm00_address(rl);
+       imm = fetch_byte_imm();
+       DECODE_PRINTF2(",%2x\n", imm);
+       TRACE_AND_STEP();
+       store_data_byte(destoffset, imm);
+       break;
     case 1:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm01_address(rl);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2(",%2x\n", imm);
-        TRACE_AND_STEP();
-        store_data_byte(destoffset, imm);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm01_address(rl);
+       imm = fetch_byte_imm();
+       DECODE_PRINTF2(",%2x\n", imm);
+       TRACE_AND_STEP();
+       store_data_byte(destoffset, imm);
+       break;
     case 2:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm10_address(rl);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2(",%2x\n", imm);
-        TRACE_AND_STEP();
-        store_data_byte(destoffset, imm);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm10_address(rl);
+       imm = fetch_byte_imm();
+       DECODE_PRINTF2(",%2x\n", imm);
+       TRACE_AND_STEP();
+       store_data_byte(destoffset, imm);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2(",%2x\n", imm);
-        TRACE_AND_STEP();
-        *destreg = imm;
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       imm = fetch_byte_imm();
+       DECODE_PRINTF2(",%2x\n", imm);
+       TRACE_AND_STEP();
+       *destreg = imm;
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8630,94 +8630,94 @@ void x86emuOp_mov_word_RM_IMM(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("MOV\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (rh != 0) {
-        DECODE_PRINTF("ILLEGAL DECODE OF OPCODE 8F\n");
-        HALT_SYS();
+       DECODE_PRINTF("ILLEGAL DECODE OF OPCODE 8F\n");
+       HALT_SYS();
     }
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 imm;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm00_address(rl);
-            imm = fetch_long_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            store_data_long(destoffset, imm);
-        } else {
-            u16 imm;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm00_address(rl);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            store_data_word(destoffset, imm);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 imm;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm00_address(rl);
+           imm = fetch_long_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           store_data_long(destoffset, imm);
+       } else {
+           u16 imm;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm00_address(rl);
+           imm = fetch_word_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           store_data_word(destoffset, imm);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 imm;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm01_address(rl);
-            imm = fetch_long_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            store_data_long(destoffset, imm);
-        } else {
-            u16 imm;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm01_address(rl);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            store_data_word(destoffset, imm);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 imm;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm01_address(rl);
+           imm = fetch_long_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           store_data_long(destoffset, imm);
+       } else {
+           u16 imm;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm01_address(rl);
+           imm = fetch_word_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           store_data_word(destoffset, imm);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 imm;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm10_address(rl);
-            imm = fetch_long_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            store_data_long(destoffset, imm);
-        } else {
-            u16 imm;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm10_address(rl);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            store_data_word(destoffset, imm);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 imm;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm10_address(rl);
+           imm = fetch_long_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           store_data_long(destoffset, imm);
+       } else {
+           u16 imm;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm10_address(rl);
+           imm = fetch_word_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           store_data_word(destoffset, imm);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
                        u32 *destreg;
                        u32 imm;
 
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            imm = fetch_long_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            *destreg = imm;
-        } else {
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           imm = fetch_long_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           *destreg = imm;
+       } else {
                        u16 *destreg;
                        u16 imm;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            *destreg = imm;
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           imm = fetch_word_imm();
+           DECODE_PRINTF2(",%x\n", imm);
+           TRACE_AND_STEP();
+           *destreg = imm;
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8742,12 +8742,12 @@ void x86emuOp_enter(u8 X86EMU_UNUSED(op1))
     push_word(M.x86.R_BP);
     frame_pointer = M.x86.R_SP;
     if (nesting > 0) {
-        for (i = 1; i < nesting; i++) {
-            M.x86.R_BP -= 2;
-            push_word(fetch_data_word_abs(M.x86.R_SS, M.x86.R_BP));
-            }
-        push_word(frame_pointer);
-        }
+       for (i = 1; i < nesting; i++) {
+           M.x86.R_BP -= 2;
+           push_word(fetch_data_word_abs(M.x86.R_SS, M.x86.R_BP));
+           }
+       push_word(frame_pointer);
+       }
     M.x86.R_BP = frame_pointer;
     M.x86.R_SP = (u16)(M.x86.R_SP - local);
     DECODE_CLEAR_SEGOVR();
@@ -8822,13 +8822,13 @@ void x86emuOp_int3(u8 X86EMU_UNUSED(op1))
        if (_X86EMU_intrTab[3]) {
                (*_X86EMU_intrTab[3])(3);
     } else {
-        push_word((u16)M.x86.R_FLG);
-        CLEAR_FLAG(F_IF);
-        CLEAR_FLAG(F_TF);
-        push_word(M.x86.R_CS);
-        M.x86.R_CS = mem_access_word(3 * 4 + 2);
-        push_word(M.x86.R_IP);
-        M.x86.R_IP = mem_access_word(3 * 4);
+       push_word((u16)M.x86.R_FLG);
+       CLEAR_FLAG(F_IF);
+       CLEAR_FLAG(F_TF);
+       push_word(M.x86.R_CS);
+       M.x86.R_CS = mem_access_word(3 * 4 + 2);
+       push_word(M.x86.R_IP);
+       M.x86.R_IP = mem_access_word(3 * 4);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8852,13 +8852,13 @@ void x86emuOp_int_IMM(u8 X86EMU_UNUSED(op1))
        if (_X86EMU_intrTab[intnum]) {
                (*_X86EMU_intrTab[intnum])(intnum);
     } else {
-        push_word((u16)M.x86.R_FLG);
-        CLEAR_FLAG(F_IF);
-        CLEAR_FLAG(F_TF);
-        push_word(M.x86.R_CS);
-        M.x86.R_CS = mem_access_word(intnum * 4 + 2);
-        push_word(M.x86.R_IP);
-        M.x86.R_IP = mem_access_word(intnum * 4);
+       push_word((u16)M.x86.R_FLG);
+       CLEAR_FLAG(F_IF);
+       CLEAR_FLAG(F_TF);
+       push_word(M.x86.R_CS);
+       M.x86.R_CS = mem_access_word(intnum * 4 + 2);
+       push_word(M.x86.R_IP);
+       M.x86.R_IP = mem_access_word(intnum * 4);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8876,18 +8876,18 @@ void x86emuOp_into(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("INTO\n");
     TRACE_AND_STEP();
     if (ACCESS_FLAG(F_OF)) {
-        tmp = mem_access_word(4 * 4 + 2);
+       tmp = mem_access_word(4 * 4 + 2);
                if (_X86EMU_intrTab[4]) {
                        (*_X86EMU_intrTab[4])(4);
-        } else {
-            push_word((u16)M.x86.R_FLG);
-            CLEAR_FLAG(F_IF);
-            CLEAR_FLAG(F_TF);
-            push_word(M.x86.R_CS);
-            M.x86.R_CS = mem_access_word(4 * 4 + 2);
-            push_word(M.x86.R_IP);
-            M.x86.R_IP = mem_access_word(4 * 4);
-        }
+       } else {
+           push_word((u16)M.x86.R_FLG);
+           CLEAR_FLAG(F_IF);
+           CLEAR_FLAG(F_TF);
+           push_word(M.x86.R_CS);
+           M.x86.R_CS = mem_access_word(4 * 4 + 2);
+           push_word(M.x86.R_IP);
+           M.x86.R_IP = mem_access_word(4 * 4);
+       }
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -8931,75 +8931,75 @@ void x86emuOp_opcD0_byte_RM_1(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
 #ifdef DEBUG
     if (DEBUG_DECODE()) {
-        /* XXX DECODE_PRINTF may be changed to something more
-           general, so that it is important to leave the strings
-           in the same format, even though the result is that the
-           above test is done twice. */
-        switch (rh) {
-        case 0:
-            DECODE_PRINTF("ROL\t");
-            break;
-        case 1:
-            DECODE_PRINTF("ROR\t");
-            break;
-        case 2:
-            DECODE_PRINTF("RCL\t");
-            break;
-        case 3:
-            DECODE_PRINTF("RCR\t");
-            break;
-        case 4:
-            DECODE_PRINTF("SHL\t");
-            break;
-        case 5:
-            DECODE_PRINTF("SHR\t");
-            break;
-        case 6:
-            DECODE_PRINTF("SAL\t");
-            break;
-        case 7:
-            DECODE_PRINTF("SAR\t");
-            break;
-        }
+       /* XXX DECODE_PRINTF may be changed to something more
+          general, so that it is important to leave the strings
+          in the same format, even though the result is that the
+          above test is done twice. */
+       switch (rh) {
+       case 0:
+           DECODE_PRINTF("ROL\t");
+           break;
+       case 1:
+           DECODE_PRINTF("ROR\t");
+           break;
+       case 2:
+           DECODE_PRINTF("RCL\t");
+           break;
+       case 3:
+           DECODE_PRINTF("RCR\t");
+           break;
+       case 4:
+           DECODE_PRINTF("SHL\t");
+           break;
+       case 5:
+           DECODE_PRINTF("SHR\t");
+           break;
+       case 6:
+           DECODE_PRINTF("SAL\t");
+           break;
+       case 7:
+           DECODE_PRINTF("SAR\t");
+           break;
+       }
     }
 #endif
     /* know operation, decode the mod byte to find the addressing
        mode. */
     switch (mod) {
     case 0:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",1\n");
-        destval = fetch_data_byte(destoffset);
-        TRACE_AND_STEP();
-        destval = (*opcD0_byte_operation[rh]) (destval, 1);
-        store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",1\n");
+       destval = fetch_data_byte(destoffset);
+       TRACE_AND_STEP();
+       destval = (*opcD0_byte_operation[rh]) (destval, 1);
+       store_data_byte(destoffset, destval);
+       break;
     case 1:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",1\n");
-        destval = fetch_data_byte(destoffset);
-        TRACE_AND_STEP();
-        destval = (*opcD0_byte_operation[rh]) (destval, 1);
-        store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",1\n");
+       destval = fetch_data_byte(destoffset);
+       TRACE_AND_STEP();
+       destval = (*opcD0_byte_operation[rh]) (destval, 1);
+       store_data_byte(destoffset, destval);
+       break;
     case 2:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",1\n");
-        destval = fetch_data_byte(destoffset);
-        TRACE_AND_STEP();
-        destval = (*opcD0_byte_operation[rh]) (destval, 1);
-        store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",1\n");
+       destval = fetch_data_byte(destoffset);
+       TRACE_AND_STEP();
+       destval = (*opcD0_byte_operation[rh]) (destval, 1);
+       store_data_byte(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",1\n");
-        TRACE_AND_STEP();
-        destval = (*opcD0_byte_operation[rh]) (*destreg, 1);
-        *destreg = destval;
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",1\n");
+       TRACE_AND_STEP();
+       destval = (*opcD0_byte_operation[rh]) (*destreg, 1);
+       *destreg = destval;
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -9023,131 +9023,131 @@ void x86emuOp_opcD1_word_RM_1(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
 #ifdef DEBUG
     if (DEBUG_DECODE()) {
-        /* XXX DECODE_PRINTF may be changed to something more
-           general, so that it is important to leave the strings
-           in the same format, even though the result is that the
-           above test is done twice. */
-        switch (rh) {
-        case 0:
-            DECODE_PRINTF("ROL\t");
-            break;
-        case 1:
-            DECODE_PRINTF("ROR\t");
-            break;
-        case 2:
-            DECODE_PRINTF("RCL\t");
-            break;
-        case 3:
-            DECODE_PRINTF("RCR\t");
-            break;
-        case 4:
-            DECODE_PRINTF("SHL\t");
-            break;
-        case 5:
-            DECODE_PRINTF("SHR\t");
-            break;
-        case 6:
-            DECODE_PRINTF("SAL\t");
-            break;
-        case 7:
-            DECODE_PRINTF("SAR\t");
-            break;
-        }
+       /* XXX DECODE_PRINTF may be changed to something more
+          general, so that it is important to leave the strings
+          in the same format, even though the result is that the
+          above test is done twice. */
+       switch (rh) {
+       case 0:
+           DECODE_PRINTF("ROL\t");
+           break;
+       case 1:
+           DECODE_PRINTF("ROR\t");
+           break;
+       case 2:
+           DECODE_PRINTF("RCL\t");
+           break;
+       case 3:
+           DECODE_PRINTF("RCR\t");
+           break;
+       case 4:
+           DECODE_PRINTF("SHL\t");
+           break;
+       case 5:
+           DECODE_PRINTF("SHR\t");
+           break;
+       case 6:
+           DECODE_PRINTF("SAL\t");
+           break;
+       case 7:
+           DECODE_PRINTF("SAR\t");
+           break;
+       }
     }
 #endif
     /* know operation, decode the mod byte to find the addressing
        mode. */
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",1\n");
-            destval = fetch_data_long(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_long_operation[rh]) (destval, 1);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",1\n");
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_word_operation[rh]) (destval, 1);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",1\n");
+           destval = fetch_data_long(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_long_operation[rh]) (destval, 1);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",1\n");
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_word_operation[rh]) (destval, 1);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",1\n");
-            destval = fetch_data_long(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_long_operation[rh]) (destval, 1);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",1\n");
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_word_operation[rh]) (destval, 1);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",1\n");
+           destval = fetch_data_long(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_long_operation[rh]) (destval, 1);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",1\n");
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_word_operation[rh]) (destval, 1);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",1\n");
-            destval = fetch_data_long(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_long_operation[rh]) (destval, 1);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            DECODE_PRINTF("BYTE PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",1\n");
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_word_operation[rh]) (destval, 1);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",1\n");
+           destval = fetch_data_long(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_long_operation[rh]) (destval, 1);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+
+           DECODE_PRINTF("BYTE PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",1\n");
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_word_operation[rh]) (destval, 1);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
                        u32 destval;
                        u32 *destreg;
 
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",1\n");
-            TRACE_AND_STEP();
-            destval = (*opcD1_long_operation[rh]) (*destreg, 1);
-            *destreg = destval;
-        } else {
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",1\n");
+           TRACE_AND_STEP();
+           destval = (*opcD1_long_operation[rh]) (*destreg, 1);
+           *destreg = destval;
+       } else {
                        u16 destval;
                        u16 *destreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",1\n");
-            TRACE_AND_STEP();
-            destval = (*opcD1_word_operation[rh]) (*destreg, 1);
-            *destreg = destval;
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",1\n");
+           TRACE_AND_STEP();
+           destval = (*opcD1_word_operation[rh]) (*destreg, 1);
+           *destreg = destval;
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -9174,36 +9174,36 @@ void x86emuOp_opcD2_byte_RM_CL(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
 #ifdef DEBUG
     if (DEBUG_DECODE()) {
-        /* XXX DECODE_PRINTF may be changed to something more
-           general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
-           above test is done twice. */
-        switch (rh) {
-        case 0:
-            DECODE_PRINTF("ROL\t");
-            break;
-        case 1:
-            DECODE_PRINTF("ROR\t");
-            break;
-        case 2:
-            DECODE_PRINTF("RCL\t");
-            break;
-        case 3:
-            DECODE_PRINTF("RCR\t");
-            break;
-        case 4:
-            DECODE_PRINTF("SHL\t");
-            break;
-        case 5:
-            DECODE_PRINTF("SHR\t");
-            break;
-        case 6:
-            DECODE_PRINTF("SAL\t");
-            break;
-        case 7:
-            DECODE_PRINTF("SAR\t");
-            break;
-        }
+       /* XXX DECODE_PRINTF may be changed to something more
+          general, so that it is important to leave the strings
+          in the same format, even though the result is that the
+          above test is done twice. */
+       switch (rh) {
+       case 0:
+           DECODE_PRINTF("ROL\t");
+           break;
+       case 1:
+           DECODE_PRINTF("ROR\t");
+           break;
+       case 2:
+           DECODE_PRINTF("RCL\t");
+           break;
+       case 3:
+           DECODE_PRINTF("RCR\t");
+           break;
+       case 4:
+           DECODE_PRINTF("SHL\t");
+           break;
+       case 5:
+           DECODE_PRINTF("SHR\t");
+           break;
+       case 6:
+           DECODE_PRINTF("SAL\t");
+           break;
+       case 7:
+           DECODE_PRINTF("SAR\t");
+           break;
+       }
     }
 #endif
     /* know operation, decode the mod byte to find the addressing
@@ -9211,39 +9211,39 @@ void x86emuOp_opcD2_byte_RM_CL(u8 X86EMU_UNUSED(op1))
     amt = M.x86.R_CL;
     switch (mod) {
     case 0:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF(",CL\n");
-        destval = fetch_data_byte(destoffset);
-        TRACE_AND_STEP();
-        destval = (*opcD0_byte_operation[rh]) (destval, amt);
-        store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF(",CL\n");
+       destval = fetch_data_byte(destoffset);
+       TRACE_AND_STEP();
+       destval = (*opcD0_byte_operation[rh]) (destval, amt);
+       store_data_byte(destoffset, destval);
+       break;
     case 1:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF(",CL\n");
-        destval = fetch_data_byte(destoffset);
-        TRACE_AND_STEP();
-        destval = (*opcD0_byte_operation[rh]) (destval, amt);
-        store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF(",CL\n");
+       destval = fetch_data_byte(destoffset);
+       TRACE_AND_STEP();
+       destval = (*opcD0_byte_operation[rh]) (destval, amt);
+       store_data_byte(destoffset, destval);
+       break;
     case 2:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF(",CL\n");
-        destval = fetch_data_byte(destoffset);
-        TRACE_AND_STEP();
-        destval = (*opcD0_byte_operation[rh]) (destval, amt);
-        store_data_byte(destoffset, destval);
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF(",CL\n");
+       destval = fetch_data_byte(destoffset);
+       TRACE_AND_STEP();
+       destval = (*opcD0_byte_operation[rh]) (destval, amt);
+       store_data_byte(destoffset, destval);
+       break;
     case 3:                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",CL\n");
-        TRACE_AND_STEP();
-        destval = (*opcD0_byte_operation[rh]) (*destreg, amt);
-        *destreg = destval;
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF(",CL\n");
+       TRACE_AND_STEP();
+       destval = (*opcD0_byte_operation[rh]) (*destreg, amt);
+       *destreg = destval;
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -9268,36 +9268,36 @@ void x86emuOp_opcD3_word_RM_CL(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
 #ifdef DEBUG
     if (DEBUG_DECODE()) {
-        /* XXX DECODE_PRINTF may be changed to something more
-           general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
-           above test is done twice. */
-        switch (rh) {
-        case 0:
-            DECODE_PRINTF("ROL\t");
-            break;
-        case 1:
-            DECODE_PRINTF("ROR\t");
-            break;
-        case 2:
-            DECODE_PRINTF("RCL\t");
-            break;
-        case 3:
-            DECODE_PRINTF("RCR\t");
-            break;
-        case 4:
-            DECODE_PRINTF("SHL\t");
-            break;
-        case 5:
-            DECODE_PRINTF("SHR\t");
-            break;
-        case 6:
-            DECODE_PRINTF("SAL\t");
-            break;
-        case 7:
-            DECODE_PRINTF("SAR\t");
-            break;
-        }
+       /* XXX DECODE_PRINTF may be changed to something more
+          general, so that it is important to leave the strings
+          in the same format, even though the result is that the
+          above test is done twice. */
+       switch (rh) {
+       case 0:
+           DECODE_PRINTF("ROL\t");
+           break;
+       case 1:
+           DECODE_PRINTF("ROR\t");
+           break;
+       case 2:
+           DECODE_PRINTF("RCL\t");
+           break;
+       case 3:
+           DECODE_PRINTF("RCR\t");
+           break;
+       case 4:
+           DECODE_PRINTF("SHL\t");
+           break;
+       case 5:
+           DECODE_PRINTF("SHR\t");
+           break;
+       case 6:
+           DECODE_PRINTF("SAL\t");
+           break;
+       case 7:
+           DECODE_PRINTF("SAR\t");
+           break;
+       }
     }
 #endif
     /* know operation, decode the mod byte to find the addressing
@@ -9305,91 +9305,91 @@ void x86emuOp_opcD3_word_RM_CL(u8 X86EMU_UNUSED(op1))
     amt = M.x86.R_CL;
     switch (mod) {
     case 0:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",CL\n");
-            destval = fetch_data_long(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_long_operation[rh]) (destval, amt);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",CL\n");
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_word_operation[rh]) (destval, amt);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",CL\n");
+           destval = fetch_data_long(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_long_operation[rh]) (destval, amt);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",CL\n");
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_word_operation[rh]) (destval, amt);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 1:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",CL\n");
-            destval = fetch_data_long(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_long_operation[rh]) (destval, amt);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",CL\n");
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_word_operation[rh]) (destval, amt);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",CL\n");
+           destval = fetch_data_long(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_long_operation[rh]) (destval, amt);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",CL\n");
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_word_operation[rh]) (destval, amt);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 2:
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",CL\n");
-            destval = fetch_data_long(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_long_operation[rh]) (destval, amt);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",CL\n");
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            destval = (*opcD1_word_operation[rh]) (destval, amt);
-            store_data_word(destoffset, destval);
-        }
-        break;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 destval;
+
+           DECODE_PRINTF("DWORD PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",CL\n");
+           destval = fetch_data_long(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_long_operation[rh]) (destval, amt);
+           store_data_long(destoffset, destval);
+       } else {
+           u16 destval;
+
+           DECODE_PRINTF("WORD PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",CL\n");
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           destval = (*opcD1_word_operation[rh]) (destval, amt);
+           store_data_word(destoffset, destval);
+       }
+       break;
     case 3:                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
+       if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+           u32 *destreg;
 
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",CL\n");
-            TRACE_AND_STEP();
-            *destreg = (*opcD1_long_operation[rh]) (*destreg, amt);
-        } else {
-            u16 *destreg;
+           destreg = DECODE_RM_LONG_REGISTER(rl);
+           DECODE_PRINTF(",CL\n");
+           TRACE_AND_STEP();
+           *destreg = (*opcD1_long_operation[rh]) (*destreg, amt);
+       } else {
+           u16 *destreg;
 
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",CL\n");
-            TRACE_AND_STEP();
-            *destreg = (*opcD1_word_operation[rh]) (*destreg, amt);
-        }
-        break;
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF(",CL\n");
+           TRACE_AND_STEP();
+           *destreg = (*opcD1_word_operation[rh]) (*destreg, amt);
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -9407,9 +9407,9 @@ void x86emuOp_aam(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("AAM\n");
     a = fetch_byte_imm();      /* this is a stupid encoding. */
     if (a != 10) {
-        DECODE_PRINTF("ERROR DECODING AAM\n");
-        TRACE_REGS();
-        HALT_SYS();
+       DECODE_PRINTF("ERROR DECODING AAM\n");
+       TRACE_REGS();
+       HALT_SYS();
     }
     TRACE_AND_STEP();
     /* note the type change here --- returning AL and AH in AX. */
@@ -9472,7 +9472,7 @@ void x86emuOp_loopne(u8 X86EMU_UNUSED(op1))
     TRACE_AND_STEP();
     M.x86.R_CX -= 1;
     if (M.x86.R_CX != 0 && !ACCESS_FLAG(F_ZF))      /* CX != 0 and !ZF */
-        M.x86.R_IP = ip;
+       M.x86.R_IP = ip;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -9493,7 +9493,7 @@ void x86emuOp_loope(u8 X86EMU_UNUSED(op1))
     TRACE_AND_STEP();
     M.x86.R_CX -= 1;
     if (M.x86.R_CX != 0 && ACCESS_FLAG(F_ZF))       /* CX != 0 and ZF */
-        M.x86.R_IP = ip;
+       M.x86.R_IP = ip;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -9514,7 +9514,7 @@ void x86emuOp_loop(u8 X86EMU_UNUSED(op1))
     TRACE_AND_STEP();
     M.x86.R_CX -= 1;
     if (M.x86.R_CX != 0)
-        M.x86.R_IP = ip;
+       M.x86.R_IP = ip;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -9536,7 +9536,7 @@ void x86emuOp_jcxz(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (M.x86.R_CX == 0)
-        M.x86.R_IP = target;
+       M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -9571,15 +9571,15 @@ void x86emuOp_in_word_AX_IMM(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("IN\t");
        port = (u8) fetch_byte_imm();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF2("EAX,%x\n", port);
+       DECODE_PRINTF2("EAX,%x\n", port);
     } else {
-        DECODE_PRINTF2("AX,%x\n", port);
+       DECODE_PRINTF2("AX,%x\n", port);
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = (*sys_inl)(port);
+       M.x86.R_EAX = (*sys_inl)(port);
     } else {
-        M.x86.R_AX = (*sys_inw)(port);
+       M.x86.R_AX = (*sys_inw)(port);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -9615,15 +9615,15 @@ void x86emuOp_out_word_IMM_AX(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("OUT\t");
        port = (u8) fetch_byte_imm();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF2("%x,EAX\n", port);
+       DECODE_PRINTF2("%x,EAX\n", port);
     } else {
-        DECODE_PRINTF2("%x,AX\n", port);
+       DECODE_PRINTF2("%x,AX\n", port);
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        (*sys_outl)(port, M.x86.R_EAX);
+       (*sys_outl)(port, M.x86.R_EAX);
     } else {
-        (*sys_outw)(port, M.x86.R_AX);
+       (*sys_outw)(port, M.x86.R_AX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -9732,15 +9732,15 @@ void x86emuOp_in_word_AX_DX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("IN\tEAX,DX\n");
+       DECODE_PRINTF("IN\tEAX,DX\n");
     } else {
-        DECODE_PRINTF("IN\tAX,DX\n");
+       DECODE_PRINTF("IN\tAX,DX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = (*sys_inl)(M.x86.R_DX);
+       M.x86.R_EAX = (*sys_inl)(M.x86.R_DX);
     } else {
-        M.x86.R_AX = (*sys_inw)(M.x86.R_DX);
+       M.x86.R_AX = (*sys_inw)(M.x86.R_DX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -9768,15 +9768,15 @@ void x86emuOp_out_word_DX_AX(u8 X86EMU_UNUSED(op1))
 {
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("OUT\tDX,EAX\n");
+       DECODE_PRINTF("OUT\tDX,EAX\n");
     } else {
-        DECODE_PRINTF("OUT\tDX,AX\n");
+       DECODE_PRINTF("OUT\tDX,AX\n");
     }
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        (*sys_outl)(M.x86.R_DX, M.x86.R_EAX);
+       (*sys_outl)(M.x86.R_DX, M.x86.R_EAX);
     } else {
-        (*sys_outw)(M.x86.R_DX, M.x86.R_AX);
+       (*sys_outw)(M.x86.R_DX, M.x86.R_AX);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -9871,268 +9871,268 @@ void x86emuOp_opcF6_byte_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:                     /* mod=00 */
-        switch (rh) {
-        case 0:         /* test byte imm */
-            DECODE_PRINTF("TEST\tBYTE PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF(",");
-            srcval = fetch_byte_imm();
-            DECODE_PRINTF2("%02x\n", srcval);
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            test_byte(destval, srcval);
-            break;
-        case 1:
-            DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
-            HALT_SYS();
-            break;
-        case 2:
-            DECODE_PRINTF("NOT\tBYTE PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            destval = not_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        case 3:
-            DECODE_PRINTF("NEG\tBYTE PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            destval = neg_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        case 4:
-            DECODE_PRINTF("MUL\tBYTE PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            mul_byte(destval);
-            break;
-        case 5:
-            DECODE_PRINTF("IMUL\tBYTE PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            imul_byte(destval);
-            break;
-        case 6:
-            DECODE_PRINTF("DIV\tBYTE PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            div_byte(destval);
-            break;
-        case 7:
-            DECODE_PRINTF("IDIV\tBYTE PTR ");
-            destoffset = decode_rm00_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            idiv_byte(destval);
-            break;
-        }
-        break;                  /* end mod==00 */
+       switch (rh) {
+       case 0:         /* test byte imm */
+           DECODE_PRINTF("TEST\tBYTE PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF(",");
+           srcval = fetch_byte_imm();
+           DECODE_PRINTF2("%02x\n", srcval);
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           test_byte(destval, srcval);
+           break;
+       case 1:
+           DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
+           HALT_SYS();
+           break;
+       case 2:
+           DECODE_PRINTF("NOT\tBYTE PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           destval = not_byte(destval);
+           store_data_byte(destoffset, destval);
+           break;
+       case 3:
+           DECODE_PRINTF("NEG\tBYTE PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           destval = neg_byte(destval);
+           store_data_byte(destoffset, destval);
+           break;
+       case 4:
+           DECODE_PRINTF("MUL\tBYTE PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           mul_byte(destval);
+           break;
+       case 5:
+           DECODE_PRINTF("IMUL\tBYTE PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           imul_byte(destval);
+           break;
+       case 6:
+           DECODE_PRINTF("DIV\tBYTE PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           div_byte(destval);
+           break;
+       case 7:
+           DECODE_PRINTF("IDIV\tBYTE PTR ");
+           destoffset = decode_rm00_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           idiv_byte(destval);
+           break;
+       }
+       break;                  /* end mod==00 */
     case 1:                     /* mod=01 */
-        switch (rh) {
-        case 0:         /* test byte imm */
-            DECODE_PRINTF("TEST\tBYTE PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF(",");
-            srcval = fetch_byte_imm();
-            DECODE_PRINTF2("%02x\n", srcval);
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            test_byte(destval, srcval);
-            break;
-        case 1:
-            DECODE_PRINTF("ILLEGAL OP MOD=01 RH=01 OP=F6\n");
-            HALT_SYS();
-            break;
-        case 2:
-            DECODE_PRINTF("NOT\tBYTE PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            destval = not_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        case 3:
-            DECODE_PRINTF("NEG\tBYTE PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            destval = neg_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        case 4:
-            DECODE_PRINTF("MUL\tBYTE PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            mul_byte(destval);
-            break;
-        case 5:
-            DECODE_PRINTF("IMUL\tBYTE PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            imul_byte(destval);
-            break;
-        case 6:
-            DECODE_PRINTF("DIV\tBYTE PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            div_byte(destval);
-            break;
-        case 7:
-            DECODE_PRINTF("IDIV\tBYTE PTR ");
-            destoffset = decode_rm01_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            idiv_byte(destval);
-            break;
-        }
-        break;                  /* end mod==01 */
+       switch (rh) {
+       case 0:         /* test byte imm */
+           DECODE_PRINTF("TEST\tBYTE PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF(",");
+           srcval = fetch_byte_imm();
+           DECODE_PRINTF2("%02x\n", srcval);
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           test_byte(destval, srcval);
+           break;
+       case 1:
+           DECODE_PRINTF("ILLEGAL OP MOD=01 RH=01 OP=F6\n");
+           HALT_SYS();
+           break;
+       case 2:
+           DECODE_PRINTF("NOT\tBYTE PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           destval = not_byte(destval);
+           store_data_byte(destoffset, destval);
+           break;
+       case 3:
+           DECODE_PRINTF("NEG\tBYTE PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           destval = neg_byte(destval);
+           store_data_byte(destoffset, destval);
+           break;
+       case 4:
+           DECODE_PRINTF("MUL\tBYTE PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           mul_byte(destval);
+           break;
+       case 5:
+           DECODE_PRINTF("IMUL\tBYTE PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           imul_byte(destval);
+           break;
+       case 6:
+           DECODE_PRINTF("DIV\tBYTE PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           div_byte(destval);
+           break;
+       case 7:
+           DECODE_PRINTF("IDIV\tBYTE PTR ");
+           destoffset = decode_rm01_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           idiv_byte(destval);
+           break;
+       }
+       break;                  /* end mod==01 */
     case 2:                     /* mod=10 */
-        switch (rh) {
-        case 0:         /* test byte imm */
-            DECODE_PRINTF("TEST\tBYTE PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF(",");
-            srcval = fetch_byte_imm();
-            DECODE_PRINTF2("%02x\n", srcval);
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            test_byte(destval, srcval);
-            break;
-        case 1:
-            DECODE_PRINTF("ILLEGAL OP MOD=10 RH=01 OP=F6\n");
-            HALT_SYS();
-            break;
-        case 2:
-            DECODE_PRINTF("NOT\tBYTE PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            destval = not_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        case 3:
-            DECODE_PRINTF("NEG\tBYTE PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            destval = neg_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        case 4:
-            DECODE_PRINTF("MUL\tBYTE PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            mul_byte(destval);
-            break;
-        case 5:
-            DECODE_PRINTF("IMUL\tBYTE PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            imul_byte(destval);
-            break;
-        case 6:
-            DECODE_PRINTF("DIV\tBYTE PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            div_byte(destval);
-            break;
-        case 7:
-            DECODE_PRINTF("IDIV\tBYTE PTR ");
-            destoffset = decode_rm10_address(rl);
-            DECODE_PRINTF("\n");
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            idiv_byte(destval);
-            break;
-        }
-        break;                  /* end mod==10 */
+       switch (rh) {
+       case 0:         /* test byte imm */
+           DECODE_PRINTF("TEST\tBYTE PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF(",");
+           srcval = fetch_byte_imm();
+           DECODE_PRINTF2("%02x\n", srcval);
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           test_byte(destval, srcval);
+           break;
+       case 1:
+           DECODE_PRINTF("ILLEGAL OP MOD=10 RH=01 OP=F6\n");
+           HALT_SYS();
+           break;
+       case 2:
+           DECODE_PRINTF("NOT\tBYTE PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           destval = not_byte(destval);
+           store_data_byte(destoffset, destval);
+           break;
+       case 3:
+           DECODE_PRINTF("NEG\tBYTE PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           destval = neg_byte(destval);
+           store_data_byte(destoffset, destval);
+           break;
+       case 4:
+           DECODE_PRINTF("MUL\tBYTE PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           mul_byte(destval);
+           break;
+       case 5:
+           DECODE_PRINTF("IMUL\tBYTE PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           imul_byte(destval);
+           break;
+       case 6:
+           DECODE_PRINTF("DIV\tBYTE PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           div_byte(destval);
+           break;
+       case 7:
+           DECODE_PRINTF("IDIV\tBYTE PTR ");
+           destoffset = decode_rm10_address(rl);
+           DECODE_PRINTF("\n");
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           idiv_byte(destval);
+           break;
+       }
+       break;                  /* end mod==10 */
     case 3:                     /* mod=11 */
-        switch (rh) {
-        case 0:         /* test byte imm */
-            DECODE_PRINTF("TEST\t");
-            destreg = DECODE_RM_BYTE_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcval = fetch_byte_imm();
-            DECODE_PRINTF2("%02x\n", srcval);
-            TRACE_AND_STEP();
-            test_byte(*destreg, srcval);
-            break;
-        case 1:
-            DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
-            HALT_SYS();
-            break;
-        case 2:
-            DECODE_PRINTF("NOT\t");
-            destreg = DECODE_RM_BYTE_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = not_byte(*destreg);
-            break;
-        case 3:
-            DECODE_PRINTF("NEG\t");
-            destreg = DECODE_RM_BYTE_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = neg_byte(*destreg);
-            break;
-        case 4:
-            DECODE_PRINTF("MUL\t");
-            destreg = DECODE_RM_BYTE_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            mul_byte(*destreg);      /*!!!  */
-            break;
-        case 5:
-            DECODE_PRINTF("IMUL\t");
-            destreg = DECODE_RM_BYTE_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            imul_byte(*destreg);
-            break;
-        case 6:
-            DECODE_PRINTF("DIV\t");
-            destreg = DECODE_RM_BYTE_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            div_byte(*destreg);
-            break;
-        case 7:
-            DECODE_PRINTF("IDIV\t");
-            destreg = DECODE_RM_BYTE_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            idiv_byte(*destreg);
-            break;
-        }
-        break;                  /* end mod==11 */
+       switch (rh) {
+       case 0:         /* test byte imm */
+           DECODE_PRINTF("TEST\t");
+           destreg = DECODE_RM_BYTE_REGISTER(rl);
+           DECODE_PRINTF(",");
+           srcval = fetch_byte_imm();
+           DECODE_PRINTF2("%02x\n", srcval);
+           TRACE_AND_STEP();
+           test_byte(*destreg, srcval);
+           break;
+       case 1:
+           DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
+           HALT_SYS();
+           break;
+       case 2:
+           DECODE_PRINTF("NOT\t");
+           destreg = DECODE_RM_BYTE_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = not_byte(*destreg);
+           break;
+       case 3:
+           DECODE_PRINTF("NEG\t");
+           destreg = DECODE_RM_BYTE_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           *destreg = neg_byte(*destreg);
+           break;
+       case 4:
+           DECODE_PRINTF("MUL\t");
+           destreg = DECODE_RM_BYTE_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           mul_byte(*destreg);      /*!!!  */
+           break;
+       case 5:
+           DECODE_PRINTF("IMUL\t");
+           destreg = DECODE_RM_BYTE_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           imul_byte(*destreg);
+           break;
+       case 6:
+           DECODE_PRINTF("DIV\t");
+           destreg = DECODE_RM_BYTE_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           div_byte(*destreg);
+           break;
+       case 7:
+           DECODE_PRINTF("IDIV\t");
+           destreg = DECODE_RM_BYTE_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           idiv_byte(*destreg);
+           break;
+       }
+       break;                  /* end mod==11 */
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -10153,641 +10153,641 @@ void x86emuOp_opcF7_word_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (mod) {
     case 0:                     /* mod=00 */
-        switch (rh) {
-        case 0:         /* test word imm */
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval,srcval;
-
-                DECODE_PRINTF("TEST\tDWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF(",");
-                srcval = fetch_long_imm();
-                DECODE_PRINTF2("%x\n", srcval);
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                test_long(destval, srcval);
-            } else {
-                u16 destval,srcval;
-
-                DECODE_PRINTF("TEST\tWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF(",");
-                srcval = fetch_word_imm();
-                DECODE_PRINTF2("%x\n", srcval);
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                test_word(destval, srcval);
-            }
-            break;
-        case 1:
-            DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F7\n");
-            HALT_SYS();
-            break;
-        case 2:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("NOT\tDWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                destval = not_long(destval);
-                store_data_long(destoffset, destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("NOT\tWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                destval = not_word(destval);
-                store_data_word(destoffset, destval);
-            }
-            break;
-        case 3:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("NEG\tDWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                destval = neg_long(destval);
-                store_data_long(destoffset, destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("NEG\tWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                destval = neg_word(destval);
-                store_data_word(destoffset, destval);
-            }
-            break;
-        case 4:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("MUL\tDWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                mul_long(destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("MUL\tWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                mul_word(destval);
-            }
-            break;
-        case 5:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("IMUL\tDWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                imul_long(destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("IMUL\tWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                imul_word(destval);
-            }
-            break;
-        case 6:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("DIV\tDWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                div_long(destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("DIV\tWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                div_word(destval);
-            }
-            break;
-        case 7:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("IDIV\tDWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                idiv_long(destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("IDIV\tWORD PTR ");
-                destoffset = decode_rm00_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                idiv_word(destval);
-            }
-            break;
-        }
-        break;                  /* end mod==00 */
+       switch (rh) {
+       case 0:         /* test word imm */
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval,srcval;
+
+               DECODE_PRINTF("TEST\tDWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF(",");
+               srcval = fetch_long_imm();
+               DECODE_PRINTF2("%x\n", srcval);
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               test_long(destval, srcval);
+           } else {
+               u16 destval,srcval;
+
+               DECODE_PRINTF("TEST\tWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF(",");
+               srcval = fetch_word_imm();
+               DECODE_PRINTF2("%x\n", srcval);
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               test_word(destval, srcval);
+           }
+           break;
+       case 1:
+           DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F7\n");
+           HALT_SYS();
+           break;
+       case 2:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("NOT\tDWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               destval = not_long(destval);
+               store_data_long(destoffset, destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("NOT\tWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               destval = not_word(destval);
+               store_data_word(destoffset, destval);
+           }
+           break;
+       case 3:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("NEG\tDWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               destval = neg_long(destval);
+               store_data_long(destoffset, destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("NEG\tWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               destval = neg_word(destval);
+               store_data_word(destoffset, destval);
+           }
+           break;
+       case 4:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("MUL\tDWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               mul_long(destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("MUL\tWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               mul_word(destval);
+           }
+           break;
+       case 5:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("IMUL\tDWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               imul_long(destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("IMUL\tWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               imul_word(destval);
+           }
+           break;
+       case 6:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("DIV\tDWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               div_long(destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("DIV\tWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               div_word(destval);
+           }
+           break;
+       case 7:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("IDIV\tDWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               idiv_long(destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("IDIV\tWORD PTR ");
+               destoffset = decode_rm00_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               idiv_word(destval);
+           }
+           break;
+       }
+       break;                  /* end mod==00 */
     case 1:                     /* mod=01 */
-        switch (rh) {
-        case 0:         /* test word imm */
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval,srcval;
-
-                DECODE_PRINTF("TEST\tDWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF(",");
-                srcval = fetch_long_imm();
-                DECODE_PRINTF2("%x\n", srcval);
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                test_long(destval, srcval);
-            } else {
-                u16 destval,srcval;
-
-                DECODE_PRINTF("TEST\tWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF(",");
-                srcval = fetch_word_imm();
-                DECODE_PRINTF2("%x\n", srcval);
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                test_word(destval, srcval);
-            }
-            break;
-        case 1:
-            DECODE_PRINTF("ILLEGAL OP MOD=01 RH=01 OP=F6\n");
-            HALT_SYS();
-            break;
-        case 2:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("NOT\tDWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                destval = not_long(destval);
-                store_data_long(destoffset, destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("NOT\tWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                destval = not_word(destval);
-                store_data_word(destoffset, destval);
-            }
-            break;
-        case 3:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("NEG\tDWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                destval = neg_long(destval);
-                store_data_long(destoffset, destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("NEG\tWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                destval = neg_word(destval);
-                store_data_word(destoffset, destval);
-            }
-            break;
-        case 4:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("MUL\tDWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                mul_long(destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("MUL\tWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                mul_word(destval);
-            }
-            break;
-        case 5:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("IMUL\tDWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                imul_long(destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("IMUL\tWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                imul_word(destval);
-            }
-            break;
-        case 6:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("DIV\tDWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                div_long(destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("DIV\tWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                div_word(destval);
-            }
-            break;
-        case 7:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("IDIV\tDWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                idiv_long(destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("IDIV\tWORD PTR ");
-                destoffset = decode_rm01_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                idiv_word(destval);
-            }
-            break;
-        }
-        break;                  /* end mod==01 */
+       switch (rh) {
+       case 0:         /* test word imm */
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval,srcval;
+
+               DECODE_PRINTF("TEST\tDWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF(",");
+               srcval = fetch_long_imm();
+               DECODE_PRINTF2("%x\n", srcval);
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               test_long(destval, srcval);
+           } else {
+               u16 destval,srcval;
+
+               DECODE_PRINTF("TEST\tWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF(",");
+               srcval = fetch_word_imm();
+               DECODE_PRINTF2("%x\n", srcval);
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               test_word(destval, srcval);
+           }
+           break;
+       case 1:
+           DECODE_PRINTF("ILLEGAL OP MOD=01 RH=01 OP=F6\n");
+           HALT_SYS();
+           break;
+       case 2:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("NOT\tDWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               destval = not_long(destval);
+               store_data_long(destoffset, destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("NOT\tWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               destval = not_word(destval);
+               store_data_word(destoffset, destval);
+           }
+           break;
+       case 3:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("NEG\tDWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               destval = neg_long(destval);
+               store_data_long(destoffset, destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("NEG\tWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               destval = neg_word(destval);
+               store_data_word(destoffset, destval);
+           }
+           break;
+       case 4:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("MUL\tDWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               mul_long(destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("MUL\tWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               mul_word(destval);
+           }
+           break;
+       case 5:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("IMUL\tDWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               imul_long(destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("IMUL\tWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               imul_word(destval);
+           }
+           break;
+       case 6:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("DIV\tDWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               div_long(destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("DIV\tWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               div_word(destval);
+           }
+           break;
+       case 7:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("IDIV\tDWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               idiv_long(destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("IDIV\tWORD PTR ");
+               destoffset = decode_rm01_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               idiv_word(destval);
+           }
+           break;
+       }
+       break;                  /* end mod==01 */
     case 2:                     /* mod=10 */
-        switch (rh) {
-        case 0:         /* test word imm */
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval,srcval;
-
-                DECODE_PRINTF("TEST\tDWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF(",");
-                srcval = fetch_long_imm();
-                DECODE_PRINTF2("%x\n", srcval);
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                test_long(destval, srcval);
-            } else {
-                u16 destval,srcval;
-
-                DECODE_PRINTF("TEST\tWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF(",");
-                srcval = fetch_word_imm();
-                DECODE_PRINTF2("%x\n", srcval);
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                test_word(destval, srcval);
-            }
-            break;
-        case 1:
-            DECODE_PRINTF("ILLEGAL OP MOD=10 RH=01 OP=F6\n");
-            HALT_SYS();
-            break;
-        case 2:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("NOT\tDWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                destval = not_long(destval);
-                store_data_long(destoffset, destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("NOT\tWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                destval = not_word(destval);
-                store_data_word(destoffset, destval);
-            }
-            break;
-        case 3:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("NEG\tDWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                destval = neg_long(destval);
-                store_data_long(destoffset, destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("NEG\tWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                destval = neg_word(destval);
-                store_data_word(destoffset, destval);
-            }
-            break;
-        case 4:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("MUL\tDWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                mul_long(destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("MUL\tWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                mul_word(destval);
-            }
-            break;
-        case 5:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("IMUL\tDWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                imul_long(destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("IMUL\tWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                imul_word(destval);
-            }
-            break;
-        case 6:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("DIV\tDWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                div_long(destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("DIV\tWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                div_word(destval);
-            }
-            break;
-        case 7:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                DECODE_PRINTF("IDIV\tDWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                idiv_long(destval);
-            } else {
-                u16 destval;
-
-                DECODE_PRINTF("IDIV\tWORD PTR ");
-                destoffset = decode_rm10_address(rl);
-                DECODE_PRINTF("\n");
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                idiv_word(destval);
-            }
-            break;
-        }
-        break;                  /* end mod==10 */
+       switch (rh) {
+       case 0:         /* test word imm */
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval,srcval;
+
+               DECODE_PRINTF("TEST\tDWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF(",");
+               srcval = fetch_long_imm();
+               DECODE_PRINTF2("%x\n", srcval);
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               test_long(destval, srcval);
+           } else {
+               u16 destval,srcval;
+
+               DECODE_PRINTF("TEST\tWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF(",");
+               srcval = fetch_word_imm();
+               DECODE_PRINTF2("%x\n", srcval);
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               test_word(destval, srcval);
+           }
+           break;
+       case 1:
+           DECODE_PRINTF("ILLEGAL OP MOD=10 RH=01 OP=F6\n");
+           HALT_SYS();
+           break;
+       case 2:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("NOT\tDWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               destval = not_long(destval);
+               store_data_long(destoffset, destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("NOT\tWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               destval = not_word(destval);
+               store_data_word(destoffset, destval);
+           }
+           break;
+       case 3:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("NEG\tDWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               destval = neg_long(destval);
+               store_data_long(destoffset, destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("NEG\tWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               destval = neg_word(destval);
+               store_data_word(destoffset, destval);
+           }
+           break;
+       case 4:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("MUL\tDWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               mul_long(destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("MUL\tWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               mul_word(destval);
+           }
+           break;
+       case 5:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("IMUL\tDWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               imul_long(destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("IMUL\tWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               imul_word(destval);
+           }
+           break;
+       case 6:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("DIV\tDWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               div_long(destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("DIV\tWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               div_word(destval);
+           }
+           break;
+       case 7:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               DECODE_PRINTF("IDIV\tDWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               idiv_long(destval);
+           } else {
+               u16 destval;
+
+               DECODE_PRINTF("IDIV\tWORD PTR ");
+               destoffset = decode_rm10_address(rl);
+               DECODE_PRINTF("\n");
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               idiv_word(destval);
+           }
+           break;
+       }
+       break;                  /* end mod==10 */
     case 3:                     /* mod=11 */
-        switch (rh) {
-        case 0:         /* test word imm */
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 *destreg;
-                u32 srcval;
-
-                DECODE_PRINTF("TEST\t");
-                destreg = DECODE_RM_LONG_REGISTER(rl);
-                DECODE_PRINTF(",");
-                srcval = fetch_long_imm();
-                DECODE_PRINTF2("%x\n", srcval);
-                TRACE_AND_STEP();
-                test_long(*destreg, srcval);
-            } else {
-                u16 *destreg;
-                u16 srcval;
-
-                DECODE_PRINTF("TEST\t");
-                destreg = DECODE_RM_WORD_REGISTER(rl);
-                DECODE_PRINTF(",");
-                srcval = fetch_word_imm();
-                DECODE_PRINTF2("%x\n", srcval);
-                TRACE_AND_STEP();
-                test_word(*destreg, srcval);
-            }
-            break;
-        case 1:
-            DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
-            HALT_SYS();
-            break;
-        case 2:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 *destreg;
-
-                DECODE_PRINTF("NOT\t");
-                destreg = DECODE_RM_LONG_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                *destreg = not_long(*destreg);
-            } else {
-                u16 *destreg;
-
-                DECODE_PRINTF("NOT\t");
-                destreg = DECODE_RM_WORD_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                *destreg = not_word(*destreg);
-            }
-            break;
-        case 3:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 *destreg;
-
-                DECODE_PRINTF("NEG\t");
-                destreg = DECODE_RM_LONG_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                *destreg = neg_long(*destreg);
-            } else {
-                u16 *destreg;
-
-                DECODE_PRINTF("NEG\t");
-                destreg = DECODE_RM_WORD_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                *destreg = neg_word(*destreg);
-            }
-            break;
-        case 4:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 *destreg;
-
-                DECODE_PRINTF("MUL\t");
-                destreg = DECODE_RM_LONG_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                mul_long(*destreg);      /*!!!  */
-            } else {
-                u16 *destreg;
-
-                DECODE_PRINTF("MUL\t");
-                destreg = DECODE_RM_WORD_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                mul_word(*destreg);      /*!!!  */
-            }
-            break;
-        case 5:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 *destreg;
-
-                DECODE_PRINTF("IMUL\t");
-                destreg = DECODE_RM_LONG_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                imul_long(*destreg);
-            } else {
-                u16 *destreg;
-
-                DECODE_PRINTF("IMUL\t");
-                destreg = DECODE_RM_WORD_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                imul_word(*destreg);
-            }
-            break;
-        case 6:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 *destreg;
-
-                DECODE_PRINTF("DIV\t");
-                destreg = DECODE_RM_LONG_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                div_long(*destreg);
-            } else {
-                u16 *destreg;
-
-                DECODE_PRINTF("DIV\t");
-                destreg = DECODE_RM_WORD_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                div_word(*destreg);
-            }
-            break;
-        case 7:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 *destreg;
-
-                DECODE_PRINTF("IDIV\t");
-                destreg = DECODE_RM_LONG_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                idiv_long(*destreg);
-            } else {
-                u16 *destreg;
-
-                DECODE_PRINTF("IDIV\t");
-                destreg = DECODE_RM_WORD_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                idiv_word(*destreg);
-            }
-            break;
-        }
-        break;                  /* end mod==11 */
+       switch (rh) {
+       case 0:         /* test word imm */
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 *destreg;
+               u32 srcval;
+
+               DECODE_PRINTF("TEST\t");
+               destreg = DECODE_RM_LONG_REGISTER(rl);
+               DECODE_PRINTF(",");
+               srcval = fetch_long_imm();
+               DECODE_PRINTF2("%x\n", srcval);
+               TRACE_AND_STEP();
+               test_long(*destreg, srcval);
+           } else {
+               u16 *destreg;
+               u16 srcval;
+
+               DECODE_PRINTF("TEST\t");
+               destreg = DECODE_RM_WORD_REGISTER(rl);
+               DECODE_PRINTF(",");
+               srcval = fetch_word_imm();
+               DECODE_PRINTF2("%x\n", srcval);
+               TRACE_AND_STEP();
+               test_word(*destreg, srcval);
+           }
+           break;
+       case 1:
+           DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
+           HALT_SYS();
+           break;
+       case 2:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 *destreg;
+
+               DECODE_PRINTF("NOT\t");
+               destreg = DECODE_RM_LONG_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               *destreg = not_long(*destreg);
+           } else {
+               u16 *destreg;
+
+               DECODE_PRINTF("NOT\t");
+               destreg = DECODE_RM_WORD_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               *destreg = not_word(*destreg);
+           }
+           break;
+       case 3:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 *destreg;
+
+               DECODE_PRINTF("NEG\t");
+               destreg = DECODE_RM_LONG_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               *destreg = neg_long(*destreg);
+           } else {
+               u16 *destreg;
+
+               DECODE_PRINTF("NEG\t");
+               destreg = DECODE_RM_WORD_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               *destreg = neg_word(*destreg);
+           }
+           break;
+       case 4:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 *destreg;
+
+               DECODE_PRINTF("MUL\t");
+               destreg = DECODE_RM_LONG_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               mul_long(*destreg);      /*!!!  */
+           } else {
+               u16 *destreg;
+
+               DECODE_PRINTF("MUL\t");
+               destreg = DECODE_RM_WORD_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               mul_word(*destreg);      /*!!!  */
+           }
+           break;
+       case 5:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 *destreg;
+
+               DECODE_PRINTF("IMUL\t");
+               destreg = DECODE_RM_LONG_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               imul_long(*destreg);
+           } else {
+               u16 *destreg;
+
+               DECODE_PRINTF("IMUL\t");
+               destreg = DECODE_RM_WORD_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               imul_word(*destreg);
+           }
+           break;
+       case 6:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 *destreg;
+
+               DECODE_PRINTF("DIV\t");
+               destreg = DECODE_RM_LONG_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               div_long(*destreg);
+           } else {
+               u16 *destreg;
+
+               DECODE_PRINTF("DIV\t");
+               destreg = DECODE_RM_WORD_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               div_word(*destreg);
+           }
+           break;
+       case 7:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 *destreg;
+
+               DECODE_PRINTF("IDIV\t");
+               destreg = DECODE_RM_LONG_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               idiv_long(*destreg);
+           } else {
+               u16 *destreg;
+
+               DECODE_PRINTF("IDIV\t");
+               destreg = DECODE_RM_WORD_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               idiv_word(*destreg);
+           }
+           break;
+       }
+       break;                  /* end mod==11 */
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -10899,102 +10899,102 @@ void x86emuOp_opcFE_byte_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
 #ifdef DEBUG
     if (DEBUG_DECODE()) {
-        /* XXX DECODE_PRINTF may be changed to something more
-           general, so that it is important to leave the strings
-           in the same format, even though the result is that the 
-           above test is done twice. */
-
-        switch (rh) {
-        case 0:
-            DECODE_PRINTF("INC\t");
-            break;
-        case 1:
-            DECODE_PRINTF("DEC\t");
-            break;
-        case 2:
-        case 3:
-        case 4:
-        case 5:
-        case 6:
-        case 7:
-            DECODE_PRINTF2("ILLEGAL OP MAJOR OP 0xFE MINOR OP %x \n", mod);
-            HALT_SYS();
-            break;
-        }
+       /* XXX DECODE_PRINTF may be changed to something more
+          general, so that it is important to leave the strings
+          in the same format, even though the result is that the
+          above test is done twice. */
+
+       switch (rh) {
+       case 0:
+           DECODE_PRINTF("INC\t");
+           break;
+       case 1:
+           DECODE_PRINTF("DEC\t");
+           break;
+       case 2:
+       case 3:
+       case 4:
+       case 5:
+       case 6:
+       case 7:
+           DECODE_PRINTF2("ILLEGAL OP MAJOR OP 0xFE MINOR OP %x \n", mod);
+           HALT_SYS();
+           break;
+       }
     }
 #endif
     switch (mod) {
     case 0:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF("\n");
-        switch (rh) {
-        case 0:         /* inc word ptr ... */
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            destval = inc_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        case 1:         /* dec word ptr ... */
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            destval = dec_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        }
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF("\n");
+       switch (rh) {
+       case 0:         /* inc word ptr ... */
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           destval = inc_byte(destval);
+           store_data_byte(destoffset, destval);
+           break;
+       case 1:         /* dec word ptr ... */
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           destval = dec_byte(destval);
+           store_data_byte(destoffset, destval);
+           break;
+       }
+       break;
     case 1:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF("\n");
-        switch (rh) {
-        case 0:
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            destval = inc_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        case 1:
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            destval = dec_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        }
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF("\n");
+       switch (rh) {
+       case 0:
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           destval = inc_byte(destval);
+           store_data_byte(destoffset, destval);
+           break;
+       case 1:
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           destval = dec_byte(destval);
+           store_data_byte(destoffset, destval);
+           break;
+       }
+       break;
     case 2:
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF("\n");
-        switch (rh) {
-        case 0:
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            destval = inc_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        case 1:
-            destval = fetch_data_byte(destoffset);
-            TRACE_AND_STEP();
-            destval = dec_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        }
-        break;
+       DECODE_PRINTF("BYTE PTR ");
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF("\n");
+       switch (rh) {
+       case 0:
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           destval = inc_byte(destval);
+           store_data_byte(destoffset, destval);
+           break;
+       case 1:
+           destval = fetch_data_byte(destoffset);
+           TRACE_AND_STEP();
+           destval = dec_byte(destval);
+           store_data_byte(destoffset, destval);
+           break;
+       }
+       break;
     case 3:
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        switch (rh) {
-        case 0:
-            TRACE_AND_STEP();
-            *destreg = inc_byte(*destreg);
-            break;
-        case 1:
-            TRACE_AND_STEP();
-            *destreg = dec_byte(*destreg);
-            break;
-        }
-        break;
+       destreg = DECODE_RM_BYTE_REGISTER(rl);
+       DECODE_PRINTF("\n");
+       switch (rh) {
+       case 0:
+           TRACE_AND_STEP();
+           *destreg = inc_byte(*destreg);
+           break;
+       case 1:
+           TRACE_AND_STEP();
+           *destreg = dec_byte(*destreg);
+           break;
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -11016,374 +11016,374 @@ void x86emuOp_opcFF_word_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
 #ifdef DEBUG
     if (DEBUG_DECODE()) {
-        /* XXX DECODE_PRINTF may be changed to something more
-           general, so that it is important to leave the strings
-           in the same format, even though the result is that the
-           above test is done twice. */
-
-        switch (rh) {
-        case 0:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                DECODE_PRINTF("INC\tDWORD PTR ");
-            } else {
-                DECODE_PRINTF("INC\tWORD PTR ");
-            }
-            break;
-        case 1:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                DECODE_PRINTF("DEC\tDWORD PTR ");
-            } else {
-                DECODE_PRINTF("DEC\tWORD PTR ");
-            }
-            break;
-        case 2:
-            DECODE_PRINTF("CALL\t ");
-            break;
-        case 3:
-            DECODE_PRINTF("CALL\tFAR ");
-            break;
-        case 4:
-            DECODE_PRINTF("JMP\t");
-            break;
-        case 5:
-            DECODE_PRINTF("JMP\tFAR ");
-            break;
-        case 6:
-            DECODE_PRINTF("PUSH\t");
-            break;
-        case 7:
-            DECODE_PRINTF("ILLEGAL DECODING OF OPCODE FF\t");
-            HALT_SYS();
-            break;
-        }
+       /* XXX DECODE_PRINTF may be changed to something more
+          general, so that it is important to leave the strings
+          in the same format, even though the result is that the
+          above test is done twice. */
+
+       switch (rh) {
+       case 0:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               DECODE_PRINTF("INC\tDWORD PTR ");
+           } else {
+               DECODE_PRINTF("INC\tWORD PTR ");
+           }
+           break;
+       case 1:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               DECODE_PRINTF("DEC\tDWORD PTR ");
+           } else {
+               DECODE_PRINTF("DEC\tWORD PTR ");
+           }
+           break;
+       case 2:
+           DECODE_PRINTF("CALL\t ");
+           break;
+       case 3:
+           DECODE_PRINTF("CALL\tFAR ");
+           break;
+       case 4:
+           DECODE_PRINTF("JMP\t");
+           break;
+       case 5:
+           DECODE_PRINTF("JMP\tFAR ");
+           break;
+       case 6:
+           DECODE_PRINTF("PUSH\t");
+           break;
+       case 7:
+           DECODE_PRINTF("ILLEGAL DECODING OF OPCODE FF\t");
+           HALT_SYS();
+           break;
+       }
     }
 #endif
     switch (mod) {
     case 0:
-        destoffset = decode_rm00_address(rl);
-        DECODE_PRINTF("\n");
-        switch (rh) {
-        case 0:         /* inc word ptr ... */
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                destval = inc_long(destval);
-                store_data_long(destoffset, destval);
-            } else {
-                u16 destval;
-
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                destval = inc_word(destval);
-                store_data_word(destoffset, destval);
-            }
-            break;
-        case 1:         /* dec word ptr ... */
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                destval = dec_long(destval);
-                store_data_long(destoffset, destval);
-            } else {
-                u16 destval;
-
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                destval = dec_word(destval);
-                store_data_word(destoffset, destval);
-            }
-            break;
-        case 2:         /* call word ptr ... */
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            push_word(M.x86.R_IP);
-            M.x86.R_IP = destval;
-            break;
-        case 3:         /* call far ptr ... */
-            destval = fetch_data_word(destoffset);
-            destval2 = fetch_data_word(destoffset + 2);
-            TRACE_AND_STEP();
-            push_word(M.x86.R_CS);
-            M.x86.R_CS = destval2;
-            push_word(M.x86.R_IP);
-            M.x86.R_IP = destval;
-            break;
-        case 4:         /* jmp word ptr ... */
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            M.x86.R_IP = destval;
-            break;
-        case 5:         /* jmp far ptr ... */
-            destval = fetch_data_word(destoffset);
-            destval2 = fetch_data_word(destoffset + 2);
-            TRACE_AND_STEP();
-            M.x86.R_IP = destval;
-            M.x86.R_CS = destval2;
-            break;
-        case 6:         /*  push word ptr ... */
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                push_long(destval);
-            } else {
-                u16 destval;
-
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                push_word(destval);
-            }
-            break;
-        }
-        break;
+       destoffset = decode_rm00_address(rl);
+       DECODE_PRINTF("\n");
+       switch (rh) {
+       case 0:         /* inc word ptr ... */
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               destval = inc_long(destval);
+               store_data_long(destoffset, destval);
+           } else {
+               u16 destval;
+
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               destval = inc_word(destval);
+               store_data_word(destoffset, destval);
+           }
+           break;
+       case 1:         /* dec word ptr ... */
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               destval = dec_long(destval);
+               store_data_long(destoffset, destval);
+           } else {
+               u16 destval;
+
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               destval = dec_word(destval);
+               store_data_word(destoffset, destval);
+           }
+           break;
+       case 2:         /* call word ptr ... */
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           push_word(M.x86.R_IP);
+           M.x86.R_IP = destval;
+           break;
+       case 3:         /* call far ptr ... */
+           destval = fetch_data_word(destoffset);
+           destval2 = fetch_data_word(destoffset + 2);
+           TRACE_AND_STEP();
+           push_word(M.x86.R_CS);
+           M.x86.R_CS = destval2;
+           push_word(M.x86.R_IP);
+           M.x86.R_IP = destval;
+           break;
+       case 4:         /* jmp word ptr ... */
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           M.x86.R_IP = destval;
+           break;
+       case 5:         /* jmp far ptr ... */
+           destval = fetch_data_word(destoffset);
+           destval2 = fetch_data_word(destoffset + 2);
+           TRACE_AND_STEP();
+           M.x86.R_IP = destval;
+           M.x86.R_CS = destval2;
+           break;
+       case 6:         /*  push word ptr ... */
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               push_long(destval);
+           } else {
+               u16 destval;
+
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               push_word(destval);
+           }
+           break;
+       }
+       break;
     case 1:
-        destoffset = decode_rm01_address(rl);
-        DECODE_PRINTF("\n");
-        switch (rh) {
-        case 0:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                destval = inc_long(destval);
-                store_data_long(destoffset, destval);
-            } else {
-                u16 destval;
-
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                destval = inc_word(destval);
-                store_data_word(destoffset, destval);
-            }
-            break;
-        case 1:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                destval = dec_long(destval);
-                store_data_long(destoffset, destval);
-            } else {
-                u16 destval;
-
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                destval = dec_word(destval);
-                store_data_word(destoffset, destval);
-            }
-            break;
-        case 2:         /* call word ptr ... */
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            push_word(M.x86.R_IP);
-            M.x86.R_IP = destval;
-            break;
-        case 3:         /* call far ptr ... */
-            destval = fetch_data_word(destoffset);
-            destval2 = fetch_data_word(destoffset + 2);
-            TRACE_AND_STEP();
-            push_word(M.x86.R_CS);
-            M.x86.R_CS = destval2;
-            push_word(M.x86.R_IP);
-            M.x86.R_IP = destval;
-            break;
-        case 4:         /* jmp word ptr ... */
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            M.x86.R_IP = destval;
-            break;
-        case 5:         /* jmp far ptr ... */
-            destval = fetch_data_word(destoffset);
-            destval2 = fetch_data_word(destoffset + 2);
-            TRACE_AND_STEP();
-            M.x86.R_IP = destval;
-            M.x86.R_CS = destval2;
-            break;
-        case 6:         /*  push word ptr ... */
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                push_long(destval);
-            } else {
-                u16 destval;
-
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                push_word(destval);
-            }
-            break;
-        }
-        break;
+       destoffset = decode_rm01_address(rl);
+       DECODE_PRINTF("\n");
+       switch (rh) {
+       case 0:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               destval = inc_long(destval);
+               store_data_long(destoffset, destval);
+           } else {
+               u16 destval;
+
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               destval = inc_word(destval);
+               store_data_word(destoffset, destval);
+           }
+           break;
+       case 1:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               destval = dec_long(destval);
+               store_data_long(destoffset, destval);
+           } else {
+               u16 destval;
+
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               destval = dec_word(destval);
+               store_data_word(destoffset, destval);
+           }
+           break;
+       case 2:         /* call word ptr ... */
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           push_word(M.x86.R_IP);
+           M.x86.R_IP = destval;
+           break;
+       case 3:         /* call far ptr ... */
+           destval = fetch_data_word(destoffset);
+           destval2 = fetch_data_word(destoffset + 2);
+           TRACE_AND_STEP();
+           push_word(M.x86.R_CS);
+           M.x86.R_CS = destval2;
+           push_word(M.x86.R_IP);
+           M.x86.R_IP = destval;
+           break;
+       case 4:         /* jmp word ptr ... */
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           M.x86.R_IP = destval;
+           break;
+       case 5:         /* jmp far ptr ... */
+           destval = fetch_data_word(destoffset);
+           destval2 = fetch_data_word(destoffset + 2);
+           TRACE_AND_STEP();
+           M.x86.R_IP = destval;
+           M.x86.R_CS = destval2;
+           break;
+       case 6:         /*  push word ptr ... */
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               push_long(destval);
+           } else {
+               u16 destval;
+
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               push_word(destval);
+           }
+           break;
+       }
+       break;
     case 2:
-        destoffset = decode_rm10_address(rl);
-        DECODE_PRINTF("\n");
-        switch (rh) {
-        case 0:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                destval = inc_long(destval);
-                store_data_long(destoffset, destval);
-            } else {
-                u16 destval;
-
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                destval = inc_word(destval);
-                store_data_word(destoffset, destval);
-            }
-            break;
-        case 1:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                destval = dec_long(destval);
-                store_data_long(destoffset, destval);
-            } else {
-                u16 destval;
-
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                destval = dec_word(destval);
-                store_data_word(destoffset, destval);
-            }
-            break;
-        case 2:         /* call word ptr ... */
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            push_word(M.x86.R_IP);
-            M.x86.R_IP = destval;
-            break;
-        case 3:         /* call far ptr ... */
-            destval = fetch_data_word(destoffset);
-            destval2 = fetch_data_word(destoffset + 2);
-            TRACE_AND_STEP();
-            push_word(M.x86.R_CS);
-            M.x86.R_CS = destval2;
-            push_word(M.x86.R_IP);
-            M.x86.R_IP = destval;
-            break;
-        case 4:         /* jmp word ptr ... */
-            destval = fetch_data_word(destoffset);
-            TRACE_AND_STEP();
-            M.x86.R_IP = destval;
-            break;
-        case 5:         /* jmp far ptr ... */
-            destval = fetch_data_word(destoffset);
-            destval2 = fetch_data_word(destoffset + 2);
-            TRACE_AND_STEP();
-            M.x86.R_IP = destval;
-            M.x86.R_CS = destval2;
-            break;
-        case 6:         /*  push word ptr ... */
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 destval;
-
-                destval = fetch_data_long(destoffset);
-                TRACE_AND_STEP();
-                push_long(destval);
-            } else {
-                u16 destval;
-
-                destval = fetch_data_word(destoffset);
-                TRACE_AND_STEP();
-                push_word(destval);
-            }
-            break;
-        }
-        break;
+       destoffset = decode_rm10_address(rl);
+       DECODE_PRINTF("\n");
+       switch (rh) {
+       case 0:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               destval = inc_long(destval);
+               store_data_long(destoffset, destval);
+           } else {
+               u16 destval;
+
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               destval = inc_word(destval);
+               store_data_word(destoffset, destval);
+           }
+           break;
+       case 1:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               destval = dec_long(destval);
+               store_data_long(destoffset, destval);
+           } else {
+               u16 destval;
+
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               destval = dec_word(destval);
+               store_data_word(destoffset, destval);
+           }
+           break;
+       case 2:         /* call word ptr ... */
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           push_word(M.x86.R_IP);
+           M.x86.R_IP = destval;
+           break;
+       case 3:         /* call far ptr ... */
+           destval = fetch_data_word(destoffset);
+           destval2 = fetch_data_word(destoffset + 2);
+           TRACE_AND_STEP();
+           push_word(M.x86.R_CS);
+           M.x86.R_CS = destval2;
+           push_word(M.x86.R_IP);
+           M.x86.R_IP = destval;
+           break;
+       case 4:         /* jmp word ptr ... */
+           destval = fetch_data_word(destoffset);
+           TRACE_AND_STEP();
+           M.x86.R_IP = destval;
+           break;
+       case 5:         /* jmp far ptr ... */
+           destval = fetch_data_word(destoffset);
+           destval2 = fetch_data_word(destoffset + 2);
+           TRACE_AND_STEP();
+           M.x86.R_IP = destval;
+           M.x86.R_CS = destval2;
+           break;
+       case 6:         /*  push word ptr ... */
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 destval;
+
+               destval = fetch_data_long(destoffset);
+               TRACE_AND_STEP();
+               push_long(destval);
+           } else {
+               u16 destval;
+
+               destval = fetch_data_word(destoffset);
+               TRACE_AND_STEP();
+               push_word(destval);
+           }
+           break;
+       }
+       break;
     case 3:
-        switch (rh) {
-        case 0:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 *destreg;
-
-                destreg = DECODE_RM_LONG_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                *destreg = inc_long(*destreg);
-            } else {
-                u16 *destreg;
-
-                destreg = DECODE_RM_WORD_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                *destreg = inc_word(*destreg);
-            }
-            break;
-        case 1:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 *destreg;
-
-                destreg = DECODE_RM_LONG_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                *destreg = dec_long(*destreg);
-            } else {
-                u16 *destreg;
-
-                destreg = DECODE_RM_WORD_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                *destreg = dec_word(*destreg);
-            }
-            break;
-        case 2:         /* call word ptr ... */
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            push_word(M.x86.R_IP);
-            M.x86.R_IP = *destreg;
-            break;
-        case 3:         /* jmp far ptr ... */
-            DECODE_PRINTF("OPERATION UNDEFINED 0XFF \n");
-            TRACE_AND_STEP();
-            HALT_SYS();
-            break;
-
-        case 4:         /* jmp  ... */
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            M.x86.R_IP = (u16) (*destreg);
-            break;
-        case 5:         /* jmp far ptr ... */
-            DECODE_PRINTF("OPERATION UNDEFINED 0XFF \n");
-            TRACE_AND_STEP();
-            HALT_SYS();
-            break;
-        case 6:
-            if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-                u32 *destreg;
-
-                destreg = DECODE_RM_LONG_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                push_long(*destreg);
-            } else {
-                u16 *destreg;
-
-                destreg = DECODE_RM_WORD_REGISTER(rl);
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                push_word(*destreg);
-            }
-            break;
-        }
-        break;
+       switch (rh) {
+       case 0:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 *destreg;
+
+               destreg = DECODE_RM_LONG_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               *destreg = inc_long(*destreg);
+           } else {
+               u16 *destreg;
+
+               destreg = DECODE_RM_WORD_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               *destreg = inc_word(*destreg);
+           }
+           break;
+       case 1:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 *destreg;
+
+               destreg = DECODE_RM_LONG_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               *destreg = dec_long(*destreg);
+           } else {
+               u16 *destreg;
+
+               destreg = DECODE_RM_WORD_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               *destreg = dec_word(*destreg);
+           }
+           break;
+       case 2:         /* call word ptr ... */
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           push_word(M.x86.R_IP);
+           M.x86.R_IP = *destreg;
+           break;
+       case 3:         /* jmp far ptr ... */
+           DECODE_PRINTF("OPERATION UNDEFINED 0XFF \n");
+           TRACE_AND_STEP();
+           HALT_SYS();
+           break;
+
+       case 4:         /* jmp  ... */
+           destreg = DECODE_RM_WORD_REGISTER(rl);
+           DECODE_PRINTF("\n");
+           TRACE_AND_STEP();
+           M.x86.R_IP = (u16) (*destreg);
+           break;
+       case 5:         /* jmp far ptr ... */
+           DECODE_PRINTF("OPERATION UNDEFINED 0XFF \n");
+           TRACE_AND_STEP();
+           HALT_SYS();
+           break;
+       case 6:
+           if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+               u32 *destreg;
+
+               destreg = DECODE_RM_LONG_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               push_long(*destreg);
+           } else {
+               u16 *destreg;
+
+               destreg = DECODE_RM_WORD_REGISTER(rl);
+               DECODE_PRINTF("\n");
+               TRACE_AND_STEP();
+               push_word(*destreg);
+           }
+           break;
+       }
+       break;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();