react-native-update 10.34.3 → 10.34.5

package/harmony/pushy/src/main/cpp/lzma/C/XzDec.c

@@ -1,5 +1,5 @@
 /* XzDec.c -- Xz Decode
-: Igor Pavlov : Public domain */
+2019-02-02 : Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -59,7 +59,7 @@ unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value)
 
   for (i = 0; i < limit;)
   {
-    const unsigned b = p[i];
+    Byte b = p[i];
     *value |= (UInt64)(b & 0x7F) << (7 * i++);
     if ((b & 0x80) == 0)
       return (b == 0 && i != 1) ? 0 : i;
@@ -67,8 +67,7 @@ unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value)
   return 0;
 }
 
-
-/* ---------- XzBcFilterState ---------- */
+/* ---------- BraState ---------- */
 
 #define BRA_BUF_SIZE (1 << 14)
 
@@ -77,60 +76,55 @@ typedef struct
   size_t bufPos;
   size_t bufConv;
   size_t bufTotal;
-  Byte *buf;  // must be aligned for 4 bytes
-  Xz_Func_BcFilterStateBase_Filter filter_func;
-  // int encodeMode;
-  CXzBcFilterStateBase base;
-  // Byte buf[BRA_BUF_SIZE];
-} CXzBcFilterState;
 
+  int encodeMode;
+
+  UInt32 methodId;
+  UInt32 delta;
+  UInt32 ip;
+  UInt32 x86State;
+  Byte deltaState[DELTA_STATE_SIZE];
 
-static void XzBcFilterState_Free(void *pp, ISzAllocPtr alloc)
+  Byte buf[BRA_BUF_SIZE];
+} CBraState;
+
+static void BraState_Free(void *pp, ISzAllocPtr alloc)
 {
-  if (pp)
-  {
-    CXzBcFilterState *p = ((CXzBcFilterState *)pp);
-    ISzAlloc_Free(alloc, p->buf);
-    ISzAlloc_Free(alloc, pp);
-  }
+  ISzAlloc_Free(alloc, pp);
 }
 
-
-static SRes XzBcFilterState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
+static SRes BraState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
 {
-  CXzBcFilterStateBase *p = &((CXzBcFilterState *)pp)->base;
-  UNUSED_VAR(alloc)
+  CBraState *p = ((CBraState *)pp);
+  UNUSED_VAR(alloc);
   p->ip = 0;
   if (p->methodId == XZ_ID_Delta)
   {
     if (propSize != 1)
       return SZ_ERROR_UNSUPPORTED;
-    p->delta = (UInt32)props[0] + 1;
+    p->delta = (unsigned)props[0] + 1;
   }
   else
   {
     if (propSize == 4)
     {
-      const UInt32 v = GetUi32(props);
+      UInt32 v = GetUi32(props);
       switch (p->methodId)
       {
         case XZ_ID_PPC:
         case XZ_ID_ARM:
         case XZ_ID_SPARC:
-        case XZ_ID_ARM64:
-          if (v & 3)
+          if ((v & 3) != 0)
             return SZ_ERROR_UNSUPPORTED;
           break;
         case XZ_ID_ARMT:
-        case XZ_ID_RISCV:
-          if (v & 1)
+          if ((v & 1) != 0)
             return SZ_ERROR_UNSUPPORTED;
           break;
         case XZ_ID_IA64:
-          if (v & 0xf)
+          if ((v & 0xF) != 0)
             return SZ_ERROR_UNSUPPORTED;
           break;
-        default: break;
       }
       p->ip = v;
     }
@@ -140,91 +134,73 @@ static SRes XzBcFilterState_SetProps(void *pp, const Byte *props, size_t propSiz
   return SZ_OK;
 }
 
-
-static void XzBcFilterState_Init(void *pp)
+static void BraState_Init(void *pp)
 {
-  CXzBcFilterState *p = ((CXzBcFilterState *)pp);
+  CBraState *p = ((CBraState *)pp);
   p->bufPos = p->bufConv = p->bufTotal = 0;
-  p->base.X86_State = Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL;
-  if (p->base.methodId == XZ_ID_Delta)
-    Delta_Init(p->base.delta_State);
+  x86_Convert_Init(p->x86State);
+  if (p->methodId == XZ_ID_Delta)
+    Delta_Init(p->deltaState);
 }
 
 
-static const z7_Func_BranchConv g_Funcs_BranchConv_RISC_Dec[] =
-{
-  Z7_BRANCH_CONV_DEC_2 (BranchConv_PPC),
-  Z7_BRANCH_CONV_DEC_2 (BranchConv_IA64),
-  Z7_BRANCH_CONV_DEC_2 (BranchConv_ARM),
-  Z7_BRANCH_CONV_DEC_2 (BranchConv_ARMT),
-  Z7_BRANCH_CONV_DEC_2 (BranchConv_SPARC),
-  Z7_BRANCH_CONV_DEC_2 (BranchConv_ARM64),
-  Z7_BRANCH_CONV_DEC_2 (BranchConv_RISCV)
-};
-
-static SizeT XzBcFilterStateBase_Filter_Dec(CXzBcFilterStateBase *p, Byte *data, SizeT size)
+#define CASE_BRA_CONV(isa) case XZ_ID_ ## isa: size = isa ## _Convert(data, size, p->ip, p->encodeMode); break;
+
+static SizeT BraState_Filter(void *pp, Byte *data, SizeT size)
 {
+  CBraState *p = ((CBraState *)pp);
   switch (p->methodId)
   {
     case XZ_ID_Delta:
-      Delta_Decode(p->delta_State, p->delta, data, size);
+      if (p->encodeMode)
+        Delta_Encode(p->deltaState, p->delta, data, size);
+      else
+        Delta_Decode(p->deltaState, p->delta, data, size);
       break;
     case XZ_ID_X86:
-      size = (SizeT)(z7_BranchConvSt_X86_Dec(data, size, p->ip, &p->X86_State) - data);
-      break;
-    default:
-      if (p->methodId >= XZ_ID_PPC)
-      {
-        const UInt32 i = p->methodId - XZ_ID_PPC;
-        if (i < Z7_ARRAY_SIZE(g_Funcs_BranchConv_RISC_Dec))
-          size = (SizeT)(g_Funcs_BranchConv_RISC_Dec[i](data, size, p->ip) - data);
-      }
+      size = x86_Convert(data, size, p->ip, &p->x86State, p->encodeMode);
       break;
+    CASE_BRA_CONV(PPC)
+    CASE_BRA_CONV(IA64)
+    CASE_BRA_CONV(ARM)
+    CASE_BRA_CONV(ARMT)
+    CASE_BRA_CONV(SPARC)
   }
   p->ip += (UInt32)size;
   return size;
 }
 
 
-static SizeT XzBcFilterState_Filter(void *pp, Byte *data, SizeT size)
-{
-  CXzBcFilterState *p = ((CXzBcFilterState *)pp);
-  return p->filter_func(&p->base, data, size);
-}
-
-
-static SRes XzBcFilterState_Code2(void *pp,
+static SRes BraState_Code2(void *pp,
     Byte *dest, SizeT *destLen,
     const Byte *src, SizeT *srcLen, int srcWasFinished,
     ECoderFinishMode finishMode,
     // int *wasFinished
     ECoderStatus *status)
 {
-  CXzBcFilterState *p = ((CXzBcFilterState *)pp);
+  CBraState *p = ((CBraState *)pp);
   SizeT destRem = *destLen;
   SizeT srcRem = *srcLen;
-  UNUSED_VAR(finishMode)
+  UNUSED_VAR(finishMode);
 
   *destLen = 0;
   *srcLen = 0;
   // *wasFinished = False;
   *status = CODER_STATUS_NOT_FINISHED;
   
-  while (destRem != 0)
+  while (destRem > 0)
   {
+    if (p->bufPos != p->bufConv)
     {
       size_t size = p->bufConv - p->bufPos;
-      if (size)
-      {
-        if (size > destRem)
-          size = destRem;
-        memcpy(dest, p->buf + p->bufPos, size);
-        p->bufPos += size;
-        *destLen += size;
-        dest += size;
-        destRem -= size;
-        continue;
-      }
+      if (size > destRem)
+        size = destRem;
+      memcpy(dest, p->buf + p->bufPos, size);
+      p->bufPos += size;
+      *destLen += size;
+      dest += size;
+      destRem -= size;
+      continue;
     }
     
     p->bufTotal -= p->bufPos;
@@ -244,7 +220,7 @@ static SRes XzBcFilterState_Code2(void *pp,
     if (p->bufTotal == 0)
       break;
     
-    p->bufConv = p->filter_func(&p->base, p->buf, p->bufTotal);
+    p->bufConv = BraState_Filter(pp, p->buf, p->bufTotal);
 
     if (p->bufConv == 0)
     {
@@ -264,37 +240,26 @@ static SRes XzBcFilterState_Code2(void *pp,
 }
 
 
-#define XZ_IS_SUPPORTED_FILTER_ID(id) \
-    ((id) >= XZ_ID_Delta && (id) <= XZ_ID_RISCV)
-     
-SRes Xz_StateCoder_Bc_SetFromMethod_Func(IStateCoder *p, UInt64 id,
-    Xz_Func_BcFilterStateBase_Filter func, ISzAllocPtr alloc)
+SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAllocPtr alloc)
 {
-  CXzBcFilterState *decoder;
-  if (!XZ_IS_SUPPORTED_FILTER_ID(id))
+  CBraState *decoder;
+  if (id < XZ_ID_Delta || id > XZ_ID_SPARC)
     return SZ_ERROR_UNSUPPORTED;
-  decoder = (CXzBcFilterState *)p->p;
+  decoder = (CBraState *)p->p;
   if (!decoder)
   {
-    decoder = (CXzBcFilterState *)ISzAlloc_Alloc(alloc, sizeof(CXzBcFilterState));
+    decoder = (CBraState *)ISzAlloc_Alloc(alloc, sizeof(CBraState));
     if (!decoder)
       return SZ_ERROR_MEM;
-    decoder->buf = ISzAlloc_Alloc(alloc, BRA_BUF_SIZE);
-    if (!decoder->buf)
-    {
-      ISzAlloc_Free(alloc, decoder);
-      return SZ_ERROR_MEM;
-    }
     p->p = decoder;
-    p->Free     = XzBcFilterState_Free;
-    p->SetProps = XzBcFilterState_SetProps;
-    p->Init     = XzBcFilterState_Init;
-    p->Code2    = XzBcFilterState_Code2;
-    p->Filter   = XzBcFilterState_Filter;
-    decoder->filter_func = func;
+    p->Free = BraState_Free;
+    p->SetProps = BraState_SetProps;
+    p->Init = BraState_Init;
+    p->Code2 = BraState_Code2;
+    p->Filter = BraState_Filter;
   }
-  decoder->base.methodId = (UInt32)id;
-  // decoder->encodeMode = encodeMode;
+  decoder->methodId = (UInt32)id;
+  decoder->encodeMode = encodeMode;
   return SZ_OK;
 }
 
@@ -313,9 +278,9 @@ static void SbState_Free(void *pp, ISzAllocPtr alloc)
 
 static SRes SbState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
 {
-  UNUSED_VAR(pp)
-  UNUSED_VAR(props)
-  UNUSED_VAR(alloc)
+  UNUSED_VAR(pp);
+  UNUSED_VAR(props);
+  UNUSED_VAR(alloc);
   return (propSize == 0) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
 }
 
@@ -331,7 +296,7 @@ static SRes SbState_Code2(void *pp, Byte *dest, SizeT *destLen, const Byte *src,
 {
   CSbDec *p = (CSbDec *)pp;
   SRes res;
-  UNUSED_VAR(srcWasFinished)
+  UNUSED_VAR(srcWasFinished);
   p->dest = dest;
   p->destLen = *destLen;
   p->src = src;
@@ -423,7 +388,7 @@ static SRes Lzma2State_Code2(void *pp, Byte *dest, SizeT *destLen, const Byte *s
   ELzmaStatus status2;
   /* ELzmaFinishMode fm = (finishMode == LZMA_FINISH_ANY) ? LZMA_FINISH_ANY : LZMA_FINISH_END; */
   SRes res;
-  UNUSED_VAR(srcWasFinished)
+  UNUSED_VAR(srcWasFinished);
   if (spec->outBufMode)
   {
     SizeT dicPos = spec->decoder.decoder.dicPos;
@@ -454,7 +419,7 @@ static SRes Lzma2State_SetFromMethod(IStateCoder *p, Byte *outBuf, size_t outBuf
     p->Init = Lzma2State_Init;
     p->Code2 = Lzma2State_Code2;
     p->Filter = NULL;
-    Lzma2Dec_CONSTRUCT(&spec->decoder)
+    Lzma2Dec_Construct(&spec->decoder);
   }
   spec->outBufMode = False;
   if (outBuf)
@@ -544,24 +509,26 @@ static SRes MixCoder_SetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 met
 {
   IStateCoder *sc = &p->coders[coderIndex];
   p->ids[coderIndex] = methodId;
-  if (methodId == XZ_ID_LZMA2)
-    return Lzma2State_SetFromMethod(sc, outBuf, outBufSize, p->alloc);
-#ifdef USE_SUBBLOCK
-  if (methodId == XZ_ID_Subblock)
-    return SbState_SetFromMethod(sc, p->alloc);
-#endif
+  switch (methodId)
+  {
+    case XZ_ID_LZMA2: return Lzma2State_SetFromMethod(sc, outBuf, outBufSize, p->alloc);
+    #ifdef USE_SUBBLOCK
+    case XZ_ID_Subblock: return SbState_SetFromMethod(sc, p->alloc);
+    #endif
+  }
   if (coderIndex == 0)
     return SZ_ERROR_UNSUPPORTED;
-  return Xz_StateCoder_Bc_SetFromMethod_Func(sc, methodId,
-      XzBcFilterStateBase_Filter_Dec, p->alloc);
+  return BraState_SetFromMethod(sc, methodId, 0, p->alloc);
 }
 
 
 static SRes MixCoder_ResetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 methodId, Byte *outBuf, size_t outBufSize)
 {
   IStateCoder *sc = &p->coders[coderIndex];
-  if (methodId == XZ_ID_LZMA2)
-    return Lzma2State_ResetOutBuf(sc, outBuf, outBufSize);
+  switch (methodId)
+  {
+    case XZ_ID_LZMA2: return Lzma2State_ResetOutBuf(sc, outBuf, outBufSize);
+  }
   return SZ_ERROR_UNSUPPORTED;
 }
 
@@ -600,7 +567,7 @@ static SRes MixCoder_Code(CMixCoder *p,
     SizeT destLen2, srcLen2;
     int wasFinished;
     
-    PRF_STR("------- MixCoder Single ----------")
+    PRF_STR("------- MixCoder Single ----------");
       
     srcLen2 = srcLenOrig;
     destLen2 = destLenOrig;
@@ -647,14 +614,14 @@ static SRes MixCoder_Code(CMixCoder *p,
         processed = coder->Filter(coder->p, p->outBuf, processed);
         if (wasFinished || (destFinish && p->outWritten == destLenOrig))
           processed = p->outWritten;
-        PRF_STR_INT("filter", i)
+        PRF_STR_INT("filter", i);
       }
       *destLen = processed;
     }
     return res;
   }
 
-  PRF_STR("standard mix")
+  PRF_STR("standard mix");
 
   if (p->numCoders != 1)
   {
@@ -796,21 +763,21 @@ SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf)
 
 static BoolInt Xz_CheckFooter(CXzStreamFlags flags, UInt64 indexSize, const Byte *buf)
 {
-  return indexSize == (((UInt64)GetUi32a(buf + 4) + 1) << 2)
-      && GetUi32a(buf) == CrcCalc(buf + 4, 6)
-      && flags == GetBe16a(buf + 8)
-      && GetUi16a(buf + 10) == (XZ_FOOTER_SIG_0 | (XZ_FOOTER_SIG_1 << 8));
+  return indexSize == (((UInt64)GetUi32(buf + 4) + 1) << 2)
+      && GetUi32(buf) == CrcCalc(buf + 4, 6)
+      && flags == GetBe16(buf + 8)
+      && buf[10] == XZ_FOOTER_SIG_0
+      && buf[11] == XZ_FOOTER_SIG_1;
 }
 
 #define READ_VARINT_AND_CHECK(buf, pos, size, res) \
-  { const unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \
-  if (s == 0) return SZ_ERROR_ARCHIVE; \
-  pos += s; }
+  { unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \
+  if (s == 0) return SZ_ERROR_ARCHIVE; pos += s; }
 
 
 static BoolInt XzBlock_AreSupportedFilters(const CXzBlock *p)
 {
-  const unsigned numFilters = XzBlock_GetNumFilters(p) - 1;
+  unsigned numFilters = XzBlock_GetNumFilters(p) - 1;
   unsigned i;
   {
     const CXzFilter *f = &p->filters[numFilters];
@@ -826,7 +793,8 @@ static BoolInt XzBlock_AreSupportedFilters(const CXzBlock *p)
       if (f->propsSize != 1)
         return False;
     }
-    else if (!XZ_IS_SUPPORTED_FILTER_ID(f->id)
+    else if (f->id < XZ_ID_Delta
+        || f->id > XZ_ID_SPARC
         || (f->propsSize != 0 && f->propsSize != 4))
       return False;
   }
@@ -851,24 +819,22 @@ SRes XzBlock_Parse(CXzBlock *p, const Byte *header)
   p->packSize = (UInt64)(Int64)-1;
   if (XzBlock_HasPackSize(p))
   {
-    READ_VARINT_AND_CHECK(header, pos, headerSize, &p->packSize)
+    READ_VARINT_AND_CHECK(header, pos, headerSize, &p->packSize);
     if (p->packSize == 0 || p->packSize + headerSize >= (UInt64)1 << 63)
       return SZ_ERROR_ARCHIVE;
   }
 
   p->unpackSize = (UInt64)(Int64)-1;
   if (XzBlock_HasUnpackSize(p))
-  {
-    READ_VARINT_AND_CHECK(header, pos, headerSize, &p->unpackSize)
-  }
+    READ_VARINT_AND_CHECK(header, pos, headerSize, &p->unpackSize);
 
   numFilters = XzBlock_GetNumFilters(p);
   for (i = 0; i < numFilters; i++)
   {
     CXzFilter *filter = p->filters + i;
     UInt64 size;
-    READ_VARINT_AND_CHECK(header, pos, headerSize, &filter->id)
-    READ_VARINT_AND_CHECK(header, pos, headerSize, &size)
+    READ_VARINT_AND_CHECK(header, pos, headerSize, &filter->id);
+    READ_VARINT_AND_CHECK(header, pos, headerSize, &size);
     if (size > headerSize - pos || size > XZ_FILTER_PROPS_SIZE_MAX)
       return SZ_ERROR_ARCHIVE;
     filter->propsSize = (UInt32)size;
@@ -926,20 +892,20 @@ static SRes XzDecMix_Init(CMixCoder *p, const CXzBlock *block, Byte *outBuf, siz
     MixCoder_Free(p);
     for (i = 0; i < numFilters; i++)
     {
-      RINOK(MixCoder_SetFromMethod(p, i, block->filters[numFilters - 1 - i].id, outBuf, outBufSize))
+      RINOK(MixCoder_SetFromMethod(p, i, block->filters[numFilters - 1 - i].id, outBuf, outBufSize));
     }
     p->numCoders = numFilters;
   }
   else
   {
-    RINOK(MixCoder_ResetFromMethod(p, 0, block->filters[numFilters - 1].id, outBuf, outBufSize))
+    RINOK(MixCoder_ResetFromMethod(p, 0, block->filters[numFilters - 1].id, outBuf, outBufSize));
   }
 
   for (i = 0; i < numFilters; i++)
   {
     const CXzFilter *f = &block->filters[numFilters - 1 - i];
     IStateCoder *sc = &p->coders[i];
-    RINOK(sc->SetProps(sc->p, f->props, f->propsSize, p->alloc))
+    RINOK(sc->SetProps(sc->p, f->props, f->propsSize, p->alloc));
   }
   
   MixCoder_Init(p);
@@ -1033,7 +999,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
       SRes res;
 
       ECoderFinishMode finishMode2 = finishMode;
-      BoolInt srcFinished2 = (BoolInt)srcFinished;
+      BoolInt srcFinished2 = srcFinished;
       BoolInt destFinish = False;
 
       if (p->block.packSize != (UInt64)(Int64)-1)
@@ -1072,7 +1038,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
             (p->outBuf ? NULL : dest), &destLen2, destFinish,
             src, &srcLen2, srcFinished2,
             finishMode2);
-
+        
         *status = p->decoder.status;
         XzCheck_Update(&p->check, (p->outBuf ? p->outBuf + p->outDataWritten : dest), destLen2);
         if (!p->outBuf)
@@ -1086,14 +1052,14 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
       (*destLen) += destLen2;
       p->unpackSize += destLen2;
 
-      RINOK(res)
+      RINOK(res);
 
       if (*status != CODER_STATUS_FINISHED_WITH_MARK)
       {
         if (p->block.packSize == p->packSize
             && *status == CODER_STATUS_NEEDS_MORE_INPUT)
         {
-          PRF_STR("CODER_STATUS_NEEDS_MORE_INPUT")
+          PRF_STR("CODER_STATUS_NEEDS_MORE_INPUT");
           *status = CODER_STATUS_NOT_SPECIFIED;
           return SZ_ERROR_DATA;
         }
@@ -1110,7 +1076,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
         if ((p->block.packSize != (UInt64)(Int64)-1 && p->block.packSize != p->packSize)
            || (p->block.unpackSize != (UInt64)(Int64)-1 && p->block.unpackSize != p->unpackSize))
         {
-          PRF_STR("ERROR: block.size mismatch")
+          PRF_STR("ERROR: block.size mismatch");
           return SZ_ERROR_DATA;
         }
       }
@@ -1126,7 +1092,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
       return SZ_OK;
     }
 
-    switch ((int)p->state)
+    switch (p->state)
     {
       case XZ_STATE_STREAM_HEADER:
       {
@@ -1141,7 +1107,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
         }
         else
         {
-          RINOK(Xz_ParseHeader(&p->streamFlags, p->buf))
+          RINOK(Xz_ParseHeader(&p->streamFlags, p->buf));
           p->numStartedStreams++;
           p->indexSize = 0;
           p->numBlocks = 0;
@@ -1165,21 +1131,21 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
             p->indexPreSize = 1 + Xz_WriteVarInt(p->buf + 1, p->numBlocks);
             p->indexPos = p->indexPreSize;
             p->indexSize += p->indexPreSize;
-            Sha256_Final(&p->sha, (Byte *)(void *)p->shaDigest32);
+            Sha256_Final(&p->sha, p->shaDigest);
             Sha256_Init(&p->sha);
             p->crc = CrcUpdate(CRC_INIT_VAL, p->buf, p->indexPreSize);
             p->state = XZ_STATE_STREAM_INDEX;
             break;
           }
-          p->blockHeaderSize = ((unsigned)p->buf[0] << 2) + 4;
+          p->blockHeaderSize = ((UInt32)p->buf[0] << 2) + 4;
           break;
         }
         
         if (p->pos != p->blockHeaderSize)
         {
-          unsigned cur = p->blockHeaderSize - p->pos;
+          UInt32 cur = p->blockHeaderSize - p->pos;
           if (cur > srcRem)
-            cur = (unsigned)srcRem;
+            cur = (UInt32)srcRem;
           memcpy(p->buf + p->pos, src, cur);
           p->pos += cur;
           (*srcLen) += cur;
@@ -1187,7 +1153,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
         }
         else
         {
-          RINOK(XzBlock_Parse(&p->block, p->buf))
+          RINOK(XzBlock_Parse(&p->block, p->buf));
           if (!XzBlock_AreSupportedFilters(&p->block))
             return SZ_ERROR_UNSUPPORTED;
           p->numTotalBlocks++;
@@ -1200,7 +1166,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
             p->headerParsedOk = True;
             return SZ_OK;
           }
-          RINOK(XzDecMix_Init(&p->decoder, &p->block, p->outBuf, p->outBufSize))
+          RINOK(XzDecMix_Init(&p->decoder, &p->block, p->outBuf, p->outBufSize));
         }
         break;
       }
@@ -1221,8 +1187,8 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
         }
         else
         {
-          const unsigned checkSize = XzFlags_GetCheckSize(p->streamFlags);
-          unsigned cur = checkSize - p->pos;
+          UInt32 checkSize = XzFlags_GetCheckSize(p->streamFlags);
+          UInt32 cur = checkSize - p->pos;
           if (cur != 0)
           {
             if (srcRem == 0)
@@ -1231,7 +1197,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
               return SZ_OK;
             }
             if (cur > srcRem)
-              cur = (unsigned)srcRem;
+              cur = (UInt32)srcRem;
             memcpy(p->buf + p->pos, src, cur);
             p->pos += cur;
             (*srcLen) += cur;
@@ -1240,10 +1206,10 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
               break;
           }
           {
-            UInt32 digest32[XZ_CHECK_SIZE_MAX / 4];
+            Byte digest[XZ_CHECK_SIZE_MAX];
             p->state = XZ_STATE_BLOCK_HEADER;
             p->pos = 0;
-            if (XzCheck_Final(&p->check, (void *)digest32) && memcmp(digest32, p->buf, checkSize) != 0)
+            if (XzCheck_Final(&p->check, digest) && memcmp(digest, p->buf, checkSize) != 0)
               return SZ_ERROR_CRC;
             if (p->decodeOnlyOneBlock)
             {
@@ -1288,12 +1254,12 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
           }
           else
           {
-            UInt32 digest32[SHA256_DIGEST_SIZE / 4];
+            Byte digest[SHA256_DIGEST_SIZE];
             p->state = XZ_STATE_STREAM_INDEX_CRC;
             p->indexSize += 4;
             p->pos = 0;
-            Sha256_Final(&p->sha, (void *)digest32);
-            if (memcmp(digest32, p->shaDigest32, SHA256_DIGEST_SIZE) != 0)
+            Sha256_Final(&p->sha, digest);
+            if (memcmp(digest, p->shaDigest, SHA256_DIGEST_SIZE) != 0)
               return SZ_ERROR_CRC;
           }
         }
@@ -1309,10 +1275,9 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
         }
         else
         {
-          const Byte *ptr = p->buf;
           p->state = XZ_STATE_STREAM_FOOTER;
           p->pos = 0;
-          if (CRC_GET_DIGEST(p->crc) != GetUi32a(ptr))
+          if (CRC_GET_DIGEST(p->crc) != GetUi32(p->buf))
             return SZ_ERROR_CRC;
         }
         break;
@@ -1320,9 +1285,9 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
 
       case XZ_STATE_STREAM_FOOTER:
       {
-        unsigned cur = XZ_STREAM_FOOTER_SIZE - p->pos;
+        UInt32 cur = XZ_STREAM_FOOTER_SIZE - p->pos;
         if (cur > srcRem)
-          cur = (unsigned)srcRem;
+          cur = (UInt32)srcRem;
         memcpy(p->buf + p->pos, src, cur);
         p->pos += cur;
         (*srcLen) += cur;
@@ -1342,7 +1307,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
       {
         if (*src != 0)
         {
-          if ((unsigned)p->padSize & 3)
+          if (((UInt32)p->padSize & 3) != 0)
             return SZ_ERROR_NO_ARCHIVE;
           p->pos = 0;
           p->state = XZ_STATE_STREAM_HEADER;
@@ -1357,8 +1322,6 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
       }
       
       case XZ_STATE_BLOCK: break; /* to disable GCC warning */
-      
-      default: return SZ_ERROR_FAIL;
     }
   }
   /*
@@ -1423,7 +1386,7 @@ UInt64 XzUnpacker_GetExtraSize(const CXzUnpacker *p)
 
 
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 #include "MtDec.h"
 #endif
 
@@ -1434,7 +1397,7 @@ void XzDecMtProps_Init(CXzDecMtProps *p)
   p->outStep_ST = 1 << 20;
   p->ignoreErrors = False;
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   p->numThreads = 1;
   p->inBufSize_MT = 1 << 18;
   p->memUseMax = sizeof(size_t) << 28;
@@ -1443,7 +1406,7 @@ void XzDecMtProps_Init(CXzDecMtProps *p)
 
 
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 
 /* ---------- CXzDecMtThread ---------- */
 
@@ -1482,7 +1445,7 @@ typedef struct
 
 /* ---------- CXzDecMt ---------- */
 
-struct CXzDecMt
+typedef struct
 {
   CAlignOffsetAlloc alignOffsetAlloc;
   ISzAllocPtr allocMid;
@@ -1490,9 +1453,10 @@ struct CXzDecMt
   CXzDecMtProps props;
   size_t unpackBlockMaxSize;
   
-  ISeqInStreamPtr inStream;
-  ISeqOutStreamPtr outStream;
-  ICompressProgressPtr progress;
+  ISeqInStream *inStream;
+  ISeqOutStream *outStream;
+  ICompressProgress *progress;
+  // CXzStatInfo *stat;
 
   BoolInt finishMode;
   BoolInt outSize_Defined;
@@ -1515,7 +1479,7 @@ struct CXzDecMt
   ECoderStatus status;
   SRes codeRes;
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   BoolInt mainDecoderWasCalled;
   // int statErrorDefined;
   int finishedDecoderIndex;
@@ -1528,9 +1492,8 @@ struct CXzDecMt
   UInt64 numBlocks;
 
   // UInt64 numBadBlocks;
-  SRes mainErrorCode;  // it's set to error code, if the size Code() output doesn't patch the size from Parsing stage
-                       // it can be = SZ_ERROR_INPUT_EOF
-                       // it can be = SZ_ERROR_DATA, in some another cases
+  SRes mainErrorCode;
+
   BoolInt isBlockHeaderState_Parse;
   BoolInt isBlockHeaderState_Write;
   UInt64 outProcessed_Parse;
@@ -1538,9 +1501,10 @@ struct CXzDecMt
 
   BoolInt mtc_WasConstructed;
   CMtDec mtc;
-  CXzDecMtThread coders[MTDEC_THREADS_MAX];
+  CXzDecMtThread coders[MTDEC__THREADS_MAX];
   #endif
-};
+
+} CXzDecMt;
 
 
 
@@ -1568,11 +1532,11 @@ CXzDecMtHandle XzDecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid)
 
   XzDecMtProps_Init(&p->props);
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   p->mtc_WasConstructed = False;
   {
     unsigned i;
-    for (i = 0; i < MTDEC_THREADS_MAX; i++)
+    for (i = 0; i < MTDEC__THREADS_MAX; i++)
     {
       CXzDecMtThread *coder = &p->coders[i];
       coder->dec_created = False;
@@ -1582,16 +1546,16 @@ CXzDecMtHandle XzDecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid)
   }
   #endif
 
-  return (CXzDecMtHandle)p;
+  return p;
 }
 
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 
 static void XzDecMt_FreeOutBufs(CXzDecMt *p)
 {
   unsigned i;
-  for (i = 0; i < MTDEC_THREADS_MAX; i++)
+  for (i = 0; i < MTDEC__THREADS_MAX; i++)
   {
     CXzDecMtThread *coder = &p->coders[i];
     if (coder->outBuf)
@@ -1628,15 +1592,13 @@ static void XzDecMt_FreeSt(CXzDecMt *p)
 }
 
 
-// #define GET_CXzDecMt_p  CXzDecMt *p = pp;
-
-void XzDecMt_Destroy(CXzDecMtHandle p)
+void XzDecMt_Destroy(CXzDecMtHandle pp)
 {
-  // GET_CXzDecMt_p
+  CXzDecMt *p = (CXzDecMt *)pp;
 
   XzDecMt_FreeSt(p);
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
 
   if (p->mtc_WasConstructed)
   {
@@ -1645,7 +1607,7 @@ void XzDecMt_Destroy(CXzDecMtHandle p)
   }
   {
     unsigned i;
-    for (i = 0; i < MTDEC_THREADS_MAX; i++)
+    for (i = 0; i < MTDEC__THREADS_MAX; i++)
     {
       CXzDecMtThread *t = &p->coders[i];
       if (t->dec_created)
@@ -1660,12 +1622,12 @@ void XzDecMt_Destroy(CXzDecMtHandle p)
 
   #endif
 
-  ISzAlloc_Free(p->alignOffsetAlloc.baseAlloc, p);
+  ISzAlloc_Free(p->alignOffsetAlloc.baseAlloc, pp);
 }
 
 
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 
 static void XzDecMt_Callback_Parse(void *obj, unsigned coderIndex, CMtDecCallbackInfo *cc)
 {
@@ -1731,7 +1693,7 @@ static void XzDecMt_Callback_Parse(void *obj, unsigned coderIndex, CMtDecCallbac
     coder->dec.parseMode = True;
     coder->dec.headerParsedOk = False;
     
-    PRF_STR_INT("Parse", srcSize2)
+    PRF_STR_INT("Parse", srcSize2);
     
     res = XzUnpacker_Code(&coder->dec,
         NULL, &destSize,
@@ -1774,10 +1736,10 @@ static void XzDecMt_Callback_Parse(void *obj, unsigned coderIndex, CMtDecCallbac
           }
         }
         {
-        const UInt64 packSize = block->packSize;
-        const UInt64 packSizeAligned = packSize + ((0 - (unsigned)packSize) & 3);
-        const unsigned checkSize = XzFlags_GetCheckSize(coder->dec.streamFlags);
-        const UInt64 blockPackSum = coder->inPreSize + packSizeAligned + checkSize;
+        UInt64 packSize = block->packSize;
+        UInt64 packSizeAligned = packSize + ((0 - (unsigned)packSize) & 3);
+        UInt32 checkSize = XzFlags_GetCheckSize(coder->dec.streamFlags);
+        UInt64 blockPackSum = coder->inPreSize + packSizeAligned + checkSize;
         // if (blockPackSum <= me->props.inBlockMax)
         // unpackBlockMaxSize
         {
@@ -1915,7 +1877,7 @@ static SRes XzDecMt_Callback_PreCode(void *pp, unsigned coderIndex)
     {
       // if (res == SZ_ERROR_MEM) return res;
       if (me->props.ignoreErrors && res != SZ_ERROR_MEM)
-        return SZ_OK;
+        return S_OK;
       return res;
     }
   }
@@ -1936,18 +1898,15 @@ static SRes XzDecMt_Callback_Code(void *pp, unsigned coderIndex,
   *outCodePos = coder->outCodeSize;
   *stop = True;
 
-  if (srcSize > coder->inPreSize - coder->inCodeSize)
-    return SZ_ERROR_FAIL;
-  
   if (coder->inCodeSize < coder->inPreHeaderSize)
   {
-    size_t step = coder->inPreHeaderSize - coder->inCodeSize;
-    if (step > srcSize)
-      step = srcSize;
+    UInt64 rem = coder->inPreHeaderSize - coder->inCodeSize;
+    size_t step = srcSize;
+    if (step > rem)
+      step = (size_t)rem;
     src += step;
     srcSize -= step;
     coder->inCodeSize += step;
-    *inCodePos = coder->inCodeSize;
     if (coder->inCodeSize < coder->inPreHeaderSize)
     {
       *stop = False;
@@ -1997,7 +1956,7 @@ static SRes XzDecMt_Callback_Code(void *pp, unsigned coderIndex,
   {
     *inCodePos = coder->inPreSize;
     *outCodePos = coder->outPreSize;
-    return SZ_OK;
+    return S_OK;
   }
   return coder->codeRes;
 }
@@ -2007,7 +1966,7 @@ static SRes XzDecMt_Callback_Code(void *pp, unsigned coderIndex,
 
 static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
     BoolInt needWriteToStream,
-    const Byte *src, size_t srcSize, BoolInt isCross,
+    const Byte *src, size_t srcSize,
     // int srcFinished,
     BoolInt *needContinue,
     BoolInt *canRecode)
@@ -2026,7 +1985,7 @@ static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
   if (!coder->dec.headerParsedOk || !coder->outBuf)
   {
     if (me->finishedDecoderIndex < 0)
-      me->finishedDecoderIndex = (int)coderIndex;
+      me->finishedDecoderIndex = coderIndex;
     return SZ_OK;
   }
 
@@ -2106,7 +2065,7 @@ static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
         }
         data += cur;
         size -= cur;
-        // PRF_STR_INT("Written size =", size)
+        // PRF_STR_INT("Written size =", size);
         if (size == 0)
           break;
         res = MtProgress_ProgressAdd(&me->mtc.mtProgress, 0, 0);
@@ -2118,16 +2077,16 @@ static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
     if (coder->codeRes != SZ_OK)
       if (!me->props.ignoreErrors)
       {
-        me->finishedDecoderIndex = (int)coderIndex;
+        me->finishedDecoderIndex = coderIndex;
         return res;
       }
 
-    RINOK(res)
+    RINOK(res);
 
     if (coder->inPreSize != coder->inCodeSize
         || coder->blockPackTotal != coder->inCodeSize)
     {
-      me->finishedDecoderIndex = (int)coderIndex;
+      me->finishedDecoderIndex = coderIndex;
       return SZ_OK;
     }
 
@@ -2141,13 +2100,13 @@ static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
   // (coder->state == MTDEC_PARSE_END) means that there are no other working threads
   // so we can use mtc variables without lock
 
-  PRF_STR_INT("Write MTDEC_PARSE_END", me->mtc.inProcessed)
+  PRF_STR_INT("Write MTDEC_PARSE_END", me->mtc.inProcessed);
 
   me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
   {
     CXzUnpacker *dec = &me->dec;
     
-    PRF_STR_INT("PostSingle", srcSize)
+    PRF_STR_INT("PostSingle", srcSize);
     
     {
       size_t srcProcessed = srcSize;
@@ -2166,41 +2125,22 @@ static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
         return SZ_OK;
       }
       
-      /*
-      We have processed all xz-blocks of stream,
-      And xz unpacker is at XZ_STATE_BLOCK_HEADER state, where
-      (src) is a pointer to xz-Index structure.
-      We finish reading of current xz-Stream, including Zero padding after xz-Stream.
-      We exit, if we reach extra byte (first byte of new-Stream or another data).
-      But we don't update input stream pointer for that new extra byte.
-      If extra byte is not correct first byte of xz-signature,
-      we have SZ_ERROR_NO_ARCHIVE error here.
-      */
-
       res = XzUnpacker_Code(dec,
           NULL, &outSizeCur,
           src, &srcProcessed,
           me->mtc.readWasFinished, // srcFinished
           CODER_FINISH_END, // CODER_FINISH_ANY,
           &status);
-
-      // res = SZ_ERROR_ARCHIVE; // for failure test
       
       me->status = status;
       me->codeRes = res;
 
-      if (isCross)
-        me->mtc.crossStart += srcProcessed;
-
       me->mtc.inProcessed += srcProcessed;
       me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
 
-      srcSize -= srcProcessed;
-      src += srcProcessed;
-
       if (res != SZ_OK)
       {
-        return SZ_OK;
+        return S_OK;
         // return res;
       }
       
@@ -2209,26 +2149,20 @@ static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
         *needContinue = True;
         me->isBlockHeaderState_Parse = False;
         me->isBlockHeaderState_Write = False;
-
-        if (!isCross)
         {
           Byte *crossBuf = MtDec_GetCrossBuff(&me->mtc);
           if (!crossBuf)
             return SZ_ERROR_MEM;
-          if (srcSize != 0)
-            memcpy(crossBuf, src, srcSize);
-          me->mtc.crossStart = 0;
-          me->mtc.crossEnd = srcSize;
+          memcpy(crossBuf, src + srcProcessed, srcSize - srcProcessed);
         }
-
-        PRF_STR_INT("XZ_STATE_STREAM_HEADER crossEnd = ", (unsigned)me->mtc.crossEnd)
-
+        me->mtc.crossStart = 0;
+        me->mtc.crossEnd = srcSize - srcProcessed;
         return SZ_OK;
       }
       
-      if (status != CODER_STATUS_NEEDS_MORE_INPUT || srcSize != 0)
+      if (status != CODER_STATUS_NEEDS_MORE_INPUT)
       {
-        return SZ_ERROR_FAIL;
+        return E_FAIL;
       }
       
       if (me->mtc.readWasFinished)
@@ -2240,7 +2174,7 @@ static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
     {
       size_t inPos;
       size_t inLim;
-      // const Byte *inData;
+      const Byte *inData;
       UInt64 inProgressPrev = me->mtc.inProcessed;
       
       // XzDecMt_Prepare_InBuf_ST(p);
@@ -2250,8 +2184,9 @@ static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
       
       inPos = 0;
       inLim = 0;
+      // outProcessed = 0;
       
-      // inData = crossBuf;
+      inData = crossBuf;
       
       for (;;)
       {
@@ -2266,7 +2201,7 @@ static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
           {
             inPos = 0;
             inLim = me->mtc.inBufSize;
-            me->mtc.readRes = ISeqInStream_Read(me->inStream, (void *)crossBuf, &inLim);
+            me->mtc.readRes = ISeqInStream_Read(me->inStream, (void *)inData, &inLim);
             me->mtc.readProcessed += inLim;
             if (inLim == 0 || me->mtc.readRes != SZ_OK)
               me->mtc.readWasFinished = True;
@@ -2278,7 +2213,7 @@ static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
 
         res = XzUnpacker_Code(dec,
             NULL, &outProcessed,
-            crossBuf + inPos, &inProcessed,
+            inData + inPos, &inProcessed,
             (inProcessed == 0), // srcFinished
             CODER_FINISH_END, &status);
         
@@ -2290,7 +2225,7 @@ static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
 
         if (res != SZ_OK)
         {
-          return SZ_OK;
+          return S_OK;
           // return res;
         }
 
@@ -2305,14 +2240,14 @@ static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
         }
         
         if (status != CODER_STATUS_NEEDS_MORE_INPUT)
-          return SZ_ERROR_FAIL;
+          return E_FAIL;
         
         if (me->mtc.progress)
         {
           UInt64 inDelta = me->mtc.inProcessed - inProgressPrev;
           if (inDelta >= (1 << 22))
           {
-            RINOK(MtProgress_Progress_ST(&me->mtc.mtProgress))
+            RINOK(MtProgress_Progress_ST(&me->mtc.mtProgress));
             inProgressPrev = me->mtc.inProcessed;
           }
         }
@@ -2341,6 +2276,13 @@ void XzStatInfo_Clear(CXzStatInfo *p)
   p->NumStreams_Defined = False;
   p->NumBlocks_Defined = False;
   
+  // p->IsArc = False;
+  // p->UnexpectedEnd = False;
+  // p->Unsupported = False;
+  // p->HeadersError = False;
+  // p->DataError = False;
+  // p->CrcError = False;
+
   p->DataAfterEnd = False;
   p->DecodingTruncated = False;
   
@@ -2354,19 +2296,9 @@ void XzStatInfo_Clear(CXzStatInfo *p)
 
 
 
-/*
-  XzDecMt_Decode_ST() can return SZ_OK or the following errors
-     - SZ_ERROR_MEM for memory allocation error
-     - error from XzUnpacker_Code() function
-     - SZ_ERROR_WRITE for ISeqOutStream::Write(). stat->CombinedRes_Type = SZ_ERROR_WRITE in that case
-     - ICompressProgress::Progress() error,  stat->CombinedRes_Type = SZ_ERROR_PROGRESS.
-  But XzDecMt_Decode_ST() doesn't return ISeqInStream::Read() errors.
-  ISeqInStream::Read() result is set to p->readRes.
-  also it can set stat->CombinedRes_Type to SZ_ERROR_WRITE or SZ_ERROR_PROGRESS.
-*/
 
 static SRes XzDecMt_Decode_ST(CXzDecMt *p
-    #ifndef Z7_ST
+    #ifndef _7ZIP_ST
     , BoolInt tMode
     #endif
     , CXzStatInfo *stat)
@@ -2378,11 +2310,11 @@ static SRes XzDecMt_Decode_ST(CXzDecMt *p
 
   CXzUnpacker *dec;
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   if (tMode)
   {
     XzDecMt_FreeOutBufs(p);
-    tMode = (BoolInt)MtDec_PrepareRead(&p->mtc);
+    tMode = MtDec_PrepareRead(&p->mtc);
   }
   #endif
 
@@ -2435,7 +2367,7 @@ static SRes XzDecMt_Decode_ST(CXzDecMt *p
 
     if (inPos == inLim)
     {
-      #ifndef Z7_ST
+      #ifndef _7ZIP_ST
       if (tMode)
       {
         inData = MtDec_Read(&p->mtc, &inLim);
@@ -2452,7 +2384,7 @@ static SRes XzDecMt_Decode_ST(CXzDecMt *p
         inPos = 0;
         inLim = p->inBufSize;
         inData = p->inBuf;
-        p->readRes = ISeqInStream_Read(p->inStream, (void *)p->inBuf, &inLim);
+        p->readRes = ISeqInStream_Read(p->inStream, (void *)inData, &inLim);
         p->readProcessed += inLim;
         if (inLim == 0 || p->readRes != SZ_OK)
           p->readWasFinished = True;
@@ -2494,8 +2426,8 @@ static SRes XzDecMt_Decode_ST(CXzDecMt *p
     if (finished || outProcessed >= outSize)
       if (outPos != 0)
       {
-        const size_t written = ISeqOutStream_Write(p->outStream, p->outBuf, outPos);
-        // p->outProcessed += written; // 21.01: BUG fixed
+        size_t written = ISeqOutStream_Write(p->outStream, p->outBuf, outPos);
+        p->outProcessed += written;
         if (written != outPos)
         {
           stat->CombinedRes_Type = SZ_ERROR_WRITE;
@@ -2506,8 +2438,9 @@ static SRes XzDecMt_Decode_ST(CXzDecMt *p
 
     if (p->progress && res == SZ_OK)
     {
-      if (p->inProcessed - inPrev >= (1 << 22) ||
-          p->outProcessed - outPrev >= (1 << 22))
+      UInt64 inDelta = p->inProcessed - inPrev;
+      UInt64 outDelta = p->outProcessed - outPrev;
+      if (inDelta >= (1 << 22) || outDelta >= (1 << 22))
       {
         res = ICompressProgress_Progress(p->progress, p->inProcessed, p->outProcessed);
         if (res != SZ_OK)
@@ -2522,31 +2455,14 @@ static SRes XzDecMt_Decode_ST(CXzDecMt *p
     }
 
     if (finished)
-    {
-      // p->codeRes is preliminary error from XzUnpacker_Code.
-      // and it can be corrected later as final result
-      // so we return SZ_OK here instead of (res);
-      return SZ_OK;
-      // return res;
-    }
+      return res;
   }
 }
 
-
-
-/*
-XzStatInfo_SetStat() transforms
-    CXzUnpacker return code and status to combined CXzStatInfo results.
-    it can convert SZ_OK to SZ_ERROR_INPUT_EOF
-    it can convert SZ_ERROR_NO_ARCHIVE to SZ_OK and (DataAfterEnd = 1)
-*/
-
-static void XzStatInfo_SetStat(const CXzUnpacker *dec,
+static SRes XzStatInfo_SetStat(const CXzUnpacker *dec,
     int finishMode,
-    // UInt64 readProcessed,
-    UInt64 inProcessed,
-    SRes res,                     // it's result from CXzUnpacker unpacker
-    ECoderStatus status,
+    UInt64 readProcessed, UInt64 inProcessed,
+    SRes res, ECoderStatus status,
     BoolInt decodingTruncated,
     CXzStatInfo *stat)
 {
@@ -2568,20 +2484,12 @@ static void XzStatInfo_SetStat(const CXzUnpacker *dec,
     if (status == CODER_STATUS_NEEDS_MORE_INPUT)
     {
       // CODER_STATUS_NEEDS_MORE_INPUT is expected status for correct xz streams
-      // any extra data is part of correct data
       extraSize = 0;
-      // if xz stream was not finished, then we need more data
       if (!XzUnpacker_IsStreamWasFinished(dec))
         res = SZ_ERROR_INPUT_EOF;
     }
-    else
-    {
-      // CODER_STATUS_FINISHED_WITH_MARK is not possible for multi stream xz decoding
-      // so he we have (status == CODER_STATUS_NOT_FINISHED)
-      // if (status != CODER_STATUS_FINISHED_WITH_MARK)
-      if (!decodingTruncated || finishMode)
-        res = SZ_ERROR_DATA;
-    }
+    else if (!decodingTruncated || finishMode) // (status == CODER_STATUS_NOT_FINISHED)
+      res = SZ_ERROR_DATA;
   }
   else if (res == SZ_ERROR_NO_ARCHIVE)
   {
@@ -2589,42 +2497,37 @@ static void XzStatInfo_SetStat(const CXzUnpacker *dec,
     SZ_ERROR_NO_ARCHIVE is possible for 2 states:
       XZ_STATE_STREAM_HEADER  - if bad signature or bad CRC
       XZ_STATE_STREAM_PADDING - if non-zero padding data
-    extraSize and inProcessed don't include "bad" byte
+    extraSize / inProcessed don't include "bad" byte
     */
-    // if (inProcessed == extraSize), there was no any good xz stream header, and we keep error
-    if (inProcessed != extraSize) // if there were good xz streams before error
-    {
-      // if (extraSize != 0 || readProcessed != inProcessed)
+    if (inProcessed != extraSize) // if good streams before error
+      if (extraSize != 0 || readProcessed != inProcessed)
       {
-        // he we suppose that all xz streams were finsihed OK, and we have
-        // some extra data after all streams
         stat->DataAfterEnd = True;
+        // there is some good xz stream before. So we set SZ_OK
         res = SZ_OK;
       }
-    }
   }
   
-  if (stat->DecodeRes == SZ_OK)
-    stat->DecodeRes = res;
+  stat->DecodeRes = res;
 
   stat->InSize -= extraSize;
+  return res;
 }
 
 
-
-SRes XzDecMt_Decode(CXzDecMtHandle p,
+SRes XzDecMt_Decode(CXzDecMtHandle pp,
     const CXzDecMtProps *props,
     const UInt64 *outDataSize, int finishMode,
-    ISeqOutStreamPtr outStream,
+    ISeqOutStream *outStream,
     // Byte *outBuf, size_t *outBufSize,
-    ISeqInStreamPtr inStream,
+    ISeqInStream *inStream,
     // const Byte *inData, size_t inDataSize,
     CXzStatInfo *stat,
     int *isMT,
-    ICompressProgressPtr progress)
+    ICompressProgress *progress)
 {
-  // GET_CXzDecMt_p
-  #ifndef Z7_ST
+  CXzDecMt *p = (CXzDecMt *)pp;
+  #ifndef _7ZIP_ST
   BoolInt tMode;
   #endif
 
@@ -2645,7 +2548,7 @@ SRes XzDecMt_Decode(CXzDecMtHandle p,
     p->outSize = *outDataSize;
   }
 
-  p->finishMode = (BoolInt)finishMode;
+  p->finishMode = finishMode;
 
   // p->outSize = 457; p->outSize_Defined = True; p->finishMode = False; // for test
 
@@ -2654,9 +2557,8 @@ SRes XzDecMt_Decode(CXzDecMtHandle p,
   p->inProcessed = 0;
   p->readProcessed = 0;
   p->readWasFinished = False;
-  p->readRes = SZ_OK;
 
-  p->codeRes = SZ_OK;
+  p->codeRes = 0;
   p->status = CODER_STATUS_NOT_SPECIFIED;
 
   XzUnpacker_Init(&p->dec);
@@ -2675,7 +2577,7 @@ SRes XzDecMt_Decode(CXzDecMtHandle p,
     */
 
   
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
 
   p->isBlockHeaderState_Parse = False;
   p->isBlockHeaderState_Write = False;
@@ -2687,9 +2589,8 @@ SRes XzDecMt_Decode(CXzDecMtHandle p,
 
   if (p->props.numThreads > 1)
   {
-    IMtDecCallback2 vt;
-    BoolInt needContinue;
-    SRes res;
+    IMtDecCallback vt;
+
     // we just free ST buffers here
     // but we still keep state variables, that was set in XzUnpacker_Init()
     XzDecMt_FreeSt(p);
@@ -2727,45 +2628,45 @@ SRes XzDecMt_Decode(CXzDecMtHandle p,
     vt.Code = XzDecMt_Callback_Code;
     vt.Write = XzDecMt_Callback_Write;
 
+    {
+      BoolInt needContinue;
+      
+      SRes res = MtDec_Code(&p->mtc);
+
+      stat->InSize = p->mtc.inProcessed;
 
-    res = MtDec_Code(&p->mtc);
+      p->inProcessed = p->mtc.inProcessed;
+      p->readRes = p->mtc.readRes;
+      p->readWasFinished = p->mtc.readWasFinished;
+      p->readProcessed = p->mtc.readProcessed;
 
+      tMode = True;
+      needContinue = False;
 
-    stat->InSize = p->mtc.inProcessed;
-    
-    p->inProcessed = p->mtc.inProcessed;
-    p->readRes = p->mtc.readRes;
-    p->readWasFinished = p->mtc.readWasFinished;
-    p->readProcessed = p->mtc.readProcessed;
-    
-    tMode = True;
-    needContinue = False;
-    
-    if (res == SZ_OK)
-    {
-      if (p->mtc.mtProgress.res != SZ_OK)
+      if (res == SZ_OK)
       {
-        res = p->mtc.mtProgress.res;
-        stat->ProgressRes = res;
-        stat->CombinedRes_Type = SZ_ERROR_PROGRESS;
+        if (p->mtc.mtProgress.res != SZ_OK)
+        {
+          res = p->mtc.mtProgress.res;
+          stat->ProgressRes = res;
+          stat->CombinedRes_Type = SZ_ERROR_PROGRESS;
+        }
+        else
+          needContinue = p->mtc.needContinue;
       }
-      else
-        needContinue = p->mtc.needContinue;
-    }
-    
-    if (!needContinue)
-    {
+
+      if (!needContinue)
       {
         SRes codeRes;
         BoolInt truncated = False;
         ECoderStatus status;
-        const CXzUnpacker *dec;
+        CXzUnpacker *dec;
 
         stat->OutSize = p->outProcessed;
        
         if (p->finishedDecoderIndex >= 0)
         {
-          const CXzDecMtThread *coder = &p->coders[(unsigned)p->finishedDecoderIndex];
+          CXzDecMtThread *coder = &p->coders[(unsigned)p->finishedDecoderIndex];
           codeRes = coder->codeRes;
           dec = &coder->dec;
           status = coder->status;
@@ -2778,46 +2679,41 @@ SRes XzDecMt_Decode(CXzDecMtHandle p,
           truncated = p->parsing_Truncated;
         }
         else
-          return SZ_ERROR_FAIL;
-
-        if (p->mainErrorCode != SZ_OK)
-          stat->DecodeRes = p->mainErrorCode;
+          return E_FAIL;
 
         XzStatInfo_SetStat(dec, p->finishMode,
-            // p->mtc.readProcessed,
-            p->mtc.inProcessed,
+            p->mtc.readProcessed, p->mtc.inProcessed,
             codeRes, status,
             truncated,
             stat);
-      }
-
-      if (res == SZ_OK)
-      {
-        stat->ReadRes = p->mtc.readRes;
 
-        if (p->writeRes != SZ_OK)
-        {
-          res = p->writeRes;
-          stat->CombinedRes_Type = SZ_ERROR_WRITE;
-        }
-        else if (p->mtc.readRes != SZ_OK
-            // && p->mtc.inProcessed == p->mtc.readProcessed
-            && stat->DecodeRes == SZ_ERROR_INPUT_EOF)
+        if (res == SZ_OK)
         {
-          res = p->mtc.readRes;
-          stat->CombinedRes_Type = SZ_ERROR_READ;
+          if (p->writeRes != SZ_OK)
+          {
+            res = p->writeRes;
+            stat->CombinedRes_Type = SZ_ERROR_WRITE;
+          }
+          else if (p->mtc.readRes != SZ_OK && p->mtc.inProcessed == p->mtc.readProcessed)
+          {
+            res = p->mtc.readRes;
+            stat->ReadRes = res;
+            stat->CombinedRes_Type = SZ_ERROR_READ;
+          }
+          else if (p->mainErrorCode != SZ_OK)
+          {
+            res = p->mainErrorCode;
+          }
         }
-        else if (stat->DecodeRes != SZ_OK)
-          res = stat->DecodeRes;
+
+        stat->CombinedRes = res;
+        if (stat->CombinedRes_Type == SZ_OK)
+          stat->CombinedRes_Type = res;
+        return res;
       }
-      
-      stat->CombinedRes = res;
-      if (stat->CombinedRes_Type == SZ_OK)
-        stat->CombinedRes_Type = res;
-      return res;
-    }
 
-    PRF_STR("----- decoding ST -----")
+      PRF_STR("----- decoding ST -----");
+    }
   }
 
   #endif
@@ -2827,41 +2723,39 @@ SRes XzDecMt_Decode(CXzDecMtHandle p,
 
   {
     SRes res = XzDecMt_Decode_ST(p
-        #ifndef Z7_ST
+        #ifndef _7ZIP_ST
         , tMode
         #endif
         , stat
         );
 
-    #ifndef Z7_ST
-    // we must set error code from MT decoding at first
-    if (p->mainErrorCode != SZ_OK)
-      stat->DecodeRes = p->mainErrorCode;
-    #endif
-
     XzStatInfo_SetStat(&p->dec,
         p->finishMode,
-        // p->readProcessed,
-        p->inProcessed,
+        p->readProcessed, p->inProcessed,
         p->codeRes, p->status,
         False, // truncated
         stat);
 
-    stat->ReadRes = p->readRes;
-
     if (res == SZ_OK)
     {
-      if (p->readRes != SZ_OK
-          // && p->inProcessed == p->readProcessed
-          && stat->DecodeRes == SZ_ERROR_INPUT_EOF)
+      /*
+      if (p->writeRes != SZ_OK)
+      {
+        res = p->writeRes;
+        stat->CombinedRes_Type = SZ_ERROR_WRITE;
+      }
+      else
+      */
+      if (p->readRes != SZ_OK && p->inProcessed == p->readProcessed)
       {
-        // we set read error as combined error, only if that error was the reason
-        // of decoding problem
         res = p->readRes;
+        stat->ReadRes = res;
         stat->CombinedRes_Type = SZ_ERROR_READ;
       }
-      else if (stat->DecodeRes != SZ_OK)
-        res = stat->DecodeRes;
+      #ifndef _7ZIP_ST
+      else if (p->mainErrorCode != SZ_OK)
+        res = p->mainErrorCode;
+      #endif
     }
 
     stat->CombinedRes = res;
@@ -2870,7 +2764,3 @@ SRes XzDecMt_Decode(CXzDecMtHandle p,
     return res;
   }
 }
-
-#undef PRF
-#undef PRF_STR
-#undef PRF_STR_INT_2