diff --git a/bochs/cpu/cpu.h b/bochs/cpu/cpu.h
index ae5530c81..1fa17df2e 100644
--- a/bochs/cpu/cpu.h
+++ b/bochs/cpu/cpu.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: cpu.h,v 1.469 2008-05-02 22:47:07 sshwarts Exp $
+// $Id: cpu.h,v 1.470 2008-05-04 15:07:08 sshwarts Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -3374,9 +3374,9 @@ BX_CPP_INLINE bx_bool BX_CPU_C::get_PFLazy(void)
 
 /* op1, op2, result */
 #define SET_FLAGS_OSZAPC_SIZE(size, lf_op1, lf_op2, lf_result, ins) { \
-  BX_CPU_THIS_PTR oszapc.op1_##size = (lf_op1); \
-  BX_CPU_THIS_PTR oszapc.op2_##size = (lf_op2); \
-  BX_CPU_THIS_PTR oszapc.result = (Bit##size##s)(lf_result); \
+  BX_CPU_THIS_PTR oszapc.op1    = (bx_address)(Bit##size##s)(lf_op1); \
+  BX_CPU_THIS_PTR oszapc.op2    = (bx_address)(Bit##size##s)(lf_op2); \
+  BX_CPU_THIS_PTR oszapc.result = (bx_address)(Bit##size##s)(lf_result); \
   BX_CPU_THIS_PTR oszapc.instr = (ins); \
   BX_CPU_THIS_PTR lf_flags_status = EFlagsOSZAPCMask; \
 }
@@ -3394,7 +3394,7 @@ BX_CPP_INLINE bx_bool BX_CPU_C::get_PFLazy(void)
 
 /* op1 and result only */
 #define SET_FLAGS_OSZAPC_S1_SIZE(size, lf_op1, lf_result, ins) { \
-  BX_CPU_THIS_PTR oszapc.op1_##size = (lf_op1); \
+  BX_CPU_THIS_PTR oszapc.op1    = (bx_address)(Bit##size##s)(lf_op1); \
   BX_CPU_THIS_PTR oszapc.result = (Bit##size##s)(lf_result); \
   BX_CPU_THIS_PTR oszapc.instr = (ins); \
   BX_CPU_THIS_PTR lf_flags_status = EFlagsOSZAPCMask; \
@@ -3413,7 +3413,7 @@ BX_CPP_INLINE bx_bool BX_CPU_C::get_PFLazy(void)
 
 /* op2 and result only */
 #define SET_FLAGS_OSZAPC_S2_SIZE(size, lf_op2, lf_result, ins) { \
-  BX_CPU_THIS_PTR oszapc.op2_##size = (lf_op2); \
+  BX_CPU_THIS_PTR oszapc.op2    = (bx_address)(Bit##size##s)(lf_op2); \
   BX_CPU_THIS_PTR oszapc.result = (Bit##size##s)(lf_result); \
   BX_CPU_THIS_PTR oszapc.instr = (ins); \
   BX_CPU_THIS_PTR lf_flags_status = EFlagsOSZAPCMask; \
diff --git a/bochs/cpu/icache.h b/bochs/cpu/icache.h
index eed240887..8e98944e0 100755
--- a/bochs/cpu/icache.h
+++ b/bochs/cpu/icache.h
@@ -1,14 +1,9 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: icache.h,v 1.34 2008-05-04 05:37:36 sshwarts Exp $
+// $Id: icache.h,v 1.35 2008-05-04 15:07:08 sshwarts Exp $
 /////////////////////////////////////////////////////////////////////////
 //
-//  Copyright (C) 2001  MandrakeSoft S.A.
-//
-//    MandrakeSoft S.A.
-//    43, rue d'Aboukir
-//    75002 Paris - France
-//    http://www.linux-mandrake.com/
-//    http://www.mandrakesoft.com/
+//   Copyright (c) 2007 Stanislav Shwartsman
+//          Written by Stanislav Shwartsman [sshwarts at sourceforge net]
 //
 //  This library is free software; you can redistribute it and/or
 //  modify it under the terms of the GNU Lesser General Public
diff --git a/bochs/cpu/lazy_flags.cc b/bochs/cpu/lazy_flags.cc
index 3fdb7ede9..16e2752b9 100644
--- a/bochs/cpu/lazy_flags.cc
+++ b/bochs/cpu/lazy_flags.cc
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: lazy_flags.cc,v 1.46 2008-04-04 22:39:45 sshwarts Exp $
+// $Id: lazy_flags.cc,v 1.47 2008-05-04 15:07:08 sshwarts Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -52,10 +52,23 @@ const bx_bool bx_parity_lookup[256] = {
   1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1
 };
 
-#define result_8  ((Bit8u) (BX_CPU_THIS_PTR oszapc.result))
+#define op1_8     ((Bit8u)(BX_CPU_THIS_PTR oszapc.op1))
+#define op2_8     ((Bit8u)(BX_CPU_THIS_PTR oszapc.op2))
+#define result_8  ((Bit8u)(BX_CPU_THIS_PTR oszapc.result))
+
+#define op1_16    ((Bit16u)(BX_CPU_THIS_PTR oszapc.op1))
+#define op2_16    ((Bit16u)(BX_CPU_THIS_PTR oszapc.op2))
 #define result_16 ((Bit16u)(BX_CPU_THIS_PTR oszapc.result))
+
+#define op1_32    ((Bit32u)(BX_CPU_THIS_PTR oszapc.op1))
+#define op2_32    ((Bit32u)(BX_CPU_THIS_PTR oszapc.op2))
 #define result_32 ((Bit32u)(BX_CPU_THIS_PTR oszapc.result))
-#define result_64          (BX_CPU_THIS_PTR oszapc.result)
+
+#if BX_SUPPORT_X86_64
+#define op1_64    ((Bit64u)(BX_CPU_THIS_PTR oszapc.op1))
+#define op2_64    ((Bit64u)(BX_CPU_THIS_PTR oszapc.op2))
+#define result_64 ((Bit64u)(BX_CPU_THIS_PTR oszapc.result))
+#endif
 
 bx_bool BX_CPU_C::get_CFLazy(void)
 {
@@ -63,83 +76,57 @@ bx_bool BX_CPU_C::get_CFLazy(void)
 
   switch (BX_CPU_THIS_PTR oszapc.instr) {
     case BX_LF_INSTR_ADD8:
-      cf = (result_8 < BX_CPU_THIS_PTR oszapc.op1_8);
-      break;
     case BX_LF_INSTR_ADD16:
-      cf = (result_16 < BX_CPU_THIS_PTR oszapc.op1_16);
-      break;
     case BX_LF_INSTR_ADD32:
-      cf = (result_32 < BX_CPU_THIS_PTR oszapc.op1_32);
+      cf = (result_32 < op1_32);
       break;
 #if BX_SUPPORT_X86_64
     case BX_LF_INSTR_ADD64:
-      cf = (result_64 < BX_CPU_THIS_PTR oszapc.op1_64);
+      cf = (result_64 < op1_64);
       break;
 #endif
     // used only if CF = 1 when executing ADC instruction
     case BX_LF_INSTR_ADC8:
-      cf = (result_8 <= BX_CPU_THIS_PTR oszapc.op1_8);
-      break;
-    // used only if CF = 1 when executing ADC instruction
     case BX_LF_INSTR_ADC16:
-      cf = (result_16 <= BX_CPU_THIS_PTR oszapc.op1_16);
-      break;
-    // used only if CF = 1 when executing ADC instruction
     case BX_LF_INSTR_ADC32:
-      cf = (result_32 <= BX_CPU_THIS_PTR oszapc.op1_32);
+      cf = (result_32 <= op1_32);
       break;
 #if BX_SUPPORT_X86_64
     // used only if CF = 1 when executing ADC instruction
     case BX_LF_INSTR_ADC64:
-      cf = (result_64 <= BX_CPU_THIS_PTR oszapc.op1_64);
+      cf = (result_64 <= op1_64);
       break;
 #endif
     case BX_LF_INSTR_SUB8:
-      cf = (BX_CPU_THIS_PTR oszapc.op1_8 <
-                          BX_CPU_THIS_PTR oszapc.op2_8);
-      break;
     case BX_LF_INSTR_SUB16:
-      cf = (BX_CPU_THIS_PTR oszapc.op1_16 <
-                          BX_CPU_THIS_PTR oszapc.op2_16);
-      break;
     case BX_LF_INSTR_SUB32:
-      cf = (BX_CPU_THIS_PTR oszapc.op1_32 <
-                          BX_CPU_THIS_PTR oszapc.op2_32);
+      cf = (op1_32 < op2_32);
       break;
 #if BX_SUPPORT_X86_64
     case BX_LF_INSTR_SUB64:
-      cf = (BX_CPU_THIS_PTR oszapc.op1_64 <
-                          BX_CPU_THIS_PTR oszapc.op2_64);
+      cf = (op1_64 < op2_64);
       break;
 #endif
     // used only if CF = 1 when executing SBB instruction
     case BX_LF_INSTR_SBB8:
-      cf = (BX_CPU_THIS_PTR oszapc.op1_8 < result_8) ||
-           (BX_CPU_THIS_PTR oszapc.op2_8==0xff);
+      cf = (op1_8 < result_8) || (op2_8==0xff);
       break;
     // used only if CF = 1 when executing SBB instruction
     case BX_LF_INSTR_SBB16:
-      cf = (BX_CPU_THIS_PTR oszapc.op1_16 < result_16) ||
-           (BX_CPU_THIS_PTR oszapc.op2_16==0xffff);
+      cf = (op1_16 < result_16) || (op2_16==0xffff);
       break;
     // used only if CF = 1 when executing SBB instruction
     case BX_LF_INSTR_SBB32:
-      cf = (BX_CPU_THIS_PTR oszapc.op1_32 < result_32) ||
-           (BX_CPU_THIS_PTR oszapc.op2_32==0xffffffff);
+      cf = (op1_32 < result_32) || (op2_32==0xffffffff);
       break;
 #if BX_SUPPORT_X86_64
     // used only if CF = 1 when executing SBB instruction
     case BX_LF_INSTR_SBB64:
-      cf = (BX_CPU_THIS_PTR oszapc.op1_64 < result_64) ||
-           (BX_CPU_THIS_PTR oszapc.op2_64==BX_CONST64(0xffffffffffffffff));
+      cf = (op1_64 < result_64) || (op2_64==BX_CONST64(0xffffffffffffffff));
       break;
 #endif
     case BX_LF_INSTR_NEG8:
-      cf = (result_8 != 0);
-      break;
     case BX_LF_INSTR_NEG16:
-      cf = (result_16 != 0);
-      break;
     case BX_LF_INSTR_NEG32:
       cf = (result_32 != 0);
       break;
@@ -174,32 +161,22 @@ bx_bool BX_CPU_C::get_AFLazy(void)
     case BX_LF_INSTR_ADC8:
     case BX_LF_INSTR_SUB8:
     case BX_LF_INSTR_SBB8:
-      af = ((BX_CPU_THIS_PTR oszapc.op1_8 ^
-                 BX_CPU_THIS_PTR oszapc.op2_8) ^ result_8) & 0x10;
-      break;
     case BX_LF_INSTR_ADD16:
     case BX_LF_INSTR_ADC16:
     case BX_LF_INSTR_SUB16:
     case BX_LF_INSTR_SBB16:
-      af = ((BX_CPU_THIS_PTR oszapc.op1_16 ^
-                 BX_CPU_THIS_PTR oszapc.op2_16) ^ result_16) & 0x10;
-      break;
     case BX_LF_INSTR_ADD32:
     case BX_LF_INSTR_ADC32:
     case BX_LF_INSTR_SUB32:
     case BX_LF_INSTR_SBB32:
-      af = ((BX_CPU_THIS_PTR oszapc.op1_32 ^
-                 BX_CPU_THIS_PTR oszapc.op2_32) ^ result_32) & 0x10;
-      break;
 #if BX_SUPPORT_X86_64
     case BX_LF_INSTR_ADD64:
     case BX_LF_INSTR_ADC64:
     case BX_LF_INSTR_SUB64:
     case BX_LF_INSTR_SBB64:
-      af = ((BX_CPU_THIS_PTR oszapc.op1_64 ^
-                 BX_CPU_THIS_PTR oszapc.op2_64) ^ result_64) & 0x10;
-      break;
 #endif
+      af = ((op1_8 ^ op2_8) ^ result_8) & 0x10;
+      break;
     case BX_LF_INSTR_NEG8:
     case BX_LF_INSTR_NEG16:
     case BX_LF_INSTR_NEG32:
@@ -253,54 +230,30 @@ bx_bool BX_CPU_C::get_OFLazy(void)
   switch (BX_CPU_THIS_PTR oszapc.instr) {
     case BX_LF_INSTR_ADD8:
     case BX_LF_INSTR_ADC8:
-      of = GET_ADD_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_8,
-                            BX_CPU_THIS_PTR oszapc.op2_8,
-                            result_8, 0x80);
-      break;
     case BX_LF_INSTR_ADD16:
     case BX_LF_INSTR_ADC16:
-      of = GET_ADD_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_16,
-                            BX_CPU_THIS_PTR oszapc.op2_16,
-                            result_16, 0x8000);
-      break;
     case BX_LF_INSTR_ADD32:
     case BX_LF_INSTR_ADC32:
-      of = GET_ADD_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_32,
-                            BX_CPU_THIS_PTR oszapc.op2_32,
-                            result_32, 0x80000000);
+      of = GET_ADD_OVERFLOW(op1_32, op2_32, result_32, 0x80000000);
       break;
 #if BX_SUPPORT_X86_64
     case BX_LF_INSTR_ADD64:
     case BX_LF_INSTR_ADC64:
-      of = GET_ADD_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_64,
-                            BX_CPU_THIS_PTR oszapc.op2_64,
-                            result_64, BX_CONST64(0x8000000000000000));
+      of = GET_ADD_OVERFLOW(op1_64, op2_64, result_64, BX_CONST64(0x8000000000000000));
       break;
 #endif
     case BX_LF_INSTR_SUB8:
     case BX_LF_INSTR_SBB8:
-      of = GET_SUB_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_8,
-                            BX_CPU_THIS_PTR oszapc.op2_8,
-                            result_8, 0x80);
-      break;
     case BX_LF_INSTR_SUB16:
     case BX_LF_INSTR_SBB16:
-      of = GET_SUB_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_16,
-                            BX_CPU_THIS_PTR oszapc.op2_16,
-                            result_16, 0x8000);
-      break;
     case BX_LF_INSTR_SUB32:
     case BX_LF_INSTR_SBB32:
-      of = GET_SUB_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_32,
-                            BX_CPU_THIS_PTR oszapc.op2_32,
-                            result_32, 0x80000000);
+      of = GET_SUB_OVERFLOW(op1_32, op2_32, result_32, 0x80000000);
       break;
 #if BX_SUPPORT_X86_64
     case BX_LF_INSTR_SUB64:
     case BX_LF_INSTR_SBB64:
-      of = GET_SUB_OVERFLOW(BX_CPU_THIS_PTR oszapc.op1_64,
-                            BX_CPU_THIS_PTR oszapc.op2_64,
-                            result_64, BX_CONST64(0x8000000000000000));
+      of = GET_SUB_OVERFLOW(op1_64, op2_64, result_64, BX_CONST64(0x8000000000000000));
       break;
 #endif
     case BX_LF_INSTR_LOGIC8:
@@ -313,12 +266,8 @@ bx_bool BX_CPU_C::get_OFLazy(void)
       break;
     case BX_LF_INSTR_NEG8:
     case BX_LF_INSTR_INC8:
-      of = (result_8 == 0x80);
-      break;
     case BX_LF_INSTR_NEG16:
     case BX_LF_INSTR_INC16:
-      of = (result_16 == 0x8000);
-      break;
     case BX_LF_INSTR_NEG32:
     case BX_LF_INSTR_INC32:
       of = (result_32 == 0x80000000);
diff --git a/bochs/cpu/lazy_flags.h b/bochs/cpu/lazy_flags.h
index da9812a71..99863c083 100644
--- a/bochs/cpu/lazy_flags.h
+++ b/bochs/cpu/lazy_flags.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: lazy_flags.h,v 1.32 2008-04-04 22:39:45 sshwarts Exp $
+// $Id: lazy_flags.h,v 1.33 2008-05-04 15:07:08 sshwarts Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -88,22 +88,9 @@
 #endif
 
 typedef struct {
-  Bit8u op1_8;
-  Bit8u op2_8;
-
-  Bit16u op1_16;
-  Bit16u op2_16;
-
-  Bit32u op1_32;
-  Bit32u op2_32;
-
-#if BX_SUPPORT_X86_64
-  Bit64u op1_64;
-  Bit64u op2_64;
-#endif
-
+  bx_address op1;
+  bx_address op2;
   bx_address result;
-
   unsigned instr;
 } bx_lf_flags_entry;