Coding style cleanup. Update CHANGELOG.

Signed-off-by: Wolfgang Denk <wd@denx.de>

4 files changed, 4371 insertions, 4376 deletions

diff --git a/drivers/bios_emulator/x86emu/decode.c b/drivers/bios_emulator/x86emu/decode.c
index b4dbb20..1e2dcfe 100644
--- a/drivers/bios_emulator/x86emu/decode.c
+++ b/drivers/bios_emulator/x86emu/decode.c
@@ -1,10 +1,10 @@
 /****************************************************************************
 *
-*                       Realmode X86 Emulator Library
+*			Realmode X86 Emulator Library
 *
-*               Copyright (C) 1991-2004 SciTech Software, Inc.
-*                    Copyright (C) David Mosberger-Tang
-*                      Copyright (C) 1999 Egbert Eich
+*		Copyright (C) 1991-2004 SciTech Software, Inc.
+*		     Copyright (C) David Mosberger-Tang
+*		       Copyright (C) 1999 Egbert Eich
 *
 *  ========================================================================
 *
@@ -14,7 +14,7 @@
 *  both that copyright notice and this permission notice appear in
 *  supporting documentation, and that the name of the authors not be used
 *  in advertising or publicity pertaining to distribution of the software
-*  without specific, written prior permission.  The authors makes no
+*  without specific, written prior permission.	The authors makes no
 *  representations about the suitability of this software for any purpose.
 *  It is provided "as is" without express or implied warranty.
 *
@@ -28,12 +28,12 @@
 *
 *  ========================================================================
 *
-* Language:     ANSI C
-* Environment:  Any
-* Developer:    Kendall Bennett
+* Language:	ANSI C
+* Environment:	Any
+* Developer:	Kendall Bennett
 *
-* Description:  This file includes subroutines which are related to
-*               instruction decoding and accessess of immediate data via IP.  etc.
+* Description:	This file includes subroutines which are related to
+*		instruction decoding and accessess of immediate data via IP.  etc.
 *
 ****************************************************************************/
 
@@ -47,22 +47,22 @@ Handles any pending asychronous interrupts.
 ****************************************************************************/
 static void x86emu_intr_handle(void)
 {
-    u8  intno;
+    u8	intno;
 
     if (M.x86.intr & INTR_SYNCH) {
-        intno = M.x86.intno;
-        if (_X86EMU_intrTab[intno]) {
-            (*_X86EMU_intrTab[intno])(intno);
-        } 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(intno * 4 + 2);
-            push_word(M.x86.R_IP);
-            M.x86.R_IP = mem_access_word(intno * 4);
-            M.x86.intr = 0;
-        }
+	intno = M.x86.intno;
+	if (_X86EMU_intrTab[intno]) {
+	    (*_X86EMU_intrTab[intno])(intno);
+	} 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(intno * 4 + 2);
+	    push_word(M.x86.R_IP);
+	    M.x86.R_IP = mem_access_word(intno * 4);
+	    M.x86.intr = 0;
+	}
     }
 }
 
@@ -95,34 +95,34 @@ void X86EMU_exec(void)
     DB(x86emu_end_instr();)
 
     for (;;) {
-DB(     if (CHECK_IP_FETCH())
-            x86emu_check_ip_access();)
-        /* If debugging, save the IP and CS values. */
-        SAVE_IP_CS(M.x86.R_CS, M.x86.R_IP);
-        INC_DECODED_INST_LEN(1);
-        if (M.x86.intr) {
-            if (M.x86.intr & INTR_HALTED) {
-DB(             if (M.x86.R_SP != 0) {
-                    printk("halted\n");
-                    X86EMU_trace_regs();
-                    }
-                else {
-                    if (M.x86.debug)
-                        printk("Service completed successfully\n");
-                    })
-                return;
-            }
-            if (((M.x86.intr & INTR_SYNCH) && (M.x86.intno == 0 || M.x86.intno == 2)) ||
-                !ACCESS_FLAG(F_IF)) {
-                x86emu_intr_handle();
-            }
-        }
-        op1 = (*sys_rdb)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP++));
-        (*x86emu_optab[op1])(op1);
-        if (M.x86.debug & DEBUG_EXIT) {
-            M.x86.debug &= ~DEBUG_EXIT;
-            return;
-        }
+DB(	if (CHECK_IP_FETCH())
+	    x86emu_check_ip_access();)
+	/* If debugging, save the IP and CS values. */
+	SAVE_IP_CS(M.x86.R_CS, M.x86.R_IP);
+	INC_DECODED_INST_LEN(1);
+	if (M.x86.intr) {
+	    if (M.x86.intr & INTR_HALTED) {
+DB(		if (M.x86.R_SP != 0) {
+		    printk("halted\n");
+		    X86EMU_trace_regs();
+		    }
+		else {
+		    if (M.x86.debug)
+			printk("Service completed successfully\n");
+		    })
+		return;
+	    }
+	    if (((M.x86.intr & INTR_SYNCH) && (M.x86.intno == 0 || M.x86.intno == 2)) ||
+		!ACCESS_FLAG(F_IF)) {
+		x86emu_intr_handle();
+	    }
+	}
+	op1 = (*sys_rdb)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP++));
+	(*x86emu_optab[op1])(op1);
+	if (M.x86.debug & DEBUG_EXIT) {
+	    M.x86.debug &= ~DEBUG_EXIT;
+	    return;
+	}
     }
 }
 
@@ -137,9 +137,9 @@ void X86EMU_halt_sys(void)
 
 /****************************************************************************
 PARAMETERS:
-mod     - Mod value from decoded byte
-regh    - Reg h value from decoded byte
-regl    - Reg l value from decoded byte
+mod	- Mod value from decoded byte
+regh	- Reg h value from decoded byte
+regl	- Reg l value from decoded byte
 
 REMARKS:
 Raise the specified interrupt to be handled before the execution of the
@@ -155,7 +155,7 @@ void fetch_decode_modrm(
     int fetched;
 
 DB( if (CHECK_IP_FETCH())
-        x86emu_check_ip_access();)
+	x86emu_check_ip_access();)
     fetched = (*sys_rdb)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP++));
     INC_DECODED_INST_LEN(1);
     *mod  = (fetched >> 6) & 0x03;
@@ -178,7 +178,7 @@ u8 fetch_byte_imm(void)
     u8 fetched;
 
 DB( if (CHECK_IP_FETCH())
-        x86emu_check_ip_access();)
+	x86emu_check_ip_access();)
     fetched = (*sys_rdb)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP++));
     INC_DECODED_INST_LEN(1);
     return fetched;
@@ -199,7 +199,7 @@ u16 fetch_word_imm(void)
     u16 fetched;
 
 DB( if (CHECK_IP_FETCH())
-        x86emu_check_ip_access();)
+	x86emu_check_ip_access();)
     fetched = (*sys_rdw)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP));
     M.x86.R_IP += 2;
     INC_DECODED_INST_LEN(2);
@@ -221,7 +221,7 @@ u32 fetch_long_imm(void)
     u32 fetched;
 
 DB( if (CHECK_IP_FETCH())
-        x86emu_check_ip_access();)
+	x86emu_check_ip_access();)
     fetched = (*sys_rdl)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP));
     M.x86.R_IP += 4;
     INC_DECODED_INST_LEN(4);
@@ -261,39 +261,39 @@ _INLINE u32 get_data_segment(void)
 {
 #define GET_SEGMENT(segment)
     switch (M.x86.mode & SYSMODE_SEGMASK) {
-      case 0:                   /* default case: use ds register */
+      case 0:			/* default case: use ds register */
       case SYSMODE_SEGOVR_DS:
       case SYSMODE_SEGOVR_DS | SYSMODE_SEG_DS_SS:
-        return  M.x86.R_DS;
-      case SYSMODE_SEG_DS_SS:   /* non-overridden, use ss register */
-        return  M.x86.R_SS;
+	return	M.x86.R_DS;
+      case SYSMODE_SEG_DS_SS:	/* non-overridden, use ss register */
+	return	M.x86.R_SS;
       case SYSMODE_SEGOVR_CS:
       case SYSMODE_SEGOVR_CS | SYSMODE_SEG_DS_SS:
-        return  M.x86.R_CS;
+	return	M.x86.R_CS;
       case SYSMODE_SEGOVR_ES:
       case SYSMODE_SEGOVR_ES | SYSMODE_SEG_DS_SS:
-        return  M.x86.R_ES;
+	return	M.x86.R_ES;
       case SYSMODE_SEGOVR_FS:
       case SYSMODE_SEGOVR_FS | SYSMODE_SEG_DS_SS:
-        return  M.x86.R_FS;
+	return	M.x86.R_FS;
       case SYSMODE_SEGOVR_GS:
       case SYSMODE_SEGOVR_GS | SYSMODE_SEG_DS_SS:
-        return  M.x86.R_GS;
+	return	M.x86.R_GS;
       case SYSMODE_SEGOVR_SS:
       case SYSMODE_SEGOVR_SS | SYSMODE_SEG_DS_SS:
-        return  M.x86.R_SS;
+	return	M.x86.R_SS;
       default:
-#ifdef  DEBUG
-        printk("error: should not happen:  multiple overrides.\n");
+#ifdef	DEBUG
+	printk("error: should not happen:  multiple overrides.\n");
 #endif
-        HALT_SYS();
-        return 0;
+	HALT_SYS();
+	return 0;
     }
 }
 
 /****************************************************************************
 PARAMETERS:
-offset  - Offset to load data from
+offset	- Offset to load data from
 
 RETURNS:
 Byte value read from the absolute memory location.
@@ -305,14 +305,14 @@ u8 fetch_data_byte(
 {
 #ifdef DEBUG
     if (CHECK_DATA_ACCESS())
-        x86emu_check_data_access((u16)get_data_segment(), offset);
+	x86emu_check_data_access((u16)get_data_segment(), offset);
 #endif
     return (*sys_rdb)((get_data_segment() << 4) + offset);
 }
 
 /****************************************************************************
 PARAMETERS:
-offset  - Offset to load data from
+offset	- Offset to load data from
 
 RETURNS:
 Word value read from the absolute memory location.
@@ -324,14 +324,14 @@ u16 fetch_data_word(
 {
 #ifdef DEBUG
     if (CHECK_DATA_ACCESS())
-        x86emu_check_data_access((u16)get_data_segment(), offset);
+	x86emu_check_data_access((u16)get_data_segment(), offset);
 #endif
     return (*sys_rdw)((get_data_segment() << 4) + offset);
 }
 
 /****************************************************************************
 PARAMETERS:
-offset  - Offset to load data from
+offset	- Offset to load data from
 
 RETURNS:
 Long value read from the absolute memory location.
@@ -343,7 +343,7 @@ u32 fetch_data_long(
 {
 #ifdef DEBUG
     if (CHECK_DATA_ACCESS())
-        x86emu_check_data_access((u16)get_data_segment(), offset);
+	x86emu_check_data_access((u16)get_data_segment(), offset);
 #endif
     return (*sys_rdl)((get_data_segment() << 4) + offset);
 }
@@ -351,7 +351,7 @@ u32 fetch_data_long(
 /****************************************************************************
 PARAMETERS:
 segment - Segment to load data from
-offset  - Offset to load data from
+offset	- Offset to load data from
 
 RETURNS:
 Byte value read from the absolute memory location.
@@ -364,7 +364,7 @@ u8 fetch_data_byte_abs(
 {
 #ifdef DEBUG
     if (CHECK_DATA_ACCESS())
-        x86emu_check_data_access(segment, offset);
+	x86emu_check_data_access(segment, offset);
 #endif
     return (*sys_rdb)(((u32)segment << 4) + offset);
 }
@@ -372,7 +372,7 @@ u8 fetch_data_byte_abs(
 /****************************************************************************
 PARAMETERS:
 segment - Segment to load data from
-offset  - Offset to load data from
+offset	- Offset to load data from
 
 RETURNS:
 Word value read from the absolute memory location.
@@ -385,7 +385,7 @@ u16 fetch_data_word_abs(
 {
 #ifdef DEBUG
     if (CHECK_DATA_ACCESS())
-        x86emu_check_data_access(segment, offset);
+	x86emu_check_data_access(segment, offset);
 #endif
     return (*sys_rdw)(((u32)segment << 4) + offset);
 }
@@ -393,7 +393,7 @@ u16 fetch_data_word_abs(
 /****************************************************************************
 PARAMETERS:
 segment - Segment to load data from
-offset  - Offset to load data from
+offset	- Offset to load data from
 
 RETURNS:
 Long value read from the absolute memory location.
@@ -406,15 +406,15 @@ u32 fetch_data_long_abs(
 {
 #ifdef DEBUG
     if (CHECK_DATA_ACCESS())
-        x86emu_check_data_access(segment, offset);
+	x86emu_check_data_access(segment, offset);
 #endif
     return (*sys_rdl)(((u32)segment << 4) + offset);
 }
 
 /****************************************************************************
 PARAMETERS:
-offset  - Offset to store data at
-val     - Value to store
+offset	- Offset to store data at
+val	- Value to store
 
 REMARKS:
 Writes a word value to an segmented memory location. The segment used is
@@ -428,15 +428,15 @@ void store_data_byte(
 {
 #ifdef DEBUG
     if (CHECK_DATA_ACCESS())
-        x86emu_check_data_access((u16)get_data_segment(), offset);
+	x86emu_check_data_access((u16)get_data_segment(), offset);
 #endif
     (*sys_wrb)((get_data_segment() << 4) + offset, val);
 }
 
 /****************************************************************************
 PARAMETERS:
-offset  - Offset to store data at
-val     - Value to store
+offset	- Offset to store data at
+val	- Value to store
 
 REMARKS:
 Writes a word value to an segmented memory location. The segment used is
@@ -450,15 +450,15 @@ void store_data_word(
 {
 #ifdef DEBUG
     if (CHECK_DATA_ACCESS())
-        x86emu_check_data_access((u16)get_data_segment(), offset);
+	x86emu_check_data_access((u16)get_data_segment(), offset);
 #endif
     (*sys_wrw)((get_data_segment() << 4) + offset, val);
 }
 
 /****************************************************************************
 PARAMETERS:
-offset  - Offset to store data at
-val     - Value to store
+offset	- Offset to store data at
+val	- Value to store
 
 REMARKS:
 Writes a long value to an segmented memory location. The segment used is
@@ -472,7 +472,7 @@ void store_data_long(
 {
 #ifdef DEBUG
     if (CHECK_DATA_ACCESS())
-        x86emu_check_data_access((u16)get_data_segment(), offset);
+	x86emu_check_data_access((u16)get_data_segment(), offset);
 #endif
     (*sys_wrl)((get_data_segment() << 4) + offset, val);
 }
@@ -480,8 +480,8 @@ void store_data_long(
 /****************************************************************************
 PARAMETERS:
 segment - Segment to store data at
-offset  - Offset to store data at
-val     - Value to store
+offset	- Offset to store data at
+val	- Value to store
 
 REMARKS:
 Writes a byte value to an absolute memory location.
@@ -495,7 +495,7 @@ void store_data_byte_abs(
 {
 #ifdef DEBUG
     if (CHECK_DATA_ACCESS())
-        x86emu_check_data_access(segment, offset);
+	x86emu_check_data_access(segment, offset);
 #endif
     (*sys_wrb)(((u32)segment << 4) + offset, val);
 }
@@ -503,8 +503,8 @@ void store_data_byte_abs(
 /****************************************************************************
 PARAMETERS:
 segment - Segment to store data at
-offset  - Offset to store data at
-val     - Value to store
+offset	- Offset to store data at
+val	- Value to store
 
 REMARKS:
 Writes a word value to an absolute memory location.
@@ -518,7 +518,7 @@ void store_data_word_abs(
 {
 #ifdef DEBUG
     if (CHECK_DATA_ACCESS())
-        x86emu_check_data_access(segment, offset);
+	x86emu_check_data_access(segment, offset);
 #endif
     (*sys_wrw)(((u32)segment << 4) + offset, val);
 }
@@ -526,8 +526,8 @@ void store_data_word_abs(
 /****************************************************************************
 PARAMETERS:
 segment - Segment to store data at
-offset  - Offset to store data at
-val     - Value to store
+offset	- Offset to store data at
+val	- Value to store
 
 REMARKS:
 Writes a long value to an absolute memory location.
@@ -541,7 +541,7 @@ void store_data_long_abs(
 {
 #ifdef DEBUG
     if (CHECK_DATA_ACCESS())
-        x86emu_check_data_access(segment, offset);
+	x86emu_check_data_access(segment, offset);
 #endif
     (*sys_wrl)(((u32)segment << 4) + offset, val);
 }
@@ -562,32 +562,32 @@ u8* decode_rm_byte_register(
 {
     switch (reg) {
       case 0:
-        DECODE_PRINTF("AL");
-        return &M.x86.R_AL;
+	DECODE_PRINTF("AL");
+	return &M.x86.R_AL;
       case 1:
-        DECODE_PRINTF("CL");
-        return &M.x86.R_CL;
+	DECODE_PRINTF("CL");
+	return &M.x86.R_CL;
       case 2:
-        DECODE_PRINTF("DL");
-        return &M.x86.R_DL;
+	DECODE_PRINTF("DL");
+	return &M.x86.R_DL;
       case 3:
-        DECODE_PRINTF("BL");
-        return &M.x86.R_BL;
+	DECODE_PRINTF("BL");
+	return &M.x86.R_BL;
       case 4:
-        DECODE_PRINTF("AH");
-        return &M.x86.R_AH;
+	DECODE_PRINTF("AH");
+	return &M.x86.R_AH;
       case 5:
-        DECODE_PRINTF("CH");
-        return &M.x86.R_CH;
+	DECODE_PRINTF("CH");
+	return &M.x86.R_CH;
       case 6:
-        DECODE_PRINTF("DH");
-        return &M.x86.R_DH;
+	DECODE_PRINTF("DH");
+	return &M.x86.R_DH;
       case 7:
-        DECODE_PRINTF("BH");
-        return &M.x86.R_BH;
+	DECODE_PRINTF("BH");
+	return &M.x86.R_BH;
     }
     HALT_SYS();
-    return NULL;                /* NOT REACHED OR REACHED ON ERROR */
+    return NULL;		/* NOT REACHED OR REACHED ON ERROR */
 }
 
 /****************************************************************************
@@ -599,39 +599,39 @@ Pointer to the appropriate register
 
 REMARKS:
 Return a pointer to the register given by the R/RM field of the
-modrm byte, for word operands.  Also enables the decoding of instructions.
+modrm byte, for word operands.	Also enables the decoding of instructions.
 ****************************************************************************/
 u16* decode_rm_word_register(
     int reg)
 {
     switch (reg) {
       case 0:
-        DECODE_PRINTF("AX");
-        return &M.x86.R_AX;
+	DECODE_PRINTF("AX");
+	return &M.x86.R_AX;
       case 1:
-        DECODE_PRINTF("CX");
-        return &M.x86.R_CX;
+	DECODE_PRINTF("CX");
+	return &M.x86.R_CX;
       case 2:
-        DECODE_PRINTF("DX");
-        return &M.x86.R_DX;
+	DECODE_PRINTF("DX");
+	return &M.x86.R_DX;
       case 3:
-        DECODE_PRINTF("BX");
-        return &M.x86.R_BX;
+	DECODE_PRINTF("BX");
+	return &M.x86.R_BX;
       case 4:
-        DECODE_PRINTF("SP");
-        return &M.x86.R_SP;
+	DECODE_PRINTF("SP");
+	return &M.x86.R_SP;
       case 5:
-        DECODE_PRINTF("BP");
-        return &M.x86.R_BP;
+	DECODE_PRINTF("BP");
+	return &M.x86.R_BP;
       case 6:
-        DECODE_PRINTF("SI");
-        return &M.x86.R_SI;
+	DECODE_PRINTF("SI");
+	return &M.x86.R_SI;
       case 7:
-        DECODE_PRINTF("DI");
-        return &M.x86.R_DI;
+	DECODE_PRINTF("DI");
+	return &M.x86.R_DI;
     }
     HALT_SYS();
-    return NULL;                /* NOTREACHED OR REACHED ON ERROR */
+    return NULL;		/* NOTREACHED OR REACHED ON ERROR */
 }
 
 /****************************************************************************
@@ -643,39 +643,39 @@ Pointer to the appropriate register
 
 REMARKS:
 Return a pointer to the register given by the R/RM field of the
-modrm byte, for dword operands.  Also enables the decoding of instructions.
+modrm byte, for dword operands.	 Also enables the decoding of instructions.
 ****************************************************************************/
 u32* decode_rm_long_register(
     int reg)
 {
     switch (reg) {
       case 0:
-        DECODE_PRINTF("EAX");
-        return &M.x86.R_EAX;
+	DECODE_PRINTF("EAX");
+	return &M.x86.R_EAX;
       case 1:
-        DECODE_PRINTF("ECX");
-        return &M.x86.R_ECX;
+	DECODE_PRINTF("ECX");
+	return &M.x86.R_ECX;
       case 2:
-        DECODE_PRINTF("EDX");
-        return &M.x86.R_EDX;
+	DECODE_PRINTF("EDX");
+	return &M.x86.R_EDX;
       case 3:
-        DECODE_PRINTF("EBX");
-        return &M.x86.R_EBX;
+	DECODE_PRINTF("EBX");
+	return &M.x86.R_EBX;
       case 4:
-        DECODE_PRINTF("ESP");
-        return &M.x86.R_ESP;
+	DECODE_PRINTF("ESP");
+	return &M.x86.R_ESP;
       case 5:
-        DECODE_PRINTF("EBP");
-        return &M.x86.R_EBP;
+	DECODE_PRINTF("EBP");
+	return &M.x86.R_EBP;
       case 6:
-        DECODE_PRINTF("ESI");
-        return &M.x86.R_ESI;
+	DECODE_PRINTF("ESI");
+	return &M.x86.R_ESI;
       case 7:
-        DECODE_PRINTF("EDI");
-        return &M.x86.R_EDI;
+	DECODE_PRINTF("EDI");
+	return &M.x86.R_EDI;
     }
     HALT_SYS();
-    return NULL;                /* NOTREACHED OR REACHED ON ERROR */
+    return NULL;		/* NOTREACHED OR REACHED ON ERROR */
 }
 
 /****************************************************************************
@@ -695,30 +695,30 @@ u16* decode_rm_seg_register(
 {
     switch (reg) {
       case 0:
-        DECODE_PRINTF("ES");
-        return &M.x86.R_ES;
+	DECODE_PRINTF("ES");
+	return &M.x86.R_ES;
       case 1:
-        DECODE_PRINTF("CS");
-        return &M.x86.R_CS;
+	DECODE_PRINTF("CS");
+	return &M.x86.R_CS;
       case 2:
-        DECODE_PRINTF("SS");
-        return &M.x86.R_SS;
+	DECODE_PRINTF("SS");
+	return &M.x86.R_SS;
       case 3:
-        DECODE_PRINTF("DS");
-        return &M.x86.R_DS;
+	DECODE_PRINTF("DS");
+	return &M.x86.R_DS;
       case 4:
-        DECODE_PRINTF("FS");
-        return &M.x86.R_FS;
+	DECODE_PRINTF("FS");
+	return &M.x86.R_FS;
       case 5:
-        DECODE_PRINTF("GS");
-        return &M.x86.R_GS;
+	DECODE_PRINTF("GS");
+	return &M.x86.R_GS;
       case 6:
       case 7:
-        DECODE_PRINTF("ILLEGAL SEGREG");
-        break;
+	DECODE_PRINTF("ILLEGAL SEGREG");
+	break;
     }
     HALT_SYS();
-    return NULL;                /* NOT REACHED OR REACHED ON ERROR */
+    return NULL;		/* NOT REACHED OR REACHED ON ERROR */
 }
 
 /****************************************************************************
@@ -739,38 +739,38 @@ unsigned decode_sib_si(
 {
     scale = 1 << scale;
     if (scale > 1) {
-        DECODE_PRINTF2("[%d*", scale);
+	DECODE_PRINTF2("[%d*", scale);
     } else {
-        DECODE_PRINTF("[");
+	DECODE_PRINTF("[");
     }
     switch (index) {
       case 0:
-        DECODE_PRINTF("EAX]");
-        return M.x86.R_EAX * index;
+	DECODE_PRINTF("EAX]");
+	return M.x86.R_EAX * index;
       case 1:
-        DECODE_PRINTF("ECX]");
-        return M.x86.R_ECX * index;
+	DECODE_PRINTF("ECX]");
+	return M.x86.R_ECX * index;
       case 2:
-        DECODE_PRINTF("EDX]");
-        return M.x86.R_EDX * index;
+	DECODE_PRINTF("EDX]");
+	return M.x86.R_EDX * index;
       case 3:
-        DECODE_PRINTF("EBX]");
-        return M.x86.R_EBX * index;
+	DECODE_PRINTF("EBX]");
+	return M.x86.R_EBX * index;
       case 4:
-        DECODE_PRINTF("0]");
-        return 0;
+	DECODE_PRINTF("0]");
+	return 0;
       case 5:
-        DECODE_PRINTF("EBP]");
-        return M.x86.R_EBP * index;
+	DECODE_PRINTF("EBP]");
+	return M.x86.R_EBP * index;
       case 6:
-        DECODE_PRINTF("ESI]");
-        return M.x86.R_ESI * index;
+	DECODE_PRINTF("ESI]");
+	return M.x86.R_ESI * index;
       case 7:
-        DECODE_PRINTF("EDI]");
-        return M.x86.R_EDI * index;
+	DECODE_PRINTF("EDI]");
+	return M.x86.R_EDI * index;
     }
     HALT_SYS();
-    return 0;                   /* NOT REACHED OR REACHED ON ERROR */
+    return 0;			/* NOT REACHED OR REACHED ON ERROR */
 }
 
 /****************************************************************************
@@ -795,58 +795,58 @@ unsigned decode_sib_address(
 
     switch (base) {
       case 0:
-        DECODE_PRINTF("[EAX]");
-        offset = M.x86.R_EAX;
-        break;
+	DECODE_PRINTF("[EAX]");
+	offset = M.x86.R_EAX;
+	break;
       case 1:
-        DECODE_PRINTF("[ECX]");
-        offset = M.x86.R_ECX;
-        break;
+	DECODE_PRINTF("[ECX]");
+	offset = M.x86.R_ECX;
+	break;
       case 2:
-        DECODE_PRINTF("[EDX]");
-        offset = M.x86.R_EDX;
-        break;
+	DECODE_PRINTF("[EDX]");
+	offset = M.x86.R_EDX;
+	break;
       case 3:
-        DECODE_PRINTF("[EBX]");
-        offset = M.x86.R_EBX;
-        break;
+	DECODE_PRINTF("[EBX]");
+	offset = M.x86.R_EBX;
+	break;
       case 4:
-        DECODE_PRINTF("[ESP]");
-        offset = M.x86.R_ESP;
-        break;
+	DECODE_PRINTF("[ESP]");
+	offset = M.x86.R_ESP;
+	break;
       case 5:
-        switch (mod) {
-          case 0:
-            displacement = (s32)fetch_long_imm();
-            DECODE_PRINTF2("[%d]", displacement);
-            offset = displacement;
-            break;
-          case 1:
-            displacement = (s8)fetch_byte_imm();
-            DECODE_PRINTF2("[%d][EBP]", displacement);
-            offset = M.x86.R_EBP + displacement;
-            break;
-          case 2:
-            displacement = (s32)fetch_long_imm();
-            DECODE_PRINTF2("[%d][EBP]", displacement);
-            offset = M.x86.R_EBP + displacement;
-            break;
-          default:
-            HALT_SYS();
-        }
-        DECODE_PRINTF("[EAX]");
-        offset = M.x86.R_EAX;
-        break;
+	switch (mod) {
+	  case 0:
+	    displacement = (s32)fetch_long_imm();
+	    DECODE_PRINTF2("[%d]", displacement);
+	    offset = displacement;
+	    break;
+	  case 1:
+	    displacement = (s8)fetch_byte_imm();
+	    DECODE_PRINTF2("[%d][EBP]", displacement);
+	    offset = M.x86.R_EBP + displacement;
+	    break;
+	  case 2:
+	    displacement = (s32)fetch_long_imm();
+	    DECODE_PRINTF2("[%d][EBP]", displacement);
+	    offset = M.x86.R_EBP + displacement;
+	    break;
+	  default:
+	    HALT_SYS();
+	}
+	DECODE_PRINTF("[EAX]");
+	offset = M.x86.R_EAX;
+	break;
       case 6:
-        DECODE_PRINTF("[ESI]");
-        offset = M.x86.R_ESI;
-        break;
+	DECODE_PRINTF("[ESI]");
+	offset = M.x86.R_ESI;
+	break;
       case 7:
-        DECODE_PRINTF("[EDI]");
-        offset = M.x86.R_EDI;
-        break;
+	DECODE_PRINTF("[EDI]");
+	offset = M.x86.R_EDI;
+	break;
       default:
-        HALT_SYS();
+	HALT_SYS();
     }
     offset += decode_sib_si(ss, index);
     return offset;
@@ -864,14 +864,14 @@ REMARKS:
 Return the offset given by mod=00 addressing.  Also enables the
 decoding of instructions.
 
-NOTE:   The code which specifies the corresponding segment (ds vs ss)
-        below in the case of [BP+..].  The assumption here is that at the
-        point that this subroutine is called, the bit corresponding to
-        SYSMODE_SEG_DS_SS will be zero.  After every instruction
-        except the segment override instructions, this bit (as well
-        as any bits indicating segment overrides) will be clear.  So
-        if a SS access is needed, set this bit.  Otherwise, DS access
-        occurs (unless any of the segment override bits are set).
+NOTE:	The code which specifies the corresponding segment (ds vs ss)
+	below in the case of [BP+..].  The assumption here is that at the
+	point that this subroutine is called, the bit corresponding to
+	SYSMODE_SEG_DS_SS will be zero.	 After every instruction
+	except the segment override instructions, this bit (as well
+	as any bits indicating segment overrides) will be clear.  So
+	if a SS access is needed, set this bit.	 Otherwise, DS access
+	occurs (unless any of the segment override bits are set).
 ****************************************************************************/
 unsigned decode_rm00_address(
     int rm)
@@ -879,64 +879,64 @@ unsigned decode_rm00_address(
     unsigned offset;
 
     if (M.x86.mode & SYSMODE_PREFIX_ADDR) {
-        /* 32-bit addressing */
-        switch (rm) {
-          case 0:
-            DECODE_PRINTF("[EAX]");
-            return M.x86.R_EAX;
-          case 1:
-            DECODE_PRINTF("[ECX]");
-            return M.x86.R_ECX;
-          case 2:
-            DECODE_PRINTF("[EDX]");
-            return M.x86.R_EDX;
-          case 3:
-            DECODE_PRINTF("[EBX]");
-            return M.x86.R_EBX;
-          case 4:
-            return decode_sib_address(0);
-          case 5:
-            offset = fetch_long_imm();
-            DECODE_PRINTF2("[%08x]", offset);
-            return offset;
-          case 6:
-            DECODE_PRINTF("[ESI]");
-            return M.x86.R_ESI;
-          case 7:
-            DECODE_PRINTF("[EDI]");
-            return M.x86.R_EDI;
-        }
+	/* 32-bit addressing */
+	switch (rm) {
+	  case 0:
+	    DECODE_PRINTF("[EAX]");
+	    return M.x86.R_EAX;
+	  case 1:
+	    DECODE_PRINTF("[ECX]");
+	    return M.x86.R_ECX;
+	  case 2:
+	    DECODE_PRINTF("[EDX]");
+	    return M.x86.R_EDX;
+	  case 3:
+	    DECODE_PRINTF("[EBX]");
+	    return M.x86.R_EBX;
+	  case 4:
+	    return decode_sib_address(0);
+	  case 5:
+	    offset = fetch_long_imm();
+	    DECODE_PRINTF2("[%08x]", offset);
+	    return offset;
+	  case 6:
+	    DECODE_PRINTF("[ESI]");
+	    return M.x86.R_ESI;
+	  case 7:
+	    DECODE_PRINTF("[EDI]");
+	    return M.x86.R_EDI;
+	}
     } else {
-        /* 16-bit addressing */
-        switch (rm) {
-          case 0:
-            DECODE_PRINTF("[BX+SI]");
-            return (M.x86.R_BX + M.x86.R_SI) & 0xffff;
-          case 1:
-            DECODE_PRINTF("[BX+DI]");
-            return (M.x86.R_BX + M.x86.R_DI) & 0xffff;
-          case 2:
-            DECODE_PRINTF("[BP+SI]");
-            M.x86.mode |= SYSMODE_SEG_DS_SS;
-            return (M.x86.R_BP + M.x86.R_SI) & 0xffff;
-          case 3:
-            DECODE_PRINTF("[BP+DI]");
-            M.x86.mode |= SYSMODE_SEG_DS_SS;
-            return (M.x86.R_BP + M.x86.R_DI) & 0xffff;
-          case 4:
-            DECODE_PRINTF("[SI]");
-            return M.x86.R_SI;
-          case 5:
-            DECODE_PRINTF("[DI]");
-            return M.x86.R_DI;
-          case 6:
-            offset = fetch_word_imm();
-            DECODE_PRINTF2("[%04x]", offset);
-            return offset;
-          case 7:
-            DECODE_PRINTF("[BX]");
-            return M.x86.R_BX;
-        }
+	/* 16-bit addressing */
+	switch (rm) {
+	  case 0:
+	    DECODE_PRINTF("[BX+SI]");
+	    return (M.x86.R_BX + M.x86.R_SI) & 0xffff;
+	  case 1:
+	    DECODE_PRINTF("[BX+DI]");
+	    return (M.x86.R_BX + M.x86.R_DI) & 0xffff;
+	  case 2:
+	    DECODE_PRINTF("[BP+SI]");
+	    M.x86.mode |= SYSMODE_SEG_DS_SS;
+	    return (M.x86.R_BP + M.x86.R_SI) & 0xffff;
+	  case 3:
+	    DECODE_PRINTF("[BP+DI]");
+	    M.x86.mode |= SYSMODE_SEG_DS_SS;
+	    return (M.x86.R_BP + M.x86.R_DI) & 0xffff;
+	  case 4:
+	    DECODE_PRINTF("[SI]");
+	    return M.x86.R_SI;
+	  case 5:
+	    DECODE_PRINTF("[DI]");
+	    return M.x86.R_DI;
+	  case 6:
+	    offset = fetch_word_imm();
+	    DECODE_PRINTF2("[%04x]", offset);
+	    return offset;
+	  case 7:
+	    DECODE_PRINTF("[BX]");
+	    return M.x86.R_BX;
+	}
     }
     HALT_SYS();
     return 0;
@@ -959,76 +959,76 @@ unsigned decode_rm01_address(
     int displacement;
 
     if (M.x86.mode & SYSMODE_PREFIX_ADDR) {
-        /* 32-bit addressing */
-        if (rm != 4)
-            displacement = (s8)fetch_byte_imm();
-        else
-            displacement = 0;
-
-        switch (rm) {
-          case 0:
-            DECODE_PRINTF2("%d[EAX]", displacement);
-            return M.x86.R_EAX + displacement;
-          case 1:
-            DECODE_PRINTF2("%d[ECX]", displacement);
-            return M.x86.R_ECX + displacement;
-          case 2:
-            DECODE_PRINTF2("%d[EDX]", displacement);
-            return M.x86.R_EDX + displacement;
-          case 3:
-            DECODE_PRINTF2("%d[EBX]", displacement);
-            return M.x86.R_EBX + displacement;
-          case 4: {
-            int offset = decode_sib_address(1);
-            displacement = (s8)fetch_byte_imm();
-            DECODE_PRINTF2("[%d]", displacement);
-            return offset + displacement;
-          }
-          case 5:
-            DECODE_PRINTF2("%d[EBP]", displacement);
-            return M.x86.R_EBP + displacement;
-          case 6:
-            DECODE_PRINTF2("%d[ESI]", displacement);
-            return M.x86.R_ESI + displacement;
-          case 7:
-            DECODE_PRINTF2("%d[EDI]", displacement);
-            return M.x86.R_EDI + displacement;
-        }
+	/* 32-bit addressing */
+	if (rm != 4)
+	    displacement = (s8)fetch_byte_imm();
+	else
+	    displacement = 0;
+
+	switch (rm) {
+	  case 0:
+	    DECODE_PRINTF2("%d[EAX]", displacement);
+	    return M.x86.R_EAX + displacement;
+	  case 1:
+	    DECODE_PRINTF2("%d[ECX]", displacement);
+	    return M.x86.R_ECX + displacement;
+	  case 2:
+	    DECODE_PRINTF2("%d[EDX]", displacement);
+	    return M.x86.R_EDX + displacement;
+	  case 3:
+	    DECODE_PRINTF2("%d[EBX]", displacement);
+	    return M.x86.R_EBX + displacement;
+	  case 4: {
+	    int offset = decode_sib_address(1);
+	    displacement = (s8)fetch_byte_imm();
+	    DECODE_PRINTF2("[%d]", displacement);
+	    return offset + displacement;
+	  }
+	  case 5:
+	    DECODE_PRINTF2("%d[EBP]", displacement);
+	    return M.x86.R_EBP + displacement;
+	  case 6:
+	    DECODE_PRINTF2("%d[ESI]", displacement);
+	    return M.x86.R_ESI + displacement;
+	  case 7:
+	    DECODE_PRINTF2("%d[EDI]", displacement);
+	    return M.x86.R_EDI + displacement;
+	}
     } else {
-        /* 16-bit addressing */
-        displacement = (s8)fetch_byte_imm();
-        switch (rm) {
-          case 0:
-            DECODE_PRINTF2("%d[BX+SI]", displacement);
-            return (M.x86.R_BX + M.x86.R_SI + displacement) & 0xffff;
-          case 1:
-            DECODE_PRINTF2("%d[BX+DI]", displacement);
-            return (M.x86.R_BX + M.x86.R_DI + displacement) & 0xffff;
-          case 2:
-            DECODE_PRINTF2("%d[BP+SI]", displacement);
-            M.x86.mode |= SYSMODE_SEG_DS_SS;
-            return (M.x86.R_BP + M.x86.R_SI + displacement) & 0xffff;
-          case 3:
-            DECODE_PRINTF2("%d[BP+DI]", displacement);
-            M.x86.mode |= SYSMODE_SEG_DS_SS;
-            return (M.x86.R_BP + M.x86.R_DI + displacement) & 0xffff;
-          case 4:
-            DECODE_PRINTF2("%d[SI]", displacement);
-            return (M.x86.R_SI + displacement) & 0xffff;
-          case 5:
-            DECODE_PRINTF2("%d[DI]", displacement);
-            return (M.x86.R_DI + displacement) & 0xffff;
-          case 6:
-            DECODE_PRINTF2("%d[BP]", displacement);
-            M.x86.mode |= SYSMODE_SEG_DS_SS;
-            return (M.x86.R_BP + displacement) & 0xffff;
-          case 7:
-            DECODE_PRINTF2("%d[BX]", displacement);
-            return (M.x86.R_BX + displacement) & 0xffff;
-        }
+	/* 16-bit addressing */
+	displacement = (s8)fetch_byte_imm();
+	switch (rm) {
+	  case 0:
+	    DECODE_PRINTF2("%d[BX+SI]", displacement);
+	    return (M.x86.R_BX + M.x86.R_SI + displacement) & 0xffff;
+	  case 1:
+	    DECODE_PRINTF2("%d[BX+DI]", displacement);
+	    return (M.x86.R_BX + M.x86.R_DI + displacement) & 0xffff;
+	  case 2:
+	    DECODE_PRINTF2("%d[BP+SI]", displacement);
+	    M.x86.mode |= SYSMODE_SEG_DS_SS;
+	    return (M.x86.R_BP + M.x86.R_SI + displacement) & 0xffff;
+	  case 3:
+	    DECODE_PRINTF2("%d[BP+DI]", displacement);
+	    M.x86.mode |= SYSMODE_SEG_DS_SS;
+	    return (M.x86.R_BP + M.x86.R_DI + displacement) & 0xffff;
+	  case 4:
+	    DECODE_PRINTF2("%d[SI]", displacement);
+	    return (M.x86.R_SI + displacement) & 0xffff;
+	  case 5:
+	    DECODE_PRINTF2("%d[DI]", displacement);
+	    return (M.x86.R_DI + displacement) & 0xffff;
+	  case 6:
+	    DECODE_PRINTF2("%d[BP]", displacement);
+	    M.x86.mode |= SYSMODE_SEG_DS_SS;
+	    return (M.x86.R_BP + displacement) & 0xffff;
+	  case 7:
+	    DECODE_PRINTF2("%d[BX]", displacement);
+	    return (M.x86.R_BX + displacement) & 0xffff;
+	}
     }
     HALT_SYS();
-    return 0;                   /* SHOULD NOT HAPPEN */
+    return 0;			/* SHOULD NOT HAPPEN */
 }
 
 /****************************************************************************
@@ -1046,82 +1046,81 @@ unsigned decode_rm10_address(
     int rm)
 {
     if (M.x86.mode & SYSMODE_PREFIX_ADDR) {
-        int displacement;
-
-        /* 32-bit addressing */
-        if (rm != 4)
-            displacement = (s32)fetch_long_imm();
-        else
-            displacement = 0;
-
-        switch (rm) {
-          case 0:
-            DECODE_PRINTF2("%d[EAX]", displacement);
-            return M.x86.R_EAX + displacement;
-          case 1:
-            DECODE_PRINTF2("%d[ECX]", displacement);
-            return M.x86.R_ECX + displacement;
-          case 2:
-            DECODE_PRINTF2("%d[EDX]", displacement);
-            return M.x86.R_EDX + displacement;
-          case 3:
-            DECODE_PRINTF2("%d[EBX]", displacement);
-            return M.x86.R_EBX + displacement;
-          case 4: {
-            int offset = decode_sib_address(2);
-            displacement = (s32)fetch_long_imm();
-            DECODE_PRINTF2("[%d]", displacement);
-            return offset + displacement;
-          }
-          case 5:
-            DECODE_PRINTF2("%d[EBP]", displacement);
-            return M.x86.R_EBP + displacement;
-          case 6:
-            DECODE_PRINTF2("%d[ESI]", displacement);
-            return M.x86.R_ESI + displacement;
-          case 7:
-            DECODE_PRINTF2("%d[EDI]", displacement);
-            return M.x86.R_EDI + displacement;
-        }
+	int displacement;
+
+	/* 32-bit addressing */
+	if (rm != 4)
+	    displacement = (s32)fetch_long_imm();
+	else
+	    displacement = 0;
+
+	switch (rm) {
+	  case 0:
+	    DECODE_PRINTF2("%d[EAX]", displacement);
+	    return M.x86.R_EAX + displacement;
+	  case 1:
+	    DECODE_PRINTF2("%d[ECX]", displacement);
+	    return M.x86.R_ECX + displacement;
+	  case 2:
+	    DECODE_PRINTF2("%d[EDX]", displacement);
+	    return M.x86.R_EDX + displacement;
+	  case 3:
+	    DECODE_PRINTF2("%d[EBX]", displacement);
+	    return M.x86.R_EBX + displacement;
+	  case 4: {
+	    int offset = decode_sib_address(2);
+	    displacement = (s32)fetch_long_imm();
+	    DECODE_PRINTF2("[%d]", displacement);
+	    return offset + displacement;
+	  }
+	  case 5:
+	    DECODE_PRINTF2("%d[EBP]", displacement);
+	    return M.x86.R_EBP + displacement;
+	  case 6:
+	    DECODE_PRINTF2("%d[ESI]", displacement);
+	    return M.x86.R_ESI + displacement;
+	  case 7:
+	    DECODE_PRINTF2("%d[EDI]", displacement);
+	    return M.x86.R_EDI + displacement;
+	}
     } else {
-        int displacement = (s16)fetch_word_imm();
-
-        /* 16-bit addressing */
-        switch (rm) {
-          case 0:
-            DECODE_PRINTF2("%d[BX+SI]", displacement);
-            return (M.x86.R_BX + M.x86.R_SI + displacement) & 0xffff;
-          case 1:
-            DECODE_PRINTF2("%d[BX+DI]", displacement);
-            return (M.x86.R_BX + M.x86.R_DI + displacement) & 0xffff;
-          case 2:
-            DECODE_PRINTF2("%d[BP+SI]", displacement);
-            M.x86.mode |= SYSMODE_SEG_DS_SS;
-            return (M.x86.R_BP + M.x86.R_SI + displacement) & 0xffff;
-          case 3:
-            DECODE_PRINTF2("%d[BP+DI]", displacement);
-            M.x86.mode |= SYSMODE_SEG_DS_SS;
-            return (M.x86.R_BP + M.x86.R_DI + displacement) & 0xffff;
-          case 4:
-            DECODE_PRINTF2("%d[SI]", displacement);
-            return (M.x86.R_SI + displacement) & 0xffff;
-          case 5:
-            DECODE_PRINTF2("%d[DI]", displacement);
-            return (M.x86.R_DI + displacement) & 0xffff;
-          case 6:
-            DECODE_PRINTF2("%d[BP]", displacement);
-            M.x86.mode |= SYSMODE_SEG_DS_SS;
-            return (M.x86.R_BP + displacement) & 0xffff;
-          case 7:
-            DECODE_PRINTF2("%d[BX]", displacement);
-            return (M.x86.R_BX + displacement) & 0xffff;
-        }
+	int displacement = (s16)fetch_word_imm();
+
+	/* 16-bit addressing */
+	switch (rm) {
+	  case 0:
+	    DECODE_PRINTF2("%d[BX+SI]", displacement);
+	    return (M.x86.R_BX + M.x86.R_SI + displacement) & 0xffff;
+	  case 1:
+	    DECODE_PRINTF2("%d[BX+DI]", displacement);
+	    return (M.x86.R_BX + M.x86.R_DI + displacement) & 0xffff;
+	  case 2:
+	    DECODE_PRINTF2("%d[BP+SI]", displacement);
+	    M.x86.mode |= SYSMODE_SEG_DS_SS;
+	    return (M.x86.R_BP + M.x86.R_SI + displacement) & 0xffff;
+	  case 3:
+	    DECODE_PRINTF2("%d[BP+DI]", displacement);
+	    M.x86.mode |= SYSMODE_SEG_DS_SS;
+	    return (M.x86.R_BP + M.x86.R_DI + displacement) & 0xffff;
+	  case 4:
+	    DECODE_PRINTF2("%d[SI]", displacement);
+	    return (M.x86.R_SI + displacement) & 0xffff;
+	  case 5:
+	    DECODE_PRINTF2("%d[DI]", displacement);
+	    return (M.x86.R_DI + displacement) & 0xffff;
+	  case 6:
+	    DECODE_PRINTF2("%d[BP]", displacement);
+	    M.x86.mode |= SYSMODE_SEG_DS_SS;
+	    return (M.x86.R_BP + displacement) & 0xffff;
+	  case 7:
+	    DECODE_PRINTF2("%d[BX]", displacement);
+	    return (M.x86.R_BX + displacement) & 0xffff;
+	}
     }
     HALT_SYS();
-    return 0;                   /* SHOULD NOT HAPPEN */
+    return 0;			/* SHOULD NOT HAPPEN */
 }
 
-
 /****************************************************************************
 PARAMETERS:
 mod - modifier
@@ -1143,6 +1142,3 @@ unsigned decode_rmXX_address(int mod, int rm)
     return decode_rm01_address(rm);
   return decode_rm10_address(rm);
 }
-
-
-
diff --git a/drivers/bios_emulator/x86emu/ops.c b/drivers/bios_emulator/x86emu/ops.c
index 632979d..d1380ce 100644
--- a/drivers/bios_emulator/x86emu/ops.c
+++ b/drivers/bios_emulator/x86emu/ops.c
@@ -4,9 +4,9 @@
 *  Copyright (C) 2007 Freescale Semiconductor, Inc. All rights reserved.
 *  Jason Jin <Jason.jin@freescale.com>
 *
-*            	Copyright (C) 1991-2004 SciTech Software, Inc.
-* 				     Copyright (C) David Mosberger-Tang
-* 					   Copyright (C) 1999 Egbert Eich
+*		Copyright (C) 1991-2004 SciTech Software, Inc.
+*				     Copyright (C) David Mosberger-Tang
+*					   Copyright (C) 1999 Egbert Eich
 *
 *  ========================================================================
 *
@@ -16,7 +16,7 @@
 *  both that copyright notice and this permission notice appear in
 *  supporting documentation, and that the name of the authors not be used
 *  in advertising or publicity pertaining to distribution of the software
-*  without specific, written prior permission.  The authors makes no
+*  without specific, written prior permission.	The authors makes no
 *  representations about the suitability of this software for any purpose.
 *  It is provided "as is" without express or implied warranty.
 *
@@ -32,13 +32,13 @@
 *
 * Language:		ANSI C
 * Environment:	Any
-* Developer:    Kendall Bennett
+* Developer:	Kendall Bennett
 *
-* Description:  This file includes subroutines to implement the decoding
-*               and emulation of all the x86 processor instructions.
+* Description:	This file includes subroutines to implement the decoding
+*		and emulation of all the x86 processor instructions.
 *
 * There are approximately 250 subroutines in here, which correspond
-* to the 256 byte-"opcodes" found on the 8086.  The table which
+* to the 256 byte-"opcodes" found on the 8086.	The table which
 * dispatches this is found in the files optab.[ch].
 *
 * Each opcode proc has a comment preceeding it which gives it's table
@@ -48,14 +48,14 @@
 * DECODE_PRINTF2), debugging (TRACE_REGS, SINGLE_STEP), and misc
 * functions (START_OF_INSTR, END_OF_INSTR).
 *
-* Many of the procedures are *VERY* similar in coding.  This has
+* Many of the procedures are *VERY* similar in coding.	This has
 * allowed for a very large amount of code to be generated in a fairly
 * short amount of time (i.e. cut, paste, and modify).  The result is
 * that much of the code below could have been folded into subroutines
 * for a large reduction in size of this file.  The downside would be
 * that there would be a penalty in execution speed.  The file could
 * also have been *MUCH* larger by inlining certain functions which
-* were called.  This could have resulted even faster execution.  The
+* were called.	This could have resulted even faster execution.	 The
 * prime directive I used to decide whether to inline the code or to
 * modularize it, was basically: 1) no unnecessary subroutine calls,
 * 2) no routines more than about 200 lines in size, and 3) modularize
@@ -88,38 +88,38 @@ static char *x86emu_GenOpName[8] = {
 /* used by several opcodes  */
 static u8 (*genop_byte_operation[])(u8 d, u8 s) __attribute__ ((section(".got2"))) =
 {
-    add_byte,           /* 00 */
-    or_byte,            /* 01 */
-    adc_byte,           /* 02 */
-    sbb_byte,           /* 03 */
-    and_byte,           /* 04 */
-    sub_byte,           /* 05 */
-    xor_byte,           /* 06 */
-    cmp_byte,           /* 07 */
+    add_byte,		/* 00 */
+    or_byte,		/* 01 */
+    adc_byte,		/* 02 */
+    sbb_byte,		/* 03 */
+    and_byte,		/* 04 */
+    sub_byte,		/* 05 */
+    xor_byte,		/* 06 */
+    cmp_byte,		/* 07 */
 };
 
 static u16 (*genop_word_operation[])(u16 d, u16 s) __attribute__ ((section(".got2"))) =
 {
-    add_word,           /*00 */
-    or_word,            /*01 */
-    adc_word,           /*02 */
-    sbb_word,           /*03 */
-    and_word,           /*04 */
-    sub_word,           /*05 */
-    xor_word,           /*06 */
-    cmp_word,           /*07 */
+    add_word,		/*00 */
+    or_word,		/*01 */
+    adc_word,		/*02 */
+    sbb_word,		/*03 */
+    and_word,		/*04 */
+    sub_word,		/*05 */
+    xor_word,		/*06 */
+    cmp_word,		/*07 */
 };
 
 static u32 (*genop_long_operation[])(u32 d, u32 s) __attribute__ ((section(".got2"))) =
 {
-    add_long,           /*00 */
-    or_long,            /*01 */
-    adc_long,           /*02 */
-    sbb_long,           /*03 */
-    and_long,           /*04 */
-    sub_long,           /*05 */
-    xor_long,           /*06 */
-    cmp_long,           /*07 */
+    add_long,		/*00 */
+    or_long,		/*01 */
+    adc_long,		/*02 */
+    sbb_long,		/*03 */
+    and_long,		/*04 */
+    sub_long,		/*05 */
+    xor_long,		/*06 */
+    cmp_long,		/*07 */
 };
 
 /* used by opcodes 80, c0, d0, and d2. */
@@ -131,7 +131,7 @@ static u8(*opcD0_byte_operation[])(u8 d, u8 s) __attribute__ ((section(".got2"))
     rcr_byte,
     shl_byte,
     shr_byte,
-    shl_byte,           /* sal_byte === shl_byte  by definition */
+    shl_byte,		/* sal_byte === shl_byte  by definition */
     sar_byte,
 };
 
@@ -144,7 +144,7 @@ static u16(*opcD1_word_operation[])(u16 s, u8 d) __attribute__ ((section(".got2"
     rcr_word,
     shl_word,
     shr_word,
-    shl_word,           /* sal_byte === shl_byte  by definition */
+    shl_word,		/* sal_byte === shl_byte  by definition */
     sar_word,
 };
 
@@ -157,7 +157,7 @@ static u32 (*opcD1_long_operation[])(u32 s, u8 d) __attribute__ ((section(".got2
     rcr_long,
     shl_long,
     shr_long,
-    shl_long,           /* sal_byte === shl_byte  by definition */
+    shl_long,		/* sal_byte === shl_byte  by definition */
     sar_long,
 };
 
@@ -180,21 +180,21 @@ void x86emuOp_illegal_op(
 {
     START_OF_INSTR();
     if (M.x86.R_SP != 0) {
-        DECODE_PRINTF("ILLEGAL X86 OPCODE\n");
-        TRACE_REGS();
-        DB( printk("%04x:%04x: %02X ILLEGAL X86 OPCODE!\n",
-            M.x86.R_CS, M.x86.R_IP-1,op1));
-        HALT_SYS();
-        }
+	DECODE_PRINTF("ILLEGAL X86 OPCODE\n");
+	TRACE_REGS();
+	DB( printk("%04x:%04x: %02X ILLEGAL X86 OPCODE!\n",
+	    M.x86.R_CS, M.x86.R_IP-1,op1));
+	HALT_SYS();
+	}
     else {
-        /* If we get here, it means the stack pointer is back to zero
-         * so we are just returning from an emulator service call
-         * so therte is no need to display an error message. We trap
-         * the emulator with an 0xF1 opcode to finish the service
-         * call.
-         */
-        X86EMU_halt_sys();
-        }
+	/* If we get here, it means the stack pointer is back to zero
+	 * so we are just returning from an emulator service call
+	 * so therte is no need to display an error message. We trap
+	 * the emulator with an 0xF1 opcode to finish the service
+	 * call.
+	 */
+	X86EMU_halt_sys();
+	}
     END_OF_INSTR();
 }
 
@@ -216,24 +216,24 @@ void x86emuOp_genop_byte_RM_R(u8 op1)
     DECODE_PRINTF("\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if(mod<3)
-        { destoffset = decode_rmXX_address(mod,rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = genop_byte_operation[op1](destval, *srcreg);
-        store_data_byte(destoffset, destval);
-        }
+	{ destoffset = decode_rmXX_address(mod,rl);
+	DECODE_PRINTF(",");
+	destval = fetch_data_byte(destoffset);
+	srcreg = DECODE_RM_BYTE_REGISTER(rh);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	destval = genop_byte_operation[op1](destval, *srcreg);
+	store_data_byte(destoffset, destval);
+	}
     else
-        {                       /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = genop_byte_operation[op1](*destreg, *srcreg);
-        }
+	{			/* register to register */
+	destreg = DECODE_RM_BYTE_REGISTER(rl);
+	DECODE_PRINTF(",");
+	srcreg = DECODE_RM_BYTE_REGISTER(rh);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*destreg = genop_byte_operation[op1](*destreg, *srcreg);
+	}
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -255,50 +255,50 @@ void x86emuOp_genop_word_RM_R(u8 op1)
     FETCH_DECODE_MODRM(mod, rh, rl);
 
     if(mod<3) {
-        destoffset = decode_rmXX_address(mod,rl);
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = genop_long_operation[op1](destval, *srcreg);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *srcreg;
-
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = genop_word_operation[op1](destval, *srcreg);
-            store_data_word(destoffset, destval);
-        }
-    } else {                    /* 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 = genop_long_operation[op1](*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 = genop_word_operation[op1](*destreg, *srcreg);
-        }
+	destoffset = decode_rmXX_address(mod,rl);
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval;
+	    u32 *srcreg;
+
+	    DECODE_PRINTF(",");
+	    destval = fetch_data_long(destoffset);
+	    srcreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    destval = genop_long_operation[op1](destval, *srcreg);
+	    store_data_long(destoffset, destval);
+	} else {
+	    u16 destval;
+	    u16 *srcreg;
+
+	    DECODE_PRINTF(",");
+	    destval = fetch_data_word(destoffset);
+	    srcreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    destval = genop_word_operation[op1](destval, *srcreg);
+	    store_data_word(destoffset, destval);
+	}
+    } else {			/* 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 = genop_long_operation[op1](*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 = genop_word_operation[op1](*destreg, *srcreg);
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -322,15 +322,15 @@ void x86emuOp_genop_byte_R_RM(u8 op1)
     DECODE_PRINTF("\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rmXX_address(mod,rl);
-        srcval = fetch_data_byte(srcoffset);
-    } else {     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rl);
-        srcval = *srcreg;
+	destreg = DECODE_RM_BYTE_REGISTER(rh);
+	DECODE_PRINTF(",");
+	srcoffset = decode_rmXX_address(mod,rl);
+	srcval = fetch_data_byte(srcoffset);
+    } else {	 /* register to register */
+	destreg = DECODE_RM_BYTE_REGISTER(rh);
+	DECODE_PRINTF(",");
+	srcreg = DECODE_RM_BYTE_REGISTER(rl);
+	srcval = *srcreg;
     }
     DECODE_PRINTF("\n");
     TRACE_AND_STEP();
@@ -358,40 +358,40 @@ void x86emuOp_genop_word_R_RM(u8 op1)
     DECODE_PRINTF("\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        srcoffset = decode_rmXX_address(mod,rl);
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            destreg32 = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcval = fetch_data_long(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg32 = genop_long_operation[op1](*destreg32, srcval);
-        } else {
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = genop_word_operation[op1](*destreg, srcval);
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg;
-            destreg32 = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg32 = genop_long_operation[op1](*destreg32, *srcreg);
-        } else {
-            u16 *srcreg;
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = genop_word_operation[op1](*destreg, *srcreg);
-        }
+	srcoffset = decode_rmXX_address(mod,rl);
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    destreg32 = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcval = fetch_data_long(srcoffset);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg32 = genop_long_operation[op1](*destreg32, srcval);
+	} else {
+	    destreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcval = fetch_data_word(srcoffset);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = genop_word_operation[op1](*destreg, srcval);
+	}
+    } else {			 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *srcreg;
+	    destreg32 = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcreg = DECODE_RM_LONG_REGISTER(rl);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg32 = genop_long_operation[op1](*destreg32, *srcreg);
+	} else {
+	    u16 *srcreg;
+	    destreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = genop_word_operation[op1](*destreg, *srcreg);
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -430,20 +430,20 @@ void x86emuOp_genop_word_AX_IMM(u8 op1)
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF(x86emu_GenOpName[op1]);
-        DECODE_PRINTF("\tEAX,");
-        srcval = fetch_long_imm();
+	DECODE_PRINTF(x86emu_GenOpName[op1]);
+	DECODE_PRINTF("\tEAX,");
+	srcval = fetch_long_imm();
     } else {
-        DECODE_PRINTF(x86emu_GenOpName[op1]);
-        DECODE_PRINTF("\tAX,");
-        srcval = fetch_word_imm();
+	DECODE_PRINTF(x86emu_GenOpName[op1]);
+	DECODE_PRINTF("\tAX,");
+	srcval = fetch_word_imm();
     }
     DECODE_PRINTF2("%x\n", srcval);
     TRACE_AND_STEP();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        M.x86.R_EAX = genop_long_operation[op1](M.x86.R_EAX, srcval);
+	M.x86.R_EAX = genop_long_operation[op1](M.x86.R_EAX, srcval);
     } else {
-        M.x86.R_AX = genop_word_operation[op1](M.x86.R_AX, (u16)srcval);
+	M.x86.R_AX = genop_word_operation[op1](M.x86.R_AX, (u16)srcval);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -683,17 +683,17 @@ void x86emuOp_inc_register(u8 op1)
     op1 &= 0x7;
     DECODE_PRINTF("INC\t");
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        u32 *reg;
-        reg = DECODE_RM_LONG_REGISTER(op1);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *reg = inc_long(*reg);
+	u32 *reg;
+	reg = DECODE_RM_LONG_REGISTER(op1);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*reg = inc_long(*reg);
     } else {
-        u16 *reg;
-        reg = DECODE_RM_WORD_REGISTER(op1);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *reg = inc_word(*reg);
+	u16 *reg;
+	reg = DECODE_RM_WORD_REGISTER(op1);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*reg = inc_word(*reg);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -709,17 +709,17 @@ void x86emuOp_dec_register(u8 op1)
     op1 &= 0x7;
     DECODE_PRINTF("DEC\t");
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        u32 *reg;
-        reg = DECODE_RM_LONG_REGISTER(op1);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *reg = dec_long(*reg);
+	u32 *reg;
+	reg = DECODE_RM_LONG_REGISTER(op1);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*reg = dec_long(*reg);
     } else {
-        u16 *reg;
-        reg = DECODE_RM_WORD_REGISTER(op1);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *reg = dec_word(*reg);
+	u16 *reg;
+	reg = DECODE_RM_WORD_REGISTER(op1);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*reg = dec_word(*reg);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -735,17 +735,17 @@ void x86emuOp_push_register(u8 op1)
     op1 &= 0x7;
     DECODE_PRINTF("PUSH\t");
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        u32 *reg;
-        reg = DECODE_RM_LONG_REGISTER(op1);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        push_long(*reg);
+	u32 *reg;
+	reg = DECODE_RM_LONG_REGISTER(op1);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	push_long(*reg);
     } else {
-        u16 *reg;
-        reg = DECODE_RM_WORD_REGISTER(op1);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        push_word(*reg);
+	u16 *reg;
+	reg = DECODE_RM_WORD_REGISTER(op1);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	push_word(*reg);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -761,17 +761,17 @@ void x86emuOp_pop_register(u8 op1)
     op1 &= 0x7;
     DECODE_PRINTF("POP\t");
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        u32 *reg;
-        reg = DECODE_RM_LONG_REGISTER(op1);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *reg = pop_long();
+	u32 *reg;
+	reg = DECODE_RM_LONG_REGISTER(op1);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*reg = pop_long();
     } else {
-        u16 *reg;
-        reg = DECODE_RM_WORD_REGISTER(op1);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *reg = pop_word();
+	u16 *reg;
+	reg = DECODE_RM_WORD_REGISTER(op1);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*reg = pop_word();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -785,33 +785,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;
-
-        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);
+	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);
     } else {
-        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);
+	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);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -825,36 +825,36 @@ 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();
 }
 
-/*opcode 0x62   ILLEGAL OP, calls x86emuOp_illegal_op() */
-/*opcode 0x63   ILLEGAL OP, calls x86emuOp_illegal_op() */
+/*opcode 0x62	ILLEGAL OP, calls x86emuOp_illegal_op() */
+/*opcode 0x63	ILLEGAL OP, calls x86emuOp_illegal_op() */
 
 /****************************************************************************
 REMARKS:
@@ -928,16 +928,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();
@@ -956,95 +956,95 @@ void x86emuOp_imul_word_IMM(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("IMUL\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        srcoffset = decode_rmXX_address(mod, rl);
-        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(",");
-            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_lo & 0x80000000) == 0) && (res_hi == 0x00000000)) ||
-                (((res_lo & 0x80000000) != 0) && (res_hi == 0xFFFFFFFF))) {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            } else {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            }
-            *destreg = (u32)res_lo;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-            u32 res;
-            s16 imm;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            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 & 0x8000) == 0) && ((res >> 16) == 0x0000)) ||
-                (((res & 0x8000) != 0) && ((res >> 16) == 0xFFFF))) {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            } else {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
-    } else {                     /* 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_lo & 0x80000000) == 0) && (res_hi == 0x00000000)) ||
-                (((res_lo & 0x80000000) != 0) && (res_hi == 0xFFFFFFFF))) {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            } else {
-                SET_FLAG(F_CF);
-                SET_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 & 0x8000) == 0) && ((res >> 16) == 0x0000)) ||
-                (((res & 0x8000) != 0) && ((res >> 16) == 0xFFFF))) {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            } else {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
+	srcoffset = decode_rmXX_address(mod, rl);
+	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(",");
+	    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_lo & 0x80000000) == 0) && (res_hi == 0x00000000)) ||
+		(((res_lo & 0x80000000) != 0) && (res_hi == 0xFFFFFFFF))) {
+		CLEAR_FLAG(F_CF);
+		CLEAR_FLAG(F_OF);
+	    } else {
+		SET_FLAG(F_CF);
+		SET_FLAG(F_OF);
+	    }
+	    *destreg = (u32)res_lo;
+	} else {
+	    u16 *destreg;
+	    u16 srcval;
+	    u32 res;
+	    s16 imm;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    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 & 0x8000) == 0) && ((res >> 16) == 0x0000)) ||
+		(((res & 0x8000) != 0) && ((res >> 16) == 0xFFFF))) {
+		CLEAR_FLAG(F_CF);
+		CLEAR_FLAG(F_OF);
+	    } else {
+		SET_FLAG(F_CF);
+		SET_FLAG(F_OF);
+	    }
+	    *destreg = (u16)res;
+	}
+    } else {			 /* 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_lo & 0x80000000) == 0) && (res_hi == 0x00000000)) ||
+		(((res_lo & 0x80000000) != 0) && (res_hi == 0xFFFFFFFF))) {
+		CLEAR_FLAG(F_CF);
+		CLEAR_FLAG(F_OF);
+	    } else {
+		SET_FLAG(F_CF);
+		SET_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 & 0x8000) == 0) && ((res >> 16) == 0x0000)) ||
+		(((res & 0x8000) != 0) && ((res >> 16) == 0xFFFF))) {
+		CLEAR_FLAG(F_CF);
+		CLEAR_FLAG(F_OF);
+	    } else {
+		SET_FLAG(F_CF);
+		SET_FLAG(F_OF);
+	    }
+	    *destreg = (u16)res;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1075,98 +1075,98 @@ void x86emuOp_imul_byte_IMM(u8 X86EMU_UNUSED(op1))
 {
     int mod, rl, rh;
     uint srcoffset;
-    s8  imm;
+    s8	imm;
 
     START_OF_INSTR();
     DECODE_PRINTF("IMUL\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        srcoffset = decode_rmXX_address(mod, rl);
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-            u32 res_lo,res_hi;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            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_lo & 0x80000000) == 0) && (res_hi == 0x00000000)) ||
-                (((res_lo & 0x80000000) != 0) && (res_hi == 0xFFFFFFFF))) {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            } else {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            }
-            *destreg = (u32)res_lo;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-            u32 res;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            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 & 0x8000) == 0) && ((res >> 16) == 0x0000)) ||
-                (((res & 0x8000) != 0) && ((res >> 16) == 0xFFFF))) {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            } else {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
-    } else {                     /* 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_lo & 0x80000000) == 0) && (res_hi == 0x00000000)) ||
-                (((res_lo & 0x80000000) != 0) && (res_hi == 0xFFFFFFFF))) {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            } else {
-                SET_FLAG(F_CF);
-                SET_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);
-            TRACE_AND_STEP();
-            res = (s16)*srcreg * (s16)imm;
-            if ((((res & 0x8000) == 0) && ((res >> 16) == 0x0000)) ||
-                (((res & 0x8000) != 0) && ((res >> 16) == 0xFFFF))) {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            } else {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
+	srcoffset = decode_rmXX_address(mod, rl);
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *destreg;
+	    u32 srcval;
+	    u32 res_lo,res_hi;
+
+	    destreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    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_lo & 0x80000000) == 0) && (res_hi == 0x00000000)) ||
+		(((res_lo & 0x80000000) != 0) && (res_hi == 0xFFFFFFFF))) {
+		CLEAR_FLAG(F_CF);
+		CLEAR_FLAG(F_OF);
+	    } else {
+		SET_FLAG(F_CF);
+		SET_FLAG(F_OF);
+	    }
+	    *destreg = (u32)res_lo;
+	} else {
+	    u16 *destreg;
+	    u16 srcval;
+	    u32 res;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    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 & 0x8000) == 0) && ((res >> 16) == 0x0000)) ||
+		(((res & 0x8000) != 0) && ((res >> 16) == 0xFFFF))) {
+		CLEAR_FLAG(F_CF);
+		CLEAR_FLAG(F_OF);
+	    } else {
+		SET_FLAG(F_CF);
+		SET_FLAG(F_OF);
+	    }
+	    *destreg = (u16)res;
+	}
+    } else {			 /* 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_lo & 0x80000000) == 0) && (res_hi == 0x00000000)) ||
+		(((res_lo & 0x80000000) != 0) && (res_hi == 0xFFFFFFFF))) {
+		CLEAR_FLAG(F_CF);
+		CLEAR_FLAG(F_OF);
+	    } else {
+		SET_FLAG(F_CF);
+		SET_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);
+	    TRACE_AND_STEP();
+	    res = (s16)*srcreg * (s16)imm;
+	    if ((((res & 0x8000) == 0) && ((res >> 16) == 0x0000)) ||
+		(((res & 0x8000) != 0) && ((res >> 16) == 0xFFFF))) {
+		CLEAR_FLAG(F_CF);
+		CLEAR_FLAG(F_OF);
+	    } else {
+		SET_FLAG(F_CF);
+		SET_FLAG(F_OF);
+	    }
+	    *destreg = (u16)res;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1194,11 +1194,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();
@@ -1227,11 +1227,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();
@@ -1258,7 +1258,7 @@ void x86emuOp_jump_near_cond(u8 op1)
     DECODE_PRINTF2("%x\n", target);
     TRACE_AND_STEP();
     if (cond)
-        M.x86.R_IP = target;
+	M.x86.R_IP = target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -1276,7 +1276,7 @@ void x86emuOp_opc80_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
     u8 destval;
 
     /*
-     * Weirdo special case instruction format.  Part of the opcode
+     * Weirdo special case instruction format.	Part of the opcode
      * held below in "RH".  Doubly nested case would result, except
      * that the decoded instruction
      */
@@ -1284,61 +1284,61 @@ 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. */
     if (mod < 3) {
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2("%x\n", imm);
-        TRACE_AND_STEP();
-        destval = (*genop_byte_operation[rh]) (destval, imm);
-        if (rh != 7)
-            store_data_byte(destoffset, destval);
-    } else {                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF(",");
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2("%x\n", imm);
-        TRACE_AND_STEP();
-        destval = (*genop_byte_operation[rh]) (*destreg, imm);
-        if (rh != 7)
-            *destreg = destval;
+	DECODE_PRINTF("BYTE PTR ");
+	destoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF(",");
+	destval = fetch_data_byte(destoffset);
+	imm = fetch_byte_imm();
+	DECODE_PRINTF2("%x\n", imm);
+	TRACE_AND_STEP();
+	destval = (*genop_byte_operation[rh]) (destval, imm);
+	if (rh != 7)
+	    store_data_byte(destoffset, destval);
+    } else {			 /* register to register */
+	destreg = DECODE_RM_BYTE_REGISTER(rl);
+	DECODE_PRINTF(",");
+	imm = fetch_byte_imm();
+	DECODE_PRINTF2("%x\n", imm);
+	TRACE_AND_STEP();
+	destval = (*genop_byte_operation[rh]) (*destreg, imm);
+	if (rh != 7)
+	    *destreg = destval;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1354,7 +1354,7 @@ void x86emuOp_opc81_word_RM_IMM(u8 X86EMU_UNUSED(op1))
     uint destoffset;
 
     /*
-     * Weirdo special case instruction format.  Part of the opcode
+     * Weirdo special case instruction format.	Part of the opcode
      * held below in "RH".  Doubly nested case would result, except
      * that the decoded instruction
      */
@@ -1362,37 +1362,37 @@ 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
     /*
@@ -1400,57 +1400,57 @@ void x86emuOp_opc81_word_RM_IMM(u8 X86EMU_UNUSED(op1))
      * mode.
      */
     if (mod < 3) {
-        DECODE_PRINTF("DWORD PTR ");
-        destoffset = decode_rmXX_address(mod, rl);
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval,imm;
-
-            DECODE_PRINTF(",");
-            destval = fetch_data_long(destoffset);
-            imm = fetch_long_imm();
-            DECODE_PRINTF2("%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*genop_long_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_long(destoffset, destval);
-        } else {
-            u16 destval,imm;
-
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2("%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*genop_word_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_word(destoffset, destval);
-        }
-    } else {                     /* 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 = (*genop_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 = (*genop_word_operation[rh]) (*destreg, imm);
-            if (rh != 7)
-                *destreg = destval;
-        }
+	DECODE_PRINTF("DWORD PTR ");
+	destoffset = decode_rmXX_address(mod, rl);
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval,imm;
+
+	    DECODE_PRINTF(",");
+	    destval = fetch_data_long(destoffset);
+	    imm = fetch_long_imm();
+	    DECODE_PRINTF2("%x\n", imm);
+	    TRACE_AND_STEP();
+	    destval = (*genop_long_operation[rh]) (destval, imm);
+	    if (rh != 7)
+		store_data_long(destoffset, destval);
+	} else {
+	    u16 destval,imm;
+
+	    DECODE_PRINTF(",");
+	    destval = fetch_data_word(destoffset);
+	    imm = fetch_word_imm();
+	    DECODE_PRINTF2("%x\n", imm);
+	    TRACE_AND_STEP();
+	    destval = (*genop_word_operation[rh]) (destval, imm);
+	    if (rh != 7)
+		store_data_word(destoffset, destval);
+	}
+    } else {			 /* 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 = (*genop_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 = (*genop_word_operation[rh]) (*destreg, imm);
+	    if (rh != 7)
+		*destreg = destval;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1469,7 +1469,7 @@ void x86emuOp_opc82_byte_RM_IMM(u8 X86EMU_UNUSED(op1))
     u8 destval;
 
     /*
-     * Weirdo special case instruction format.  Part of the opcode
+     * Weirdo special case instruction format.	Part of the opcode
      * held below in "RH".  Doubly nested case would result, except
      * that the decoded instruction Similar to opcode 81, except that
      * the immediate byte is sign extended to a word length.
@@ -1478,58 +1478,58 @@ 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. */
     if (mod < 3) {
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rmXX_address(mod, rl);
-        destval = fetch_data_byte(destoffset);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2(",%x\n", imm);
-        TRACE_AND_STEP();
-        destval = (*genop_byte_operation[rh]) (destval, imm);
-        if (rh != 7)
-            store_data_byte(destoffset, destval);
-    } else {                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2(",%x\n", imm);
-        TRACE_AND_STEP();
-        destval = (*genop_byte_operation[rh]) (*destreg, imm);
-        if (rh != 7)
-            *destreg = destval;
+	DECODE_PRINTF("BYTE PTR ");
+	destoffset = decode_rmXX_address(mod, rl);
+	destval = fetch_data_byte(destoffset);
+	imm = fetch_byte_imm();
+	DECODE_PRINTF2(",%x\n", imm);
+	TRACE_AND_STEP();
+	destval = (*genop_byte_operation[rh]) (destval, imm);
+	if (rh != 7)
+	    store_data_byte(destoffset, destval);
+    } else {			 /* register to register */
+	destreg = DECODE_RM_BYTE_REGISTER(rl);
+	imm = fetch_byte_imm();
+	DECODE_PRINTF2(",%x\n", imm);
+	TRACE_AND_STEP();
+	destval = (*genop_byte_operation[rh]) (*destreg, imm);
+	if (rh != 7)
+	    *destreg = destval;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1545,7 +1545,7 @@ void x86emuOp_opc83_word_RM_IMM(u8 X86EMU_UNUSED(op1))
     uint destoffset;
 
     /*
-     * Weirdo special case instruction format.  Part of the opcode
+     * Weirdo special case instruction format.	Part of the opcode
      * held below in "RH".  Doubly nested case would result, except
      * that the decoded instruction Similar to opcode 81, except that
      * the immediate byte is sign extended to a word length.
@@ -1554,89 +1554,89 @@ 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. */
     if (mod < 3) {
-        DECODE_PRINTF("DWORD PTR ");
-        destoffset = decode_rmXX_address(mod,rl);
-
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval,imm;
-
-            destval = fetch_data_long(destoffset);
-            imm = (s8) fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*genop_long_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_long(destoffset, destval);
-        } else {
-            u16 destval,imm;
-
-            destval = fetch_data_word(destoffset);
-            imm = (s8) fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            destval = (*genop_word_operation[rh]) (destval, imm);
-            if (rh != 7)
-                store_data_word(destoffset, destval);
-        }
-    } else {                     /* 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 = (*genop_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 = (*genop_word_operation[rh]) (*destreg, imm);
-            if (rh != 7)
-                *destreg = destval;
-        }
+	DECODE_PRINTF("DWORD PTR ");
+	destoffset = decode_rmXX_address(mod,rl);
+
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval,imm;
+
+	    destval = fetch_data_long(destoffset);
+	    imm = (s8) fetch_byte_imm();
+	    DECODE_PRINTF2(",%x\n", imm);
+	    TRACE_AND_STEP();
+	    destval = (*genop_long_operation[rh]) (destval, imm);
+	    if (rh != 7)
+		store_data_long(destoffset, destval);
+	} else {
+	    u16 destval,imm;
+
+	    destval = fetch_data_word(destoffset);
+	    imm = (s8) fetch_byte_imm();
+	    DECODE_PRINTF2(",%x\n", imm);
+	    TRACE_AND_STEP();
+	    destval = (*genop_word_operation[rh]) (destval, imm);
+	    if (rh != 7)
+		store_data_word(destoffset, destval);
+	}
+    } else {			 /* 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 = (*genop_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 = (*genop_word_operation[rh]) (*destreg, imm);
+	    if (rh != 7)
+		*destreg = destval;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1657,20 +1657,20 @@ void x86emuOp_test_byte_RM_R(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("TEST\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF(",");
-        destval = fetch_data_byte(destoffset);
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        test_byte(destval, *srcreg);
-    } else {                     /* 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);
+	destoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF(",");
+	destval = fetch_data_byte(destoffset);
+	srcreg = DECODE_RM_BYTE_REGISTER(rh);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	test_byte(destval, *srcreg);
+    } else {			 /* 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);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1689,48 +1689,48 @@ void x86emuOp_test_word_RM_R(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("TEST\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, rl);
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *srcreg;
-
-            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;
-
-            DECODE_PRINTF(",");
-            destval = fetch_data_word(destoffset);
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            test_word(destval, *srcreg);
-        }
-    } else {                     /* 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;
-
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            test_word(*destreg, *srcreg);
-        }
+	destoffset = decode_rmXX_address(mod, rl);
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval;
+	    u32 *srcreg;
+
+	    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;
+
+	    DECODE_PRINTF(",");
+	    destval = fetch_data_word(destoffset);
+	    srcreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    test_word(destval, *srcreg);
+	}
+    } else {			 /* 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;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    srcreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    test_word(*destreg, *srcreg);
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1752,25 +1752,25 @@ void x86emuOp_xchg_byte_RM_R(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("XCHG\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, 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);
-    } else {                     /* 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;
+	destoffset = decode_rmXX_address(mod, 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);
+    } else {			 /* 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;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1789,59 +1789,59 @@ void x86emuOp_xchg_word_RM_R(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("XCHG\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF(",");
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg;
-            u32 destval,tmp;
-
-            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;
-
-            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);
-        }
-    } else {                     /* 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;
-
-            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;
-        }
+	destoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF(",");
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *srcreg;
+	    u32 destval,tmp;
+
+	    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;
+
+	    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);
+	}
+    } else {			 /* 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;
+
+	    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;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1861,19 +1861,19 @@ void x86emuOp_mov_byte_RM_R(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("MOV\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        store_data_byte(destoffset, *srcreg);
-    } else {                     /* 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;
+	destoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF(",");
+	srcreg = DECODE_RM_BYTE_REGISTER(rh);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	store_data_byte(destoffset, *srcreg);
+    } else {			 /* 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;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1892,44 +1892,44 @@ void x86emuOp_mov_word_RM_R(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("MOV\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, rl);
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg;
-
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            store_data_long(destoffset, *srcreg);
-        } else {
-            u16 *srcreg;
-
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            store_data_word(destoffset, *srcreg);
-        }
-    } else {                     /* 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;
-
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = *srcreg;
-        }
+	destoffset = decode_rmXX_address(mod, rl);
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *srcreg;
+
+	    DECODE_PRINTF(",");
+	    srcreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    store_data_long(destoffset, *srcreg);
+	} else {
+	    u16 *srcreg;
+
+	    DECODE_PRINTF(",");
+	    srcreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    store_data_word(destoffset, *srcreg);
+	}
+    } else {			 /* 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;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    srcreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = *srcreg;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1950,20 +1950,20 @@ void x86emuOp_mov_byte_R_RM(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("MOV\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destreg = DECODE_RM_BYTE_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rmXX_address(mod, rl);
-        srcval = fetch_data_byte(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = srcval;
-    } else {                     /* 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;
+	destreg = DECODE_RM_BYTE_REGISTER(rh);
+	DECODE_PRINTF(",");
+	srcoffset = decode_rmXX_address(mod, rl);
+	srcval = fetch_data_byte(srcoffset);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*destreg = srcval;
+    } else {			 /* 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;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1982,49 +1982,49 @@ void x86emuOp_mov_word_R_RM(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("MOV\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rmXX_address(mod, 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_rmXX_address(mod, rl);
-            srcval = fetch_data_word(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = srcval;
-        }
-    } else {                     /* 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;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = *srcreg;
-        }
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *destreg;
+	    u32 srcval;
+
+	    destreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcoffset = decode_rmXX_address(mod, 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_rmXX_address(mod, rl);
+	    srcval = fetch_data_word(srcoffset);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = srcval;
+	}
+    } else {			 /* 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;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = *srcreg;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2045,20 +2045,20 @@ void x86emuOp_mov_word_RM_SR(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("MOV\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF(",");
-        srcreg = decode_rm_seg_register(rh);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        destval = *srcreg;
-        store_data_word(destoffset, destval);
-    } else {                     /* 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;
+	destoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF(",");
+	srcreg = decode_rm_seg_register(rh);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	destval = *srcreg;
+	store_data_word(destoffset, destval);
+    } else {			 /* 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;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2077,20 +2077,20 @@ void x86emuOp_lea_word_R_M(u8 X86EMU_UNUSED(op1))
 /*
  * TODO: Need to handle address size prefix!
  *
- * lea  eax,[eax+ebx*2] ??
+ * lea	eax,[eax+ebx*2] ??
  */
 
     START_OF_INSTR();
     DECODE_PRINTF("LEA\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        srcreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        destoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *srcreg = (u16)destoffset;
-        }
+	srcreg = DECODE_RM_WORD_REGISTER(rh);
+	DECODE_PRINTF(",");
+	destoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*srcreg = (u16)destoffset;
+	}
     /* } else { undefined.  Do nothing. } */
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2111,20 +2111,20 @@ void x86emuOp_mov_word_SR_RM(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("MOV\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destreg = decode_rm_seg_register(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rmXX_address(mod, rl);
-        srcval = fetch_data_word(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = srcval;
-    } else {                     /* 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;
+	destreg = decode_rm_seg_register(rh);
+	DECODE_PRINTF(",");
+	srcoffset = decode_rmXX_address(mod, rl);
+	srcval = fetch_data_word(srcoffset);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*destreg = srcval;
+    } else {			 /* 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;
     }
     /*
      * Clean up, and reset all the R_xSP pointers to the correct
@@ -2149,42 +2149,42 @@ 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();
     }
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, rl);
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = pop_long();
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = pop_word();
-            store_data_word(destoffset, destval);
-        }
-    } else {                    /* register to register */
-        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_WORD_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = pop_word();
-        }
+	destoffset = decode_rmXX_address(mod, rl);
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval;
+
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    destval = pop_long();
+	    store_data_long(destoffset, destval);
+	} else {
+	    u16 destval;
+
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    destval = pop_word();
+	    store_data_word(destoffset, destval);
+	}
+    } else {			/* register to register */
+	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_WORD_REGISTER(rl);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = pop_word();
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2216,23 +2216,23 @@ void x86emuOp_xchg_word_AX_register(u8 X86EMU_UNUSED(op1))
     START_OF_INSTR();
 
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        u32 *reg32;
-        DECODE_PRINTF("XCHG\tEAX,");
-        reg32 = DECODE_RM_LONG_REGISTER(op1);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        tmp = M.x86.R_EAX;
-        M.x86.R_EAX = *reg32;
-        *reg32 = tmp;
+	u32 *reg32;
+	DECODE_PRINTF("XCHG\tEAX,");
+	reg32 = DECODE_RM_LONG_REGISTER(op1);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	tmp = M.x86.R_EAX;
+	M.x86.R_EAX = *reg32;
+	*reg32 = tmp;
     } else {
-        u16 *reg16;
-        DECODE_PRINTF("XCHG\tAX,");
-        reg16 = DECODE_RM_WORD_REGISTER(op1);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        tmp = M.x86.R_AX;
-        M.x86.R_EAX = *reg16;
-        *reg16 = (u16)tmp;
+	u16 *reg16;
+	DECODE_PRINTF("XCHG\tAX,");
+	reg16 = DECODE_RM_WORD_REGISTER(op1);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	tmp = M.x86.R_AX;
+	M.x86.R_EAX = *reg16;
+	*reg16 = (u16)tmp;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -2246,23 +2246,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();
@@ -2276,24 +2276,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();
@@ -2319,7 +2319,7 @@ void x86emuOp_call_far_IMM(u8 X86EMU_UNUSED(op1))
      *
      * 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.
+     * access.	Check needed here.  For moment, let it alone.
      */
     TRACE_AND_STEP();
     push_word(M.x86.R_CS);
@@ -2354,18 +2354,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();
@@ -2379,15 +2379,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();
@@ -2456,15 +2456,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();
@@ -2499,15 +2499,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();
@@ -2519,30 +2519,30 @@ Handles opcode 0xa4
 ****************************************************************************/
 void x86emuOp_movs_byte(u8 X86EMU_UNUSED(op1))
 {
-    u8  val;
+    u8	val;
     u32 count;
     int inc;
 
     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();
@@ -2560,37 +2560,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();
@@ -2609,30 +2609,30 @@ 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 | SYSMODE_PREFIX_REPNE)) {
-        /* 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 ( (M.x86.mode & SYSMODE_PREFIX_REPE) && (ACCESS_FLAG(F_ZF) == 0) ) break;
-            if ( (M.x86.mode & SYSMODE_PREFIX_REPNE) && ACCESS_FLAG(F_ZF) ) break;
-        }
-        M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
+	/* 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 ( (M.x86.mode & SYSMODE_PREFIX_REPE) && (ACCESS_FLAG(F_ZF) == 0) ) break;
+	    if ( (M.x86.mode & SYSMODE_PREFIX_REPNE) && ACCESS_FLAG(F_ZF) ) break;
+	}
+	M.x86.mode &= ~(SYSMODE_PREFIX_REPE | 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();
@@ -2649,48 +2649,48 @@ void x86emuOp_cmps_word(u8 X86EMU_UNUSED(op1))
 
     START_OF_INSTR();
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        DECODE_PRINTF("CMPS\tDWORD\n");
-        inc = 4;
+	DECODE_PRINTF("CMPS\tDWORD\n");
+	inc = 4;
     } else {
-        DECODE_PRINTF("CMPS\tWORD\n");
-        inc = 2;
+	DECODE_PRINTF("CMPS\tWORD\n");
+	inc = 2;
     }
     if (ACCESS_FLAG(F_DF))   /* down */
-        inc = -inc;
+	inc = -inc;
 
     TRACE_AND_STEP();
     if (M.x86.mode & (SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE)) {
-        /* 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 ( (M.x86.mode & SYSMODE_PREFIX_REPE) && ACCESS_FLAG(F_ZF) == 0 ) break;
-            if ( (M.x86.mode & SYSMODE_PREFIX_REPNE) && ACCESS_FLAG(F_ZF) ) break;
-        }
-        M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
+	/* 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 ( (M.x86.mode & SYSMODE_PREFIX_REPE) && ACCESS_FLAG(F_ZF) == 0 ) break;
+	    if ( (M.x86.mode & SYSMODE_PREFIX_REPNE) && ACCESS_FLAG(F_ZF) ) break;
+	}
+	M.x86.mode &= ~(SYSMODE_PREFIX_REPE | 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;
+	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();
@@ -2724,18 +2724,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();
@@ -2752,22 +2752,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();
@@ -2784,34 +2784,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();
@@ -2829,21 +2829,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();
@@ -2860,34 +2860,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();
@@ -2906,37 +2906,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();
@@ -2953,62 +2953,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();
@@ -3047,19 +3047,19 @@ void x86emuOp_mov_word_register_IMM(u8 X86EMU_UNUSED(op1))
     START_OF_INSTR();
     DECODE_PRINTF("MOV\t");
     if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-        u32 *reg32;
-        reg32 = DECODE_RM_LONG_REGISTER(op1);
-        srcval = fetch_long_imm();
-        DECODE_PRINTF2(",%x\n", srcval);
-        TRACE_AND_STEP();
-        *reg32 = srcval;
+	u32 *reg32;
+	reg32 = DECODE_RM_LONG_REGISTER(op1);
+	srcval = fetch_long_imm();
+	DECODE_PRINTF2(",%x\n", srcval);
+	TRACE_AND_STEP();
+	*reg32 = srcval;
     } else {
-        u16 *reg16;
-        reg16 = DECODE_RM_WORD_REGISTER(op1);
-        srcval = fetch_word_imm();
-        DECODE_PRINTF2(",%x\n", srcval);
-        TRACE_AND_STEP();
-        *reg16 = (u16)srcval;
+	u16 *reg16;
+	reg16 = DECODE_RM_WORD_REGISTER(op1);
+	srcval = fetch_word_imm();
+	DECODE_PRINTF2(",%x\n", srcval);
+	TRACE_AND_STEP();
+	*reg16 = (u16)srcval;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3086,57 +3086,57 @@ 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. */
     if (mod < 3) {
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rmXX_address(mod, 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);
-    } else {                     /* 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;
+	DECODE_PRINTF("BYTE PTR ");
+	destoffset = decode_rmXX_address(mod, 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);
+    } else {			 /* 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;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3161,83 +3161,83 @@ 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. */
     if (mod < 3) {
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rmXX_address(mod, 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_rmXX_address(mod, 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);
-        }
-    } else {                     /* register to register */
-        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_WORD_REGISTER(rl);
-            amt = fetch_byte_imm();
-            DECODE_PRINTF2(",%x\n", amt);
-            TRACE_AND_STEP();
-            *destreg = (*opcD1_word_operation[rh]) (*destreg, amt);
-        }
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval;
+
+	    DECODE_PRINTF("DWORD PTR ");
+	    destoffset = decode_rmXX_address(mod, 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_rmXX_address(mod, 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);
+	}
+    } else {			 /* register to register */
+	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_WORD_REGISTER(rl);
+	    amt = fetch_byte_imm();
+	    DECODE_PRINTF2(",%x\n", amt);
+	    TRACE_AND_STEP();
+	    *destreg = (*opcD1_word_operation[rh]) (*destreg, amt);
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3292,15 +3292,15 @@ void x86emuOp_les_R_IMM(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("LES\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        dstreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *dstreg = fetch_data_word(srcoffset);
-        M.x86.R_ES = fetch_data_word(srcoffset + 2);
+	dstreg = DECODE_RM_WORD_REGISTER(rh);
+	DECODE_PRINTF(",");
+	srcoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*dstreg = fetch_data_word(srcoffset);
+	M.x86.R_ES = fetch_data_word(srcoffset + 2);
     }
-    /* else UNDEFINED!                   register to register */
+    /* else UNDEFINED!			 register to register */
 
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3320,13 +3320,13 @@ void x86emuOp_lds_R_IMM(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF("LDS\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        dstreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *dstreg = fetch_data_word(srcoffset);
-        M.x86.R_DS = fetch_data_word(srcoffset + 2);
+	dstreg = DECODE_RM_WORD_REGISTER(rh);
+	DECODE_PRINTF(",");
+	srcoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*dstreg = fetch_data_word(srcoffset);
+	M.x86.R_DS = fetch_data_word(srcoffset + 2);
     }
     /* else UNDEFINED! */
     DECODE_CLEAR_SEGOVR();
@@ -3348,22 +3348,22 @@ 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();
     }
     if (mod < 3) {
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rmXX_address(mod, rl);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2(",%2x\n", imm);
-        TRACE_AND_STEP();
-        store_data_byte(destoffset, imm);
-    } else {                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        imm = fetch_byte_imm();
-        DECODE_PRINTF2(",%2x\n", imm);
-        TRACE_AND_STEP();
-        *destreg = imm;
+	DECODE_PRINTF("BYTE PTR ");
+	destoffset = decode_rmXX_address(mod, rl);
+	imm = fetch_byte_imm();
+	DECODE_PRINTF2(",%2x\n", imm);
+	TRACE_AND_STEP();
+	store_data_byte(destoffset, imm);
+    } else {			 /* register to register */
+	destreg = DECODE_RM_BYTE_REGISTER(rl);
+	imm = fetch_byte_imm();
+	DECODE_PRINTF2(",%2x\n", imm);
+	TRACE_AND_STEP();
+	*destreg = imm;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3382,49 +3382,49 @@ 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();
     }
     if (mod < 3) {
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 imm;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rmXX_address(mod, 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_rmXX_address(mod, rl);
-            imm = fetch_word_imm();
-            DECODE_PRINTF2(",%x\n", imm);
-            TRACE_AND_STEP();
-            store_data_word(destoffset, imm);
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 imm;
+
+	    DECODE_PRINTF("DWORD PTR ");
+	    destoffset = decode_rmXX_address(mod, 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_rmXX_address(mod, rl);
+	    imm = fetch_word_imm();
+	    DECODE_PRINTF2(",%x\n", imm);
+	    TRACE_AND_STEP();
+	    store_data_word(destoffset, imm);
+	}
+    } else {			 /* register to register */
+	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;
-        }
+	    destreg = DECODE_RM_WORD_REGISTER(rl);
+	    imm = fetch_word_imm();
+	    DECODE_PRINTF2(",%x\n", imm);
+	    TRACE_AND_STEP();
+	    *destreg = imm;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3437,7 +3437,7 @@ Handles opcode 0xc8
 void x86emuOp_enter(u8 X86EMU_UNUSED(op1))
 {
     u16 local,frame_pointer;
-    u8  nesting;
+    u8	nesting;
     int i;
 
     START_OF_INSTR();
@@ -3449,12 +3449,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();
@@ -3529,13 +3529,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();
@@ -3559,13 +3559,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();
@@ -3583,18 +3583,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();
@@ -3638,54 +3638,54 @@ 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. */
     if (mod < 3) {
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rmXX_address(mod, 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);
-    } else {                     /* 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;
+	DECODE_PRINTF("BYTE PTR ");
+	destoffset = decode_rmXX_address(mod, 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);
+    } else {			 /* 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;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3709,82 +3709,82 @@ 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. */
     if (mod < 3) {
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rmXX_address(mod, 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_rmXX_address(mod, 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);
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval;
+
+	    DECODE_PRINTF("DWORD PTR ");
+	    destoffset = decode_rmXX_address(mod, 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_rmXX_address(mod, 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);
+	}
+    } else {			 /* register to register */
+	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;
-        }
+	    destreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",1\n");
+	    TRACE_AND_STEP();
+	    destval = (*opcD1_word_operation[rh]) (*destreg, 1);
+	    *destreg = destval;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3811,55 +3811,55 @@ 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
        mode. */
     amt = M.x86.R_CL;
     if (mod < 3) {
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rmXX_address(mod, 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);
-    } else {                     /* 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;
+	DECODE_PRINTF("BYTE PTR ");
+	destoffset = decode_rmXX_address(mod, 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);
+    } else {			 /* 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;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3884,79 +3884,79 @@ 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
        mode. */
     amt = M.x86.R_CL;
     if (mod < 3) {
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rmXX_address(mod, 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_rmXX_address(mod, 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);
-        }
-    } else {                     /* register to register */
-        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_WORD_REGISTER(rl);
-            DECODE_PRINTF(",CL\n");
-            TRACE_AND_STEP();
-            *destreg = (*opcD1_word_operation[rh]) (*destreg, amt);
-        }
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval;
+
+	    DECODE_PRINTF("DWORD PTR ");
+	    destoffset = decode_rmXX_address(mod, 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_rmXX_address(mod, 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);
+	}
+    } else {			 /* register to register */
+	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_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",CL\n");
+	    TRACE_AND_STEP();
+	    *destreg = (*opcD1_word_operation[rh]) (*destreg, amt);
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -3974,9 +3974,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. */
@@ -4021,7 +4021,7 @@ void x86emuOp_xlat(u8 X86EMU_UNUSED(op1))
     END_OF_INSTR();
 }
 
-/* instuctions  D8 .. DF are in i87_ops.c */
+/* instuctions	D8 .. DF are in i87_ops.c */
 
 /****************************************************************************
 REMARKS:
@@ -4038,8 +4038,8 @@ void x86emuOp_loopne(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%04x\n", ip);
     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;
+    if (M.x86.R_CX != 0 && !ACCESS_FLAG(F_ZF))	    /* CX != 0 and !ZF */
+	M.x86.R_IP = ip;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -4059,8 +4059,8 @@ void x86emuOp_loope(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF2("%04x\n", ip);
     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;
+    if (M.x86.R_CX != 0 && ACCESS_FLAG(F_ZF))	    /* CX != 0 and ZF */
+	M.x86.R_IP = ip;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -4081,7 +4081,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();
 }
@@ -4093,7 +4093,7 @@ Handles opcode 0xe3
 void x86emuOp_jcxz(u8 X86EMU_UNUSED(op1))
 {
     u16 target;
-    s8  offset;
+    s8	offset;
 
     /* jump to byte offset if overflow flag is set */
     START_OF_INSTR();
@@ -4103,7 +4103,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();
 }
@@ -4138,15 +4138,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();
@@ -4182,15 +4182,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();
@@ -4207,7 +4207,7 @@ void x86emuOp_call_near_IMM(u8 X86EMU_UNUSED(op1))
     START_OF_INSTR();
 	DECODE_PRINTF("CALL\t");
 	ip = (s16) fetch_word_imm();
-	ip += (s16) M.x86.R_IP;    /* CHECK SIGN */
+	ip += (s16) M.x86.R_IP;	   /* CHECK SIGN */
 	DECODE_PRINTF2("%04x\n", ip);
 	CALL_TRACE(M.x86.saved_cs, M.x86.saved_ip, M.x86.R_CS, ip, "");
     TRACE_AND_STEP();
@@ -4299,15 +4299,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();
@@ -4335,15 +4335,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();
@@ -4438,100 +4438,100 @@ void x86emuOp_opcF6_byte_RM(u8 X86EMU_UNUSED(op1))
     FETCH_DECODE_MODRM(mod, rh, rl);
     DECODE_PRINTF(opF6_names[rh]);
     if (mod < 3) {
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rmXX_address(mod, rl);
-        destval = fetch_data_byte(destoffset);
-
-        switch (rh) {
-        case 0:         /* test byte imm */
-            DECODE_PRINTF(",");
-            srcval = fetch_byte_imm();
-            DECODE_PRINTF2("%02x\n", srcval);
-            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("\n");
-            TRACE_AND_STEP();
-            destval = not_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        case 3:
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            destval = neg_byte(destval);
-            store_data_byte(destoffset, destval);
-            break;
-        case 4:
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            mul_byte(destval);
-            break;
-        case 5:
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            imul_byte(destval);
-            break;
-        case 6:
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            div_byte(destval);
-            break;
-        default:
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            idiv_byte(destval);
-            break;
-        }
-    } else {                     /* mod=11 */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        switch (rh) {
-        case 0:         /* test byte imm */
-            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("\n");
-            TRACE_AND_STEP();
-            *destreg = not_byte(*destreg);
-            break;
-        case 3:
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = neg_byte(*destreg);
-            break;
-        case 4:
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            mul_byte(*destreg);      /*!!!  */
-            break;
-        case 5:
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            imul_byte(*destreg);
-            break;
-        case 6:
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            div_byte(*destreg);
-            break;
-        default:
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            idiv_byte(*destreg);
-            break;
-        }
+	DECODE_PRINTF("BYTE PTR ");
+	destoffset = decode_rmXX_address(mod, rl);
+	destval = fetch_data_byte(destoffset);
+
+	switch (rh) {
+	case 0:		/* test byte imm */
+	    DECODE_PRINTF(",");
+	    srcval = fetch_byte_imm();
+	    DECODE_PRINTF2("%02x\n", srcval);
+	    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("\n");
+	    TRACE_AND_STEP();
+	    destval = not_byte(destval);
+	    store_data_byte(destoffset, destval);
+	    break;
+	case 3:
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    destval = neg_byte(destval);
+	    store_data_byte(destoffset, destval);
+	    break;
+	case 4:
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    mul_byte(destval);
+	    break;
+	case 5:
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    imul_byte(destval);
+	    break;
+	case 6:
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    div_byte(destval);
+	    break;
+	default:
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    idiv_byte(destval);
+	    break;
+	}
+    } else {			 /* mod=11 */
+	destreg = DECODE_RM_BYTE_REGISTER(rl);
+	switch (rh) {
+	case 0:		/* test byte imm */
+	    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("\n");
+	    TRACE_AND_STEP();
+	    *destreg = not_byte(*destreg);
+	    break;
+	case 3:
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = neg_byte(*destreg);
+	    break;
+	case 4:
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    mul_byte(*destreg);	     /*!!!  */
+	    break;
+	case 5:
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    imul_byte(*destreg);
+	    break;
+	case 6:
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    div_byte(*destreg);
+	    break;
+	default:
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    idiv_byte(*destreg);
+	    break;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4551,213 +4551,213 @@ void x86emuOp_opcF7_word_RM(u8 X86EMU_UNUSED(op1))
     DECODE_PRINTF(opF6_names[rh]);
     if (mod < 3) {
 
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval, srcval;
-
-            DECODE_PRINTF("DWORD PTR ");
-            destoffset = decode_rmXX_address(mod, rl);
-            destval = fetch_data_long(destoffset);
-
-            switch (rh) {
-            case 0:
-                DECODE_PRINTF(",");
-                srcval = fetch_long_imm();
-                DECODE_PRINTF2("%x\n", srcval);
-                TRACE_AND_STEP();
-                test_long(destval, srcval);
-                break;
-            case 1:
-                DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F7\n");
-                HALT_SYS();
-                break;
-            case 2:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                destval = not_long(destval);
-                store_data_long(destoffset, destval);
-                break;
-            case 3:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                destval = neg_long(destval);
-                store_data_long(destoffset, destval);
-                break;
-            case 4:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                mul_long(destval);
-                break;
-            case 5:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                imul_long(destval);
-                break;
-            case 6:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                div_long(destval);
-                break;
-            case 7:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                idiv_long(destval);
-                break;
-            }
-        } else {
-            u16 destval, srcval;
-
-            DECODE_PRINTF("WORD PTR ");
-            destoffset = decode_rmXX_address(mod, rl);
-            destval = fetch_data_word(destoffset);
-
-            switch (rh) {
-            case 0:         /* test word imm */
-                DECODE_PRINTF(",");
-                srcval = fetch_word_imm();
-                DECODE_PRINTF2("%x\n", srcval);
-                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:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                destval = not_word(destval);
-                store_data_word(destoffset, destval);
-                break;
-            case 3:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                destval = neg_word(destval);
-                store_data_word(destoffset, destval);
-                break;
-            case 4:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                mul_word(destval);
-                break;
-            case 5:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                imul_word(destval);
-                break;
-            case 6:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                div_word(destval);
-                break;
-            case 7:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                idiv_word(destval);
-                break;
-            }
-        }
-
-    } else {                     /* mod=11 */
-
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-
-            switch (rh) {
-            case 0:         /* test word imm */
-                DECODE_PRINTF(",");
-                srcval = fetch_long_imm();
-                DECODE_PRINTF2("%x\n", srcval);
-                TRACE_AND_STEP();
-                test_long(*destreg, srcval);
-                break;
-            case 1:
-                DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
-                HALT_SYS();
-                break;
-            case 2:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                *destreg = not_long(*destreg);
-                break;
-            case 3:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                *destreg = neg_long(*destreg);
-                break;
-            case 4:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                mul_long(*destreg);      /*!!!  */
-                break;
-            case 5:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                imul_long(*destreg);
-                break;
-            case 6:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                div_long(*destreg);
-                break;
-            case 7:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                idiv_long(*destreg);
-                break;
-            }
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-
-            switch (rh) {
-            case 0:         /* test word imm */
-                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:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                *destreg = not_word(*destreg);
-                break;
-            case 3:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                *destreg = neg_word(*destreg);
-                break;
-            case 4:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                mul_word(*destreg);      /*!!!  */
-                break;
-            case 5:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                imul_word(*destreg);
-                break;
-            case 6:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                div_word(*destreg);
-                break;
-            case 7:
-                DECODE_PRINTF("\n");
-                TRACE_AND_STEP();
-                idiv_word(*destreg);
-                break;
-            }
-        }
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval, srcval;
+
+	    DECODE_PRINTF("DWORD PTR ");
+	    destoffset = decode_rmXX_address(mod, rl);
+	    destval = fetch_data_long(destoffset);
+
+	    switch (rh) {
+	    case 0:
+		DECODE_PRINTF(",");
+		srcval = fetch_long_imm();
+		DECODE_PRINTF2("%x\n", srcval);
+		TRACE_AND_STEP();
+		test_long(destval, srcval);
+		break;
+	    case 1:
+		DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F7\n");
+		HALT_SYS();
+		break;
+	    case 2:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		destval = not_long(destval);
+		store_data_long(destoffset, destval);
+		break;
+	    case 3:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		destval = neg_long(destval);
+		store_data_long(destoffset, destval);
+		break;
+	    case 4:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		mul_long(destval);
+		break;
+	    case 5:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		imul_long(destval);
+		break;
+	    case 6:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		div_long(destval);
+		break;
+	    case 7:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		idiv_long(destval);
+		break;
+	    }
+	} else {
+	    u16 destval, srcval;
+
+	    DECODE_PRINTF("WORD PTR ");
+	    destoffset = decode_rmXX_address(mod, rl);
+	    destval = fetch_data_word(destoffset);
+
+	    switch (rh) {
+	    case 0:	    /* test word imm */
+		DECODE_PRINTF(",");
+		srcval = fetch_word_imm();
+		DECODE_PRINTF2("%x\n", srcval);
+		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:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		destval = not_word(destval);
+		store_data_word(destoffset, destval);
+		break;
+	    case 3:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		destval = neg_word(destval);
+		store_data_word(destoffset, destval);
+		break;
+	    case 4:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		mul_word(destval);
+		break;
+	    case 5:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		imul_word(destval);
+		break;
+	    case 6:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		div_word(destval);
+		break;
+	    case 7:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		idiv_word(destval);
+		break;
+	    }
+	}
+
+    } else {			 /* mod=11 */
+
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *destreg;
+	    u32 srcval;
+
+	    destreg = DECODE_RM_LONG_REGISTER(rl);
+
+	    switch (rh) {
+	    case 0:	    /* test word imm */
+		DECODE_PRINTF(",");
+		srcval = fetch_long_imm();
+		DECODE_PRINTF2("%x\n", srcval);
+		TRACE_AND_STEP();
+		test_long(*destreg, srcval);
+		break;
+	    case 1:
+		DECODE_PRINTF("ILLEGAL OP MOD=00 RH=01 OP=F6\n");
+		HALT_SYS();
+		break;
+	    case 2:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		*destreg = not_long(*destreg);
+		break;
+	    case 3:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		*destreg = neg_long(*destreg);
+		break;
+	    case 4:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		mul_long(*destreg);	 /*!!!	*/
+		break;
+	    case 5:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		imul_long(*destreg);
+		break;
+	    case 6:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		div_long(*destreg);
+		break;
+	    case 7:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		idiv_long(*destreg);
+		break;
+	    }
+	} else {
+	    u16 *destreg;
+	    u16 srcval;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rl);
+
+	    switch (rh) {
+	    case 0:	    /* test word imm */
+		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:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		*destreg = not_word(*destreg);
+		break;
+	    case 3:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		*destreg = neg_word(*destreg);
+		break;
+	    case 4:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		mul_word(*destreg);	 /*!!!	*/
+		break;
+	    case 5:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		imul_word(*destreg);
+		break;
+	    case 6:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		div_word(*destreg);
+		break;
+	    case 7:
+		DECODE_PRINTF("\n");
+		TRACE_AND_STEP();
+		idiv_word(*destreg);
+		break;
+	    }
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4869,49 +4869,49 @@ 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
     if (mod < 3) {
-        DECODE_PRINTF("BYTE PTR ");
-        destoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF("\n");
-        destval = fetch_data_byte(destoffset);
-        TRACE_AND_STEP();
-        if (rh == 0)
-          destval = inc_byte(destval);
-        else
-          destval = dec_byte(destval);
-        store_data_byte(destoffset, destval);
+	DECODE_PRINTF("BYTE PTR ");
+	destoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF("\n");
+	destval = fetch_data_byte(destoffset);
+	TRACE_AND_STEP();
+	if (rh == 0)
+	  destval = inc_byte(destval);
+	else
+	  destval = dec_byte(destval);
+	store_data_byte(destoffset, destval);
     } else {
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        if (rh == 0)
-          *destreg = inc_byte(*destreg);
-        else
-          *destreg = dec_byte(*destreg);
+	destreg = DECODE_RM_BYTE_REGISTER(rl);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	if (rh == 0)
+	  *destreg = inc_byte(*destreg);
+	else
+	  *destreg = dec_byte(*destreg);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -4933,207 +4933,207 @@ 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
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, 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;
-        }
+	destoffset = decode_rmXX_address(mod, 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;
+	}
     } else {
-        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;
-        }
+	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;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
diff --git a/drivers/bios_emulator/x86emu/ops2.c b/drivers/bios_emulator/x86emu/ops2.c
index 2412b24..631a340 100644
--- a/drivers/bios_emulator/x86emu/ops2.c
+++ b/drivers/bios_emulator/x86emu/ops2.c
@@ -1,13 +1,13 @@
 /****************************************************************************
 *
-*                       Realmode X86 Emulator Library
+*			Realmode X86 Emulator Library
 *
 *  Copyright (C) 2007 Freescale Semiconductor, Inc. All rights reserved.
 *  Jason Jin <Jason.jin@freescale.com>
 *
-*               Copyright (C) 1991-2004 SciTech Software, Inc.
-*                    Copyright (C) David Mosberger-Tang
-*                      Copyright (C) 1999 Egbert Eich
+*		Copyright (C) 1991-2004 SciTech Software, Inc.
+*		     Copyright (C) David Mosberger-Tang
+*		       Copyright (C) 1999 Egbert Eich
 *
 *  ========================================================================
 *
@@ -17,7 +17,7 @@
 *  both that copyright notice and this permission notice appear in
 *  supporting documentation, and that the name of the authors not be used
 *  in advertising or publicity pertaining to distribution of the software
-*  without specific, written prior permission.  The authors makes no
+*  without specific, written prior permission.	The authors makes no
 *  representations about the suitability of this software for any purpose.
 *  It is provided "as is" without express or implied warranty.
 *
@@ -31,16 +31,16 @@
 *
 *  ========================================================================
 *
-* Language:     ANSI C
-* Environment:  Any
-* Developer:    Kendall Bennett
+* Language:	ANSI C
+* Environment:	Any
+* Developer:	Kendall Bennett
 *
-* Description:  This file includes subroutines to implement the decoding
-*               and emulation of all the x86 extended two-byte processor
-*               instructions.
+* Description:	This file includes subroutines to implement the decoding
+*		and emulation of all the x86 extended two-byte processor
+*		instructions.
 *
-*               Jason port this file to u-boot. Put the function pointer into
-*               got2 sector.
+*		Jason port this file to u-boot. Put the function pointer into
+*		got2 sector.
 *
 ****************************************************************************/
 
@@ -62,7 +62,7 @@ void x86emuOp2_illegal_op(
     DECODE_PRINTF("ILLEGAL EXTENDED X86 OPCODE\n");
     TRACE_REGS();
     printk("%04x:%04x: %02X ILLEGAL EXTENDED X86 OPCODE!\n",
-        M.x86.R_CS, M.x86.R_IP-2,op2);
+	M.x86.R_CS, M.x86.R_IP-2,op2);
     HALT_SYS();
     END_OF_INSTR();
 }
@@ -77,69 +77,69 @@ int x86emu_check_jump_condition(u8 op)
 {
     switch (op) {
       case 0x0:
-        DECODE_PRINTF("JO\t");
-        return ACCESS_FLAG(F_OF);
+	DECODE_PRINTF("JO\t");
+	return ACCESS_FLAG(F_OF);
       case 0x1:
-        DECODE_PRINTF("JNO\t");
-        return !ACCESS_FLAG(F_OF);
-        break;
+	DECODE_PRINTF("JNO\t");
+	return !ACCESS_FLAG(F_OF);
+	break;
       case 0x2:
-        DECODE_PRINTF("JB\t");
-        return ACCESS_FLAG(F_CF);
-        break;
+	DECODE_PRINTF("JB\t");
+	return ACCESS_FLAG(F_CF);
+	break;
       case 0x3:
-        DECODE_PRINTF("JNB\t");
-        return !ACCESS_FLAG(F_CF);
-        break;
+	DECODE_PRINTF("JNB\t");
+	return !ACCESS_FLAG(F_CF);
+	break;
       case 0x4:
-        DECODE_PRINTF("JZ\t");
-        return ACCESS_FLAG(F_ZF);
-        break;
+	DECODE_PRINTF("JZ\t");
+	return ACCESS_FLAG(F_ZF);
+	break;
       case 0x5:
-        DECODE_PRINTF("JNZ\t");
-        return !ACCESS_FLAG(F_ZF);
-        break;
+	DECODE_PRINTF("JNZ\t");
+	return !ACCESS_FLAG(F_ZF);
+	break;
       case 0x6:
-        DECODE_PRINTF("JBE\t");
-        return ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF);
-        break;
+	DECODE_PRINTF("JBE\t");
+	return ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF);
+	break;
       case 0x7:
-        DECODE_PRINTF("JNBE\t");
-        return !(ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF));
-        break;
+	DECODE_PRINTF("JNBE\t");
+	return !(ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF));
+	break;
       case 0x8:
-        DECODE_PRINTF("JS\t");
-        return ACCESS_FLAG(F_SF);
-        break;
+	DECODE_PRINTF("JS\t");
+	return ACCESS_FLAG(F_SF);
+	break;
       case 0x9:
-        DECODE_PRINTF("JNS\t");
-        return !ACCESS_FLAG(F_SF);
-        break;
+	DECODE_PRINTF("JNS\t");
+	return !ACCESS_FLAG(F_SF);
+	break;
       case 0xa:
-        DECODE_PRINTF("JP\t");
-        return ACCESS_FLAG(F_PF);
-        break;
+	DECODE_PRINTF("JP\t");
+	return ACCESS_FLAG(F_PF);
+	break;
       case 0xb:
-        DECODE_PRINTF("JNP\t");
-        return !ACCESS_FLAG(F_PF);
-        break;
+	DECODE_PRINTF("JNP\t");
+	return !ACCESS_FLAG(F_PF);
+	break;
       case 0xc:
-        DECODE_PRINTF("JL\t");
-        return xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF));
-        break;
+	DECODE_PRINTF("JL\t");
+	return xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF));
+	break;
       case 0xd:
-        DECODE_PRINTF("JNL\t");
-        return !xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF));
-        break;
+	DECODE_PRINTF("JNL\t");
+	return !xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF));
+	break;
       case 0xe:
-        DECODE_PRINTF("JLE\t");
-        return (xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF)) ||
-                ACCESS_FLAG(F_ZF));
-        break;
+	DECODE_PRINTF("JLE\t");
+	return (xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF)) ||
+		ACCESS_FLAG(F_ZF));
+	break;
       default:
-        DECODE_PRINTF("JNLE\t");
-        return !(xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF)) ||
-                 ACCESS_FLAG(F_ZF));
+	DECODE_PRINTF("JNLE\t");
+	return !(xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF)) ||
+		 ACCESS_FLAG(F_ZF));
     }
 }
 
@@ -156,7 +156,7 @@ void x86emuOp2_long_jump(u8 op2)
     DECODE_PRINTF2("%04x\n", target);
     TRACE_AND_STEP();
     if (cond)
-        M.x86.R_IP = (u16)target;
+	M.x86.R_IP = (u16)target;
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
 }
@@ -169,89 +169,89 @@ void x86emuOp2_set_byte(u8 op2)
 {
     int mod, rl, rh;
     uint destoffset;
-    u8  *destreg;
+    u8	*destreg;
     char *name = 0;
     int cond = 0;
 
     START_OF_INSTR();
     switch (op2) {
       case 0x90:
-        name = "SETO\t";
-        cond =  ACCESS_FLAG(F_OF);
-        break;
+	name = "SETO\t";
+	cond =	ACCESS_FLAG(F_OF);
+	break;
       case 0x91:
-        name = "SETNO\t";
-        cond = !ACCESS_FLAG(F_OF);
-        break;
+	name = "SETNO\t";
+	cond = !ACCESS_FLAG(F_OF);
+	break;
       case 0x92:
-        name = "SETB\t";
-        cond = ACCESS_FLAG(F_CF);
-        break;
+	name = "SETB\t";
+	cond = ACCESS_FLAG(F_CF);
+	break;
       case 0x93:
-        name = "SETNB\t";
-        cond = !ACCESS_FLAG(F_CF);
-        break;
+	name = "SETNB\t";
+	cond = !ACCESS_FLAG(F_CF);
+	break;
       case 0x94:
-        name = "SETZ\t";
-        cond = ACCESS_FLAG(F_ZF);
-        break;
+	name = "SETZ\t";
+	cond = ACCESS_FLAG(F_ZF);
+	break;
       case 0x95:
-        name = "SETNZ\t";
-        cond = !ACCESS_FLAG(F_ZF);
-        break;
+	name = "SETNZ\t";
+	cond = !ACCESS_FLAG(F_ZF);
+	break;
       case 0x96:
-        name = "SETBE\t";
-        cond = ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF);
-        break;
+	name = "SETBE\t";
+	cond = ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF);
+	break;
       case 0x97:
-        name = "SETNBE\t";
-        cond = !(ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF));
-        break;
+	name = "SETNBE\t";
+	cond = !(ACCESS_FLAG(F_CF) || ACCESS_FLAG(F_ZF));
+	break;
       case 0x98:
-        name = "SETS\t";
-        cond = ACCESS_FLAG(F_SF);
-        break;
+	name = "SETS\t";
+	cond = ACCESS_FLAG(F_SF);
+	break;
       case 0x99:
-        name = "SETNS\t";
-        cond = !ACCESS_FLAG(F_SF);
-        break;
+	name = "SETNS\t";
+	cond = !ACCESS_FLAG(F_SF);
+	break;
       case 0x9a:
-        name = "SETP\t";
-        cond = ACCESS_FLAG(F_PF);
-        break;
+	name = "SETP\t";
+	cond = ACCESS_FLAG(F_PF);
+	break;
       case 0x9b:
-        name = "SETNP\t";
-        cond = !ACCESS_FLAG(F_PF);
-        break;
+	name = "SETNP\t";
+	cond = !ACCESS_FLAG(F_PF);
+	break;
       case 0x9c:
-        name = "SETL\t";
-        cond = xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF));
-        break;
+	name = "SETL\t";
+	cond = xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF));
+	break;
       case 0x9d:
-        name = "SETNL\t";
-        cond = !xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF));
-        break;
+	name = "SETNL\t";
+	cond = !xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF));
+	break;
       case 0x9e:
-        name = "SETLE\t";
-        cond = (xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF)) ||
-                ACCESS_FLAG(F_ZF));
-        break;
+	name = "SETLE\t";
+	cond = (xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF)) ||
+		ACCESS_FLAG(F_ZF));
+	break;
       case 0x9f:
-        name = "SETNLE\t";
-        cond = !(xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF)) ||
-                 ACCESS_FLAG(F_ZF));
-        break;
+	name = "SETNLE\t";
+	cond = !(xorl(ACCESS_FLAG(F_SF), ACCESS_FLAG(F_OF)) ||
+		 ACCESS_FLAG(F_ZF));
+	break;
     }
     DECODE_PRINTF(name);
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, rl);
-        TRACE_AND_STEP();
-        store_data_byte(destoffset, cond ? 0x01 : 0x00);
-    } else {                     /* register to register */
-        destreg = DECODE_RM_BYTE_REGISTER(rl);
-        TRACE_AND_STEP();
-        *destreg = cond ? 0x01 : 0x00;
+	destoffset = decode_rmXX_address(mod, rl);
+	TRACE_AND_STEP();
+	store_data_byte(destoffset, cond ? 0x01 : 0x00);
+    } else {			 /* register to register */
+	destreg = DECODE_RM_BYTE_REGISTER(rl);
+	TRACE_AND_STEP();
+	*destreg = cond ? 0x01 : 0x00;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -299,50 +299,50 @@ void x86emuOp2_bt_R(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("BT\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        srcoffset = decode_rmXX_address(mod, rl);
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 srcval;
-            u32 *shiftreg;
-
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0x1F;
-            disp = (s16)*shiftreg >> 5;
-            srcval = fetch_data_long(srcoffset+disp);
-            CONDITIONAL_SET_FLAG(srcval & (0x1 << bit),F_CF);
-        } else {
-            u16 srcval;
-            u16 *shiftreg;
-
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0xF;
-            disp = (s16)*shiftreg >> 4;
-            srcval = fetch_data_word(srcoffset+disp);
-            CONDITIONAL_SET_FLAG(srcval & (0x1 << bit),F_CF);
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg,*shiftreg;
-
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0x1F;
-            CONDITIONAL_SET_FLAG(*srcreg & (0x1 << bit),F_CF);
-        } else {
-            u16 *srcreg,*shiftreg;
-
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0xF;
-            CONDITIONAL_SET_FLAG(*srcreg & (0x1 << bit),F_CF);
-        }
+	srcoffset = decode_rmXX_address(mod, rl);
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 srcval;
+	    u32 *shiftreg;
+
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0x1F;
+	    disp = (s16)*shiftreg >> 5;
+	    srcval = fetch_data_long(srcoffset+disp);
+	    CONDITIONAL_SET_FLAG(srcval & (0x1 << bit),F_CF);
+	} else {
+	    u16 srcval;
+	    u16 *shiftreg;
+
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0xF;
+	    disp = (s16)*shiftreg >> 4;
+	    srcval = fetch_data_word(srcoffset+disp);
+	    CONDITIONAL_SET_FLAG(srcval & (0x1 << bit),F_CF);
+	}
+    } else {			 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *srcreg,*shiftreg;
+
+	    srcreg = DECODE_RM_LONG_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0x1F;
+	    CONDITIONAL_SET_FLAG(*srcreg & (0x1 << bit),F_CF);
+	} else {
+	    u16 *srcreg,*shiftreg;
+
+	    srcreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0xF;
+	    CONDITIONAL_SET_FLAG(*srcreg & (0x1 << bit),F_CF);
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -362,58 +362,58 @@ void x86emuOp2_shld_IMM(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("SHLD\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, rl);
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *shiftreg;
-
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            shift = fetch_byte_imm();
-            DECODE_PRINTF2("%d\n", shift);
-            TRACE_AND_STEP();
-            destval = fetch_data_long(destoffset);
-            destval = shld_long(destval,*shiftreg,shift);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *shiftreg;
-
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            shift = fetch_byte_imm();
-            DECODE_PRINTF2("%d\n", shift);
-            TRACE_AND_STEP();
-            destval = fetch_data_word(destoffset);
-            destval = shld_word(destval,*shiftreg,shift);
-            store_data_word(destoffset, destval);
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*shiftreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            shift = fetch_byte_imm();
-            DECODE_PRINTF2("%d\n", shift);
-            TRACE_AND_STEP();
-            *destreg = shld_long(*destreg,*shiftreg,shift);
-        } else {
-            u16 *destreg,*shiftreg;
-
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            shift = fetch_byte_imm();
-            DECODE_PRINTF2("%d\n", shift);
-            TRACE_AND_STEP();
-            *destreg = shld_word(*destreg,*shiftreg,shift);
-        }
+	destoffset = decode_rmXX_address(mod, rl);
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval;
+	    u32 *shiftreg;
+
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    shift = fetch_byte_imm();
+	    DECODE_PRINTF2("%d\n", shift);
+	    TRACE_AND_STEP();
+	    destval = fetch_data_long(destoffset);
+	    destval = shld_long(destval,*shiftreg,shift);
+	    store_data_long(destoffset, destval);
+	} else {
+	    u16 destval;
+	    u16 *shiftreg;
+
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    shift = fetch_byte_imm();
+	    DECODE_PRINTF2("%d\n", shift);
+	    TRACE_AND_STEP();
+	    destval = fetch_data_word(destoffset);
+	    destval = shld_word(destval,*shiftreg,shift);
+	    store_data_word(destoffset, destval);
+	}
+    } else {			 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *destreg,*shiftreg;
+
+	    destreg = DECODE_RM_LONG_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    shift = fetch_byte_imm();
+	    DECODE_PRINTF2("%d\n", shift);
+	    TRACE_AND_STEP();
+	    *destreg = shld_long(*destreg,*shiftreg,shift);
+	} else {
+	    u16 *destreg,*shiftreg;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    shift = fetch_byte_imm();
+	    DECODE_PRINTF2("%d\n", shift);
+	    TRACE_AND_STEP();
+	    *destreg = shld_word(*destreg,*shiftreg,shift);
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -432,50 +432,50 @@ void x86emuOp2_shld_CL(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("SHLD\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, rl);
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *shiftreg;
-
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",CL\n");
-            TRACE_AND_STEP();
-            destval = fetch_data_long(destoffset);
-            destval = shld_long(destval,*shiftreg,M.x86.R_CL);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *shiftreg;
-
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",CL\n");
-            TRACE_AND_STEP();
-            destval = fetch_data_word(destoffset);
-            destval = shld_word(destval,*shiftreg,M.x86.R_CL);
-            store_data_word(destoffset, destval);
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*shiftreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",CL\n");
-            TRACE_AND_STEP();
-            *destreg = shld_long(*destreg,*shiftreg,M.x86.R_CL);
-        } else {
-            u16 *destreg,*shiftreg;
-
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",CL\n");
-            TRACE_AND_STEP();
-            *destreg = shld_word(*destreg,*shiftreg,M.x86.R_CL);
-        }
+	destoffset = decode_rmXX_address(mod, rl);
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval;
+	    u32 *shiftreg;
+
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",CL\n");
+	    TRACE_AND_STEP();
+	    destval = fetch_data_long(destoffset);
+	    destval = shld_long(destval,*shiftreg,M.x86.R_CL);
+	    store_data_long(destoffset, destval);
+	} else {
+	    u16 destval;
+	    u16 *shiftreg;
+
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",CL\n");
+	    TRACE_AND_STEP();
+	    destval = fetch_data_word(destoffset);
+	    destval = shld_word(destval,*shiftreg,M.x86.R_CL);
+	    store_data_word(destoffset, destval);
+	}
+    } else {			 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *destreg,*shiftreg;
+
+	    destreg = DECODE_RM_LONG_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",CL\n");
+	    TRACE_AND_STEP();
+	    *destreg = shld_long(*destreg,*shiftreg,M.x86.R_CL);
+	} else {
+	    u16 *destreg,*shiftreg;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",CL\n");
+	    TRACE_AND_STEP();
+	    *destreg = shld_word(*destreg,*shiftreg,M.x86.R_CL);
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -523,60 +523,60 @@ void x86emuOp2_bts_R(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("BTS\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        srcoffset = decode_rmXX_address(mod, rl);
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 srcval,mask;
-            u32 *shiftreg;
-
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0x1F;
-            disp = (s16)*shiftreg >> 5;
-            srcval = fetch_data_long(srcoffset+disp);
-            mask = (0x1 << bit);
-            CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
-            store_data_long(srcoffset+disp, srcval | mask);
-        } else {
-            u16 srcval,mask;
-            u16 *shiftreg;
-
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0xF;
-            disp = (s16)*shiftreg >> 4;
-            srcval = fetch_data_word(srcoffset+disp);
-            mask = (u16)(0x1 << bit);
-            CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
-            store_data_word(srcoffset+disp, srcval | mask);
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg,*shiftreg;
-            u32 mask;
-
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0x1F;
-            mask = (0x1 << bit);
-            CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
-            *srcreg |= mask;
-        } else {
-            u16 *srcreg,*shiftreg;
-            u16 mask;
-
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0xF;
-            mask = (u16)(0x1 << bit);
-            CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
-            *srcreg |= mask;
-        }
+	srcoffset = decode_rmXX_address(mod, rl);
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 srcval,mask;
+	    u32 *shiftreg;
+
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0x1F;
+	    disp = (s16)*shiftreg >> 5;
+	    srcval = fetch_data_long(srcoffset+disp);
+	    mask = (0x1 << bit);
+	    CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
+	    store_data_long(srcoffset+disp, srcval | mask);
+	} else {
+	    u16 srcval,mask;
+	    u16 *shiftreg;
+
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0xF;
+	    disp = (s16)*shiftreg >> 4;
+	    srcval = fetch_data_word(srcoffset+disp);
+	    mask = (u16)(0x1 << bit);
+	    CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
+	    store_data_word(srcoffset+disp, srcval | mask);
+	}
+    } else {			 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *srcreg,*shiftreg;
+	    u32 mask;
+
+	    srcreg = DECODE_RM_LONG_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0x1F;
+	    mask = (0x1 << bit);
+	    CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
+	    *srcreg |= mask;
+	} else {
+	    u16 *srcreg,*shiftreg;
+	    u16 mask;
+
+	    srcreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0xF;
+	    mask = (u16)(0x1 << bit);
+	    CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
+	    *srcreg |= mask;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -596,58 +596,58 @@ void x86emuOp2_shrd_IMM(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("SHLD\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, rl);
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *shiftreg;
-
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            shift = fetch_byte_imm();
-            DECODE_PRINTF2("%d\n", shift);
-            TRACE_AND_STEP();
-            destval = fetch_data_long(destoffset);
-            destval = shrd_long(destval,*shiftreg,shift);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *shiftreg;
-
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            shift = fetch_byte_imm();
-            DECODE_PRINTF2("%d\n", shift);
-            TRACE_AND_STEP();
-            destval = fetch_data_word(destoffset);
-            destval = shrd_word(destval,*shiftreg,shift);
-            store_data_word(destoffset, destval);
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*shiftreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            shift = fetch_byte_imm();
-            DECODE_PRINTF2("%d\n", shift);
-            TRACE_AND_STEP();
-            *destreg = shrd_long(*destreg,*shiftreg,shift);
-        } else {
-            u16 *destreg,*shiftreg;
-
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            shift = fetch_byte_imm();
-            DECODE_PRINTF2("%d\n", shift);
-            TRACE_AND_STEP();
-            *destreg = shrd_word(*destreg,*shiftreg,shift);
-        }
+	destoffset = decode_rmXX_address(mod, rl);
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval;
+	    u32 *shiftreg;
+
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    shift = fetch_byte_imm();
+	    DECODE_PRINTF2("%d\n", shift);
+	    TRACE_AND_STEP();
+	    destval = fetch_data_long(destoffset);
+	    destval = shrd_long(destval,*shiftreg,shift);
+	    store_data_long(destoffset, destval);
+	} else {
+	    u16 destval;
+	    u16 *shiftreg;
+
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    shift = fetch_byte_imm();
+	    DECODE_PRINTF2("%d\n", shift);
+	    TRACE_AND_STEP();
+	    destval = fetch_data_word(destoffset);
+	    destval = shrd_word(destval,*shiftreg,shift);
+	    store_data_word(destoffset, destval);
+	}
+    } else {			 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *destreg,*shiftreg;
+
+	    destreg = DECODE_RM_LONG_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    shift = fetch_byte_imm();
+	    DECODE_PRINTF2("%d\n", shift);
+	    TRACE_AND_STEP();
+	    *destreg = shrd_long(*destreg,*shiftreg,shift);
+	} else {
+	    u16 *destreg,*shiftreg;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    shift = fetch_byte_imm();
+	    DECODE_PRINTF2("%d\n", shift);
+	    TRACE_AND_STEP();
+	    *destreg = shrd_word(*destreg,*shiftreg,shift);
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -666,49 +666,49 @@ void x86emuOp2_shrd_CL(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("SHLD\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF(",");
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 destval;
-            u32 *shiftreg;
-
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",CL\n");
-            TRACE_AND_STEP();
-            destval = fetch_data_long(destoffset);
-            destval = shrd_long(destval,*shiftreg,M.x86.R_CL);
-            store_data_long(destoffset, destval);
-        } else {
-            u16 destval;
-            u16 *shiftreg;
-
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",CL\n");
-            TRACE_AND_STEP();
-            destval = fetch_data_word(destoffset);
-            destval = shrd_word(destval,*shiftreg,M.x86.R_CL);
-            store_data_word(destoffset, destval);
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg,*shiftreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",CL\n");
-            TRACE_AND_STEP();
-            *destreg = shrd_long(*destreg,*shiftreg,M.x86.R_CL);
-        } else {
-            u16 *destreg,*shiftreg;
-
-            destreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",CL\n");
-            TRACE_AND_STEP();
-            *destreg = shrd_word(*destreg,*shiftreg,M.x86.R_CL);
-        }
+	destoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF(",");
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 destval;
+	    u32 *shiftreg;
+
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",CL\n");
+	    TRACE_AND_STEP();
+	    destval = fetch_data_long(destoffset);
+	    destval = shrd_long(destval,*shiftreg,M.x86.R_CL);
+	    store_data_long(destoffset, destval);
+	} else {
+	    u16 destval;
+	    u16 *shiftreg;
+
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",CL\n");
+	    TRACE_AND_STEP();
+	    destval = fetch_data_word(destoffset);
+	    destval = shrd_word(destval,*shiftreg,M.x86.R_CL);
+	    store_data_word(destoffset, destval);
+	}
+    } else {			 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *destreg,*shiftreg;
+
+	    destreg = DECODE_RM_LONG_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",CL\n");
+	    TRACE_AND_STEP();
+	    *destreg = shrd_long(*destreg,*shiftreg,M.x86.R_CL);
+	} else {
+	    u16 *destreg,*shiftreg;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",CL\n");
+	    TRACE_AND_STEP();
+	    *destreg = shrd_word(*destreg,*shiftreg,M.x86.R_CL);
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -727,80 +727,80 @@ void x86emuOp2_imul_R_RM(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("IMUL\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        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_rmXX_address(mod, rl);
-            srcval = fetch_data_long(srcoffset);
-            TRACE_AND_STEP();
-            imul_long_direct(&res_lo,&res_hi,(s32)*destreg,(s32)srcval);
-            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_rmXX_address(mod, rl);
-            srcval = fetch_data_word(srcoffset);
-            TRACE_AND_STEP();
-            res = (s16)*destreg * (s16)srcval;
-            if (res > 0xFFFF) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
-    } else {                     /* 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);
-            TRACE_AND_STEP();
-            imul_long_direct(&res_lo,&res_hi,(s32)*destreg,(s32)*srcreg);
-            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);
-            res = (s16)*destreg * (s16)*srcreg;
-            if (res > 0xFFFF) {
-                SET_FLAG(F_CF);
-                SET_FLAG(F_OF);
-            } else {
-                CLEAR_FLAG(F_CF);
-                CLEAR_FLAG(F_OF);
-            }
-            *destreg = (u16)res;
-        }
+	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_rmXX_address(mod, rl);
+	    srcval = fetch_data_long(srcoffset);
+	    TRACE_AND_STEP();
+	    imul_long_direct(&res_lo,&res_hi,(s32)*destreg,(s32)srcval);
+	    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_rmXX_address(mod, rl);
+	    srcval = fetch_data_word(srcoffset);
+	    TRACE_AND_STEP();
+	    res = (s16)*destreg * (s16)srcval;
+	    if (res > 0xFFFF) {
+		SET_FLAG(F_CF);
+		SET_FLAG(F_OF);
+	    } else {
+		CLEAR_FLAG(F_CF);
+		CLEAR_FLAG(F_OF);
+	    }
+	    *destreg = (u16)res;
+	}
+    } else {			 /* 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);
+	    TRACE_AND_STEP();
+	    imul_long_direct(&res_lo,&res_hi,(s32)*destreg,(s32)*srcreg);
+	    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);
+	    res = (s16)*destreg * (s16)*srcreg;
+	    if (res > 0xFFFF) {
+		SET_FLAG(F_CF);
+		SET_FLAG(F_OF);
+	    } else {
+		CLEAR_FLAG(F_CF);
+		CLEAR_FLAG(F_OF);
+	    }
+	    *destreg = (u16)res;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -820,16 +820,16 @@ void x86emuOp2_lss_R_IMM(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("LSS\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        dstreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *dstreg = fetch_data_word(srcoffset);
-        M.x86.R_SS = fetch_data_word(srcoffset + 2);
-    } else {                     /* register to register */
-        /* UNDEFINED! */
-        TRACE_AND_STEP();
+	dstreg = DECODE_RM_WORD_REGISTER(rh);
+	DECODE_PRINTF(",");
+	srcoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*dstreg = fetch_data_word(srcoffset);
+	M.x86.R_SS = fetch_data_word(srcoffset + 2);
+    } else {			 /* register to register */
+	/* UNDEFINED! */
+	TRACE_AND_STEP();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -849,59 +849,59 @@ void x86emuOp2_btr_R(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("BTR\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        srcoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF(",");
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 srcval,mask;
-            u32 *shiftreg;
-
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0x1F;
-            disp = (s16)*shiftreg >> 5;
-            srcval = fetch_data_long(srcoffset+disp);
-            mask = (0x1 << bit);
-            CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
-            store_data_long(srcoffset+disp, srcval & ~mask);
-        } else {
-            u16 srcval,mask;
-            u16 *shiftreg;
-
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0xF;
-            disp = (s16)*shiftreg >> 4;
-            srcval = fetch_data_word(srcoffset+disp);
-            mask = (u16)(0x1 << bit);
-            CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
-            store_data_word(srcoffset+disp, (u16)(srcval & ~mask));
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg,*shiftreg;
-            u32 mask;
-
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0x1F;
-            mask = (0x1 << bit);
-            CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
-            *srcreg &= ~mask;
-        } else {
-            u16 *srcreg,*shiftreg;
-            u16 mask;
-
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0xF;
-            mask = (u16)(0x1 << bit);
-            CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
-            *srcreg &= ~mask;
-        }
+	srcoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF(",");
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 srcval,mask;
+	    u32 *shiftreg;
+
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0x1F;
+	    disp = (s16)*shiftreg >> 5;
+	    srcval = fetch_data_long(srcoffset+disp);
+	    mask = (0x1 << bit);
+	    CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
+	    store_data_long(srcoffset+disp, srcval & ~mask);
+	} else {
+	    u16 srcval,mask;
+	    u16 *shiftreg;
+
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0xF;
+	    disp = (s16)*shiftreg >> 4;
+	    srcval = fetch_data_word(srcoffset+disp);
+	    mask = (u16)(0x1 << bit);
+	    CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
+	    store_data_word(srcoffset+disp, (u16)(srcval & ~mask));
+	}
+    } else {			 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *srcreg,*shiftreg;
+	    u32 mask;
+
+	    srcreg = DECODE_RM_LONG_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0x1F;
+	    mask = (0x1 << bit);
+	    CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
+	    *srcreg &= ~mask;
+	} else {
+	    u16 *srcreg,*shiftreg;
+	    u16 mask;
+
+	    srcreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0xF;
+	    mask = (u16)(0x1 << bit);
+	    CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
+	    *srcreg &= ~mask;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -921,16 +921,16 @@ void x86emuOp2_lfs_R_IMM(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("LFS\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        dstreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *dstreg = fetch_data_word(srcoffset);
-        M.x86.R_FS = fetch_data_word(srcoffset + 2);
-    } else {                     /* register to register */
-        /* UNDEFINED! */
-        TRACE_AND_STEP();
+	dstreg = DECODE_RM_WORD_REGISTER(rh);
+	DECODE_PRINTF(",");
+	srcoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*dstreg = fetch_data_word(srcoffset);
+	M.x86.R_FS = fetch_data_word(srcoffset + 2);
+    } else {			 /* register to register */
+	/* UNDEFINED! */
+	TRACE_AND_STEP();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -950,16 +950,16 @@ void x86emuOp2_lgs_R_IMM(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("LGS\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        dstreg = DECODE_RM_WORD_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *dstreg = fetch_data_word(srcoffset);
-        M.x86.R_GS = fetch_data_word(srcoffset + 2);
-    } else {                     /* register to register */
-        /* UNDEFINED! */
-        TRACE_AND_STEP();
+	dstreg = DECODE_RM_WORD_REGISTER(rh);
+	DECODE_PRINTF(",");
+	srcoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*dstreg = fetch_data_word(srcoffset);
+	M.x86.R_GS = fetch_data_word(srcoffset + 2);
+    } else {			 /* register to register */
+	/* UNDEFINED! */
+	TRACE_AND_STEP();
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -978,51 +978,51 @@ void x86emuOp2_movzx_byte_R_RM(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("MOVZX\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rmXX_address(mod, rl);
-            srcval = fetch_data_byte(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = srcval;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rmXX_address(mod, rl);
-            srcval = fetch_data_byte(srcoffset);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = srcval;
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u8  *srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_BYTE_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = *srcreg;
-        } else {
-            u16 *destreg;
-            u8  *srcreg;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_BYTE_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = *srcreg;
-        }
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *destreg;
+	    u32 srcval;
+
+	    destreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcoffset = decode_rmXX_address(mod, rl);
+	    srcval = fetch_data_byte(srcoffset);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = srcval;
+	} else {
+	    u16 *destreg;
+	    u16 srcval;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcoffset = decode_rmXX_address(mod, rl);
+	    srcval = fetch_data_byte(srcoffset);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = srcval;
+	}
+    } else {			 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *destreg;
+	    u8	*srcreg;
+
+	    destreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcreg = DECODE_RM_BYTE_REGISTER(rl);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = *srcreg;
+	} else {
+	    u16 *destreg;
+	    u8	*srcreg;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcreg = DECODE_RM_BYTE_REGISTER(rl);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = *srcreg;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1044,20 +1044,20 @@ void x86emuOp2_movzx_word_R_RM(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("MOVZX\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destreg = DECODE_RM_LONG_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rmXX_address(mod, rl);
-        srcval = fetch_data_word(srcoffset);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = srcval;
-    } else {                     /* register to register */
-        destreg = DECODE_RM_LONG_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_WORD_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = *srcreg;
+	destreg = DECODE_RM_LONG_REGISTER(rh);
+	DECODE_PRINTF(",");
+	srcoffset = decode_rmXX_address(mod, rl);
+	srcval = fetch_data_word(srcoffset);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*destreg = srcval;
+    } else {			 /* register to register */
+	destreg = DECODE_RM_LONG_REGISTER(rh);
+	DECODE_PRINTF(",");
+	srcreg = DECODE_RM_WORD_REGISTER(rl);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*destreg = *srcreg;
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1078,122 +1078,122 @@ void x86emuOp2_btX_I(u8 X86EMU_UNUSED(op2))
     FETCH_DECODE_MODRM(mod, rh, rl);
     switch (rh) {
     case 4:
-        DECODE_PRINTF("BT\t");
-        break;
+	DECODE_PRINTF("BT\t");
+	break;
     case 5:
-        DECODE_PRINTF("BTS\t");
-        break;
+	DECODE_PRINTF("BTS\t");
+	break;
     case 6:
-        DECODE_PRINTF("BTR\t");
-        break;
+	DECODE_PRINTF("BTR\t");
+	break;
     case 7:
-        DECODE_PRINTF("BTC\t");
-        break;
+	DECODE_PRINTF("BTC\t");
+	break;
     default:
-        DECODE_PRINTF("ILLEGAL EXTENDED X86 OPCODE\n");
-        TRACE_REGS();
-        printk("%04x:%04x: %02X%02X ILLEGAL EXTENDED X86 OPCODE EXTENSION!\n",
-                M.x86.R_CS, M.x86.R_IP-3,op2, (mod<<6)|(rh<<3)|rl);
-        HALT_SYS();
+	DECODE_PRINTF("ILLEGAL EXTENDED X86 OPCODE\n");
+	TRACE_REGS();
+	printk("%04x:%04x: %02X%02X ILLEGAL EXTENDED X86 OPCODE EXTENSION!\n",
+		M.x86.R_CS, M.x86.R_IP-3,op2, (mod<<6)|(rh<<3)|rl);
+	HALT_SYS();
     }
     if (mod < 3) {
 
-        srcoffset = decode_rmXX_address(mod, rl);
-        shift = fetch_byte_imm();
-        DECODE_PRINTF2(",%d\n", shift);
-        TRACE_AND_STEP();
-
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 srcval, mask;
-
-            bit = shift & 0x1F;
-            srcval = fetch_data_long(srcoffset);
-            mask = (0x1 << bit);
-            CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
-            switch (rh) {
-            case 5:
-                store_data_long(srcoffset, srcval | mask);
-                break;
-            case 6:
-                store_data_long(srcoffset, srcval & ~mask);
-                break;
-            case 7:
-                store_data_long(srcoffset, srcval ^ mask);
-                break;
-            default:
-                break;
-            }
-        } else {
-            u16 srcval, mask;
-
-            bit = shift & 0xF;
-            srcval = fetch_data_word(srcoffset);
-            mask = (0x1 << bit);
-            CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
-            switch (rh) {
-            case 5:
-                store_data_word(srcoffset, srcval | mask);
-                break;
-            case 6:
-                store_data_word(srcoffset, srcval & ~mask);
-                break;
-            case 7:
-                store_data_word(srcoffset, srcval ^ mask);
-                break;
-            default:
-                break;
-            }
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg;
-            u32 mask;
-
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            shift = fetch_byte_imm();
-            DECODE_PRINTF2(",%d\n", shift);
-            TRACE_AND_STEP();
-            bit = shift & 0x1F;
-            mask = (0x1 << bit);
-            CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
-            switch (rh) {
-            case 5:
-                *srcreg |= mask;
-                break;
-            case 6:
-                *srcreg &= ~mask;
-                break;
-            case 7:
-                *srcreg ^= mask;
-                break;
-            default:
-                break;
-            }
-        } else {
-            u16 *srcreg;
-            u16 mask;
-
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            shift = fetch_byte_imm();
-            DECODE_PRINTF2(",%d\n", shift);
-            TRACE_AND_STEP();
-            bit = shift & 0xF;
-            mask = (0x1 << bit);
-            CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
-            switch (rh) {
-            case 5:
-                *srcreg |= mask;
-                break;
-            case 6:
-                *srcreg &= ~mask;
-                break;
-            case 7:
-                *srcreg ^= mask;
-                break;
-            default:
-                break;
-            }
-        }
+	srcoffset = decode_rmXX_address(mod, rl);
+	shift = fetch_byte_imm();
+	DECODE_PRINTF2(",%d\n", shift);
+	TRACE_AND_STEP();
+
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 srcval, mask;
+
+	    bit = shift & 0x1F;
+	    srcval = fetch_data_long(srcoffset);
+	    mask = (0x1 << bit);
+	    CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
+	    switch (rh) {
+	    case 5:
+		store_data_long(srcoffset, srcval | mask);
+		break;
+	    case 6:
+		store_data_long(srcoffset, srcval & ~mask);
+		break;
+	    case 7:
+		store_data_long(srcoffset, srcval ^ mask);
+		break;
+	    default:
+		break;
+	    }
+	} else {
+	    u16 srcval, mask;
+
+	    bit = shift & 0xF;
+	    srcval = fetch_data_word(srcoffset);
+	    mask = (0x1 << bit);
+	    CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
+	    switch (rh) {
+	    case 5:
+		store_data_word(srcoffset, srcval | mask);
+		break;
+	    case 6:
+		store_data_word(srcoffset, srcval & ~mask);
+		break;
+	    case 7:
+		store_data_word(srcoffset, srcval ^ mask);
+		break;
+	    default:
+		break;
+	    }
+	}
+    } else {			 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *srcreg;
+	    u32 mask;
+
+	    srcreg = DECODE_RM_LONG_REGISTER(rl);
+	    shift = fetch_byte_imm();
+	    DECODE_PRINTF2(",%d\n", shift);
+	    TRACE_AND_STEP();
+	    bit = shift & 0x1F;
+	    mask = (0x1 << bit);
+	    CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
+	    switch (rh) {
+	    case 5:
+		*srcreg |= mask;
+		break;
+	    case 6:
+		*srcreg &= ~mask;
+		break;
+	    case 7:
+		*srcreg ^= mask;
+		break;
+	    default:
+		break;
+	    }
+	} else {
+	    u16 *srcreg;
+	    u16 mask;
+
+	    srcreg = DECODE_RM_WORD_REGISTER(rl);
+	    shift = fetch_byte_imm();
+	    DECODE_PRINTF2(",%d\n", shift);
+	    TRACE_AND_STEP();
+	    bit = shift & 0xF;
+	    mask = (0x1 << bit);
+	    CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
+	    switch (rh) {
+	    case 5:
+		*srcreg |= mask;
+		break;
+	    case 6:
+		*srcreg &= ~mask;
+		break;
+	    case 7:
+		*srcreg ^= mask;
+		break;
+	    default:
+		break;
+	    }
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1213,59 +1213,59 @@ void x86emuOp2_btc_R(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("BTC\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        srcoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF(",");
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 srcval,mask;
-            u32 *shiftreg;
-
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0x1F;
-            disp = (s16)*shiftreg >> 5;
-            srcval = fetch_data_long(srcoffset+disp);
-            mask = (0x1 << bit);
-            CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
-            store_data_long(srcoffset+disp, srcval ^ mask);
-        } else {
-            u16 srcval,mask;
-            u16 *shiftreg;
-
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0xF;
-            disp = (s16)*shiftreg >> 4;
-            srcval = fetch_data_word(srcoffset+disp);
-            mask = (u16)(0x1 << bit);
-            CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
-            store_data_word(srcoffset+disp, (u16)(srcval ^ mask));
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg,*shiftreg;
-            u32 mask;
-
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_LONG_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0x1F;
-            mask = (0x1 << bit);
-            CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
-            *srcreg ^= mask;
-        } else {
-            u16 *srcreg,*shiftreg;
-            u16 mask;
-
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            shiftreg = DECODE_RM_WORD_REGISTER(rh);
-            TRACE_AND_STEP();
-            bit = *shiftreg & 0xF;
-            mask = (u16)(0x1 << bit);
-            CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
-            *srcreg ^= mask;
-        }
+	srcoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF(",");
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 srcval,mask;
+	    u32 *shiftreg;
+
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0x1F;
+	    disp = (s16)*shiftreg >> 5;
+	    srcval = fetch_data_long(srcoffset+disp);
+	    mask = (0x1 << bit);
+	    CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
+	    store_data_long(srcoffset+disp, srcval ^ mask);
+	} else {
+	    u16 srcval,mask;
+	    u16 *shiftreg;
+
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0xF;
+	    disp = (s16)*shiftreg >> 4;
+	    srcval = fetch_data_word(srcoffset+disp);
+	    mask = (u16)(0x1 << bit);
+	    CONDITIONAL_SET_FLAG(srcval & mask,F_CF);
+	    store_data_word(srcoffset+disp, (u16)(srcval ^ mask));
+	}
+    } else {			 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *srcreg,*shiftreg;
+	    u32 mask;
+
+	    srcreg = DECODE_RM_LONG_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_LONG_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0x1F;
+	    mask = (0x1 << bit);
+	    CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
+	    *srcreg ^= mask;
+	} else {
+	    u16 *srcreg,*shiftreg;
+	    u16 mask;
+
+	    srcreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    shiftreg = DECODE_RM_WORD_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    bit = *shiftreg & 0xF;
+	    mask = (u16)(0x1 << bit);
+	    CONDITIONAL_SET_FLAG(*srcreg & mask,F_CF);
+	    *srcreg ^= mask;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1284,49 +1284,49 @@ void x86emuOp2_bsf(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("BSF\n");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        srcoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF(",");
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 srcval, *dstreg;
-
-            dstreg = DECODE_RM_LONG_REGISTER(rh);
-            TRACE_AND_STEP();
-            srcval = fetch_data_long(srcoffset);
-            CONDITIONAL_SET_FLAG(srcval == 0, F_ZF);
-            for(*dstreg = 0; *dstreg < 32; (*dstreg)++)
-                if ((srcval >> *dstreg) & 1) break;
-        } else {
-            u16 srcval, *dstreg;
-
-            dstreg = DECODE_RM_WORD_REGISTER(rh);
-            TRACE_AND_STEP();
-            srcval = fetch_data_word(srcoffset);
-            CONDITIONAL_SET_FLAG(srcval == 0, F_ZF);
-            for(*dstreg = 0; *dstreg < 16; (*dstreg)++)
-                if ((srcval >> *dstreg) & 1) break;
-        }
-    } else {             /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg, *dstreg;
-
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            dstreg = DECODE_RM_LONG_REGISTER(rh);
-            TRACE_AND_STEP();
-            CONDITIONAL_SET_FLAG(*srcreg == 0, F_ZF);
-            for(*dstreg = 0; *dstreg < 32; (*dstreg)++)
-                if ((*srcreg >> *dstreg) & 1) break;
-        } else {
-            u16 *srcreg, *dstreg;
-
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            dstreg = DECODE_RM_WORD_REGISTER(rh);
-            TRACE_AND_STEP();
-            CONDITIONAL_SET_FLAG(*srcreg == 0, F_ZF);
-            for(*dstreg = 0; *dstreg < 16; (*dstreg)++)
-                if ((*srcreg >> *dstreg) & 1) break;
-        }
+	srcoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF(",");
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 srcval, *dstreg;
+
+	    dstreg = DECODE_RM_LONG_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    srcval = fetch_data_long(srcoffset);
+	    CONDITIONAL_SET_FLAG(srcval == 0, F_ZF);
+	    for(*dstreg = 0; *dstreg < 32; (*dstreg)++)
+		if ((srcval >> *dstreg) & 1) break;
+	} else {
+	    u16 srcval, *dstreg;
+
+	    dstreg = DECODE_RM_WORD_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    srcval = fetch_data_word(srcoffset);
+	    CONDITIONAL_SET_FLAG(srcval == 0, F_ZF);
+	    for(*dstreg = 0; *dstreg < 16; (*dstreg)++)
+		if ((srcval >> *dstreg) & 1) break;
+	}
+    } else {		 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *srcreg, *dstreg;
+
+	    srcreg = DECODE_RM_LONG_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    dstreg = DECODE_RM_LONG_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    CONDITIONAL_SET_FLAG(*srcreg == 0, F_ZF);
+	    for(*dstreg = 0; *dstreg < 32; (*dstreg)++)
+		if ((*srcreg >> *dstreg) & 1) break;
+	} else {
+	    u16 *srcreg, *dstreg;
+
+	    srcreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    dstreg = DECODE_RM_WORD_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    CONDITIONAL_SET_FLAG(*srcreg == 0, F_ZF);
+	    for(*dstreg = 0; *dstreg < 16; (*dstreg)++)
+		if ((*srcreg >> *dstreg) & 1) break;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1345,49 +1345,49 @@ void x86emuOp2_bsr(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("BSF\n");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        srcoffset = decode_rmXX_address(mod, rl);
-        DECODE_PRINTF(",");
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 srcval, *dstreg;
-
-            dstreg = DECODE_RM_LONG_REGISTER(rh);
-            TRACE_AND_STEP();
-            srcval = fetch_data_long(srcoffset);
-            CONDITIONAL_SET_FLAG(srcval == 0, F_ZF);
-            for(*dstreg = 31; *dstreg > 0; (*dstreg)--)
-                if ((srcval >> *dstreg) & 1) break;
-        } else {
-            u16 srcval, *dstreg;
-
-            dstreg = DECODE_RM_WORD_REGISTER(rh);
-            TRACE_AND_STEP();
-            srcval = fetch_data_word(srcoffset);
-            CONDITIONAL_SET_FLAG(srcval == 0, F_ZF);
-            for(*dstreg = 15; *dstreg > 0; (*dstreg)--)
-                if ((srcval >> *dstreg) & 1) break;
-        }
-    } else {             /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *srcreg, *dstreg;
-
-            srcreg = DECODE_RM_LONG_REGISTER(rl);
-            DECODE_PRINTF(",");
-            dstreg = DECODE_RM_LONG_REGISTER(rh);
-            TRACE_AND_STEP();
-            CONDITIONAL_SET_FLAG(*srcreg == 0, F_ZF);
-            for(*dstreg = 31; *dstreg > 0; (*dstreg)--)
-                if ((*srcreg >> *dstreg) & 1) break;
-        } else {
-            u16 *srcreg, *dstreg;
-
-            srcreg = DECODE_RM_WORD_REGISTER(rl);
-            DECODE_PRINTF(",");
-            dstreg = DECODE_RM_WORD_REGISTER(rh);
-            TRACE_AND_STEP();
-            CONDITIONAL_SET_FLAG(*srcreg == 0, F_ZF);
-            for(*dstreg = 15; *dstreg > 0; (*dstreg)--)
-                if ((*srcreg >> *dstreg) & 1) break;
-        }
+	srcoffset = decode_rmXX_address(mod, rl);
+	DECODE_PRINTF(",");
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 srcval, *dstreg;
+
+	    dstreg = DECODE_RM_LONG_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    srcval = fetch_data_long(srcoffset);
+	    CONDITIONAL_SET_FLAG(srcval == 0, F_ZF);
+	    for(*dstreg = 31; *dstreg > 0; (*dstreg)--)
+		if ((srcval >> *dstreg) & 1) break;
+	} else {
+	    u16 srcval, *dstreg;
+
+	    dstreg = DECODE_RM_WORD_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    srcval = fetch_data_word(srcoffset);
+	    CONDITIONAL_SET_FLAG(srcval == 0, F_ZF);
+	    for(*dstreg = 15; *dstreg > 0; (*dstreg)--)
+		if ((srcval >> *dstreg) & 1) break;
+	}
+    } else {		 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *srcreg, *dstreg;
+
+	    srcreg = DECODE_RM_LONG_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    dstreg = DECODE_RM_LONG_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    CONDITIONAL_SET_FLAG(*srcreg == 0, F_ZF);
+	    for(*dstreg = 31; *dstreg > 0; (*dstreg)--)
+		if ((*srcreg >> *dstreg) & 1) break;
+	} else {
+	    u16 *srcreg, *dstreg;
+
+	    srcreg = DECODE_RM_WORD_REGISTER(rl);
+	    DECODE_PRINTF(",");
+	    dstreg = DECODE_RM_WORD_REGISTER(rh);
+	    TRACE_AND_STEP();
+	    CONDITIONAL_SET_FLAG(*srcreg == 0, F_ZF);
+	    for(*dstreg = 15; *dstreg > 0; (*dstreg)--)
+		if ((*srcreg >> *dstreg) & 1) break;
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1406,51 +1406,51 @@ void x86emuOp2_movsx_byte_R_RM(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("MOVSX\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u32 srcval;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rmXX_address(mod, rl);
-            srcval = (s32)((s8)fetch_data_byte(srcoffset));
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = srcval;
-        } else {
-            u16 *destreg;
-            u16 srcval;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcoffset = decode_rmXX_address(mod, rl);
-            srcval = (s16)((s8)fetch_data_byte(srcoffset));
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = srcval;
-        }
-    } else {                     /* register to register */
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            u32 *destreg;
-            u8  *srcreg;
-
-            destreg = DECODE_RM_LONG_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_BYTE_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = (s32)((s8)*srcreg);
-        } else {
-            u16 *destreg;
-            u8  *srcreg;
-
-            destreg = DECODE_RM_WORD_REGISTER(rh);
-            DECODE_PRINTF(",");
-            srcreg = DECODE_RM_BYTE_REGISTER(rl);
-            DECODE_PRINTF("\n");
-            TRACE_AND_STEP();
-            *destreg = (s16)((s8)*srcreg);
-        }
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *destreg;
+	    u32 srcval;
+
+	    destreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcoffset = decode_rmXX_address(mod, rl);
+	    srcval = (s32)((s8)fetch_data_byte(srcoffset));
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = srcval;
+	} else {
+	    u16 *destreg;
+	    u16 srcval;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcoffset = decode_rmXX_address(mod, rl);
+	    srcval = (s16)((s8)fetch_data_byte(srcoffset));
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = srcval;
+	}
+    } else {			 /* register to register */
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    u32 *destreg;
+	    u8	*srcreg;
+
+	    destreg = DECODE_RM_LONG_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcreg = DECODE_RM_BYTE_REGISTER(rl);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = (s32)((s8)*srcreg);
+	} else {
+	    u16 *destreg;
+	    u8	*srcreg;
+
+	    destreg = DECODE_RM_WORD_REGISTER(rh);
+	    DECODE_PRINTF(",");
+	    srcreg = DECODE_RM_BYTE_REGISTER(rl);
+	    DECODE_PRINTF("\n");
+	    TRACE_AND_STEP();
+	    *destreg = (s16)((s8)*srcreg);
+	}
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1472,20 +1472,20 @@ void x86emuOp2_movsx_word_R_RM(u8 X86EMU_UNUSED(op2))
     DECODE_PRINTF("MOVSX\t");
     FETCH_DECODE_MODRM(mod, rh, rl);
     if (mod < 3) {
-        destreg = DECODE_RM_LONG_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcoffset = decode_rmXX_address(mod, rl);
-        srcval = (s32)((s16)fetch_data_word(srcoffset));
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = srcval;
-    } else {                     /* register to register */
-        destreg = DECODE_RM_LONG_REGISTER(rh);
-        DECODE_PRINTF(",");
-        srcreg = DECODE_RM_WORD_REGISTER(rl);
-        DECODE_PRINTF("\n");
-        TRACE_AND_STEP();
-        *destreg = (s32)((s16)*srcreg);
+	destreg = DECODE_RM_LONG_REGISTER(rh);
+	DECODE_PRINTF(",");
+	srcoffset = decode_rmXX_address(mod, rl);
+	srcval = (s32)((s16)fetch_data_word(srcoffset));
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*destreg = srcval;
+    } else {			 /* register to register */
+	destreg = DECODE_RM_LONG_REGISTER(rh);
+	DECODE_PRINTF(",");
+	srcreg = DECODE_RM_WORD_REGISTER(rl);
+	DECODE_PRINTF("\n");
+	TRACE_AND_STEP();
+	*destreg = (s32)((s16)*srcreg);
     }
     DECODE_CLEAR_SEGOVR();
     END_OF_INSTR();
@@ -1498,13 +1498,13 @@ void (*x86emu_optab2[256])(u8) __attribute__((section(".got2"))) =
 {
 /*  0x00 */ x86emuOp2_illegal_op,  /* Group F (ring 0 PM)      */
 /*  0x01 */ x86emuOp2_illegal_op,  /* Group G (ring 0 PM)      */
-/*  0x02 */ x86emuOp2_illegal_op,  /* lar (ring 0 PM)          */
-/*  0x03 */ x86emuOp2_illegal_op,  /* lsl (ring 0 PM)          */
+/*  0x02 */ x86emuOp2_illegal_op,  /* lar (ring 0 PM)	       */
+/*  0x03 */ x86emuOp2_illegal_op,  /* lsl (ring 0 PM)	       */
 /*  0x04 */ x86emuOp2_illegal_op,
 /*  0x05 */ x86emuOp2_illegal_op,  /* loadall (undocumented)   */
-/*  0x06 */ x86emuOp2_illegal_op,  /* clts (ring 0 PM)         */
+/*  0x06 */ x86emuOp2_illegal_op,  /* clts (ring 0 PM)	       */
 /*  0x07 */ x86emuOp2_illegal_op,  /* loadall (undocumented)   */
-/*  0x08 */ x86emuOp2_illegal_op,  /* invd (ring 0 PM)         */
+/*  0x08 */ x86emuOp2_illegal_op,  /* invd (ring 0 PM)	       */
 /*  0x09 */ x86emuOp2_illegal_op,  /* wbinvd (ring 0 PM)       */
 /*  0x0a */ x86emuOp2_illegal_op,
 /*  0x0b */ x86emuOp2_illegal_op,
diff --git a/drivers/bios_emulator/x86emu/prim_ops.c b/drivers/bios_emulator/x86emu/prim_ops.c
index dc8cea8..e0827d7 100644
--- a/drivers/bios_emulator/x86emu/prim_ops.c
+++ b/drivers/bios_emulator/x86emu/prim_ops.c
@@ -1,10 +1,10 @@
 /****************************************************************************
 *
-*                       Realmode X86 Emulator Library
+*			Realmode X86 Emulator Library
 *
-*               Copyright (C) 1991-2004 SciTech Software, Inc.
-*                    Copyright (C) David Mosberger-Tang
-*                      Copyright (C) 1999 Egbert Eich
+*		Copyright (C) 1991-2004 SciTech Software, Inc.
+*		     Copyright (C) David Mosberger-Tang
+*		       Copyright (C) 1999 Egbert Eich
 *
 *  ========================================================================
 *
@@ -14,7 +14,7 @@
 *  both that copyright notice and this permission notice appear in
 *  supporting documentation, and that the name of the authors not be used
 *  in advertising or publicity pertaining to distribution of the software
-*  without specific, written prior permission.  The authors makes no
+*  without specific, written prior permission.	The authors makes no
 *  representations about the suitability of this software for any purpose.
 *  It is provided "as is" without express or implied warranty.
 *
@@ -28,12 +28,12 @@
 *
 *  ========================================================================
 *
-* Language:     ANSI C
-* Environment:  Any
-* Developer:    Kendall Bennett
+* Language:	ANSI C
+* Environment:	Any
+* Developer:	Kendall Bennett
 *
-* Description:  This file contains the code to implement the primitive
-*               machine operations used by the emulation code in ops.c
+* Description:	This file contains the code to implement the primitive
+*		machine operations used by the emulation code in ops.c
 *
 * Carry Chain Calculation
 *
@@ -48,23 +48,23 @@
 * So, given the following table, which represents the addition of two
 * bits, we can derive a formula for the carry chain.
 *
-* a   b   cin   r     cout
-* 0   0   0     0     0
-* 0   0   1     1     0
-* 0   1   0     1     0
-* 0   1   1     0     1
-* 1   0   0     1     0
-* 1   0   1     0     1
-* 1   1   0     0     1
-* 1   1   1     1     1
+* a   b	  cin	r     cout
+* 0   0	  0	0     0
+* 0   0	  1	1     0
+* 0   1	  0	1     0
+* 0   1	  1	0     1
+* 1   0	  0	1     0
+* 1   0	  1	0     1
+* 1   1	  0	0     1
+* 1   1	  1	1     1
 *
 * Construction of table for cout:
 *
 * ab
-* r  \  00   01   11  10
+* r  \	00   01	  11  10
 * |------------------
-* 0  |   0    1    1   1
-* 1  |   0    0    1   0
+* 0  |	 0    1	   1   1
+* 1  |	 0    0	   1   0
 *
 * By inspection, one gets:  cc = ab +  r'(a + b)
 *
@@ -75,25 +75,25 @@
 * The following table represents the subtraction of two bits, from
 * which we can derive a formula for the borrow chain.
 *
-* a   b   bin   r     bout
-* 0   0   0     0     0
-* 0   0   1     1     1
-* 0   1   0     1     1
-* 0   1   1     0     1
-* 1   0   0     1     0
-* 1   0   1     0     0
-* 1   1   0     0     0
-* 1   1   1     1     1
+* a   b	  bin	r     bout
+* 0   0	  0	0     0
+* 0   0	  1	1     1
+* 0   1	  0	1     1
+* 0   1	  1	0     1
+* 1   0	  0	1     0
+* 1   0	  1	0     0
+* 1   1	  0	0     0
+* 1   1	  1	1     1
 *
 * Construction of table for cout:
 *
 * ab
-* r  \  00   01   11  10
+* r  \	00   01	  11  10
 * |------------------
-* 0  |   0    1    0   0
-* 1  |   1    1    1   0
+* 0  |	 0    1	   0   0
+* 1  |	 1    1	   1   0
 *
-* By inspection, one gets:  bc = a'b +  r(a' + b)
+* By inspection, one gets:  bc = a'b +	r(a' + b)
 *
 ****************************************************************************/
 
@@ -115,7 +115,7 @@ static u32 x86emu_parity_tab[8] =
 };
 
 #define PARITY(x)   (((x86emu_parity_tab[(x) / 32] >> ((x) % 32)) & 1) == 0)
-#define XOR2(x)     (((x) ^ ((x)>>1)) & 0x1)
+#define XOR2(x)	    (((x) ^ ((x)>>1)) & 0x1)
 /*----------------------------- Implementation ----------------------------*/
 int abs(int v)
 {
@@ -190,7 +190,7 @@ static void calc_carry_chain(int bits, u32 d, u32 s, u32 res, int set_carry)
     CONDITIONAL_SET_FLAG(XOR2(cc >> (bits - 2)), F_OF);
     CONDITIONAL_SET_FLAG(cc & 0x8, F_AF);
     if (set_carry) {
-        CONDITIONAL_SET_FLAG(res & (1 << bits), F_CF);
+	CONDITIONAL_SET_FLAG(res & (1 << bits), F_CF);
     }
 }
 
@@ -202,7 +202,7 @@ static void calc_borrow_chain(int bits, u32 d, u32 s, u32 res, int set_carry)
     CONDITIONAL_SET_FLAG(XOR2(bc >> (bits - 2)), F_OF);
     CONDITIONAL_SET_FLAG(bc & 0x8, F_AF);
     if (set_carry) {
-        CONDITIONAL_SET_FLAG(bc & (1 << (bits - 1)), F_CF);
+	CONDITIONAL_SET_FLAG(bc & (1 << (bits - 1)), F_CF);
     }
 }
 
@@ -214,13 +214,13 @@ u16 aaa_word(u16 d)
 {
     u16 res;
     if ((d & 0xf) > 0x9 || ACCESS_FLAG(F_AF)) {
-        d += 0x6;
-        d += 0x100;
-        SET_FLAG(F_AF);
-        SET_FLAG(F_CF);
+	d += 0x6;
+	d += 0x100;
+	SET_FLAG(F_AF);
+	SET_FLAG(F_CF);
     } else {
-        CLEAR_FLAG(F_CF);
-        CLEAR_FLAG(F_AF);
+	CLEAR_FLAG(F_CF);
+	CLEAR_FLAG(F_AF);
     }
     res = (u16)(d & 0xFF0F);
     set_szp_flags_16(res);
@@ -235,13 +235,13 @@ u16 aas_word(u16 d)
 {
     u16 res;
     if ((d & 0xf) > 0x9 || ACCESS_FLAG(F_AF)) {
-        d -= 0x6;
-        d -= 0x100;
-        SET_FLAG(F_AF);
-        SET_FLAG(F_CF);
+	d -= 0x6;
+	d -= 0x100;
+	SET_FLAG(F_AF);
+	SET_FLAG(F_CF);
     } else {
-        CLEAR_FLAG(F_CF);
-        CLEAR_FLAG(F_AF);
+	CLEAR_FLAG(F_CF);
+	CLEAR_FLAG(F_AF);
     }
     res = (u16)(d & 0xFF0F);
     set_szp_flags_16(res);
@@ -308,7 +308,7 @@ u16 adc_word(u16 d, u16 s)
 
     res = d + s;
     if (ACCESS_FLAG(F_CF))
-        res++;
+	res++;
 
     set_szp_flags_16((u16)res);
     calc_carry_chain(16,s,d,res,1);
@@ -330,8 +330,8 @@ u32 adc_long(u32 d, u32 s)
     res = d + s;
 
     if (ACCESS_FLAG(F_CF)) {
-        lo++;
-        res++;
+	lo++;
+	res++;
     }
 
     hi = (lo >> 16) + (d >> 16) + (s >> 16);
@@ -485,12 +485,12 @@ u8 daa_byte(u8 d)
 {
     u32 res = d;
     if ((d & 0xf) > 9 || ACCESS_FLAG(F_AF)) {
-        res += 6;
-        SET_FLAG(F_AF);
+	res += 6;
+	SET_FLAG(F_AF);
     }
     if (res > 0x9F || ACCESS_FLAG(F_CF)) {
-        res += 0x60;
-        SET_FLAG(F_CF);
+	res += 0x60;
+	SET_FLAG(F_CF);
     }
     set_szp_flags_8((u8)res);
     return (u8)res;
@@ -503,12 +503,12 @@ Implements the DAS instruction and side effects.
 u8 das_byte(u8 d)
 {
     if ((d & 0xf) > 9 || ACCESS_FLAG(F_AF)) {
-        d -= 6;
-        SET_FLAG(F_AF);
+	d -= 6;
+	SET_FLAG(F_AF);
     }
     if (d > 0x9F || ACCESS_FLAG(F_CF)) {
-        d -= 0x60;
-        SET_FLAG(F_CF);
+	d -= 0x60;
+	SET_FLAG(F_CF);
     }
     set_szp_flags_8(d);
     return d;
@@ -749,45 +749,45 @@ u8 rcl_byte(u8 d, u8 s)
        original values, this can be expressed as:
 
        IF n > 0
-       1) CF <-  b_(8-n)
+       1) CF <-	 b_(8-n)
        2) B_(7) .. B_(n)  <-  b_(8-(n+1)) .. b_0
        3) B_(n-1) <- cf
        4) B_(n-2) .. B_0 <-  b_7 .. b_(8-(n-1))
      */
     res = d;
     if ((cnt = s % 9) != 0) {
-        /* extract the new CARRY FLAG. */
-        /* CF <-  b_(8-n)             */
-        cf = (d >> (8 - cnt)) & 0x1;
-
-        /* get the low stuff which rotated
-           into the range B_7 .. B_cnt */
-        /* B_(7) .. B_(n)  <-  b_(8-(n+1)) .. b_0  */
-        /* note that the right hand side done by the mask */
-        res = (d << cnt) & 0xff;
-
-        /* now the high stuff which rotated around
-           into the positions B_cnt-2 .. B_0 */
-        /* B_(n-2) .. B_0 <-  b_7 .. b_(8-(n-1)) */
-        /* shift it downward, 7-(n-2) = 9-n positions.
-           and mask off the result before or'ing in.
-         */
-        mask = (1 << (cnt - 1)) - 1;
-        res |= (d >> (9 - cnt)) & mask;
-
-        /* if the carry flag was set, or it in.  */
-        if (ACCESS_FLAG(F_CF)) {     /* carry flag is set */
-            /*  B_(n-1) <- cf */
-            res |= 1 << (cnt - 1);
-        }
-        /* set the new carry flag, based on the variable "cf" */
-        CONDITIONAL_SET_FLAG(cf, F_CF);
-        /* OVERFLOW is set *IFF* cnt==1, then it is the
-           xor of CF and the most significant bit.  Blecck. */
-        /* parenthesized this expression since it appears to
-           be causing OF to be misset */
-        CONDITIONAL_SET_FLAG(cnt == 1 && XOR2(cf + ((res >> 6) & 0x2)),
-                             F_OF);
+	/* extract the new CARRY FLAG. */
+	/* CF <-  b_(8-n)	      */
+	cf = (d >> (8 - cnt)) & 0x1;
+
+	/* get the low stuff which rotated
+	   into the range B_7 .. B_cnt */
+	/* B_(7) .. B_(n)  <-  b_(8-(n+1)) .. b_0  */
+	/* note that the right hand side done by the mask */
+	res = (d << cnt) & 0xff;
+
+	/* now the high stuff which rotated around
+	   into the positions B_cnt-2 .. B_0 */
+	/* B_(n-2) .. B_0 <-  b_7 .. b_(8-(n-1)) */
+	/* shift it downward, 7-(n-2) = 9-n positions.
+	   and mask off the result before or'ing in.
+	 */
+	mask = (1 << (cnt - 1)) - 1;
+	res |= (d >> (9 - cnt)) & mask;
+
+	/* if the carry flag was set, or it in.	 */
+	if (ACCESS_FLAG(F_CF)) {     /* carry flag is set */
+	    /*	B_(n-1) <- cf */
+	    res |= 1 << (cnt - 1);
+	}
+	/* set the new carry flag, based on the variable "cf" */
+	CONDITIONAL_SET_FLAG(cf, F_CF);
+	/* OVERFLOW is set *IFF* cnt==1, then it is the
+	   xor of CF and the most significant bit.  Blecck. */
+	/* parenthesized this expression since it appears to
+	   be causing OF to be misset */
+	CONDITIONAL_SET_FLAG(cnt == 1 && XOR2(cf + ((res >> 6) & 0x2)),
+			     F_OF);
 
     }
     return (u8)res;
@@ -803,16 +803,16 @@ u16 rcl_word(u16 d, u8 s)
 
     res = d;
     if ((cnt = s % 17) != 0) {
-        cf = (d >> (16 - cnt)) & 0x1;
-        res = (d << cnt) & 0xffff;
-        mask = (1 << (cnt - 1)) - 1;
-        res |= (d >> (17 - cnt)) & mask;
-        if (ACCESS_FLAG(F_CF)) {
-            res |= 1 << (cnt - 1);
-        }
-        CONDITIONAL_SET_FLAG(cf, F_CF);
-        CONDITIONAL_SET_FLAG(cnt == 1 && XOR2(cf + ((res >> 14) & 0x2)),
-                             F_OF);
+	cf = (d >> (16 - cnt)) & 0x1;
+	res = (d << cnt) & 0xffff;
+	mask = (1 << (cnt - 1)) - 1;
+	res |= (d >> (17 - cnt)) & mask;
+	if (ACCESS_FLAG(F_CF)) {
+	    res |= 1 << (cnt - 1);
+	}
+	CONDITIONAL_SET_FLAG(cf, F_CF);
+	CONDITIONAL_SET_FLAG(cnt == 1 && XOR2(cf + ((res >> 14) & 0x2)),
+			     F_OF);
     }
     return (u16)res;
 }
@@ -827,16 +827,16 @@ u32 rcl_long(u32 d, u8 s)
 
     res = d;
     if ((cnt = s % 33) != 0) {
-        cf = (d >> (32 - cnt)) & 0x1;
-        res = (d << cnt) & 0xffffffff;
-        mask = (1 << (cnt - 1)) - 1;
-        res |= (d >> (33 - cnt)) & mask;
-        if (ACCESS_FLAG(F_CF)) {     /* carry flag is set */
-            res |= 1 << (cnt - 1);
-        }
-        CONDITIONAL_SET_FLAG(cf, F_CF);
-        CONDITIONAL_SET_FLAG(cnt == 1 && XOR2(cf + ((res >> 30) & 0x2)),
-                             F_OF);
+	cf = (d >> (32 - cnt)) & 0x1;
+	res = (d << cnt) & 0xffffffff;
+	mask = (1 << (cnt - 1)) - 1;
+	res |= (d >> (33 - cnt)) & mask;
+	if (ACCESS_FLAG(F_CF)) {     /* carry flag is set */
+	    res |= 1 << (cnt - 1);
+	}
+	CONDITIONAL_SET_FLAG(cf, F_CF);
+	CONDITIONAL_SET_FLAG(cnt == 1 && XOR2(cf + ((res >> 30) & 0x2)),
+			     F_OF);
     }
     return res;
 }
@@ -867,60 +867,60 @@ u8 rcr_byte(u8 d, u8 s)
        original values, this can be expressed as:
 
        IF n > 0
-       1) CF <-  b_(n-1)
-       2) B_(8-(n+1)) .. B_(0)  <-  b_(7) .. b_(n)
+       1) CF <-	 b_(n-1)
+       2) B_(8-(n+1)) .. B_(0)	<-  b_(7) .. b_(n)
        3) B_(8-n) <- cf
        4) B_(7) .. B_(8-(n-1)) <-  b_(n-2) .. b_(0)
      */
     res = d;
     if ((cnt = s % 9) != 0) {
-        /* extract the new CARRY FLAG. */
-        /* CF <-  b_(n-1)              */
-        if (cnt == 1) {
-            cf = d & 0x1;
-            /* note hackery here.  Access_flag(..) evaluates to either
-               0 if flag not set
-               non-zero if flag is set.
-               doing access_flag(..) != 0 casts that into either
-               0..1 in any representation of the flags register
-               (i.e. packed bit array or unpacked.)
-             */
-            ocf = ACCESS_FLAG(F_CF) != 0;
-        } else
-            cf = (d >> (cnt - 1)) & 0x1;
-
-        /* B_(8-(n+1)) .. B_(0)  <-  b_(7) .. b_n  */
-        /* note that the right hand side done by the mask
-           This is effectively done by shifting the
-           object to the right.  The result must be masked,
-           in case the object came in and was treated
-           as a negative number.  Needed??? */
-
-        mask = (1 << (8 - cnt)) - 1;
-        res = (d >> cnt) & mask;
-
-        /* now the high stuff which rotated around
-           into the positions B_cnt-2 .. B_0 */
-        /* B_(7) .. B_(8-(n-1)) <-  b_(n-2) .. b_(0) */
-        /* shift it downward, 7-(n-2) = 9-n positions.
-           and mask off the result before or'ing in.
-         */
-        res |= (d << (9 - cnt));
-
-        /* if the carry flag was set, or it in.  */
-        if (ACCESS_FLAG(F_CF)) {     /* carry flag is set */
-            /*  B_(8-n) <- cf */
-            res |= 1 << (8 - cnt);
-        }
-        /* set the new carry flag, based on the variable "cf" */
-        CONDITIONAL_SET_FLAG(cf, F_CF);
-        /* OVERFLOW is set *IFF* cnt==1, then it is the
-           xor of CF and the most significant bit.  Blecck. */
-        /* parenthesized... */
-        if (cnt == 1) {
-            CONDITIONAL_SET_FLAG(XOR2(ocf + ((d >> 6) & 0x2)),
-                                 F_OF);
-        }
+	/* extract the new CARRY FLAG. */
+	/* CF <-  b_(n-1)	       */
+	if (cnt == 1) {
+	    cf = d & 0x1;
+	    /* note hackery here.  Access_flag(..) evaluates to either
+	       0 if flag not set
+	       non-zero if flag is set.
+	       doing access_flag(..) != 0 casts that into either
+	       0..1 in any representation of the flags register
+	       (i.e. packed bit array or unpacked.)
+	     */
+	    ocf = ACCESS_FLAG(F_CF) != 0;
+	} else
+	    cf = (d >> (cnt - 1)) & 0x1;
+
+	/* B_(8-(n+1)) .. B_(0)	 <-  b_(7) .. b_n  */
+	/* note that the right hand side done by the mask
+	   This is effectively done by shifting the
+	   object to the right.	 The result must be masked,
+	   in case the object came in and was treated
+	   as a negative number.  Needed??? */
+
+	mask = (1 << (8 - cnt)) - 1;
+	res = (d >> cnt) & mask;
+
+	/* now the high stuff which rotated around
+	   into the positions B_cnt-2 .. B_0 */
+	/* B_(7) .. B_(8-(n-1)) <-  b_(n-2) .. b_(0) */
+	/* shift it downward, 7-(n-2) = 9-n positions.
+	   and mask off the result before or'ing in.
+	 */
+	res |= (d << (9 - cnt));
+
+	/* if the carry flag was set, or it in.	 */
+	if (ACCESS_FLAG(F_CF)) {     /* carry flag is set */
+	    /*	B_(8-n) <- cf */
+	    res |= 1 << (8 - cnt);
+	}
+	/* set the new carry flag, based on the variable "cf" */
+	CONDITIONAL_SET_FLAG(cf, F_CF);
+	/* OVERFLOW is set *IFF* cnt==1, then it is the
+	   xor of CF and the most significant bit.  Blecck. */
+	/* parenthesized... */
+	if (cnt == 1) {
+	    CONDITIONAL_SET_FLAG(XOR2(ocf + ((d >> 6) & 0x2)),
+				 F_OF);
+	}
     }
     return (u8)res;
 }
@@ -937,22 +937,22 @@ u16 rcr_word(u16 d, u8 s)
     /* rotate right through carry */
     res = d;
     if ((cnt = s % 17) != 0) {
-        if (cnt == 1) {
-            cf = d & 0x1;
-            ocf = ACCESS_FLAG(F_CF) != 0;
-        } else
-            cf = (d >> (cnt - 1)) & 0x1;
-        mask = (1 << (16 - cnt)) - 1;
-        res = (d >> cnt) & mask;
-        res |= (d << (17 - cnt));
-        if (ACCESS_FLAG(F_CF)) {
-            res |= 1 << (16 - cnt);
-        }
-        CONDITIONAL_SET_FLAG(cf, F_CF);
-        if (cnt == 1) {
-            CONDITIONAL_SET_FLAG(XOR2(ocf + ((d >> 14) & 0x2)),
-                                 F_OF);
-        }
+	if (cnt == 1) {
+	    cf = d & 0x1;
+	    ocf = ACCESS_FLAG(F_CF) != 0;
+	} else
+	    cf = (d >> (cnt - 1)) & 0x1;
+	mask = (1 << (16 - cnt)) - 1;
+	res = (d >> cnt) & mask;
+	res |= (d << (17 - cnt));
+	if (ACCESS_FLAG(F_CF)) {
+	    res |= 1 << (16 - cnt);
+	}
+	CONDITIONAL_SET_FLAG(cf, F_CF);
+	if (cnt == 1) {
+	    CONDITIONAL_SET_FLAG(XOR2(ocf + ((d >> 14) & 0x2)),
+				 F_OF);
+	}
     }
     return (u16)res;
 }
@@ -969,23 +969,23 @@ u32 rcr_long(u32 d, u8 s)
     /* rotate right through carry */
     res = d;
     if ((cnt = s % 33) != 0) {
-        if (cnt == 1) {
-            cf = d & 0x1;
-            ocf = ACCESS_FLAG(F_CF) != 0;
-        } else
-            cf = (d >> (cnt - 1)) & 0x1;
-        mask = (1 << (32 - cnt)) - 1;
-        res = (d >> cnt) & mask;
-        if (cnt != 1)
-            res |= (d << (33 - cnt));
-        if (ACCESS_FLAG(F_CF)) {     /* carry flag is set */
-            res |= 1 << (32 - cnt);
-        }
-        CONDITIONAL_SET_FLAG(cf, F_CF);
-        if (cnt == 1) {
-            CONDITIONAL_SET_FLAG(XOR2(ocf + ((d >> 30) & 0x2)),
-                                 F_OF);
-        }
+	if (cnt == 1) {
+	    cf = d & 0x1;
+	    ocf = ACCESS_FLAG(F_CF) != 0;
+	} else
+	    cf = (d >> (cnt - 1)) & 0x1;
+	mask = (1 << (32 - cnt)) - 1;
+	res = (d >> cnt) & mask;
+	if (cnt != 1)
+	    res |= (d << (33 - cnt));
+	if (ACCESS_FLAG(F_CF)) {     /* carry flag is set */
+	    res |= 1 << (32 - cnt);
+	}
+	CONDITIONAL_SET_FLAG(cf, F_CF);
+	if (cnt == 1) {
+	    CONDITIONAL_SET_FLAG(XOR2(ocf + ((d >> 30) & 0x2)),
+				 F_OF);
+	}
     }
     return res;
 }
@@ -1016,25 +1016,25 @@ u8 rol_byte(u8 d, u8 s)
      */
     res = d;
     if ((cnt = s % 8) != 0) {
-        /* B_(7) .. B_(n)  <-  b_(8-(n+1)) .. b_(0) */
-        res = (d << cnt);
-
-        /* B_(n-1) .. B_(0) <-  b_(7) .. b_(8-n) */
-        mask = (1 << cnt) - 1;
-        res |= (d >> (8 - cnt)) & mask;
-
-        /* set the new carry flag, Note that it is the low order
-           bit of the result!!!                               */
-        CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
-        /* OVERFLOW is set *IFF* s==1, then it is the
-           xor of CF and the most significant bit.  Blecck. */
-        CONDITIONAL_SET_FLAG(s == 1 &&
-                             XOR2((res & 0x1) + ((res >> 6) & 0x2)),
-                             F_OF);
+	/* B_(7) .. B_(n)  <-  b_(8-(n+1)) .. b_(0) */
+	res = (d << cnt);
+
+	/* B_(n-1) .. B_(0) <-	b_(7) .. b_(8-n) */
+	mask = (1 << cnt) - 1;
+	res |= (d >> (8 - cnt)) & mask;
+
+	/* set the new carry flag, Note that it is the low order
+	   bit of the result!!!				      */
+	CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
+	/* OVERFLOW is set *IFF* s==1, then it is the
+	   xor of CF and the most significant bit.  Blecck. */
+	CONDITIONAL_SET_FLAG(s == 1 &&
+			     XOR2((res & 0x1) + ((res >> 6) & 0x2)),
+			     F_OF);
     } if (s != 0) {
-        /* set the new carry flag, Note that it is the low order
-           bit of the result!!!                               */
-        CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
+	/* set the new carry flag, Note that it is the low order
+	   bit of the result!!!				      */
+	CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
     }
     return (u8)res;
 }
@@ -1049,17 +1049,17 @@ u16 rol_word(u16 d, u8 s)
 
     res = d;
     if ((cnt = s % 16) != 0) {
-        res = (d << cnt);
-        mask = (1 << cnt) - 1;
-        res |= (d >> (16 - cnt)) & mask;
-        CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
-        CONDITIONAL_SET_FLAG(s == 1 &&
-                             XOR2((res & 0x1) + ((res >> 14) & 0x2)),
-                             F_OF);
+	res = (d << cnt);
+	mask = (1 << cnt) - 1;
+	res |= (d >> (16 - cnt)) & mask;
+	CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
+	CONDITIONAL_SET_FLAG(s == 1 &&
+			     XOR2((res & 0x1) + ((res >> 14) & 0x2)),
+			     F_OF);
     } if (s != 0) {
-        /* set the new carry flag, Note that it is the low order
-           bit of the result!!!                               */
-        CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
+	/* set the new carry flag, Note that it is the low order
+	   bit of the result!!!				      */
+	CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
     }
     return (u16)res;
 }
@@ -1074,17 +1074,17 @@ u32 rol_long(u32 d, u8 s)
 
     res = d;
     if ((cnt = s % 32) != 0) {
-        res = (d << cnt);
-        mask = (1 << cnt) - 1;
-        res |= (d >> (32 - cnt)) & mask;
-        CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
-        CONDITIONAL_SET_FLAG(s == 1 &&
-                             XOR2((res & 0x1) + ((res >> 30) & 0x2)),
-                             F_OF);
+	res = (d << cnt);
+	mask = (1 << cnt) - 1;
+	res |= (d >> (32 - cnt)) & mask;
+	CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
+	CONDITIONAL_SET_FLAG(s == 1 &&
+			     XOR2((res & 0x1) + ((res >> 30) & 0x2)),
+			     F_OF);
     } if (s != 0) {
-        /* set the new carry flag, Note that it is the low order
-           bit of the result!!!                               */
-        CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
+	/* set the new carry flag, Note that it is the low order
+	   bit of the result!!!				      */
+	CONDITIONAL_SET_FLAG(res & 0x1, F_CF);
     }
     return res;
 }
@@ -1109,28 +1109,28 @@ u8 ror_byte(u8 d, u8 s)
        The rotate is done mod 8.
 
        IF n > 0
-       1) B_(8-(n+1)) .. B_(0)  <-  b_(7) .. b_(n)
+       1) B_(8-(n+1)) .. B_(0)	<-  b_(7) .. b_(n)
        2) B_(7) .. B_(8-n) <-  b_(n-1) .. b_(0)
      */
     res = d;
-    if ((cnt = s % 8) != 0) {           /* not a typo, do nada if cnt==0 */
-        /* B_(7) .. B_(8-n) <-  b_(n-1) .. b_(0) */
-        res = (d << (8 - cnt));
-
-        /* B_(8-(n+1)) .. B_(0)  <-  b_(7) .. b_(n) */
-        mask = (1 << (8 - cnt)) - 1;
-        res |= (d >> (cnt)) & mask;
-
-        /* set the new carry flag, Note that it is the low order
-           bit of the result!!!                               */
-        CONDITIONAL_SET_FLAG(res & 0x80, F_CF);
-        /* OVERFLOW is set *IFF* s==1, then it is the
-           xor of the two most significant bits.  Blecck. */
-        CONDITIONAL_SET_FLAG(s == 1 && XOR2(res >> 6), F_OF);
+    if ((cnt = s % 8) != 0) {		/* not a typo, do nada if cnt==0 */
+	/* B_(7) .. B_(8-n) <-	b_(n-1) .. b_(0) */
+	res = (d << (8 - cnt));
+
+	/* B_(8-(n+1)) .. B_(0)	 <-  b_(7) .. b_(n) */
+	mask = (1 << (8 - cnt)) - 1;
+	res |= (d >> (cnt)) & mask;
+
+	/* set the new carry flag, Note that it is the low order
+	   bit of the result!!!				      */
+	CONDITIONAL_SET_FLAG(res & 0x80, F_CF);
+	/* OVERFLOW is set *IFF* s==1, then it is the
+	   xor of the two most significant bits.  Blecck. */
+	CONDITIONAL_SET_FLAG(s == 1 && XOR2(res >> 6), F_OF);
     } else if (s != 0) {
-        /* set the new carry flag, Note that it is the low order
-           bit of the result!!!                               */
-        CONDITIONAL_SET_FLAG(res & 0x80, F_CF);
+	/* set the new carry flag, Note that it is the low order
+	   bit of the result!!!				      */
+	CONDITIONAL_SET_FLAG(res & 0x80, F_CF);
     }
     return (u8)res;
 }
@@ -1145,15 +1145,15 @@ u16 ror_word(u16 d, u8 s)
 
     res = d;
     if ((cnt = s % 16) != 0) {
-        res = (d << (16 - cnt));
-        mask = (1 << (16 - cnt)) - 1;
-        res |= (d >> (cnt)) & mask;
-        CONDITIONAL_SET_FLAG(res & 0x8000, F_CF);
-        CONDITIONAL_SET_FLAG(s == 1 && XOR2(res >> 14), F_OF);
+	res = (d << (16 - cnt));
+	mask = (1 << (16 - cnt)) - 1;
+	res |= (d >> (cnt)) & mask;
+	CONDITIONAL_SET_FLAG(res & 0x8000, F_CF);
+	CONDITIONAL_SET_FLAG(s == 1 && XOR2(res >> 14), F_OF);
     } else if (s != 0) {
-        /* set the new carry flag, Note that it is the low order
-           bit of the result!!!                               */
-        CONDITIONAL_SET_FLAG(res & 0x8000, F_CF);
+	/* set the new carry flag, Note that it is the low order
+	   bit of the result!!!				      */
+	CONDITIONAL_SET_FLAG(res & 0x8000, F_CF);
     }
     return (u16)res;
 }
@@ -1168,15 +1168,15 @@ u32 ror_long(u32 d, u8 s)
 
     res = d;
     if ((cnt = s % 32) != 0) {
-        res = (d << (32 - cnt));
-        mask = (1 << (32 - cnt)) - 1;
-        res |= (d >> (cnt)) & mask;
-        CONDITIONAL_SET_FLAG(res & 0x80000000, F_CF);
-        CONDITIONAL_SET_FLAG(s == 1 && XOR2(res >> 30), F_OF);
+	res = (d << (32 - cnt));
+	mask = (1 << (32 - cnt)) - 1;
+	res |= (d >> (cnt)) & mask;
+	CONDITIONAL_SET_FLAG(res & 0x80000000, F_CF);
+	CONDITIONAL_SET_FLAG(s == 1 && XOR2(res >> 30), F_OF);
     } else if (s != 0) {
-        /* set the new carry flag, Note that it is the low order
-           bit of the result!!!                               */
-        CONDITIONAL_SET_FLAG(res & 0x80000000, F_CF);
+	/* set the new carry flag, Note that it is the low order
+	   bit of the result!!!				      */
+	CONDITIONAL_SET_FLAG(res & 0x80000000, F_CF);
     }
     return res;
 }
@@ -1190,35 +1190,35 @@ u8 shl_byte(u8 d, u8 s)
     unsigned int cnt, res, cf;
 
     if (s < 8) {
-        cnt = s % 8;
-
-        /* last bit shifted out goes into carry flag */
-        if (cnt > 0) {
-            res = d << cnt;
-            cf = d & (1 << (8 - cnt));
-            CONDITIONAL_SET_FLAG(cf, F_CF);
-            set_szp_flags_8((u8)res);
-        } else {
-            res = (u8) d;
-        }
-
-        if (cnt == 1) {
-            /* Needs simplification. */
-            CONDITIONAL_SET_FLAG(
-                                    (((res & 0x80) == 0x80) ^
-                                     (ACCESS_FLAG(F_CF) != 0)),
-            /* was (M.x86.R_FLG&F_CF)==F_CF)), */
-                                    F_OF);
-        } else {
-            CLEAR_FLAG(F_OF);
-        }
+	cnt = s % 8;
+
+	/* last bit shifted out goes into carry flag */
+	if (cnt > 0) {
+	    res = d << cnt;
+	    cf = d & (1 << (8 - cnt));
+	    CONDITIONAL_SET_FLAG(cf, F_CF);
+	    set_szp_flags_8((u8)res);
+	} else {
+	    res = (u8) d;
+	}
+
+	if (cnt == 1) {
+	    /* Needs simplification. */
+	    CONDITIONAL_SET_FLAG(
+				    (((res & 0x80) == 0x80) ^
+				     (ACCESS_FLAG(F_CF) != 0)),
+	    /* was (M.x86.R_FLG&F_CF)==F_CF)), */
+				    F_OF);
+	} else {
+	    CLEAR_FLAG(F_OF);
+	}
     } else {
-        res = 0;
-        CONDITIONAL_SET_FLAG((d << (s-1)) & 0x80, F_CF);
-        CLEAR_FLAG(F_OF);
-        CLEAR_FLAG(F_SF);
-        SET_FLAG(F_PF);
-        SET_FLAG(F_ZF);
+	res = 0;
+	CONDITIONAL_SET_FLAG((d << (s-1)) & 0x80, F_CF);
+	CLEAR_FLAG(F_OF);
+	CLEAR_FLAG(F_SF);
+	SET_FLAG(F_PF);
+	SET_FLAG(F_ZF);
     }
     return (u8)res;
 }
@@ -1232,31 +1232,31 @@ u16 shl_word(u16 d, u8 s)
     unsigned int cnt, res, cf;
 
     if (s < 16) {
-        cnt = s % 16;
-        if (cnt > 0) {
-            res = d << cnt;
-            cf = d & (1 << (16 - cnt));
-            CONDITIONAL_SET_FLAG(cf, F_CF);
-            set_szp_flags_16((u16)res);
-        } else {
-            res = (u16) d;
-        }
-
-        if (cnt == 1) {
-            CONDITIONAL_SET_FLAG(
-                                    (((res & 0x8000) == 0x8000) ^
-                                     (ACCESS_FLAG(F_CF) != 0)),
-                                    F_OF);
-        } else {
-            CLEAR_FLAG(F_OF);
-        }
+	cnt = s % 16;
+	if (cnt > 0) {
+	    res = d << cnt;
+	    cf = d & (1 << (16 - cnt));
+	    CONDITIONAL_SET_FLAG(cf, F_CF);
+	    set_szp_flags_16((u16)res);
+	} else {
+	    res = (u16) d;
+	}
+
+	if (cnt == 1) {
+	    CONDITIONAL_SET_FLAG(
+				    (((res & 0x8000) == 0x8000) ^
+				     (ACCESS_FLAG(F_CF) != 0)),
+				    F_OF);
+	} else {
+	    CLEAR_FLAG(F_OF);
+	}
     } else {
-        res = 0;
-        CONDITIONAL_SET_FLAG((d << (s-1)) & 0x8000, F_CF);
-        CLEAR_FLAG(F_OF);
-        CLEAR_FLAG(F_SF);
-        SET_FLAG(F_PF);
-        SET_FLAG(F_ZF);
+	res = 0;
+	CONDITIONAL_SET_FLAG((d << (s-1)) & 0x8000, F_CF);
+	CLEAR_FLAG(F_OF);
+	CLEAR_FLAG(F_SF);
+	SET_FLAG(F_PF);
+	SET_FLAG(F_ZF);
     }
     return (u16)res;
 }
@@ -1270,28 +1270,28 @@ u32 shl_long(u32 d, u8 s)
     unsigned int cnt, res, cf;
 
     if (s < 32) {
-        cnt = s % 32;
-        if (cnt > 0) {
-            res = d << cnt;
-            cf = d & (1 << (32 - cnt));
-            CONDITIONAL_SET_FLAG(cf, F_CF);
-            set_szp_flags_32((u32)res);
-        } else {
-            res = d;
-        }
-        if (cnt == 1) {
-            CONDITIONAL_SET_FLAG((((res & 0x80000000) == 0x80000000) ^
-                                  (ACCESS_FLAG(F_CF) != 0)), F_OF);
-        } else {
-            CLEAR_FLAG(F_OF);
-        }
+	cnt = s % 32;
+	if (cnt > 0) {
+	    res = d << cnt;
+	    cf = d & (1 << (32 - cnt));
+	    CONDITIONAL_SET_FLAG(cf, F_CF);
+	    set_szp_flags_32((u32)res);
+	} else {
+	    res = d;
+	}
+	if (cnt == 1) {
+	    CONDITIONAL_SET_FLAG((((res & 0x80000000) == 0x80000000) ^
+				  (ACCESS_FLAG(F_CF) != 0)), F_OF);
+	} else {
+	    CLEAR_FLAG(F_OF);
+	}
     } else {
-        res = 0;
-        CONDITIONAL_SET_FLAG((d << (s-1)) & 0x80000000, F_CF);
-        CLEAR_FLAG(F_OF);
-        CLEAR_FLAG(F_SF);
-        SET_FLAG(F_PF);
-        SET_FLAG(F_ZF);
+	res = 0;
+	CONDITIONAL_SET_FLAG((d << (s-1)) & 0x80000000, F_CF);
+	CLEAR_FLAG(F_OF);
+	CLEAR_FLAG(F_SF);
+	SET_FLAG(F_PF);
+	SET_FLAG(F_ZF);
     }
     return res;
 }
@@ -1305,28 +1305,28 @@ u8 shr_byte(u8 d, u8 s)
     unsigned int cnt, res, cf;
 
     if (s < 8) {
-        cnt = s % 8;
-        if (cnt > 0) {
-            cf = d & (1 << (cnt - 1));
-            res = d >> cnt;
-            CONDITIONAL_SET_FLAG(cf, F_CF);
-            set_szp_flags_8((u8)res);
-        } else {
-            res = (u8) d;
-        }
-
-        if (cnt == 1) {
-            CONDITIONAL_SET_FLAG(XOR2(res >> 6), F_OF);
-        } else {
-            CLEAR_FLAG(F_OF);
-        }
+	cnt = s % 8;
+	if (cnt > 0) {
+	    cf = d & (1 << (cnt - 1));
+	    res = d >> cnt;
+	    CONDITIONAL_SET_FLAG(cf, F_CF);
+	    set_szp_flags_8((u8)res);
+	} else {
+	    res = (u8) d;
+	}
+
+	if (cnt == 1) {
+	    CONDITIONAL_SET_FLAG(XOR2(res >> 6), F_OF);
+	} else {
+	    CLEAR_FLAG(F_OF);
+	}
     } else {
-        res = 0;
-        CONDITIONAL_SET_FLAG((d >> (s-1)) & 0x1, F_CF);
-        CLEAR_FLAG(F_OF);
-        CLEAR_FLAG(F_SF);
-        SET_FLAG(F_PF);
-        SET_FLAG(F_ZF);
+	res = 0;
+	CONDITIONAL_SET_FLAG((d >> (s-1)) & 0x1, F_CF);
+	CLEAR_FLAG(F_OF);
+	CLEAR_FLAG(F_SF);
+	SET_FLAG(F_PF);
+	SET_FLAG(F_ZF);
     }
     return (u8)res;
 }
@@ -1340,28 +1340,28 @@ u16 shr_word(u16 d, u8 s)
     unsigned int cnt, res, cf;
 
     if (s < 16) {
-        cnt = s % 16;
-        if (cnt > 0) {
-            cf = d & (1 << (cnt - 1));
-            res = d >> cnt;
-            CONDITIONAL_SET_FLAG(cf, F_CF);
-            set_szp_flags_16((u16)res);
-        } else {
-            res = d;
-        }
-
-        if (cnt == 1) {
-            CONDITIONAL_SET_FLAG(XOR2(res >> 14), F_OF);
-        } else {
-            CLEAR_FLAG(F_OF);
-        }
+	cnt = s % 16;
+	if (cnt > 0) {
+	    cf = d & (1 << (cnt - 1));
+	    res = d >> cnt;
+	    CONDITIONAL_SET_FLAG(cf, F_CF);
+	    set_szp_flags_16((u16)res);
+	} else {
+	    res = d;
+	}
+
+	if (cnt == 1) {
+	    CONDITIONAL_SET_FLAG(XOR2(res >> 14), F_OF);
+	} else {
+	    CLEAR_FLAG(F_OF);
+	}
     } else {
-        res = 0;
-        CLEAR_FLAG(F_CF);
-        CLEAR_FLAG(F_OF);
-        SET_FLAG(F_ZF);
-        CLEAR_FLAG(F_SF);
-        CLEAR_FLAG(F_PF);
+	res = 0;
+	CLEAR_FLAG(F_CF);
+	CLEAR_FLAG(F_OF);
+	SET_FLAG(F_ZF);
+	CLEAR_FLAG(F_SF);
+	CLEAR_FLAG(F_PF);
     }
     return (u16)res;
 }
@@ -1375,27 +1375,27 @@ u32 shr_long(u32 d, u8 s)
     unsigned int cnt, res, cf;
 
     if (s < 32) {
-        cnt = s % 32;
-        if (cnt > 0) {
-            cf = d & (1 << (cnt - 1));
-            res = d >> cnt;
-            CONDITIONAL_SET_FLAG(cf, F_CF);
-            set_szp_flags_32((u32)res);
-        } else {
-            res = d;
-        }
-        if (cnt == 1) {
-            CONDITIONAL_SET_FLAG(XOR2(res >> 30), F_OF);
-        } else {
-            CLEAR_FLAG(F_OF);
-        }
+	cnt = s % 32;
+	if (cnt > 0) {
+	    cf = d & (1 << (cnt - 1));
+	    res = d >> cnt;
+	    CONDITIONAL_SET_FLAG(cf, F_CF);
+	    set_szp_flags_32((u32)res);
+	} else {
+	    res = d;
+	}
+	if (cnt == 1) {
+	    CONDITIONAL_SET_FLAG(XOR2(res >> 30), F_OF);
+	} else {
+	    CLEAR_FLAG(F_OF);
+	}
     } else {
-        res = 0;
-        CLEAR_FLAG(F_CF);
-        CLEAR_FLAG(F_OF);
-        SET_FLAG(F_ZF);
-        CLEAR_FLAG(F_SF);
-        CLEAR_FLAG(F_PF);
+	res = 0;
+	CLEAR_FLAG(F_CF);
+	CLEAR_FLAG(F_OF);
+	SET_FLAG(F_ZF);
+	CLEAR_FLAG(F_SF);
+	CLEAR_FLAG(F_PF);
     }
     return res;
 }
@@ -1412,28 +1412,28 @@ u8 sar_byte(u8 d, u8 s)
     sf = d & 0x80;
     cnt = s % 8;
     if (cnt > 0 && cnt < 8) {
-        mask = (1 << (8 - cnt)) - 1;
-        cf = d & (1 << (cnt - 1));
-        res = (d >> cnt) & mask;
-        CONDITIONAL_SET_FLAG(cf, F_CF);
-        if (sf) {
-            res |= ~mask;
-        }
-        set_szp_flags_8((u8)res);
+	mask = (1 << (8 - cnt)) - 1;
+	cf = d & (1 << (cnt - 1));
+	res = (d >> cnt) & mask;
+	CONDITIONAL_SET_FLAG(cf, F_CF);
+	if (sf) {
+	    res |= ~mask;
+	}
+	set_szp_flags_8((u8)res);
     } else if (cnt >= 8) {
-        if (sf) {
-            res = 0xff;
-            SET_FLAG(F_CF);
-            CLEAR_FLAG(F_ZF);
-            SET_FLAG(F_SF);
-            SET_FLAG(F_PF);
-        } else {
-            res = 0;
-            CLEAR_FLAG(F_CF);
-            SET_FLAG(F_ZF);
-            CLEAR_FLAG(F_SF);
-            CLEAR_FLAG(F_PF);
-        }
+	if (sf) {
+	    res = 0xff;
+	    SET_FLAG(F_CF);
+	    CLEAR_FLAG(F_ZF);
+	    SET_FLAG(F_SF);
+	    SET_FLAG(F_PF);
+	} else {
+	    res = 0;
+	    CLEAR_FLAG(F_CF);
+	    SET_FLAG(F_ZF);
+	    CLEAR_FLAG(F_SF);
+	    CLEAR_FLAG(F_PF);
+	}
     }
     return (u8)res;
 }
@@ -1450,28 +1450,28 @@ u16 sar_word(u16 d, u8 s)
     cnt = s % 16;
     res = d;
     if (cnt > 0 && cnt < 16) {
-        mask = (1 << (16 - cnt)) - 1;
-        cf = d & (1 << (cnt - 1));
-        res = (d >> cnt) & mask;
-        CONDITIONAL_SET_FLAG(cf, F_CF);
-        if (sf) {
-            res |= ~mask;
-        }
-        set_szp_flags_16((u16)res);
+	mask = (1 << (16 - cnt)) - 1;
+	cf = d & (1 << (cnt - 1));
+	res = (d >> cnt) & mask;
+	CONDITIONAL_SET_FLAG(cf, F_CF);
+	if (sf) {
+	    res |= ~mask;
+	}
+	set_szp_flags_16((u16)res);
     } else if (cnt >= 16) {
-        if (sf) {
-            res = 0xffff;
-            SET_FLAG(F_CF);
-            CLEAR_FLAG(F_ZF);
-            SET_FLAG(F_SF);
-            SET_FLAG(F_PF);
-        } else {
-            res = 0;
-            CLEAR_FLAG(F_CF);
-            SET_FLAG(F_ZF);
-            CLEAR_FLAG(F_SF);
-            CLEAR_FLAG(F_PF);
-        }
+	if (sf) {
+	    res = 0xffff;
+	    SET_FLAG(F_CF);
+	    CLEAR_FLAG(F_ZF);
+	    SET_FLAG(F_SF);
+	    SET_FLAG(F_PF);
+	} else {
+	    res = 0;
+	    CLEAR_FLAG(F_CF);
+	    SET_FLAG(F_ZF);
+	    CLEAR_FLAG(F_SF);
+	    CLEAR_FLAG(F_PF);
+	}
     }
     return (u16)res;
 }
@@ -1488,28 +1488,28 @@ u32 sar_long(u32 d, u8 s)
     cnt = s % 32;
     res = d;
     if (cnt > 0 && cnt < 32) {
-        mask = (1 << (32 - cnt)) - 1;
-        cf = d & (1 << (cnt - 1));
-        res = (d >> cnt) & mask;
-        CONDITIONAL_SET_FLAG(cf, F_CF);
-        if (sf) {
-            res |= ~mask;
-        }
-        set_szp_flags_32(res);
+	mask = (1 << (32 - cnt)) - 1;
+	cf = d & (1 << (cnt - 1));
+	res = (d >> cnt) & mask;
+	CONDITIONAL_SET_FLAG(cf, F_CF);
+	if (sf) {
+	    res |= ~mask;
+	}
+	set_szp_flags_32(res);
     } else if (cnt >= 32) {
-        if (sf) {
-            res = 0xffffffff;
-            SET_FLAG(F_CF);
-            CLEAR_FLAG(F_ZF);
-            SET_FLAG(F_SF);
-            SET_FLAG(F_PF);
-        } else {
-            res = 0;
-            CLEAR_FLAG(F_CF);
-            SET_FLAG(F_ZF);
-            CLEAR_FLAG(F_SF);
-            CLEAR_FLAG(F_PF);
-        }
+	if (sf) {
+	    res = 0xffffffff;
+	    SET_FLAG(F_CF);
+	    CLEAR_FLAG(F_ZF);
+	    SET_FLAG(F_SF);
+	    SET_FLAG(F_PF);
+	} else {
+	    res = 0;
+	    CLEAR_FLAG(F_CF);
+	    SET_FLAG(F_ZF);
+	    CLEAR_FLAG(F_SF);
+	    CLEAR_FLAG(F_PF);
+	}
     }
     return res;
 }
@@ -1523,28 +1523,28 @@ u16 shld_word (u16 d, u16 fill, u8 s)
     unsigned int cnt, res, cf;
 
     if (s < 16) {
-        cnt = s % 16;
-        if (cnt > 0) {
-            res = (d << cnt) | (fill >> (16-cnt));
-            cf = d & (1 << (16 - cnt));
-            CONDITIONAL_SET_FLAG(cf, F_CF);
-            set_szp_flags_16((u16)res);
-        } else {
-            res = d;
-        }
-        if (cnt == 1) {
-            CONDITIONAL_SET_FLAG((((res & 0x8000) == 0x8000) ^
-                                  (ACCESS_FLAG(F_CF) != 0)), F_OF);
-        } else {
-            CLEAR_FLAG(F_OF);
-        }
+	cnt = s % 16;
+	if (cnt > 0) {
+	    res = (d << cnt) | (fill >> (16-cnt));
+	    cf = d & (1 << (16 - cnt));
+	    CONDITIONAL_SET_FLAG(cf, F_CF);
+	    set_szp_flags_16((u16)res);
+	} else {
+	    res = d;
+	}
+	if (cnt == 1) {
+	    CONDITIONAL_SET_FLAG((((res & 0x8000) == 0x8000) ^
+				  (ACCESS_FLAG(F_CF) != 0)), F_OF);
+	} else {
+	    CLEAR_FLAG(F_OF);
+	}
     } else {
-        res = 0;
-        CONDITIONAL_SET_FLAG((d << (s-1)) & 0x8000, F_CF);
-        CLEAR_FLAG(F_OF);
-        CLEAR_FLAG(F_SF);
-        SET_FLAG(F_PF);
-        SET_FLAG(F_ZF);
+	res = 0;
+	CONDITIONAL_SET_FLAG((d << (s-1)) & 0x8000, F_CF);
+	CLEAR_FLAG(F_OF);
+	CLEAR_FLAG(F_SF);
+	SET_FLAG(F_PF);
+	SET_FLAG(F_ZF);
     }
     return (u16)res;
 }
@@ -1558,28 +1558,28 @@ u32 shld_long (u32 d, u32 fill, u8 s)
     unsigned int cnt, res, cf;
 
     if (s < 32) {
-        cnt = s % 32;
-        if (cnt > 0) {
-            res = (d << cnt) | (fill >> (32-cnt));
-            cf = d & (1 << (32 - cnt));
-            CONDITIONAL_SET_FLAG(cf, F_CF);
-            set_szp_flags_32((u32)res);
-        } else {
-            res = d;
-        }
-        if (cnt == 1) {
-            CONDITIONAL_SET_FLAG((((res & 0x80000000) == 0x80000000) ^
-                                  (ACCESS_FLAG(F_CF) != 0)), F_OF);
-        } else {
-            CLEAR_FLAG(F_OF);
-        }
+	cnt = s % 32;
+	if (cnt > 0) {
+	    res = (d << cnt) | (fill >> (32-cnt));
+	    cf = d & (1 << (32 - cnt));
+	    CONDITIONAL_SET_FLAG(cf, F_CF);
+	    set_szp_flags_32((u32)res);
+	} else {
+	    res = d;
+	}
+	if (cnt == 1) {
+	    CONDITIONAL_SET_FLAG((((res & 0x80000000) == 0x80000000) ^
+				  (ACCESS_FLAG(F_CF) != 0)), F_OF);
+	} else {
+	    CLEAR_FLAG(F_OF);
+	}
     } else {
-        res = 0;
-        CONDITIONAL_SET_FLAG((d << (s-1)) & 0x80000000, F_CF);
-        CLEAR_FLAG(F_OF);
-        CLEAR_FLAG(F_SF);
-        SET_FLAG(F_PF);
-        SET_FLAG(F_ZF);
+	res = 0;
+	CONDITIONAL_SET_FLAG((d << (s-1)) & 0x80000000, F_CF);
+	CLEAR_FLAG(F_OF);
+	CLEAR_FLAG(F_SF);
+	SET_FLAG(F_PF);
+	SET_FLAG(F_ZF);
     }
     return res;
 }
@@ -1593,28 +1593,28 @@ u16 shrd_word (u16 d, u16 fill, u8 s)
     unsigned int cnt, res, cf;
 
     if (s < 16) {
-        cnt = s % 16;
-        if (cnt > 0) {
-            cf = d & (1 << (cnt - 1));
-            res = (d >> cnt) | (fill << (16 - cnt));
-            CONDITIONAL_SET_FLAG(cf, F_CF);
-            set_szp_flags_16((u16)res);
-        } else {
-            res = d;
-        }
-
-        if (cnt == 1) {
-            CONDITIONAL_SET_FLAG(XOR2(res >> 14), F_OF);
-        } else {
-            CLEAR_FLAG(F_OF);
-        }
+	cnt = s % 16;
+	if (cnt > 0) {
+	    cf = d & (1 << (cnt - 1));
+	    res = (d >> cnt) | (fill << (16 - cnt));
+	    CONDITIONAL_SET_FLAG(cf, F_CF);
+	    set_szp_flags_16((u16)res);
+	} else {
+	    res = d;
+	}
+
+	if (cnt == 1) {
+	    CONDITIONAL_SET_FLAG(XOR2(res >> 14), F_OF);
+	} else {
+	    CLEAR_FLAG(F_OF);
+	}
     } else {
-        res = 0;
-        CLEAR_FLAG(F_CF);
-        CLEAR_FLAG(F_OF);
-        SET_FLAG(F_ZF);
-        CLEAR_FLAG(F_SF);
-        CLEAR_FLAG(F_PF);
+	res = 0;
+	CLEAR_FLAG(F_CF);
+	CLEAR_FLAG(F_OF);
+	SET_FLAG(F_ZF);
+	CLEAR_FLAG(F_SF);
+	CLEAR_FLAG(F_PF);
     }
     return (u16)res;
 }
@@ -1628,27 +1628,27 @@ u32 shrd_long (u32 d, u32 fill, u8 s)
     unsigned int cnt, res, cf;
 
     if (s < 32) {
-        cnt = s % 32;
-        if (cnt > 0) {
-            cf = d & (1 << (cnt - 1));
-            res = (d >> cnt) | (fill << (32 - cnt));
-            CONDITIONAL_SET_FLAG(cf, F_CF);
-            set_szp_flags_32((u32)res);
-        } else {
-            res = d;
-        }
-        if (cnt == 1) {
-            CONDITIONAL_SET_FLAG(XOR2(res >> 30), F_OF);
-        } else {
-            CLEAR_FLAG(F_OF);
-        }
+	cnt = s % 32;
+	if (cnt > 0) {
+	    cf = d & (1 << (cnt - 1));
+	    res = (d >> cnt) | (fill << (32 - cnt));
+	    CONDITIONAL_SET_FLAG(cf, F_CF);
+	    set_szp_flags_32((u32)res);
+	} else {
+	    res = d;
+	}
+	if (cnt == 1) {
+	    CONDITIONAL_SET_FLAG(XOR2(res >> 30), F_OF);
+	} else {
+	    CLEAR_FLAG(F_OF);
+	}
     } else {
-        res = 0;
-        CLEAR_FLAG(F_CF);
-        CLEAR_FLAG(F_OF);
-        SET_FLAG(F_ZF);
-        CLEAR_FLAG(F_SF);
-        CLEAR_FLAG(F_PF);
+	res = 0;
+	CLEAR_FLAG(F_CF);
+	CLEAR_FLAG(F_OF);
+	SET_FLAG(F_ZF);
+	CLEAR_FLAG(F_SF);
+	CLEAR_FLAG(F_PF);
     }
     return res;
 }
@@ -1663,9 +1663,9 @@ u8 sbb_byte(u8 d, u8 s)
     u32 bc;
 
     if (ACCESS_FLAG(F_CF))
-        res = d - s - 1;
+	res = d - s - 1;
     else
-        res = d - s;
+	res = d - s;
     set_szp_flags_8((u8)res);
 
     /* calculate the borrow chain.  See note at top */
@@ -1686,9 +1686,9 @@ u16 sbb_word(u16 d, u16 s)
     u32 bc;
 
     if (ACCESS_FLAG(F_CF))
-        res = d - s - 1;
+	res = d - s - 1;
     else
-        res = d - s;
+	res = d - s;
     set_szp_flags_16((u16)res);
 
     /* calculate the borrow chain.  See note at top */
@@ -1709,9 +1709,9 @@ u32 sbb_long(u32 d, u32 s)
     u32 bc;
 
     if (ACCESS_FLAG(F_CF))
-        res = d - s - 1;
+	res = d - s - 1;
     else
-        res = d - s;
+	res = d - s;
 
     set_szp_flags_32(res);
 
@@ -1880,12 +1880,12 @@ void imul_byte(u8 s)
 
     M.x86.R_AX = res;
     if (((M.x86.R_AL & 0x80) == 0 && M.x86.R_AH == 0x00) ||
-        ((M.x86.R_AL & 0x80) != 0 && M.x86.R_AH == 0xFF)) {
-        CLEAR_FLAG(F_CF);
-        CLEAR_FLAG(F_OF);
+	((M.x86.R_AL & 0x80) != 0 && M.x86.R_AH == 0xFF)) {
+	CLEAR_FLAG(F_CF);
+	CLEAR_FLAG(F_OF);
     } else {
-        SET_FLAG(F_CF);
-        SET_FLAG(F_OF);
+	SET_FLAG(F_CF);
+	SET_FLAG(F_OF);
     }
 }
 
@@ -1900,12 +1900,12 @@ void imul_word(u16 s)
     M.x86.R_AX = (u16)res;
     M.x86.R_DX = (u16)(res >> 16);
     if (((M.x86.R_AX & 0x8000) == 0 && M.x86.R_DX == 0x0000) ||
-        ((M.x86.R_AX & 0x8000) != 0 && M.x86.R_DX == 0xFFFF)) {
-        CLEAR_FLAG(F_CF);
-        CLEAR_FLAG(F_OF);
+	((M.x86.R_AX & 0x8000) != 0 && M.x86.R_DX == 0xFFFF)) {
+	CLEAR_FLAG(F_CF);
+	CLEAR_FLAG(F_OF);
     } else {
-        SET_FLAG(F_CF);
-        SET_FLAG(F_OF);
+	SET_FLAG(F_CF);
+	SET_FLAG(F_OF);
     }
 }
 
@@ -1915,7 +1915,7 @@ Implements the IMUL instruction and side effects.
 ****************************************************************************/
 void imul_long_direct(u32 *res_lo, u32* res_hi,u32 d, u32 s)
 {
-#ifdef  __HAS_LONG_LONG__
+#ifdef	__HAS_LONG_LONG__
     s64 res = (s32)d * (s32)s;
 
     *res_lo = (u32)res;
@@ -1926,11 +1926,11 @@ void imul_long_direct(u32 *res_lo, u32* res_hi,u32 d, u32 s)
     u32 rlo_lo,rlo_hi,rhi_lo;
 
     if ((d_sign = d & 0x80000000) != 0)
-        d = -d;
+	d = -d;
     d_lo = d & 0xFFFF;
     d_hi = d >> 16;
     if ((s_sign = s & 0x80000000) != 0)
-        s = -s;
+	s = -s;
     s_lo = s & 0xFFFF;
     s_hi = s >> 16;
     rlo_lo = d_lo * s_lo;
@@ -1939,11 +1939,11 @@ void imul_long_direct(u32 *res_lo, u32* res_hi,u32 d, u32 s)
     *res_lo = (rlo_hi << 16) | (rlo_lo & 0xFFFF);
     *res_hi = rhi_lo;
     if (d_sign != s_sign) {
-        d = ~*res_lo;
-        s = (((d & 0xFFFF) + 1) >> 16) + (d >> 16);
-        *res_lo = ~*res_lo+1;
-        *res_hi = ~*res_hi+(s >> 16);
-        }
+	d = ~*res_lo;
+	s = (((d & 0xFFFF) + 1) >> 16) + (d >> 16);
+	*res_lo = ~*res_lo+1;
+	*res_hi = ~*res_hi+(s >> 16);
+	}
 #endif
 }
 
@@ -1955,12 +1955,12 @@ void imul_long(u32 s)
 {
     imul_long_direct(&M.x86.R_EAX,&M.x86.R_EDX,M.x86.R_EAX,s);
     if (((M.x86.R_EAX & 0x80000000) == 0 && M.x86.R_EDX == 0x00000000) ||
-        ((M.x86.R_EAX & 0x80000000) != 0 && M.x86.R_EDX == 0xFFFFFFFF)) {
-        CLEAR_FLAG(F_CF);
-        CLEAR_FLAG(F_OF);
+	((M.x86.R_EAX & 0x80000000) != 0 && M.x86.R_EDX == 0xFFFFFFFF)) {
+	CLEAR_FLAG(F_CF);
+	CLEAR_FLAG(F_OF);
     } else {
-        SET_FLAG(F_CF);
-        SET_FLAG(F_OF);
+	SET_FLAG(F_CF);
+	SET_FLAG(F_OF);
     }
 }
 
@@ -1974,11 +1974,11 @@ void mul_byte(u8 s)
 
     M.x86.R_AX = res;
     if (M.x86.R_AH == 0) {
-        CLEAR_FLAG(F_CF);
-        CLEAR_FLAG(F_OF);
+	CLEAR_FLAG(F_CF);
+	CLEAR_FLAG(F_OF);
     } else {
-        SET_FLAG(F_CF);
-        SET_FLAG(F_OF);
+	SET_FLAG(F_CF);
+	SET_FLAG(F_OF);
     }
 }
 
@@ -1993,11 +1993,11 @@ void mul_word(u16 s)
     M.x86.R_AX = (u16)res;
     M.x86.R_DX = (u16)(res >> 16);
     if (M.x86.R_DX == 0) {
-        CLEAR_FLAG(F_CF);
-        CLEAR_FLAG(F_OF);
+	CLEAR_FLAG(F_CF);
+	CLEAR_FLAG(F_OF);
     } else {
-        SET_FLAG(F_CF);
-        SET_FLAG(F_OF);
+	SET_FLAG(F_CF);
+	SET_FLAG(F_OF);
     }
 }
 
@@ -2007,7 +2007,7 @@ Implements the MUL instruction and side effects.
 ****************************************************************************/
 void mul_long(u32 s)
 {
-#ifdef  __HAS_LONG_LONG__
+#ifdef	__HAS_LONG_LONG__
     u64 res = (u32)M.x86.R_EAX * (u32)s;
 
     M.x86.R_EAX = (u32)res;
@@ -2029,11 +2029,11 @@ void mul_long(u32 s)
     M.x86.R_EDX = rhi_lo;
 #endif
     if (M.x86.R_EDX == 0) {
-        CLEAR_FLAG(F_CF);
-        CLEAR_FLAG(F_OF);
+	CLEAR_FLAG(F_CF);
+	CLEAR_FLAG(F_OF);
     } else {
-        SET_FLAG(F_CF);
-        SET_FLAG(F_OF);
+	SET_FLAG(F_CF);
+	SET_FLAG(F_OF);
     }
 }
 
@@ -2047,14 +2047,14 @@ void idiv_byte(u8 s)
 
     dvd = (s16)M.x86.R_AX;
     if (s == 0) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     div = dvd / (s8)s;
     mod = dvd % (s8)s;
     if (abs(div) > 0x7f) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     M.x86.R_AL = (s8) div;
     M.x86.R_AH = (s8) mod;
@@ -2070,14 +2070,14 @@ void idiv_word(u16 s)
 
     dvd = (((s32)M.x86.R_DX) << 16) | M.x86.R_AX;
     if (s == 0) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     div = dvd / (s16)s;
     mod = dvd % (s16)s;
     if (abs(div) > 0x7fff) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     CLEAR_FLAG(F_CF);
     CLEAR_FLAG(F_SF);
@@ -2094,19 +2094,19 @@ Implements the IDIV instruction and side effects.
 ****************************************************************************/
 void idiv_long(u32 s)
 {
-#ifdef  __HAS_LONG_LONG__
+#ifdef	__HAS_LONG_LONG__
     s64 dvd, div, mod;
 
     dvd = (((s64)M.x86.R_EDX) << 32) | M.x86.R_EAX;
     if (s == 0) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     div = dvd / (s32)s;
     mod = dvd % (s32)s;
     if (abs(div) > 0x7fffffff) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
 #else
     s32 div = 0, mod;
@@ -2120,32 +2120,32 @@ void idiv_long(u32 s)
     int carry;
 
     if (s == 0) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     do {
-        div <<= 1;
-        carry = (l_dvd >= l_s) ? 0 : 1;
-
-        if (abs_h_dvd < (h_s + carry)) {
-            h_s >>= 1;
-            l_s = abs_s << (--counter);
-            continue;
-        } else {
-            abs_h_dvd -= (h_s + carry);
-            l_dvd = carry ? ((0xFFFFFFFF - l_s) + l_dvd + 1)
-                : (l_dvd - l_s);
-            h_s >>= 1;
-            l_s = abs_s << (--counter);
-            div |= 1;
-            continue;
-        }
+	div <<= 1;
+	carry = (l_dvd >= l_s) ? 0 : 1;
+
+	if (abs_h_dvd < (h_s + carry)) {
+	    h_s >>= 1;
+	    l_s = abs_s << (--counter);
+	    continue;
+	} else {
+	    abs_h_dvd -= (h_s + carry);
+	    l_dvd = carry ? ((0xFFFFFFFF - l_s) + l_dvd + 1)
+		: (l_dvd - l_s);
+	    h_s >>= 1;
+	    l_s = abs_s << (--counter);
+	    div |= 1;
+	    continue;
+	}
 
     } while (counter > -1);
     /* overflow */
     if (abs_h_dvd || (l_dvd > abs_s)) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     /* sign */
     div |= ((h_dvd & 0x10000000) ^ (s & 0x10000000));
@@ -2172,14 +2172,14 @@ void div_byte(u8 s)
 
     dvd = M.x86.R_AX;
     if (s == 0) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     div = dvd / (u8)s;
     mod = dvd % (u8)s;
     if (abs(div) > 0xff) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     M.x86.R_AL = (u8)div;
     M.x86.R_AH = (u8)mod;
@@ -2195,14 +2195,14 @@ void div_word(u16 s)
 
     dvd = (((u32)M.x86.R_DX) << 16) | M.x86.R_AX;
     if (s == 0) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     div = dvd / (u16)s;
     mod = dvd % (u16)s;
     if (abs(div) > 0xffff) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     CLEAR_FLAG(F_CF);
     CLEAR_FLAG(F_SF);
@@ -2219,19 +2219,19 @@ Implements the DIV instruction and side effects.
 ****************************************************************************/
 void div_long(u32 s)
 {
-#ifdef  __HAS_LONG_LONG__
+#ifdef	__HAS_LONG_LONG__
     u64 dvd, div, mod;
 
     dvd = (((u64)M.x86.R_EDX) << 32) | M.x86.R_EAX;
     if (s == 0) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     div = dvd / (u32)s;
     mod = dvd % (u32)s;
     if (abs(div) > 0xffffffff) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
 #else
     s32 div = 0, mod;
@@ -2244,32 +2244,32 @@ void div_long(u32 s)
     int carry;
 
     if (s == 0) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     do {
-        div <<= 1;
-        carry = (l_dvd >= l_s) ? 0 : 1;
-
-        if (h_dvd < (h_s + carry)) {
-            h_s >>= 1;
-            l_s = s << (--counter);
-            continue;
-        } else {
-            h_dvd -= (h_s + carry);
-            l_dvd = carry ? ((0xFFFFFFFF - l_s) + l_dvd + 1)
-                : (l_dvd - l_s);
-            h_s >>= 1;
-            l_s = s << (--counter);
-            div |= 1;
-            continue;
-        }
+	div <<= 1;
+	carry = (l_dvd >= l_s) ? 0 : 1;
+
+	if (h_dvd < (h_s + carry)) {
+	    h_s >>= 1;
+	    l_s = s << (--counter);
+	    continue;
+	} else {
+	    h_dvd -= (h_s + carry);
+	    l_dvd = carry ? ((0xFFFFFFFF - l_s) + l_dvd + 1)
+		: (l_dvd - l_s);
+	    h_s >>= 1;
+	    l_s = s << (--counter);
+	    div |= 1;
+	    continue;
+	}
 
     } while (counter > -1);
     /* overflow */
     if (h_dvd || (l_dvd > s)) {
-        x86emu_intr_raise(0);
-        return;
+	x86emu_intr_raise(0);
+	return;
     }
     mod = l_dvd;
 #endif
@@ -2291,11 +2291,11 @@ Implements the IN string instruction and side effects.
 static void single_in(int size)
 {
     if(size == 1)
-        store_data_byte_abs(M.x86.R_ES, M.x86.R_DI,(*sys_inb)(M.x86.R_DX));
+	store_data_byte_abs(M.x86.R_ES, M.x86.R_DI,(*sys_inb)(M.x86.R_DX));
     else if (size == 2)
-        store_data_word_abs(M.x86.R_ES, M.x86.R_DI,(*sys_inw)(M.x86.R_DX));
+	store_data_word_abs(M.x86.R_ES, M.x86.R_DI,(*sys_inw)(M.x86.R_DX));
     else
-        store_data_long_abs(M.x86.R_ES, M.x86.R_DI,(*sys_inl)(M.x86.R_DX));
+	store_data_long_abs(M.x86.R_ES, M.x86.R_DI,(*sys_inl)(M.x86.R_DX));
 }
 
 void ins(int size)
@@ -2303,26 +2303,26 @@ void ins(int size)
     int inc = size;
 
     if (ACCESS_FLAG(F_DF)) {
-        inc = -size;
+	inc = -size;
     }
     if (M.x86.mode & (SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE)) {
-        /* dont care whether REPE or REPNE */
-        /* in until CX is ZERO. */
-        u32 count = ((M.x86.mode & SYSMODE_PREFIX_DATA) ?
-                     M.x86.R_ECX : M.x86.R_CX);
-
-        while (count--) {
-          single_in(size);
-          M.x86.R_DI += inc;
-          }
-        M.x86.R_CX = 0;
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            M.x86.R_ECX = 0;
-        }
-        M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
+	/* dont care whether REPE or REPNE */
+	/* in until CX is ZERO. */
+	u32 count = ((M.x86.mode & SYSMODE_PREFIX_DATA) ?
+		     M.x86.R_ECX : M.x86.R_CX);
+
+	while (count--) {
+	  single_in(size);
+	  M.x86.R_DI += inc;
+	  }
+	M.x86.R_CX = 0;
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    M.x86.R_ECX = 0;
+	}
+	M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
     } else {
-        single_in(size);
-        M.x86.R_DI += inc;
+	single_in(size);
+	M.x86.R_DI += inc;
     }
 }
 
@@ -2346,31 +2346,31 @@ void outs(int size)
     int inc = size;
 
     if (ACCESS_FLAG(F_DF)) {
-        inc = -size;
+	inc = -size;
     }
     if (M.x86.mode & (SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE)) {
-        /* dont care whether REPE or REPNE */
-        /* out until CX is ZERO. */
-        u32 count = ((M.x86.mode & SYSMODE_PREFIX_DATA) ?
-                     M.x86.R_ECX : M.x86.R_CX);
-        while (count--) {
-          single_out(size);
-          M.x86.R_SI += inc;
-          }
-        M.x86.R_CX = 0;
-        if (M.x86.mode & SYSMODE_PREFIX_DATA) {
-            M.x86.R_ECX = 0;
-        }
-        M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
+	/* dont care whether REPE or REPNE */
+	/* out until CX is ZERO. */
+	u32 count = ((M.x86.mode & SYSMODE_PREFIX_DATA) ?
+		     M.x86.R_ECX : M.x86.R_CX);
+	while (count--) {
+	  single_out(size);
+	  M.x86.R_SI += inc;
+	  }
+	M.x86.R_CX = 0;
+	if (M.x86.mode & SYSMODE_PREFIX_DATA) {
+	    M.x86.R_ECX = 0;
+	}
+	M.x86.mode &= ~(SYSMODE_PREFIX_REPE | SYSMODE_PREFIX_REPNE);
     } else {
-        single_out(size);
-        M.x86.R_SI += inc;
+	single_out(size);
+	M.x86.R_SI += inc;
     }
 }
 
 /****************************************************************************
 PARAMETERS:
-addr    - Address to fetch word from
+addr	- Address to fetch word from
 
 REMARKS:
 Fetches a word from emulator memory using an absolute address.
@@ -2443,4 +2443,3 @@ DB( if (CHECK_SP_ACCESS())
     M.x86.R_SP += 4;
     return res;
 }
-