Coding style cleanup. Update CHANGELOG.

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

1 files changed, 694 insertions, 695 deletions

diff --git a/drivers/bios_emulator/x86emu/prim_ops.c b/drivers/bios_emulator/x86emu/prim_ops.c
index dc8cea8003..e0827d7478 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;
 }
-