--- np2/i386c/ia32/instructions/shift_rotatexc_msc.mcr	2004/03/10 02:42:51	1.1
+++ np2/i386c/ia32/instructions/shift_rotatexc_msc.mcr	2004/03/10 23:01:08	1.3
@@ -1,18 +1,23 @@
 
 // Crosscheck for VC++
 
+#define	SETFLAGS \
+	__asm { cmp		CPU_OV, 0		} \
+	__asm { setne	al				} \
+	__asm { add		al, 7fh			} \
+	__asm { mov		ah, CPU_FLAGL	} \
+	__asm { sahf					}
+
+
+
 #define	BYTE_SAR1(d, s) { \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { sar		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { sar		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_SAR1(d, s); \
 	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("sarb1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -20,15 +25,11 @@
 #define	WORD_SAR1(d, s) { \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { sar		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { sar		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_SAR1(d, s); \
 	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("sarw1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -36,15 +37,11 @@
 #define	DWORD_SAR1(d, s) { \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { sar		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { sar		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_SAR1(d, s); \
 	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("sard1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -53,54 +50,42 @@
 	UINT8 _c = (c); \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { sar		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { sar		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_SARCL(d, s, c); \
-	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("sarb(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("sarb(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	WORD_SARCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { sar		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { sar		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_SARCL(d, s, c); \
-	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("sarw(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("sarw(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	DWORD_SARCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { sar		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { sar		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_SARCL(d, s, c); \
-	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("sard(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("sard(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 
@@ -108,15 +93,11 @@
 #define	BYTE_SHL1(d, s) { \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { shl		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { shl		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_SHL1(d, s); \
 	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shlb1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -124,15 +105,11 @@
 #define	WORD_SHL1(d, s) { \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { shl		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { shl		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_SHL1(d, s); \
 	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shlw1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -140,15 +117,11 @@
 #define	DWORD_SHL1(d, s) { \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { shl		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { shl		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_SHL1(d, s); \
 	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shld1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -157,54 +130,42 @@
 	UINT8 _c = (c); \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { shl		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { shl		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_SHLCL(d, s, c); \
-	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shlb(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shlb(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	WORD_SHLCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { shl		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { shl		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_SHLCL(d, s, c); \
-	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shlw(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shlw(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	DWORD_SHLCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { shl		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { shl		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_SHLCL(d, s, c); \
-	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shld(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shld(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 
@@ -212,15 +173,11 @@
 #define	BYTE_SHR1(d, s) { \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { shr		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { shr		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_SHR1(d, s); \
 	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shrb1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -228,15 +185,11 @@
 #define	WORD_SHR1(d, s) { \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { shr		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { shr		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_SHR1(d, s); \
 	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shrw1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -244,15 +197,11 @@
 #define	DWORD_SHR1(d, s) { \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { shr		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { shr		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_SHR1(d, s); \
 	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shrd1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -261,54 +210,42 @@
 	UINT8 _c = (c); \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { shr		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { shr		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_SHRCL(d, s, c); \
-	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shrb(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shrb(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	WORD_SHRCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { shr		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { shr		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_SHRCL(d, s, c); \
-	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shrw(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shrw(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	DWORD_SHRCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { shr		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { shr		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_SHRCL(d, s, c); \
-	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shrd(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shrd(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 
@@ -318,17 +255,13 @@
 	UINT16 _s = (s); \
 	UINT16 _d = (d); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm {	mov		ax, _s			} \
-	__asm { shld	_d, ax, cl		} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm {	mov		ax, _s		} \
+	__asm { shld	_d, ax, cl	} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_SHLD(d, s, c); \
 	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shldw r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -338,17 +271,13 @@
 	UINT32 _s = (s); \
 	UINT32 _d = (d); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm {	mov		eax, _s			} \
-	__asm { shld	_d, eax, cl		} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm {	mov		eax, _s		} \
+	__asm { shld	_d, eax, cl	} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_SHLD(d, s, c); \
 	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shldd r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -360,17 +289,13 @@
 	UINT16 _s = (s); \
 	UINT16 _d = (d); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm {	mov		ax, _s			} \
-	__asm { shrd	_d, ax, cl		} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm {	mov		ax, _s		} \
+	__asm { shrd	_d, ax, cl	} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_SHRD(d, s, c); \
 	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shrdw r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -380,17 +305,13 @@
 	UINT32 _s = (s); \
 	UINT32 _d = (d); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm {	mov		eax, _s			} \
-	__asm { shrd	_d, eax, cl		} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm {	mov		eax, _s		} \
+	__asm { shrd	_d, eax, cl	} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_SHRD(d, s, c); \
 	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("shrdd r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -400,15 +321,11 @@
 #define	BYTE_RCL1(d, s) { \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { rcl		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { rcl		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_RCL1(d, s); \
 	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rclb1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -416,15 +333,11 @@
 #define	WORD_RCL1(d, s) { \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { rcl		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { rcl		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_RCL1(d, s); \
 	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rclw1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -432,15 +345,11 @@
 #define	DWORD_RCL1(d, s) { \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { rcl		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { rcl		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_RCL1(d, s); \
 	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rcld1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -449,54 +358,42 @@
 	UINT8 _c = (c); \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { rcl		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { rcl		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_RCLCL(d, s, c); \
-	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rclb(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rclb(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	WORD_RCLCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { rcl		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { rcl		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_RCLCL(d, s, c); \
-	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rclw(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rclw(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	DWORD_RCLCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { rcl		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { rcl		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_RCLCL(d, s, c); \
-	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rcld(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rcld(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 
@@ -504,15 +401,11 @@
 #define	BYTE_RCR1(d, s) { \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { rcr		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { rcr		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_RCR1(d, s); \
 	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rcrb1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -520,15 +413,11 @@
 #define	WORD_RCR1(d, s) { \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { rcr		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { rcr		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_RCR1(d, s); \
 	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rcrw1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -536,15 +425,11 @@
 #define	DWORD_RCR1(d, s) { \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { rcr		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { rcr		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_RCR1(d, s); \
 	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rcrd1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -553,54 +438,42 @@
 	UINT8 _c = (c); \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { rcr		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { rcr		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_RCRCL(d, s, c); \
-	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rcrb(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rcrb(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	WORD_RCRCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { rcr		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { rcr		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_RCRCL(d, s, c); \
-	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rcrw(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rcrw(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	DWORD_RCRCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { rcr		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { rcr		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_RCRCL(d, s, c); \
-	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rcrd(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rcrd(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 
@@ -608,15 +481,11 @@
 #define	BYTE_ROL1(d, s) { \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { rol		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { rol		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_ROL1(d, s); \
 	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rolb1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -624,15 +493,11 @@
 #define	WORD_ROL1(d, s) { \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { rol		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { rol		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_ROL1(d, s); \
 	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rolw1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -640,15 +505,11 @@
 #define	DWORD_ROL1(d, s) { \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { rol		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { rol		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_ROL1(d, s); \
 	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rold1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -657,54 +518,42 @@
 	UINT8 _c = (c); \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { rol		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { rol		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_ROLCL(d, s, c); \
-	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rolb(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rolb(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	WORD_ROLCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { rol		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { rol		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_ROLCL(d, s, c); \
-	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rolw(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rolw(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	DWORD_ROLCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { rol		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { rol		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_ROLCL(d, s, c); \
-	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rold(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rold(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 
@@ -712,15 +561,11 @@
 #define	BYTE_ROR1(d, s) { \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { ror		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { ror		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_ROR1(d, s); \
 	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rorb1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -728,15 +573,11 @@
 #define	WORD_ROR1(d, s) { \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { ror		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { ror		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_ROR1(d, s); \
 	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rorw1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -744,15 +585,11 @@
 #define	DWORD_ROR1(d, s) { \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm { ror		_d, 1			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm { ror		_d, 1		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_ROR1(d, s); \
 	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rord1 r=%x:%x f=%x:%x o=%d %d", _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
@@ -761,53 +598,41 @@
 	UINT8 _c = (c); \
 	UINT8 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { ror		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { ror		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_BYTE_RORCL(d, s, c); \
-	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rorb(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT8)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rorb(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	WORD_RORCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT16 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { ror		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { ror		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_WORD_RORCL(d, s, c); \
-	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rorw(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT16)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rorw(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }
 
 #define	DWORD_RORCL(d, s, c) { \
 	UINT8 _c = (c); \
 	UINT32 _d = (s); \
 	UINT8 _f, _ov; \
-	__asm { cmp		CPU_OV, 0		} \
-	__asm { sete	al				} \
-	__asm { dec		al				} \
-	__asm { mov		ah, CPU_FLAGL	} \
-	__asm { sahf					} \
-	__asm {	mov		cl, _c			} \
-	__asm { ror		_d, cl			} \
-	__asm { seto	_ov				} \
-	__asm {	lahf					} \
-	__asm {	mov		_f, ah			} \
+	SETFLAGS \
+	__asm {	mov		cl, _c		} \
+	__asm { ror		_d, cl		} \
+	__asm { seto	_ov			} \
+	__asm {	lahf				} \
+	__asm {	mov		_f, ah		} \
 	_DWORD_RORCL(d, s, c); \
-	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rord(%x) r=%x:%x f=%x:%x o=%d %d", c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
+	if ((_d != (UINT32)(d)) || ((_f ^ CPU_FLAGL) & SZPC_FLAG) || ((!_ov) != (!CPU_OV))) TRACEOUT(("rord(%x) r=%x:%x f=%x:%x o=%d %d", _c, _d, d, _f, CPU_FLAGL, _ov, CPU_OV)); \
 }