Index: /trunk/src/VBox/Disassembler/DisasmCore.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41794)
+++ /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41795)
@@ -517,8 +517,6 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t disParseInstruction(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, size_t cbExtra)
-{
-    size_t size = 0;
-
+static size_t disParseInstruction(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis)
+{
     Assert(pOp); Assert(pDis);
 
@@ -568,5 +566,5 @@
     if (pOp->idxParse1 != IDX_ParseNop)
     {
-        size += pDis->pfnDisasmFnTable[pOp->idxParse1](offInstr, pOp, pDis, &pDis->Param1);
+        offInstr = pDis->pfnDisasmFnTable[pOp->idxParse1](offInstr, pOp, pDis, &pDis->Param1);
         if (fFiltered == false) pDis->Param1.cb = DISGetParamSize(pDis, &pDis->Param1);
     }
@@ -574,5 +572,5 @@
     if (pOp->idxParse2 != IDX_ParseNop)
     {
-        size += pDis->pfnDisasmFnTable[pOp->idxParse2](offInstr+size, pOp, pDis, &pDis->Param2);
+        offInstr = pDis->pfnDisasmFnTable[pOp->idxParse2](offInstr, pOp, pDis, &pDis->Param2);
         if (fFiltered == false) pDis->Param2.cb = DISGetParamSize(pDis, &pDis->Param2);
     }
@@ -580,10 +578,10 @@
     if (pOp->idxParse3 != IDX_ParseNop)
     {
-        size += pDis->pfnDisasmFnTable[pOp->idxParse3](offInstr+size, pOp, pDis, &pDis->Param3);
+        offInstr = pDis->pfnDisasmFnTable[pOp->idxParse3](offInstr, pOp, pDis, &pDis->Param3);
         if (fFiltered == false) pDis->Param3.cb = DISGetParamSize(pDis, &pDis->Param3);
     }
     // else simple one byte instruction
 
-    return size + cbExtra;
+    return offInstr;
 }
 //*****************************************************************************
@@ -635,15 +633,14 @@
 
     // Little hack to make sure the ModRM byte is included in the returned size
-    size_t      size = 0;
     if (fpop->idxParse1 != IDX_ParseModRM && fpop->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
+        offInstr++; //ModRM byte
 
     if (fpop->idxParse1 != IDX_ParseNop)
-        size += pDis->pfnDisasmFnTable[fpop->idxParse1](offInstr+size, fpop, pDis, pParam);
+        offInstr = pDis->pfnDisasmFnTable[fpop->idxParse1](offInstr, fpop, pDis, pParam);
 
     if (fpop->idxParse2 != IDX_ParseNop)
-        size += pDis->pfnDisasmFnTable[fpop->idxParse2](offInstr+size, fpop, pDis, pParam);
-
-    return size;
+        offInstr = pDis->pfnDisasmFnTable[fpop->idxParse2](offInstr, fpop, pDis, pParam);
+
+    return offInstr;
 }
 
@@ -707,9 +704,8 @@
 static size_t ParseSIB(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    unsigned size = sizeof(uint8_t);
     NOREF(pOp); NOREF(pParam);
 
-    unsigned SIB = disReadByte(pDis, offInstr);
-    offInstr += size;
+    uint8_t SIB = disReadByte(pDis, offInstr);
+    offInstr++;
 
     pDis->SIB.Bits.Base  = SIB_BASE(SIB);
@@ -731,7 +727,7 @@
         /* Additional 32 bits displacement. No change in long mode. */
         pDis->i32SibDisp = disReadDWord(pDis, offInstr);
-        size += sizeof(int32_t);
-    }
-    return size;
+        offInstr += 4;
+    }
+    return offInstr;
 }
 
@@ -739,8 +735,8 @@
 static size_t ParseSIB_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    unsigned size = sizeof(uint8_t);
     NOREF(pOp); NOREF(pParam);
 
-    unsigned SIB = disReadByte(pDis, offInstr);
+    uint8_t SIB = disReadByte(pDis, offInstr);
+    offInstr++;
 
     pDis->SIB.Bits.Base  = SIB_BASE(SIB);
@@ -760,7 +756,7 @@
     {
         /* Additional 32 bits displacement. No change in long mode. */
-        size += sizeof(int32_t);
-    }
-    return size;
+        offInstr += 4;
+    }
+    return offInstr;
 }
 
@@ -886,7 +882,7 @@
 {
     unsigned vtype = OP_PARM_VTYPE(pParam->fParam);
-    unsigned reg = pDis->ModRM.Bits.Reg;
-    unsigned mod = pDis->ModRM.Bits.Mod;
-    unsigned rm  = pDis->ModRM.Bits.Rm;
+    uint8_t  reg = pDis->ModRM.Bits.Reg;
+    uint8_t  mod = pDis->ModRM.Bits.Mod;
+    uint8_t  rm  = pDis->ModRM.Bits.Rm;
 
     switch (vtype)
@@ -894,5 +890,5 @@
     case OP_PARM_G: //general purpose register
         disasmModRMReg(reg, pOp, pDis, pParam, 0);
-        return 0;
+        return offInstr;
 
     default:
@@ -913,10 +909,10 @@
                 else
                     pParam->Base.idxCtrlReg = reg;
-                return 0;
+                return offInstr;
 
             case OP_PARM_D: //debug register
                 pParam->fUse |= DISUSE_REG_DBG;
                 pParam->Base.idxDbgReg = reg;
-                return 0;
+                return offInstr;
 
             case OP_PARM_P: //MMX register
@@ -924,5 +920,5 @@
                 pParam->fUse |= DISUSE_REG_MMX;
                 pParam->Base.idxMmxReg = reg;
-                return 0;
+                return offInstr;
 
             case OP_PARM_S: //segment register
@@ -930,5 +926,5 @@
                 disasmModRMSReg(reg, pOp, pDis, pParam);
                 pParam->fUse |= DISUSE_REG_SEG;
-                return 0;
+                return offInstr;
 
             case OP_PARM_T: //test register
@@ -936,5 +932,5 @@
                 pParam->fUse |= DISUSE_REG_TEST;
                 pParam->Base.idxTestReg = reg;
-                return 0;
+                return offInstr;
 
             case OP_PARM_W: //XMM register or memory operand
@@ -947,10 +943,10 @@
                 pParam->fUse |= DISUSE_REG_XMM;
                 pParam->Base.idxXmmReg = reg;
-                return 0;
+                return offInstr;
             }
         }
     }
 
-    /* @todo bound */
+    /** @todo bound */
 
     if (pDis->uAddrMode != DISCPUMODE_16BIT)
@@ -1051,21 +1047,13 @@
         }
     }
-    return 0;   //everything was already fetched in ParseModRM
+    return offInstr;
 }
 //*****************************************************************************
 // Query the size of the ModRM parameters and fetch the immediate data (if any)
 //*****************************************************************************
-static size_t QueryModRM(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam, size_t *pSibInc)
-{
-    size_t sibinc;
-    size_t size = 0;
-    // unsigned reg = pDis->ModRM.Bits.Reg;
-    unsigned mod = pDis->ModRM.Bits.Mod;
-    unsigned rm  = pDis->ModRM.Bits.Rm;
-
-    if (!pSibInc)
-        pSibInc = &sibinc;
-
-    *pSibInc = 0;
+static size_t QueryModRM(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
+{
+    uint8_t mod = pDis->ModRM.Bits.Mod;
+    uint8_t rm  = pDis->ModRM.Bits.Rm;
 
     if (pDis->uAddrMode != DISCPUMODE_16BIT)
@@ -1076,17 +1064,14 @@
          * Note: displacements in long mode are 8 or 32 bits and sign-extended to 64 bits
          */
-        if (mod != 3 && rm == 4)
-        {   /* SIB byte follows ModRM */
-            *pSibInc = ParseSIB(offInstr, pOp, pDis, pParam);
-            offInstr += *pSibInc;
-            size += *pSibInc;
-        }
+        if (mod != 3 && rm == 4) /* SIB byte follows ModRM */
+            offInstr = ParseSIB(offInstr, pOp, pDis, pParam);
 
         switch (mod)
         {
         case 0: /* Effective address */
-            if (rm == 5) {  /* 32 bits displacement */
+            if (rm == 5)    /* 32 bits displacement */
+            {
                 pDis->i32SibDisp = disReadDWord(pDis, offInstr);
-                size += sizeof(int32_t);
+                offInstr += 4;
             }
             /* else register address */
@@ -1095,10 +1080,10 @@
         case 1: /* Effective address + 8 bits displacement */
             pDis->i32SibDisp = (int8_t)disReadByte(pDis, offInstr);
-            size += sizeof(char);
+            offInstr++;
             break;
 
         case 2: /* Effective address + 32 bits displacement */
             pDis->i32SibDisp = disReadDWord(pDis, offInstr);
-            size += sizeof(int32_t);
+            offInstr += 4;
             break;
 
@@ -1113,7 +1098,8 @@
         {
         case 0: /* Effective address */
-            if (rm == 6) {
+            if (rm == 6)
+            {
                 pDis->i32SibDisp = disReadWord(pDis, offInstr);
-                size += sizeof(uint16_t);
+                offInstr += 2;
             }
             /* else register address */
@@ -1122,10 +1108,10 @@
         case 1: /* Effective address + 8 bits displacement */
             pDis->i32SibDisp = (int8_t)disReadByte(pDis, offInstr);
-            size += sizeof(char);
+            offInstr++;
             break;
 
         case 2: /* Effective address + 32 bits displacement */
             pDis->i32SibDisp = (int16_t)disReadWord(pDis, offInstr);
-            size += sizeof(uint16_t);
+            offInstr += 2;
             break;
 
@@ -1134,21 +1120,13 @@
         }
     }
-    return size;
-}
-//*****************************************************************************
-// Query the size of the ModRM parameters and fetch the immediate data (if any)
-//*****************************************************************************
-static size_t QueryModRM_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam, size_t *pSibInc)
-{
-    size_t sibinc;
-    size_t size = 0;
-    // unsigned reg = pDis->ModRM.Bits.Reg;
-    unsigned mod = pDis->ModRM.Bits.Mod;
-    unsigned rm  = pDis->ModRM.Bits.Rm;
-
-    if (!pSibInc)
-        pSibInc = &sibinc;
-
-    *pSibInc = 0;
+    return offInstr;
+}
+//*****************************************************************************
+// Parse the ModRM parameters and fetch the immediate data (if any)
+//*****************************************************************************
+static size_t QueryModRM_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
+{
+    uint8_t mod = pDis->ModRM.Bits.Mod;
+    uint8_t rm  = pDis->ModRM.Bits.Rm;
 
     if (pDis->uAddrMode != DISCPUMODE_16BIT)
@@ -1160,7 +1138,5 @@
         if (mod != 3 && rm == 4)
         {   /* SIB byte follows ModRM */
-            *pSibInc = ParseSIB_SizeOnly(offInstr, pOp, pDis, pParam);
-            offInstr += *pSibInc;
-            size += *pSibInc;
+            offInstr = ParseSIB_SizeOnly(offInstr, pOp, pDis, pParam);
         }
 
@@ -1168,16 +1144,15 @@
         {
         case 0: //effective address
-            if (rm == 5) {  /* 32 bits displacement */
-                size += sizeof(int32_t);
-            }
+            if (rm == 5)   /* 32 bits displacement */
+                offInstr += 4;
             /* else register address */
             break;
 
         case 1: /* Effective address + 8 bits displacement */
-            size += sizeof(char);
+            offInstr += 1;
             break;
 
         case 2: /* Effective address + 32 bits displacement */
-            size += sizeof(int32_t);
+            offInstr += 4;
             break;
 
@@ -1192,16 +1167,15 @@
         {
         case 0: //effective address
-            if (rm == 6) {
-                size += sizeof(uint16_t);
-            }
+            if (rm == 6)
+                offInstr += 2;
             /* else register address */
             break;
 
         case 1: /* Effective address + 8 bits displacement */
-            size += sizeof(char);
+            offInstr++;
             break;
 
         case 2: /* Effective address + 32 bits displacement */
-            size += sizeof(uint16_t);
+            offInstr += 2;
             break;
 
@@ -1210,5 +1184,5 @@
         }
     }
-    return size;
+    return offInstr;
 }
 //*****************************************************************************
@@ -1216,7 +1190,7 @@
 static size_t ParseIllegal(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
+    NOREF(pOp); NOREF(pParam); NOREF(pDis);
     AssertFailed();
-    return 0;
+    return offInstr;
 }
 //*****************************************************************************
@@ -1224,9 +1198,6 @@
 static size_t ParseModRM(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    size_t size = sizeof(uint8_t);   //ModRM byte
-    size_t sibinc;
-
-    unsigned ModRM = disReadByte(pDis, offInstr);
-    offInstr += sizeof(uint8_t);
+    uint8_t ModRM = disReadByte(pDis, offInstr);
+    offInstr++;
 
     pDis->ModRM.Bits.Rm  = MODRM_RM(ModRM);
@@ -1260,9 +1231,7 @@
         }
     }
-    size += QueryModRM(offInstr, pOp, pDis, pParam, &sibinc);
-    offInstr += sibinc;
-
-    UseModRM(offInstr, pOp, pDis, pParam);
-    return size;
+    offInstr = QueryModRM(offInstr, pOp, pDis, pParam);
+
+    return UseModRM(offInstr, pOp, pDis, pParam);
 }
 //*****************************************************************************
@@ -1270,9 +1239,6 @@
 static size_t ParseModRM_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    size_t size = sizeof(uint8_t);   //ModRM byte
-    size_t sibinc;
-
-    unsigned ModRM = disReadByte(pDis, offInstr);
-    offInstr += sizeof(uint8_t);
+    uint8_t ModRM = disReadByte(pDis, offInstr);
+    offInstr++;
 
     pDis->ModRM.Bits.Rm  = MODRM_RM(ModRM);
@@ -1307,9 +1273,8 @@
     }
 
-    size += QueryModRM_SizeOnly(offInstr, pOp, pDis, pParam, &sibinc);
-    offInstr += sibinc;
+    offInstr += QueryModRM_SizeOnly(offInstr, pOp, pDis, pParam);
 
     /* UseModRM is not necessary here; we're only interested in the opcode size */
-    return size;
+    return offInstr;
 }
 //*****************************************************************************
@@ -1319,6 +1284,6 @@
     ////AssertMsgFailed(("??\n"));
     //nothing to do apparently
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
-    return 0;
+    NOREF(pOp); NOREF(pParam); NOREF(pDis);
+    return offInstr;
 }
 //*****************************************************************************
@@ -1330,5 +1295,5 @@
     pParam->fUse  |= DISUSE_IMMEDIATE8;
     pParam->cb     = sizeof(uint8_t);
-    return sizeof(uint8_t);
+    return offInstr + 1;
 }
 //*****************************************************************************
@@ -1336,6 +1301,6 @@
 static size_t ParseImmByte_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
-    return sizeof(uint8_t);
+    NOREF(pOp); NOREF(pParam); NOREF(pDis);
+    return offInstr + 1;
 }
 //*****************************************************************************
@@ -1363,5 +1328,5 @@
         pParam->cb     = sizeof(uint16_t);
     }
-    return sizeof(uint8_t);
+    return offInstr + 1;
 }
 //*****************************************************************************
@@ -1369,6 +1334,6 @@
 static size_t ParseImmByteSX_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
-    return sizeof(uint8_t);
+    NOREF(pOp); NOREF(pParam); NOREF(pDis);
+    return offInstr + 1;
 }
 //*****************************************************************************
@@ -1380,5 +1345,5 @@
     pParam->fUse  |= DISUSE_IMMEDIATE16;
     pParam->cb     = sizeof(uint16_t);
-    return sizeof(uint16_t);
+    return offInstr + 2;
 }
 //*****************************************************************************
@@ -1386,6 +1351,6 @@
 static size_t ParseImmUshort_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
-    return sizeof(uint16_t);
+    NOREF(pOp); NOREF(pParam); NOREF(pDis);
+    return offInstr + 2;
 }
 //*****************************************************************************
@@ -1397,5 +1362,5 @@
     pParam->fUse  |= DISUSE_IMMEDIATE32;
     pParam->cb     = sizeof(uint32_t);
-    return sizeof(uint32_t);
+    return offInstr + 4;
 }
 //*****************************************************************************
@@ -1403,6 +1368,6 @@
 static size_t ParseImmUlong_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
-    return sizeof(uint32_t);
+    NOREF(pOp); NOREF(pParam); NOREF(pDis);
+    return offInstr + 4;
 }
 //*****************************************************************************
@@ -1414,5 +1379,5 @@
     pParam->fUse  |= DISUSE_IMMEDIATE64;
     pParam->cb     = sizeof(uint64_t);
-    return sizeof(uint64_t);
+    return offInstr + 8;
 }
 //*****************************************************************************
@@ -1421,5 +1386,5 @@
 {
     NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
-    return sizeof(uint64_t);
+    return offInstr + 8;
 }
 //*****************************************************************************
@@ -1433,5 +1398,5 @@
         pParam->fUse  |= DISUSE_IMMEDIATE32;
         pParam->cb     = sizeof(uint32_t);
-        return sizeof(uint32_t);
+        return offInstr + 4;
     }
 
@@ -1441,5 +1406,5 @@
         pParam->fUse  |= DISUSE_IMMEDIATE64;
         pParam->cb     = sizeof(uint64_t);
-        return sizeof(uint64_t);
+        return offInstr + 8;
     }
 
@@ -1447,5 +1412,5 @@
     pParam->fUse  |= DISUSE_IMMEDIATE16;
     pParam->cb     = sizeof(uint16_t);
-    return sizeof(uint16_t);
+    return offInstr + 2;
 }
 //*****************************************************************************
@@ -1455,8 +1420,8 @@
     NOREF(offInstr); NOREF(pOp); NOREF(pParam);
     if (pDis->uOpMode == DISCPUMODE_32BIT)
-        return sizeof(uint32_t);
+        return offInstr + 4;
     if (pDis->uOpMode == DISCPUMODE_64BIT)
-        return sizeof(uint64_t);
-    return sizeof(uint16_t);
+        return offInstr + 8;
+    return offInstr + 2;
 }
 //*****************************************************************************
@@ -1471,5 +1436,5 @@
         pParam->fUse  |= DISUSE_IMMEDIATE16;
         pParam->cb     = sizeof(uint16_t);
-        return sizeof(uint16_t);
+        return offInstr + 2;
     }
 
@@ -1487,5 +1452,5 @@
         pParam->cb     = sizeof(uint32_t);
     }
-    return sizeof(uint32_t);
+    return offInstr + 4;
 }
 //*****************************************************************************
@@ -1497,5 +1462,5 @@
     if (pDis->uOpMode == DISCPUMODE_16BIT)
         return sizeof(uint16_t);
-    return sizeof(uint32_t);
+    return offInstr + 4;
 }
 
@@ -1509,5 +1474,5 @@
     pParam->fUse  |= DISUSE_IMMEDIATE8_REL;
     pParam->cb     = sizeof(uint8_t);
-    return sizeof(char);
+    return offInstr + 1;
 }
 //*****************************************************************************
@@ -1517,5 +1482,5 @@
 {
     NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
-    return sizeof(char);
+    return offInstr + 1;
 }
 //*****************************************************************************
@@ -1530,5 +1495,5 @@
         pParam->fUse  |= DISUSE_IMMEDIATE32_REL;
         pParam->cb     = sizeof(int32_t);
-        return sizeof(int32_t);
+        return offInstr + 4;
     }
 
@@ -1539,5 +1504,5 @@
         pParam->fUse  |= DISUSE_IMMEDIATE64_REL;
         pParam->cb     = sizeof(int64_t);
-        return sizeof(int32_t);
+        return offInstr + 4;
     }
 
@@ -1545,5 +1510,5 @@
     pParam->fUse  |= DISUSE_IMMEDIATE16_REL;
     pParam->cb     = sizeof(int16_t);
-    return sizeof(int16_t);
+    return offInstr + 2;
 }
 //*****************************************************************************
@@ -1554,7 +1519,7 @@
     NOREF(offInstr); NOREF(pOp); NOREF(pParam);
     if (pDis->uOpMode == DISCPUMODE_16BIT)
-        return sizeof(int16_t);
+        return offInstr + 2;
     /* Both 32 & 64 bits mode use 32 bits relative immediates. */
-    return sizeof(int32_t);
+    return offInstr + 4;
 }
 //*****************************************************************************
@@ -1571,5 +1536,5 @@
             pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
             pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
-            return sizeof(uint32_t) + sizeof(uint16_t);
+            return offInstr + 4 + 2;
         }
 
@@ -1583,10 +1548,9 @@
         pParam->fUse  |= DISUSE_DISPLACEMENT32;
         pParam->cb     = sizeof(uint32_t);
-        return sizeof(uint32_t);
+        return offInstr + 4;
     }
 
     if (pDis->uAddrMode == DISCPUMODE_64BIT)
     {
-        Assert(OP_PARM_VSUBTYPE(pParam->fParam) != OP_PARM_p);
         /*
          * near 64 bits pointer
@@ -1595,8 +1559,9 @@
          * so we treat it like displacement.
          */
+        Assert(OP_PARM_VSUBTYPE(pParam->fParam) != OP_PARM_p);
         pParam->uDisp.i64 = disReadQWord(pDis, offInstr);
         pParam->fUse  |= DISUSE_DISPLACEMENT64;
         pParam->cb     = sizeof(uint64_t);
-        return sizeof(uint64_t);
+        return offInstr + 8;
     }
     if (OP_PARM_VSUBTYPE(pParam->fParam) == OP_PARM_p)
@@ -1606,5 +1571,5 @@
         pParam->fUse  |= DISUSE_IMMEDIATE_ADDR_16_16;
         pParam->cb     = 2*sizeof(uint16_t);
-        return sizeof(uint32_t);
+        return offInstr + 4;
     }
 
@@ -1618,5 +1583,5 @@
     pParam->fUse  |= DISUSE_DISPLACEMENT16;
     pParam->cb     = sizeof(uint16_t);
-    return sizeof(uint16_t);
+    return offInstr + 2;
 }
 //*****************************************************************************
@@ -1628,28 +1593,15 @@
     {
         if (OP_PARM_VSUBTYPE(pParam->fParam) == OP_PARM_p)
-        {// far 16:32 pointer
-            return sizeof(uint32_t) + sizeof(uint16_t);
-        }
-        else
-        {// near 32 bits pointer
-            return sizeof(uint32_t);
-        }
+            return offInstr + 4 + 2; /* far 16:32 pointer */
+        return offInstr + 4;         /* near 32 bits pointer */
     }
     if (pDis->uAddrMode == DISCPUMODE_64BIT)
     {
         Assert(OP_PARM_VSUBTYPE(pParam->fParam) != OP_PARM_p);
-        return sizeof(uint64_t);
-    }
-    else
-    {
-        if (OP_PARM_VSUBTYPE(pParam->fParam) == OP_PARM_p)
-        {// far 16:16 pointer
-            return sizeof(uint32_t);
-        }
-        else
-        {// near 16 bits pointer
-            return sizeof(uint16_t);
-        }
-    }
+        return offInstr + 8;
+    }
+    if (OP_PARM_VSUBTYPE(pParam->fParam) == OP_PARM_p)
+        return offInstr + 4;        /* far 16:16 pointer */
+    return offInstr + 2;            /* near 16 bits pointer */
 }
 //*****************************************************************************
@@ -1667,5 +1619,5 @@
         pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
         pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
-        return sizeof(uint32_t) + sizeof(uint16_t);
+        return offInstr + 4 + 2;
     }
 
@@ -1674,5 +1626,5 @@
     pParam->fUse  |= DISUSE_IMMEDIATE_ADDR_16_16;
     pParam->cb     = 2*sizeof(uint16_t);
-    return sizeof(uint32_t);
+    return offInstr + 2 + 2;
 }
 //*****************************************************************************
@@ -1685,13 +1637,6 @@
     Assert(OP_PARM_VSUBTYPE(pParam->fParam) == OP_PARM_p);
     if (pDis->uOpMode == DISCPUMODE_32BIT)
-    {
-        // far 16:32 pointer
-        return sizeof(uint32_t) + sizeof(uint16_t);
-    }
-    else
-    {
-        // far 16:16 pointer
-        return sizeof(uint32_t);
-    }
+        return offInstr + 4 + 2;    /* far 16:32 pointer */
+    return offInstr + 2 + 2;        /* far 16:16 pointer */
 }
 //*****************************************************************************
@@ -1708,5 +1653,5 @@
     {
         /* No parameter at all. */
-        return 0;
+        return offInstr;
     }
 
@@ -1794,5 +1739,5 @@
     /* else - not supported for now registers. */
 
-    return 0;
+    return offInstr;
 }
 //*****************************************************************************
@@ -1800,5 +1745,5 @@
 static size_t ParseXv(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    NOREF(offInstr);
+    NOREF(pOp);
 
     pParam->fUse |= DISUSE_POINTER_DS_BASED;
@@ -1819,5 +1764,5 @@
         pParam->fUse |= DISUSE_REG_GEN16;
     }
-    return 0;   //no additional opcode bytes
+    return offInstr;
 }
 //*****************************************************************************
@@ -1825,5 +1770,5 @@
 static size_t ParseXb(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    NOREF(offInstr); NOREF(pOp);
+    NOREF(pOp);
 
     pParam->fUse |= DISUSE_POINTER_DS_BASED;
@@ -1844,5 +1789,5 @@
         pParam->fUse |= DISUSE_REG_GEN16;
     }
-    return 0;   //no additional opcode bytes
+    return offInstr;
 }
 //*****************************************************************************
@@ -1850,5 +1795,5 @@
 static size_t ParseYv(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    NOREF(offInstr);
+    NOREF(pOp);
 
     pParam->fUse |= DISUSE_POINTER_ES_BASED;
@@ -1869,5 +1814,5 @@
         pParam->fUse |= DISUSE_REG_GEN16;
     }
-    return 0;   //no additional opcode bytes
+    return offInstr;
 }
 //*****************************************************************************
@@ -1875,5 +1820,5 @@
 static size_t ParseYb(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    NOREF(offInstr); NOREF(pOp);
+    NOREF(pOp);
 
     pParam->fUse |= DISUSE_POINTER_ES_BASED;
@@ -1894,5 +1839,5 @@
         pParam->fUse |= DISUSE_REG_GEN16;
     }
-    return 0;   //no additional opcode bytes
+    return offInstr;
 }
 //*****************************************************************************
@@ -1900,13 +1845,12 @@
 static size_t ParseTwoByteEsc(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    PCDISOPCODE   pOpcode;
-    size_t        size    = sizeof(uint8_t);
     NOREF(pOp); NOREF(pParam);
 
     /* 2nd byte */
     pDis->bOpCode = disReadByte(pDis, offInstr);
+    offInstr++;
 
     /* default to the non-prefixed table. */
-    pOpcode      = &g_aTwoByteMapX86[pDis->bOpCode];
+    PCDISOPCODE pOpcode = &g_aTwoByteMapX86[pDis->bOpCode];
 
     /* Handle opcode table extensions that rely on the address, repe or repne prefix byte.  */
@@ -1952,5 +1896,5 @@
     }
 
-    return disParseInstruction(offInstr+size, pOpcode, pDis, size);
+    return disParseInstruction(offInstr, pOpcode, pDis);
 }
 //*****************************************************************************
@@ -1958,12 +1902,12 @@
 static size_t ParseThreeByteEsc4(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    PCDISOPCODE   pOpcode;
-    size_t        size    = sizeof(uint8_t);
     NOREF(pOp); NOREF(pParam);
 
     /* 3rd byte */
     pDis->bOpCode = disReadByte(pDis, offInstr);
+    offInstr++;
 
     /* default to the non-prefixed table. */
+    PCDISOPCODE pOpcode;
     if (g_apThreeByteMapX86_0F38[pDis->bOpCode >> 4])
     {
@@ -2012,5 +1956,5 @@
     }
 
-    return disParseInstruction(offInstr+size, pOpcode, pDis, size);
+    return disParseInstruction(offInstr, pOpcode, pDis);
 }
 //*****************************************************************************
@@ -2018,10 +1962,9 @@
 static size_t ParseThreeByteEsc5(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    PCDISOPCODE   pOpcode;
-    size_t        size    = sizeof(uint8_t);
     NOREF(pOp); NOREF(pParam);
 
     /* 3rd byte */
     pDis->bOpCode = disReadByte(pDis, offInstr);
+    offInstr++;
 
     /** @todo Should we take the first or last prefix byte in case of multiple prefix bytes??? */
@@ -2029,4 +1972,5 @@
 
     /* default to the non-prefixed table. */
+    PCDISOPCODE pOpcode;
     if (g_apThreeByteMapX86_660F3A[pDis->bOpCode >> 4])
     {
@@ -2046,5 +1990,5 @@
         pOpcode = &g_InvalidOpcode[0];
 
-    return disParseInstruction(offInstr+size, pOpcode, pDis, size);
+    return disParseInstruction(offInstr, pOpcode, pDis);
 }
 //*****************************************************************************
@@ -2052,5 +1996,4 @@
 static size_t ParseNopPause(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    size_t size = 0;
     NOREF(pParam);
 
@@ -2063,5 +2006,5 @@
         pOp = &g_aMapX86_NopPause[0]; /* NOP */
 
-    return disParseInstruction(offInstr, pOp, pDis, size);
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2069,17 +2012,16 @@
 static size_t ParseImmGrpl(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    int idx = (pDis->bOpCode - 0x80) * 8;
-    size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pDis, offInstr);
-    unsigned reg   = MODRM_REG(modrm);
+    uint8_t  modrm = disReadByte(pDis, offInstr);
+    uint8_t  reg   = MODRM_REG(modrm);
+    unsigned idx   = (pDis->bOpCode - 0x80) * 8;
 
     pOp = &g_aMapX86_Group1[idx+reg];
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2087,8 +2029,7 @@
 static size_t ParseShiftGrp2(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    int idx;
-    size_t size = 0;
     NOREF(pParam);
 
+    unsigned idx;
     switch (pDis->bOpCode)
     {
@@ -2106,10 +2047,11 @@
 
     default:
-        AssertMsgFailed(("Oops\n"));
-        return sizeof(uint8_t);
-    }
-
-    unsigned modrm = disReadByte(pDis, offInstr);
-    unsigned reg   = MODRM_REG(modrm);
+        Log(("ParseShiftGrp2: bOpCode=%#x\n", pDis->bOpCode));
+        pDis->rc = VERR_DIS_INVALID_OPCODE;
+        return offInstr;
+    }
+
+    uint8_t modrm = disReadByte(pDis, offInstr);
+    uint8_t reg   = MODRM_REG(modrm);
 
     pOp = &g_aMapX86_Group2[idx+reg];
@@ -2117,7 +2059,7 @@
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2125,10 +2067,9 @@
 static size_t ParseGrp3(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    int idx = (pDis->bOpCode - 0xF6) * 8;
-    size_t size = 0;
+    unsigned idx = (pDis->bOpCode - 0xF6) * 8;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pDis, offInstr);
-    unsigned reg   = MODRM_REG(modrm);
+    uint8_t modrm = disReadByte(pDis, offInstr);
+    uint8_t reg   = MODRM_REG(modrm);
 
     pOp = &g_aMapX86_Group3[idx+reg];
@@ -2136,7 +2077,7 @@
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2144,9 +2085,8 @@
 static size_t ParseGrp4(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pDis, offInstr);
-    unsigned reg   = MODRM_REG(modrm);
+    uint8_t modrm = disReadByte(pDis, offInstr);
+    uint8_t reg   = MODRM_REG(modrm);
 
     pOp = &g_aMapX86_Group4[reg];
@@ -2154,7 +2094,7 @@
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2162,9 +2102,8 @@
 static size_t ParseGrp5(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pDis, offInstr);
-    unsigned reg   = MODRM_REG(modrm);
+    uint8_t modrm = disReadByte(pDis, offInstr);
+    uint8_t reg   = MODRM_REG(modrm);
 
     pOp = &g_aMapX86_Group5[reg];
@@ -2172,7 +2111,7 @@
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2184,6 +2123,4 @@
 static size_t Parse3DNow(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    size_t size = 0;
-
 #ifdef DEBUG_Sander
     //needs testing
@@ -2191,26 +2128,22 @@
 #endif
 
-    unsigned ModRM = disReadByte(pDis, offInstr);
+    uint8_t ModRM = disReadByte(pDis, offInstr);
     pDis->ModRM.Bits.Rm  = MODRM_RM(ModRM);
     pDis->ModRM.Bits.Mod = MODRM_MOD(ModRM);
     pDis->ModRM.Bits.Reg = MODRM_REG(ModRM);
 
-    size_t modrmsize = QueryModRM(offInstr+sizeof(uint8_t), pOp, pDis, pParam, NULL);
-
-    uint8_t opcode = disReadByte(pDis, offInstr+sizeof(uint8_t)+modrmsize);
-
+    size_t offRet = QueryModRM(offInstr + 1, pOp, pDis, pParam);
+
+    uint8_t opcode = disReadByte(pDis, offRet);
+    offRet++;
     pOp = &g_aTwoByteMapX86_3DNow[opcode];
 
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-    {
-#ifdef DEBUG_Sander /* bird, 2005-06-28: Alex is getting this during full installation of win2ksp4. */
-        AssertMsgFailed(("Oops!\n")); //shouldn't happen!
-#endif
-        size = sizeof(uint8_t); //ModRM byte
-    }
-
-    size += sizeof(uint8_t);   //imm8_opcode uint8_t
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;                 /* for illegal opcodes */
+
+    size_t offStrict = disParseInstruction(offInstr, pOp, pDis);
+    Assert(offStrict == offRet - 1);  NOREF(offStrict);   /* the imm8_opcode */
+    return offRet;
 }
 //*****************************************************************************
@@ -2218,9 +2151,8 @@
 static size_t ParseGrp6(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pDis, offInstr);
-    unsigned reg   = MODRM_REG(modrm);
+    uint8_t modrm = disReadByte(pDis, offInstr);
+    uint8_t reg   = MODRM_REG(modrm);
 
     pOp = &g_aMapX86_Group6[reg];
@@ -2228,7 +2160,7 @@
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2236,11 +2168,10 @@
 static size_t ParseGrp7(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pDis, offInstr);
-    unsigned mod   = MODRM_MOD(modrm);
-    unsigned reg   = MODRM_REG(modrm);
-    unsigned rm    = MODRM_RM(modrm);
+    uint8_t modrm = disReadByte(pDis, offInstr);
+    uint8_t mod   = MODRM_MOD(modrm);
+    uint8_t reg   = MODRM_REG(modrm);
+    uint8_t rm    = MODRM_RM(modrm);
 
     if (mod == 3 && rm == 0)
@@ -2254,7 +2185,7 @@
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2262,9 +2193,8 @@
 static size_t ParseGrp8(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pDis, offInstr);
-    unsigned reg   = MODRM_REG(modrm);
+    uint8_t modrm = disReadByte(pDis, offInstr);
+    uint8_t reg   = MODRM_REG(modrm);
 
     pOp = &g_aMapX86_Group8[reg];
@@ -2272,7 +2202,7 @@
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2280,9 +2210,8 @@
 static size_t ParseGrp9(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pDis, offInstr);
-    unsigned reg   = MODRM_REG(modrm);
+    uint8_t modrm = disReadByte(pDis, offInstr);
+    uint8_t reg   = MODRM_REG(modrm);
 
     pOp = &g_aMapX86_Group9[reg];
@@ -2290,7 +2219,7 @@
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2298,9 +2227,8 @@
 static size_t ParseGrp10(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pDis, offInstr);
-    unsigned reg   = MODRM_REG(modrm);
+    uint8_t modrm = disReadByte(pDis, offInstr);
+    uint8_t reg   = MODRM_REG(modrm);
 
     pOp = &g_aMapX86_Group10[reg];
@@ -2308,7 +2236,7 @@
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2316,9 +2244,8 @@
 static size_t ParseGrp12(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
-    size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pDis, offInstr);
-    unsigned reg   = MODRM_REG(modrm);
+    uint8_t modrm = disReadByte(pDis, offInstr);
+    uint8_t reg   = MODRM_REG(modrm);
 
     if (pDis->fPrefix & DISPREFIX_OPSIZE)
@@ -2329,31 +2256,11 @@
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
 //*****************************************************************************
 static size_t ParseGrp13(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
-{
-    size_t size = 0;
-    NOREF(pParam);
-
-    unsigned modrm = disReadByte(pDis, offInstr);
-    unsigned reg   = MODRM_REG(modrm);
-    if (pDis->fPrefix & DISPREFIX_OPSIZE)
-        reg += 8;   //2nd table
-
-    pOp = &g_aMapX86_Group13[reg];
-
-    //little hack to make sure the ModRM byte is included in the returned size
-    if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
-}
-//*****************************************************************************
-//*****************************************************************************
-static size_t ParseGrp14(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
 {
     NOREF(pParam);
@@ -2364,4 +2271,23 @@
         reg += 8;   //2nd table
 
+    pOp = &g_aMapX86_Group13[reg];
+
+    //little hack to make sure the ModRM byte is included in the returned size
+    if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
+}
+//*****************************************************************************
+//*****************************************************************************
+static size_t ParseGrp14(size_t offInstr, PCDISOPCODE pOp, PDISSTATE pDis, PDISOPPARAM pParam)
+{
+    NOREF(pParam);
+
+    uint8_t modrm = disReadByte(pDis, offInstr);
+    uint8_t reg   = MODRM_REG(modrm);
+    if (pDis->fPrefix & DISPREFIX_OPSIZE)
+        reg += 8;   //2nd table
+
     pOp = &g_aMapX86_Group14[reg];
 
@@ -2369,7 +2295,7 @@
     size_t size = 0;
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2392,7 +2318,7 @@
     size_t size = 0;
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 //*****************************************************************************
@@ -2406,9 +2332,8 @@
 
     //little hack to make sure the ModRM byte is included in the returned size
-    size_t size = 0;
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
-        size = sizeof(uint8_t); //ModRM byte
-
-    return disParseInstruction(offInstr, pOp, pDis, size);
+        offInstr++;
+
+    return disParseInstruction(offInstr, pOp, pDis);
 }
 
@@ -2594,5 +2519,5 @@
         pDis->bOpCode  = codebyte;
         pDis->cbPrefix = (uint8_t)offInstr - 1;
-        offInstr = disParseInstruction(offInstr, &paOneByteMap[pDis->bOpCode], pDis, offInstr);
+        offInstr = disParseInstruction(offInstr, &paOneByteMap[pDis->bOpCode], pDis);
         break;
     }