react-native-update 8.5.5 → 8.5.6

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

@@ -1,2766 +0,0 @@
-/* XzDec.c -- Xz Decode
-2019-02-02 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-// #include <stdio.h>
-
-// #define XZ_DUMP
-
-/* #define XZ_DUMP */
-
-#ifdef XZ_DUMP
-#include <stdio.h>
-#endif
-
-// #define SHOW_DEBUG_INFO
-
-#ifdef SHOW_DEBUG_INFO
-#include <stdio.h>
-#endif
-
-#ifdef SHOW_DEBUG_INFO
-#define PRF(x) x
-#else
-#define PRF(x)
-#endif
-
-#define PRF_STR(s) PRF(printf("\n" s "\n"))
-#define PRF_STR_INT(s, d) PRF(printf("\n" s " %d\n", (unsigned)d))
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "7zCrc.h"
-#include "Alloc.h"
-#include "Bra.h"
-#include "CpuArch.h"
-#include "Delta.h"
-#include "Lzma2Dec.h"
-
-// #define USE_SUBBLOCK
-
-#ifdef USE_SUBBLOCK
-#include "Bcj3Dec.c"
-#include "SbDec.h"
-#endif
-
-#include "Xz.h"
-
-#define XZ_CHECK_SIZE_MAX 64
-
-#define CODER_BUF_SIZE ((size_t)1 << 17)
-
-unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value)
-{
-  unsigned i, limit;
-  *value = 0;
-  limit = (maxSize > 9) ? 9 : (unsigned)maxSize;
-
-  for (i = 0; i < limit;)
-  {
-    Byte b = p[i];
-    *value |= (UInt64)(b & 0x7F) << (7 * i++);
-    if ((b & 0x80) == 0)
-      return (b == 0 && i != 1) ? 0 : i;
-  }
-  return 0;
-}
-
-/* ---------- BraState ---------- */
-
-#define BRA_BUF_SIZE (1 << 14)
-
-typedef struct
-{
-  size_t bufPos;
-  size_t bufConv;
-  size_t bufTotal;
-
-  int encodeMode;
-
-  UInt32 methodId;
-  UInt32 delta;
-  UInt32 ip;
-  UInt32 x86State;
-  Byte deltaState[DELTA_STATE_SIZE];
-
-  Byte buf[BRA_BUF_SIZE];
-} CBraState;
-
-static void BraState_Free(void *pp, ISzAllocPtr alloc)
-{
-  ISzAlloc_Free(alloc, pp);
-}
-
-static SRes BraState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr 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 = (unsigned)props[0] + 1;
-  }
-  else
-  {
-    if (propSize == 4)
-    {
-      UInt32 v = GetUi32(props);
-      switch (p->methodId)
-      {
-        case XZ_ID_PPC:
-        case XZ_ID_ARM:
-        case XZ_ID_SPARC:
-          if ((v & 3) != 0)
-            return SZ_ERROR_UNSUPPORTED;
-          break;
-        case XZ_ID_ARMT:
-          if ((v & 1) != 0)
-            return SZ_ERROR_UNSUPPORTED;
-          break;
-        case XZ_ID_IA64:
-          if ((v & 0xF) != 0)
-            return SZ_ERROR_UNSUPPORTED;
-          break;
-      }
-      p->ip = v;
-    }
-    else if (propSize != 0)
-      return SZ_ERROR_UNSUPPORTED;
-  }
-  return SZ_OK;
-}
-
-static void BraState_Init(void *pp)
-{
-  CBraState *p = ((CBraState *)pp);
-  p->bufPos = p->bufConv = p->bufTotal = 0;
-  x86_Convert_Init(p->x86State);
-  if (p->methodId == XZ_ID_Delta)
-    Delta_Init(p->deltaState);
-}
-
-
-#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:
-      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 = 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 SRes BraState_Code2(void *pp,
-    Byte *dest, SizeT *destLen,
-    const Byte *src, SizeT *srcLen, int srcWasFinished,
-    ECoderFinishMode finishMode,
-    // int *wasFinished
-    ECoderStatus *status)
-{
-  CBraState *p = ((CBraState *)pp);
-  SizeT destRem = *destLen;
-  SizeT srcRem = *srcLen;
-  UNUSED_VAR(finishMode);
-
-  *destLen = 0;
-  *srcLen = 0;
-  // *wasFinished = False;
-  *status = CODER_STATUS_NOT_FINISHED;
-  
-  while (destRem > 0)
-  {
-    if (p->bufPos != p->bufConv)
-    {
-      size_t size = p->bufConv - p->bufPos;
-      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;
-    memmove(p->buf, p->buf + p->bufPos, p->bufTotal);
-    p->bufPos = 0;
-    p->bufConv = 0;
-    {
-      size_t size = BRA_BUF_SIZE - p->bufTotal;
-      if (size > srcRem)
-        size = srcRem;
-      memcpy(p->buf + p->bufTotal, src, size);
-      *srcLen += size;
-      src += size;
-      srcRem -= size;
-      p->bufTotal += size;
-    }
-    if (p->bufTotal == 0)
-      break;
-    
-    p->bufConv = BraState_Filter(pp, p->buf, p->bufTotal);
-
-    if (p->bufConv == 0)
-    {
-      if (!srcWasFinished)
-        break;
-      p->bufConv = p->bufTotal;
-    }
-  }
-
-  if (p->bufTotal == p->bufPos && srcRem == 0 && srcWasFinished)
-  {
-    *status = CODER_STATUS_FINISHED_WITH_MARK;
-    // *wasFinished = 1;
-  }
-
-  return SZ_OK;
-}
-
-
-SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAllocPtr alloc)
-{
-  CBraState *decoder;
-  if (id < XZ_ID_Delta || id > XZ_ID_SPARC)
-    return SZ_ERROR_UNSUPPORTED;
-  decoder = (CBraState *)p->p;
-  if (!decoder)
-  {
-    decoder = (CBraState *)ISzAlloc_Alloc(alloc, sizeof(CBraState));
-    if (!decoder)
-      return SZ_ERROR_MEM;
-    p->p = decoder;
-    p->Free = BraState_Free;
-    p->SetProps = BraState_SetProps;
-    p->Init = BraState_Init;
-    p->Code2 = BraState_Code2;
-    p->Filter = BraState_Filter;
-  }
-  decoder->methodId = (UInt32)id;
-  decoder->encodeMode = encodeMode;
-  return SZ_OK;
-}
-
-
-
-/* ---------- SbState ---------- */
-
-#ifdef USE_SUBBLOCK
-
-static void SbState_Free(void *pp, ISzAllocPtr alloc)
-{
-  CSbDec *p = (CSbDec *)pp;
-  SbDec_Free(p);
-  ISzAlloc_Free(alloc, pp);
-}
-
-static SRes SbState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
-{
-  UNUSED_VAR(pp);
-  UNUSED_VAR(props);
-  UNUSED_VAR(alloc);
-  return (propSize == 0) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
-}
-
-static void SbState_Init(void *pp)
-{
-  SbDec_Init((CSbDec *)pp);
-}
-
-static SRes SbState_Code2(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
-    int srcWasFinished, ECoderFinishMode finishMode,
-    // int *wasFinished
-    ECoderStatus *status)
-{
-  CSbDec *p = (CSbDec *)pp;
-  SRes res;
-  UNUSED_VAR(srcWasFinished);
-  p->dest = dest;
-  p->destLen = *destLen;
-  p->src = src;
-  p->srcLen = *srcLen;
-  p->finish = finishMode; /* change it */
-  res = SbDec_Decode((CSbDec *)pp);
-  *destLen -= p->destLen;
-  *srcLen -= p->srcLen;
-  // *wasFinished = (*destLen == 0 && *srcLen == 0); /* change it */
-  *status = (*destLen == 0 && *srcLen == 0) ?
-      CODER_STATUS_FINISHED_WITH_MARK :
-      CODER_STATUS_NOT_FINISHED;
-  return res;
-}
-
-static SRes SbState_SetFromMethod(IStateCoder *p, ISzAllocPtr alloc)
-{
-  CSbDec *decoder = (CSbDec *)p->p;
-  if (!decoder)
-  {
-    decoder = (CSbDec *)ISzAlloc_Alloc(alloc, sizeof(CSbDec));
-    if (!decoder)
-      return SZ_ERROR_MEM;
-    p->p = decoder;
-    p->Free = SbState_Free;
-    p->SetProps = SbState_SetProps;
-    p->Init = SbState_Init;
-    p->Code2 = SbState_Code2;
-    p->Filter = NULL;
-  }
-  SbDec_Construct(decoder);
-  SbDec_SetAlloc(decoder, alloc);
-  return SZ_OK;
-}
-
-#endif
-
-
-
-/* ---------- Lzma2 ---------- */
-
-typedef struct
-{
-  CLzma2Dec decoder;
-  BoolInt outBufMode;
-} CLzma2Dec_Spec;
-
-
-static void Lzma2State_Free(void *pp, ISzAllocPtr alloc)
-{
-  CLzma2Dec_Spec *p = (CLzma2Dec_Spec *)pp;
-  if (p->outBufMode)
-    Lzma2Dec_FreeProbs(&p->decoder, alloc);
-  else
-    Lzma2Dec_Free(&p->decoder, alloc);
-  ISzAlloc_Free(alloc, pp);
-}
-
-static SRes Lzma2State_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
-{
-  if (propSize != 1)
-    return SZ_ERROR_UNSUPPORTED;
-  {
-    CLzma2Dec_Spec *p = (CLzma2Dec_Spec *)pp;
-    if (p->outBufMode)
-      return Lzma2Dec_AllocateProbs(&p->decoder, props[0], alloc);
-    else
-      return Lzma2Dec_Allocate(&p->decoder, props[0], alloc);
-  }
-}
-
-static void Lzma2State_Init(void *pp)
-{
-  Lzma2Dec_Init(&((CLzma2Dec_Spec *)pp)->decoder);
-}
-
-
-/*
-  if (outBufMode), then (dest) is not used. Use NULL.
-         Data is unpacked to (spec->decoder.decoder.dic) output buffer.
-*/
-
-static SRes Lzma2State_Code2(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
-    int srcWasFinished, ECoderFinishMode finishMode,
-    // int *wasFinished,
-    ECoderStatus *status)
-{
-  CLzma2Dec_Spec *spec = (CLzma2Dec_Spec *)pp;
-  ELzmaStatus status2;
-  /* ELzmaFinishMode fm = (finishMode == LZMA_FINISH_ANY) ? LZMA_FINISH_ANY : LZMA_FINISH_END; */
-  SRes res;
-  UNUSED_VAR(srcWasFinished);
-  if (spec->outBufMode)
-  {
-    SizeT dicPos = spec->decoder.decoder.dicPos;
-    SizeT dicLimit = dicPos + *destLen;
-    res = Lzma2Dec_DecodeToDic(&spec->decoder, dicLimit, src, srcLen, (ELzmaFinishMode)finishMode, &status2);
-    *destLen = spec->decoder.decoder.dicPos - dicPos;
-  }
-  else
-    res = Lzma2Dec_DecodeToBuf(&spec->decoder, dest, destLen, src, srcLen, (ELzmaFinishMode)finishMode, &status2);
-  // *wasFinished = (status2 == LZMA_STATUS_FINISHED_WITH_MARK);
-  // ECoderStatus values are identical to ELzmaStatus values of LZMA2 decoder
-  *status = (ECoderStatus)status2;
-  return res;
-}
-
-
-static SRes Lzma2State_SetFromMethod(IStateCoder *p, Byte *outBuf, size_t outBufSize, ISzAllocPtr alloc)
-{
-  CLzma2Dec_Spec *spec = (CLzma2Dec_Spec *)p->p;
-  if (!spec)
-  {
-    spec = (CLzma2Dec_Spec *)ISzAlloc_Alloc(alloc, sizeof(CLzma2Dec_Spec));
-    if (!spec)
-      return SZ_ERROR_MEM;
-    p->p = spec;
-    p->Free = Lzma2State_Free;
-    p->SetProps = Lzma2State_SetProps;
-    p->Init = Lzma2State_Init;
-    p->Code2 = Lzma2State_Code2;
-    p->Filter = NULL;
-    Lzma2Dec_Construct(&spec->decoder);
-  }
-  spec->outBufMode = False;
-  if (outBuf)
-  {
-    spec->outBufMode = True;
-    spec->decoder.decoder.dic = outBuf;
-    spec->decoder.decoder.dicBufSize = outBufSize;
-  }
-  return SZ_OK;
-}
-
-
-static SRes Lzma2State_ResetOutBuf(IStateCoder *p, Byte *outBuf, size_t outBufSize)
-{
-  CLzma2Dec_Spec *spec = (CLzma2Dec_Spec *)p->p;
-  if ((spec->outBufMode && !outBuf) || (!spec->outBufMode && outBuf))
-    return SZ_ERROR_FAIL;
-  if (outBuf)
-  {
-    spec->decoder.decoder.dic = outBuf;
-    spec->decoder.decoder.dicBufSize = outBufSize;
-  }
-  return SZ_OK;
-}
-
-
-
-static void MixCoder_Construct(CMixCoder *p, ISzAllocPtr alloc)
-{
-  unsigned i;
-  p->alloc = alloc;
-  p->buf = NULL;
-  p->numCoders = 0;
-  
-  p->outBufSize = 0;
-  p->outBuf = NULL;
-  // p->SingleBufMode = False;
-
-  for (i = 0; i < MIXCODER_NUM_FILTERS_MAX; i++)
-    p->coders[i].p = NULL;
-}
-
-
-static void MixCoder_Free(CMixCoder *p)
-{
-  unsigned i;
-  p->numCoders = 0;
-  for (i = 0; i < MIXCODER_NUM_FILTERS_MAX; i++)
-  {
-    IStateCoder *sc = &p->coders[i];
-    if (sc->p)
-    {
-      sc->Free(sc->p, p->alloc);
-      sc->p = NULL;
-    }
-  }
-  if (p->buf)
-  {
-    ISzAlloc_Free(p->alloc, p->buf);
-    p->buf = NULL; /* 9.31: the BUG was fixed */
-  }
-}
-
-static void MixCoder_Init(CMixCoder *p)
-{
-  unsigned i;
-  for (i = 0; i < MIXCODER_NUM_FILTERS_MAX - 1; i++)
-  {
-    p->size[i] = 0;
-    p->pos[i] = 0;
-    p->finished[i] = 0;
-  }
-  for (i = 0; i < p->numCoders; i++)
-  {
-    IStateCoder *coder = &p->coders[i];
-    coder->Init(coder->p);
-    p->results[i] = SZ_OK;
-  }
-  p->outWritten = 0;
-  p->wasFinished = False;
-  p->res = SZ_OK;
-  p->status = CODER_STATUS_NOT_SPECIFIED;
-}
-
-
-static SRes MixCoder_SetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 methodId, Byte *outBuf, size_t outBufSize)
-{
-  IStateCoder *sc = &p->coders[coderIndex];
-  p->ids[coderIndex] = methodId;
-  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 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];
-  switch (methodId)
-  {
-    case XZ_ID_LZMA2: return Lzma2State_ResetOutBuf(sc, outBuf, outBufSize);
-  }
-  return SZ_ERROR_UNSUPPORTED;
-}
-
-
-
-/*
- if (destFinish) - then unpack data block is finished at (*destLen) position,
-                   and we can return data that were not processed by filter
-
-output (status) can be :
-  CODER_STATUS_NOT_FINISHED
-  CODER_STATUS_FINISHED_WITH_MARK
-  CODER_STATUS_NEEDS_MORE_INPUT - not implemented still
-*/
-
-static SRes MixCoder_Code(CMixCoder *p,
-    Byte *dest, SizeT *destLen, int destFinish,
-    const Byte *src, SizeT *srcLen, int srcWasFinished,
-    ECoderFinishMode finishMode)
-{
-  SizeT destLenOrig = *destLen;
-  SizeT srcLenOrig = *srcLen;
-
-  *destLen = 0;
-  *srcLen = 0;
-
-  if (p->wasFinished)
-    return p->res;
-  
-  p->status = CODER_STATUS_NOT_FINISHED;
-
-  // if (p->SingleBufMode)
-  if (p->outBuf)
-  {
-    SRes res;
-    SizeT destLen2, srcLen2;
-    int wasFinished;
-    
-    PRF_STR("------- MixCoder Single ----------");
-      
-    srcLen2 = srcLenOrig;
-    destLen2 = destLenOrig;
-    
-    {
-      IStateCoder *coder = &p->coders[0];
-      res = coder->Code2(coder->p, NULL, &destLen2, src, &srcLen2, srcWasFinished, finishMode,
-          // &wasFinished,
-          &p->status);
-      wasFinished = (p->status == CODER_STATUS_FINISHED_WITH_MARK);
-    }
-    
-    p->res = res;
-    
-    /*
-    if (wasFinished)
-      p->status = CODER_STATUS_FINISHED_WITH_MARK;
-    else
-    {
-      if (res == SZ_OK)
-        if (destLen2 != destLenOrig)
-          p->status = CODER_STATUS_NEEDS_MORE_INPUT;
-    }
-    */
-
-    
-    *srcLen = srcLen2;
-    src += srcLen2;
-    p->outWritten += destLen2;
-    
-    if (res != SZ_OK || srcWasFinished || wasFinished)
-      p->wasFinished = True;
-    
-    if (p->numCoders == 1)
-      *destLen = destLen2;
-    else if (p->wasFinished)
-    {
-      unsigned i;
-      size_t processed = p->outWritten;
-      
-      for (i = 1; i < p->numCoders; i++)
-      {
-        IStateCoder *coder = &p->coders[i];
-        processed = coder->Filter(coder->p, p->outBuf, processed);
-        if (wasFinished || (destFinish && p->outWritten == destLenOrig))
-          processed = p->outWritten;
-        PRF_STR_INT("filter", i);
-      }
-      *destLen = processed;
-    }
-    return res;
-  }
-
-  PRF_STR("standard mix");
-
-  if (p->numCoders != 1)
-  {
-    if (!p->buf)
-    {
-      p->buf = (Byte *)ISzAlloc_Alloc(p->alloc, CODER_BUF_SIZE * (MIXCODER_NUM_FILTERS_MAX - 1));
-      if (!p->buf)
-        return SZ_ERROR_MEM;
-    }
-    
-    finishMode = CODER_FINISH_ANY;
-  }
-
-  for (;;)
-  {
-    BoolInt processed = False;
-    BoolInt allFinished = True;
-    SRes resMain = SZ_OK;
-    unsigned i;
-
-    p->status = CODER_STATUS_NOT_FINISHED;
-    /*
-    if (p->numCoders == 1 && *destLen == destLenOrig && finishMode == LZMA_FINISH_ANY)
-      break;
-    */
-
-    for (i = 0; i < p->numCoders; i++)
-    {
-      SRes res;
-      IStateCoder *coder = &p->coders[i];
-      Byte *dest2;
-      SizeT destLen2, srcLen2; // destLen2_Orig;
-      const Byte *src2;
-      int srcFinished2;
-      int encodingWasFinished;
-      ECoderStatus status2;
-      
-      if (i == 0)
-      {
-        src2 = src;
-        srcLen2 = srcLenOrig - *srcLen;
-        srcFinished2 = srcWasFinished;
-      }
-      else
-      {
-        size_t k = i - 1;
-        src2 = p->buf + (CODER_BUF_SIZE * k) + p->pos[k];
-        srcLen2 = p->size[k] - p->pos[k];
-        srcFinished2 = p->finished[k];
-      }
-      
-      if (i == p->numCoders - 1)
-      {
-        dest2 = dest;
-        destLen2 = destLenOrig - *destLen;
-      }
-      else
-      {
-        if (p->pos[i] != p->size[i])
-          continue;
-        dest2 = p->buf + (CODER_BUF_SIZE * i);
-        destLen2 = CODER_BUF_SIZE;
-      }
-      
-      // destLen2_Orig = destLen2;
-      
-      if (p->results[i] != SZ_OK)
-      {
-        if (resMain == SZ_OK)
-          resMain = p->results[i];
-        continue;
-      }
-
-      res = coder->Code2(coder->p,
-          dest2, &destLen2,
-          src2, &srcLen2, srcFinished2,
-          finishMode,
-          // &encodingWasFinished,
-          &status2);
-
-      if (res != SZ_OK)
-      {
-        p->results[i] = res;
-        if (resMain == SZ_OK)
-          resMain = res;
-      }
-
-      encodingWasFinished = (status2 == CODER_STATUS_FINISHED_WITH_MARK);
-      
-      if (!encodingWasFinished)
-      {
-        allFinished = False;
-        if (p->numCoders == 1 && res == SZ_OK)
-          p->status = status2;
-      }
-
-      if (i == 0)
-      {
-        *srcLen += srcLen2;
-        src += srcLen2;
-      }
-      else
-        p->pos[(size_t)i - 1] += srcLen2;
-
-      if (i == p->numCoders - 1)
-      {
-        *destLen += destLen2;
-        dest += destLen2;
-      }
-      else
-      {
-        p->size[i] = destLen2;
-        p->pos[i] = 0;
-        p->finished[i] = encodingWasFinished;
-      }
-      
-      if (destLen2 != 0 || srcLen2 != 0)
-        processed = True;
-    }
-    
-    if (!processed)
-    {
-      if (allFinished)
-        p->status = CODER_STATUS_FINISHED_WITH_MARK;
-      return resMain;
-    }
-  }
-}
-
-
-SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf)
-{
-  *p = (CXzStreamFlags)GetBe16(buf + XZ_SIG_SIZE);
-  if (CrcCalc(buf + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE) !=
-      GetUi32(buf + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE))
-    return SZ_ERROR_NO_ARCHIVE;
-  return XzFlags_IsSupported(*p) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
-}
-
-static BoolInt Xz_CheckFooter(CXzStreamFlags flags, UInt64 indexSize, const Byte *buf)
-{
-  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) \
-  { 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)
-{
-  unsigned numFilters = XzBlock_GetNumFilters(p) - 1;
-  unsigned i;
-  {
-    const CXzFilter *f = &p->filters[numFilters];
-    if (f->id != XZ_ID_LZMA2 || f->propsSize != 1 || f->props[0] > 40)
-      return False;
-  }
-
-  for (i = 0; i < numFilters; i++)
-  {
-    const CXzFilter *f = &p->filters[i];
-    if (f->id == XZ_ID_Delta)
-    {
-      if (f->propsSize != 1)
-        return False;
-    }
-    else if (f->id < XZ_ID_Delta
-        || f->id > XZ_ID_SPARC
-        || (f->propsSize != 0 && f->propsSize != 4))
-      return False;
-  }
-  return True;
-}
-
-
-SRes XzBlock_Parse(CXzBlock *p, const Byte *header)
-{
-  unsigned pos;
-  unsigned numFilters, i;
-  unsigned headerSize = (unsigned)header[0] << 2;
-
-  /* (headerSize != 0) : another code checks */
-
-  if (CrcCalc(header, headerSize) != GetUi32(header + headerSize))
-    return SZ_ERROR_ARCHIVE;
-
-  pos = 1;
-  p->flags = header[pos++];
-
-  p->packSize = (UInt64)(Int64)-1;
-  if (XzBlock_HasPackSize(p))
-  {
-    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);
-
-  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);
-    if (size > headerSize - pos || size > XZ_FILTER_PROPS_SIZE_MAX)
-      return SZ_ERROR_ARCHIVE;
-    filter->propsSize = (UInt32)size;
-    memcpy(filter->props, header + pos, (size_t)size);
-    pos += (unsigned)size;
-
-    #ifdef XZ_DUMP
-    printf("\nf[%u] = %2X: ", i, (unsigned)filter->id);
-    {
-      unsigned i;
-      for (i = 0; i < size; i++)
-        printf(" %2X", filter->props[i]);
-    }
-    #endif
-  }
-
-  if (XzBlock_HasUnsupportedFlags(p))
-    return SZ_ERROR_UNSUPPORTED;
-
-  while (pos < headerSize)
-    if (header[pos++] != 0)
-      return SZ_ERROR_ARCHIVE;
-  return SZ_OK;
-}
-
-
-
-
-static SRes XzDecMix_Init(CMixCoder *p, const CXzBlock *block, Byte *outBuf, size_t outBufSize)
-{
-  unsigned i;
-  BoolInt needReInit = True;
-  unsigned numFilters = XzBlock_GetNumFilters(block);
-
-  if (numFilters == p->numCoders && ((p->outBuf && outBuf) || (!p->outBuf && !outBuf)))
-  {
-    needReInit = False;
-    for (i = 0; i < numFilters; i++)
-      if (p->ids[i] != block->filters[numFilters - 1 - i].id)
-      {
-        needReInit = True;
-        break;
-      }
-  }
-
-  // p->SingleBufMode = (outBuf != NULL);
-  p->outBuf = outBuf;
-  p->outBufSize = outBufSize;
-
-  // p->SingleBufMode = False;
-  // outBuf = NULL;
-  
-  if (needReInit)
-  {
-    MixCoder_Free(p);
-    for (i = 0; i < numFilters; i++)
-    {
-      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));
-  }
-
-  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));
-  }
-  
-  MixCoder_Init(p);
-  return SZ_OK;
-}
-
-
-
-void XzUnpacker_Init(CXzUnpacker *p)
-{
-  p->state = XZ_STATE_STREAM_HEADER;
-  p->pos = 0;
-  p->numStartedStreams = 0;
-  p->numFinishedStreams = 0;
-  p->numTotalBlocks = 0;
-  p->padSize = 0;
-  p->decodeOnlyOneBlock = 0;
-
-  p->parseMode = False;
-  p->decodeToStreamSignature = False;
-
-  // p->outBuf = NULL;
-  // p->outBufSize = 0;
-  p->outDataWritten = 0;
-}
-
-
-void XzUnpacker_SetOutBuf(CXzUnpacker *p, Byte *outBuf, size_t outBufSize)
-{
-  p->outBuf = outBuf;
-  p->outBufSize = outBufSize;
-}
-
-
-void XzUnpacker_Construct(CXzUnpacker *p, ISzAllocPtr alloc)
-{
-  MixCoder_Construct(&p->decoder, alloc);
-  p->outBuf = NULL;
-  p->outBufSize = 0;
-  XzUnpacker_Init(p);
-}
-
-
-void XzUnpacker_Free(CXzUnpacker *p)
-{
-  MixCoder_Free(&p->decoder);
-}
-
-
-void XzUnpacker_PrepareToRandomBlockDecoding(CXzUnpacker *p)
-{
-  p->indexSize = 0;
-  p->numBlocks = 0;
-  Sha256_Init(&p->sha);
-  p->state = XZ_STATE_BLOCK_HEADER;
-  p->pos = 0;
-  p->decodeOnlyOneBlock = 1;
-}
-
-
-static void XzUnpacker_UpdateIndex(CXzUnpacker *p, UInt64 packSize, UInt64 unpackSize)
-{
-  Byte temp[32];
-  unsigned num = Xz_WriteVarInt(temp, packSize);
-  num += Xz_WriteVarInt(temp + num, unpackSize);
-  Sha256_Update(&p->sha, temp, num);
-  p->indexSize += num;
-  p->numBlocks++;
-}
-
-
-
-SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
-    const Byte *src, SizeT *srcLen, int srcFinished,
-    ECoderFinishMode finishMode, ECoderStatus *status)
-{
-  SizeT destLenOrig = *destLen;
-  SizeT srcLenOrig = *srcLen;
-  *destLen = 0;
-  *srcLen = 0;
-  *status = CODER_STATUS_NOT_SPECIFIED;
-
-  for (;;)
-  {
-    SizeT srcRem;
-
-    if (p->state == XZ_STATE_BLOCK)
-    {
-      SizeT destLen2 = destLenOrig - *destLen;
-      SizeT srcLen2 = srcLenOrig - *srcLen;
-      SRes res;
-
-      ECoderFinishMode finishMode2 = finishMode;
-      BoolInt srcFinished2 = srcFinished;
-      BoolInt destFinish = False;
-
-      if (p->block.packSize != (UInt64)(Int64)-1)
-      {
-        UInt64 rem = p->block.packSize - p->packSize;
-        if (srcLen2 >= rem)
-        {
-          srcFinished2 = True;
-          srcLen2 = (SizeT)rem;
-        }
-        if (rem == 0 && p->block.unpackSize == p->unpackSize)
-          return SZ_ERROR_DATA;
-      }
-
-      if (p->block.unpackSize != (UInt64)(Int64)-1)
-      {
-        UInt64 rem = p->block.unpackSize - p->unpackSize;
-        if (destLen2 >= rem)
-        {
-          destFinish = True;
-          finishMode2 = CODER_FINISH_END;
-          destLen2 = (SizeT)rem;
-        }
-      }
-
-      /*
-      if (srcLen2 == 0 && destLen2 == 0)
-      {
-        *status = CODER_STATUS_NOT_FINISHED;
-        return SZ_OK;
-      }
-      */
-      
-      {
-        res = MixCoder_Code(&p->decoder,
-            (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)
-          dest += destLen2;
-        p->outDataWritten += destLen2;
-      }
-      
-      (*srcLen) += srcLen2;
-      src += srcLen2;
-      p->packSize += srcLen2;
-      (*destLen) += destLen2;
-      p->unpackSize += destLen2;
-
-      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");
-          *status = CODER_STATUS_NOT_SPECIFIED;
-          return SZ_ERROR_DATA;
-        }
-        
-        return SZ_OK;
-      }
-      {
-        XzUnpacker_UpdateIndex(p, XzUnpacker_GetPackSizeForIndex(p), p->unpackSize);
-        p->state = XZ_STATE_BLOCK_FOOTER;
-        p->pos = 0;
-        p->alignPos = 0;
-        *status = CODER_STATUS_NOT_SPECIFIED;
-
-        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");
-          return SZ_ERROR_DATA;
-        }
-      }
-      // continue;
-    }
-
-    srcRem = srcLenOrig - *srcLen;
-
-    // XZ_STATE_BLOCK_FOOTER can transit to XZ_STATE_BLOCK_HEADER without input bytes
-    if (srcRem == 0 && p->state != XZ_STATE_BLOCK_FOOTER)
-    {
-      *status = CODER_STATUS_NEEDS_MORE_INPUT;
-      return SZ_OK;
-    }
-
-    switch (p->state)
-    {
-      case XZ_STATE_STREAM_HEADER:
-      {
-        if (p->pos < XZ_STREAM_HEADER_SIZE)
-        {
-          if (p->pos < XZ_SIG_SIZE && *src != XZ_SIG[p->pos])
-            return SZ_ERROR_NO_ARCHIVE;
-          if (p->decodeToStreamSignature)
-            return SZ_OK;
-          p->buf[p->pos++] = *src++;
-          (*srcLen)++;
-        }
-        else
-        {
-          RINOK(Xz_ParseHeader(&p->streamFlags, p->buf));
-          p->numStartedStreams++;
-          p->indexSize = 0;
-          p->numBlocks = 0;
-          Sha256_Init(&p->sha);
-          p->state = XZ_STATE_BLOCK_HEADER;
-          p->pos = 0;
-        }
-        break;
-      }
-
-      case XZ_STATE_BLOCK_HEADER:
-      {
-        if (p->pos == 0)
-        {
-          p->buf[p->pos++] = *src++;
-          (*srcLen)++;
-          if (p->buf[0] == 0)
-          {
-            if (p->decodeOnlyOneBlock)
-              return SZ_ERROR_DATA;
-            p->indexPreSize = 1 + Xz_WriteVarInt(p->buf + 1, p->numBlocks);
-            p->indexPos = p->indexPreSize;
-            p->indexSize += p->indexPreSize;
-            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 = ((UInt32)p->buf[0] << 2) + 4;
-          break;
-        }
-        
-        if (p->pos != p->blockHeaderSize)
-        {
-          UInt32 cur = p->blockHeaderSize - p->pos;
-          if (cur > srcRem)
-            cur = (UInt32)srcRem;
-          memcpy(p->buf + p->pos, src, cur);
-          p->pos += cur;
-          (*srcLen) += cur;
-          src += cur;
-        }
-        else
-        {
-          RINOK(XzBlock_Parse(&p->block, p->buf));
-          if (!XzBlock_AreSupportedFilters(&p->block))
-            return SZ_ERROR_UNSUPPORTED;
-          p->numTotalBlocks++;
-          p->state = XZ_STATE_BLOCK;
-          p->packSize = 0;
-          p->unpackSize = 0;
-          XzCheck_Init(&p->check, XzFlags_GetCheckType(p->streamFlags));
-          if (p->parseMode)
-          {
-            p->headerParsedOk = True;
-            return SZ_OK;
-          }
-          RINOK(XzDecMix_Init(&p->decoder, &p->block, p->outBuf, p->outBufSize));
-        }
-        break;
-      }
-
-      case XZ_STATE_BLOCK_FOOTER:
-      {
-        if ((((unsigned)p->packSize + p->alignPos) & 3) != 0)
-        {
-          if (srcRem == 0)
-          {
-            *status = CODER_STATUS_NEEDS_MORE_INPUT;
-            return SZ_OK;
-          }
-          (*srcLen)++;
-          p->alignPos++;
-          if (*src++ != 0)
-            return SZ_ERROR_CRC;
-        }
-        else
-        {
-          UInt32 checkSize = XzFlags_GetCheckSize(p->streamFlags);
-          UInt32 cur = checkSize - p->pos;
-          if (cur != 0)
-          {
-            if (srcRem == 0)
-            {
-              *status = CODER_STATUS_NEEDS_MORE_INPUT;
-              return SZ_OK;
-            }
-            if (cur > srcRem)
-              cur = (UInt32)srcRem;
-            memcpy(p->buf + p->pos, src, cur);
-            p->pos += cur;
-            (*srcLen) += cur;
-            src += cur;
-            if (checkSize != p->pos)
-              break;
-          }
-          {
-            Byte digest[XZ_CHECK_SIZE_MAX];
-            p->state = XZ_STATE_BLOCK_HEADER;
-            p->pos = 0;
-            if (XzCheck_Final(&p->check, digest) && memcmp(digest, p->buf, checkSize) != 0)
-              return SZ_ERROR_CRC;
-            if (p->decodeOnlyOneBlock)
-            {
-              *status = CODER_STATUS_FINISHED_WITH_MARK;
-              return SZ_OK;
-            }
-          }
-        }
-        break;
-      }
-
-      case XZ_STATE_STREAM_INDEX:
-      {
-        if (p->pos < p->indexPreSize)
-        {
-          (*srcLen)++;
-          if (*src++ != p->buf[p->pos++])
-            return SZ_ERROR_CRC;
-        }
-        else
-        {
-          if (p->indexPos < p->indexSize)
-          {
-            UInt64 cur = p->indexSize - p->indexPos;
-            if (srcRem > cur)
-              srcRem = (SizeT)cur;
-            p->crc = CrcUpdate(p->crc, src, srcRem);
-            Sha256_Update(&p->sha, src, srcRem);
-            (*srcLen) += srcRem;
-            src += srcRem;
-            p->indexPos += srcRem;
-          }
-          else if ((p->indexPos & 3) != 0)
-          {
-            Byte b = *src++;
-            p->crc = CRC_UPDATE_BYTE(p->crc, b);
-            (*srcLen)++;
-            p->indexPos++;
-            p->indexSize++;
-            if (b != 0)
-              return SZ_ERROR_CRC;
-          }
-          else
-          {
-            Byte digest[SHA256_DIGEST_SIZE];
-            p->state = XZ_STATE_STREAM_INDEX_CRC;
-            p->indexSize += 4;
-            p->pos = 0;
-            Sha256_Final(&p->sha, digest);
-            if (memcmp(digest, p->shaDigest, SHA256_DIGEST_SIZE) != 0)
-              return SZ_ERROR_CRC;
-          }
-        }
-        break;
-      }
-
-      case XZ_STATE_STREAM_INDEX_CRC:
-      {
-        if (p->pos < 4)
-        {
-          (*srcLen)++;
-          p->buf[p->pos++] = *src++;
-        }
-        else
-        {
-          p->state = XZ_STATE_STREAM_FOOTER;
-          p->pos = 0;
-          if (CRC_GET_DIGEST(p->crc) != GetUi32(p->buf))
-            return SZ_ERROR_CRC;
-        }
-        break;
-      }
-
-      case XZ_STATE_STREAM_FOOTER:
-      {
-        UInt32 cur = XZ_STREAM_FOOTER_SIZE - p->pos;
-        if (cur > srcRem)
-          cur = (UInt32)srcRem;
-        memcpy(p->buf + p->pos, src, cur);
-        p->pos += cur;
-        (*srcLen) += cur;
-        src += cur;
-        if (p->pos == XZ_STREAM_FOOTER_SIZE)
-        {
-          p->state = XZ_STATE_STREAM_PADDING;
-          p->numFinishedStreams++;
-          p->padSize = 0;
-          if (!Xz_CheckFooter(p->streamFlags, p->indexSize, p->buf))
-            return SZ_ERROR_CRC;
-        }
-        break;
-      }
-
-      case XZ_STATE_STREAM_PADDING:
-      {
-        if (*src != 0)
-        {
-          if (((UInt32)p->padSize & 3) != 0)
-            return SZ_ERROR_NO_ARCHIVE;
-          p->pos = 0;
-          p->state = XZ_STATE_STREAM_HEADER;
-        }
-        else
-        {
-          (*srcLen)++;
-          src++;
-          p->padSize++;
-        }
-        break;
-      }
-      
-      case XZ_STATE_BLOCK: break; /* to disable GCC warning */
-    }
-  }
-  /*
-  if (p->state == XZ_STATE_FINISHED)
-    *status = CODER_STATUS_FINISHED_WITH_MARK;
-  return SZ_OK;
-  */
-}
-
-
-SRes XzUnpacker_CodeFull(CXzUnpacker *p, Byte *dest, SizeT *destLen,
-    const Byte *src, SizeT *srcLen,
-    ECoderFinishMode finishMode, ECoderStatus *status)
-{
-  XzUnpacker_Init(p);
-  XzUnpacker_SetOutBuf(p, dest, *destLen);
-
-  return XzUnpacker_Code(p,
-      NULL, destLen,
-      src, srcLen, True,
-      finishMode, status);
-}
-
-
-BoolInt XzUnpacker_IsBlockFinished(const CXzUnpacker *p)
-{
-  return (p->state == XZ_STATE_BLOCK_HEADER) && (p->pos == 0);
-}
-
-BoolInt XzUnpacker_IsStreamWasFinished(const CXzUnpacker *p)
-{
-  return (p->state == XZ_STATE_STREAM_PADDING) && (((UInt32)p->padSize & 3) == 0);
-}
-
-UInt64 XzUnpacker_GetExtraSize(const CXzUnpacker *p)
-{
-  UInt64 num = 0;
-  if (p->state == XZ_STATE_STREAM_PADDING)
-    num = p->padSize;
-  else if (p->state == XZ_STATE_STREAM_HEADER)
-    num = p->padSize + p->pos;
-  return num;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#ifndef _7ZIP_ST
-#include "MtDec.h"
-#endif
-
-
-void XzDecMtProps_Init(CXzDecMtProps *p)
-{
-  p->inBufSize_ST = 1 << 18;
-  p->outStep_ST = 1 << 20;
-  p->ignoreErrors = False;
-
-  #ifndef _7ZIP_ST
-  p->numThreads = 1;
-  p->inBufSize_MT = 1 << 18;
-  p->memUseMax = sizeof(size_t) << 28;
-  #endif
-}
-
-
-
-#ifndef _7ZIP_ST
-
-/* ---------- CXzDecMtThread ---------- */
-
-typedef struct
-{
-  Byte *outBuf;
-  size_t outBufSize;
-  size_t outPreSize;
-  size_t inPreSize;
-  size_t inPreHeaderSize;
-  size_t blockPackSize_for_Index;  // including block header and checksum.
-  size_t blockPackTotal;  // including stream header, block header and checksum.
-  size_t inCodeSize;
-  size_t outCodeSize;
-  ECoderStatus status;
-  SRes codeRes;
-  BoolInt skipMode;
-  // BoolInt finishedWithMark;
-  EMtDecParseState parseState;
-  BoolInt parsing_Truncated;
-  BoolInt atBlockHeader;
-  CXzStreamFlags streamFlags;
-  // UInt64 numFinishedStreams
-  UInt64 numStreams;
-  UInt64 numTotalBlocks;
-  UInt64 numBlocks;
-
-  BoolInt dec_created;
-  CXzUnpacker dec;
-
-  Byte mtPad[1 << 7];
-} CXzDecMtThread;
-
-#endif
-
-
-/* ---------- CXzDecMt ---------- */
-
-typedef struct
-{
-  CAlignOffsetAlloc alignOffsetAlloc;
-  ISzAllocPtr allocMid;
-
-  CXzDecMtProps props;
-  size_t unpackBlockMaxSize;
-  
-  ISeqInStream *inStream;
-  ISeqOutStream *outStream;
-  ICompressProgress *progress;
-  // CXzStatInfo *stat;
-
-  BoolInt finishMode;
-  BoolInt outSize_Defined;
-  UInt64 outSize;
-
-  UInt64 outProcessed;
-  UInt64 inProcessed;
-  UInt64 readProcessed;
-  BoolInt readWasFinished;
-  SRes readRes;
-  SRes writeRes;
-
-  Byte *outBuf;
-  size_t outBufSize;
-  Byte *inBuf;
-  size_t inBufSize;
-
-  CXzUnpacker dec;
-
-  ECoderStatus status;
-  SRes codeRes;
-
-  #ifndef _7ZIP_ST
-  BoolInt mainDecoderWasCalled;
-  // int statErrorDefined;
-  int finishedDecoderIndex;
-
-  // global values that are used in Parse stage
-  CXzStreamFlags streamFlags;
-  // UInt64 numFinishedStreams
-  UInt64 numStreams;
-  UInt64 numTotalBlocks;
-  UInt64 numBlocks;
-
-  // UInt64 numBadBlocks;
-  SRes mainErrorCode;
-
-  BoolInt isBlockHeaderState_Parse;
-  BoolInt isBlockHeaderState_Write;
-  UInt64 outProcessed_Parse;
-  BoolInt parsing_Truncated;
-
-  BoolInt mtc_WasConstructed;
-  CMtDec mtc;
-  CXzDecMtThread coders[MTDEC__THREADS_MAX];
-  #endif
-
-} CXzDecMt;
-
-
-
-CXzDecMtHandle XzDecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid)
-{
-  CXzDecMt *p = (CXzDecMt *)ISzAlloc_Alloc(alloc, sizeof(CXzDecMt));
-  if (!p)
-    return NULL;
-  
-  AlignOffsetAlloc_CreateVTable(&p->alignOffsetAlloc);
-  p->alignOffsetAlloc.baseAlloc = alloc;
-  p->alignOffsetAlloc.numAlignBits = 7;
-  p->alignOffsetAlloc.offset = 0;
-
-  p->allocMid = allocMid;
-
-  p->outBuf = NULL;
-  p->outBufSize = 0;
-  p->inBuf = NULL;
-  p->inBufSize = 0;
-
-  XzUnpacker_Construct(&p->dec, &p->alignOffsetAlloc.vt);
-
-  p->unpackBlockMaxSize = 0;
-
-  XzDecMtProps_Init(&p->props);
-
-  #ifndef _7ZIP_ST
-  p->mtc_WasConstructed = False;
-  {
-    unsigned i;
-    for (i = 0; i < MTDEC__THREADS_MAX; i++)
-    {
-      CXzDecMtThread *coder = &p->coders[i];
-      coder->dec_created = False;
-      coder->outBuf = NULL;
-      coder->outBufSize = 0;
-    }
-  }
-  #endif
-
-  return p;
-}
-
-
-#ifndef _7ZIP_ST
-
-static void XzDecMt_FreeOutBufs(CXzDecMt *p)
-{
-  unsigned i;
-  for (i = 0; i < MTDEC__THREADS_MAX; i++)
-  {
-    CXzDecMtThread *coder = &p->coders[i];
-    if (coder->outBuf)
-    {
-      ISzAlloc_Free(p->allocMid, coder->outBuf);
-      coder->outBuf = NULL;
-      coder->outBufSize = 0;
-    }
-  }
-  p->unpackBlockMaxSize = 0;
-}
-
-#endif
-
-
-
-static void XzDecMt_FreeSt(CXzDecMt *p)
-{
-  XzUnpacker_Free(&p->dec);
-  
-  if (p->outBuf)
-  {
-    ISzAlloc_Free(p->allocMid, p->outBuf);
-    p->outBuf = NULL;
-  }
-  p->outBufSize = 0;
-  
-  if (p->inBuf)
-  {
-    ISzAlloc_Free(p->allocMid, p->inBuf);
-    p->inBuf = NULL;
-  }
-  p->inBufSize = 0;
-}
-
-
-void XzDecMt_Destroy(CXzDecMtHandle pp)
-{
-  CXzDecMt *p = (CXzDecMt *)pp;
-
-  XzDecMt_FreeSt(p);
-
-  #ifndef _7ZIP_ST
-
-  if (p->mtc_WasConstructed)
-  {
-    MtDec_Destruct(&p->mtc);
-    p->mtc_WasConstructed = False;
-  }
-  {
-    unsigned i;
-    for (i = 0; i < MTDEC__THREADS_MAX; i++)
-    {
-      CXzDecMtThread *t = &p->coders[i];
-      if (t->dec_created)
-      {
-        // we don't need to free dict here
-        XzUnpacker_Free(&t->dec);
-        t->dec_created = False;
-      }
-    }
-  }
-  XzDecMt_FreeOutBufs(p);
-
-  #endif
-
-  ISzAlloc_Free(p->alignOffsetAlloc.baseAlloc, pp);
-}
-
-
-
-#ifndef _7ZIP_ST
-
-static void XzDecMt_Callback_Parse(void *obj, unsigned coderIndex, CMtDecCallbackInfo *cc)
-{
-  CXzDecMt *me = (CXzDecMt *)obj;
-  CXzDecMtThread *coder = &me->coders[coderIndex];
-  size_t srcSize = cc->srcSize;
-
-  cc->srcSize = 0;
-  cc->outPos = 0;
-  cc->state = MTDEC_PARSE_CONTINUE;
-
-  cc->canCreateNewThread = True;
-
-  if (cc->startCall)
-  {
-    coder->outPreSize = 0;
-    coder->inPreSize = 0;
-    coder->inPreHeaderSize = 0;
-    coder->parseState = MTDEC_PARSE_CONTINUE;
-    coder->parsing_Truncated = False;
-    coder->skipMode = False;
-    coder->codeRes = SZ_OK;
-    coder->status = CODER_STATUS_NOT_SPECIFIED;
-    coder->inCodeSize = 0;
-    coder->outCodeSize = 0;
-
-    coder->numStreams = me->numStreams;
-    coder->numTotalBlocks = me->numTotalBlocks;
-    coder->numBlocks = me->numBlocks;
-
-    if (!coder->dec_created)
-    {
-      XzUnpacker_Construct(&coder->dec, &me->alignOffsetAlloc.vt);
-      coder->dec_created = True;
-    }
-    
-    XzUnpacker_Init(&coder->dec);
-
-    if (me->isBlockHeaderState_Parse)
-    {
-      coder->dec.streamFlags = me->streamFlags;
-      coder->atBlockHeader = True;
-      XzUnpacker_PrepareToRandomBlockDecoding(&coder->dec);
-    }
-    else
-    {
-      coder->atBlockHeader = False;
-      me->isBlockHeaderState_Parse = True;
-    }
-
-    coder->dec.numStartedStreams = me->numStreams;
-    coder->dec.numTotalBlocks = me->numTotalBlocks;
-    coder->dec.numBlocks = me->numBlocks;
-  }
-
-  while (!coder->skipMode)
-  {
-    ECoderStatus status;
-    SRes res;
-    size_t srcSize2 = srcSize;
-    size_t destSize = (size_t)0 - 1;
-
-    coder->dec.parseMode = True;
-    coder->dec.headerParsedOk = False;
-    
-    PRF_STR_INT("Parse", srcSize2);
-    
-    res = XzUnpacker_Code(&coder->dec,
-        NULL, &destSize,
-        cc->src, &srcSize2, cc->srcFinished,
-        CODER_FINISH_END, &status);
-    
-    // PRF(printf(" res = %d, srcSize2 = %d", res, (unsigned)srcSize2));
-    
-    coder->codeRes = res;
-    coder->status = status;
-    cc->srcSize += srcSize2;
-    srcSize -= srcSize2;
-    coder->inPreHeaderSize += srcSize2;
-    coder->inPreSize = coder->inPreHeaderSize;
-    
-    if (res != SZ_OK)
-    {
-      cc->state =
-      coder->parseState = MTDEC_PARSE_END;
-      /*
-      if (res == SZ_ERROR_MEM)
-        return res;
-      return SZ_OK;
-      */
-      return; // res;
-    }
-    
-    if (coder->dec.headerParsedOk)
-    {
-      const CXzBlock *block = &coder->dec.block;
-      if (XzBlock_HasUnpackSize(block)
-          // && block->unpackSize <= me->props.outBlockMax
-          && XzBlock_HasPackSize(block))
-      {
-        {
-          if (block->unpackSize * 2 * me->mtc.numStartedThreads > me->props.memUseMax)
-          {
-            cc->state = MTDEC_PARSE_OVERFLOW;
-            return; // SZ_OK;
-          }
-        }
-        {
-        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
-        {
-          coder->blockPackSize_for_Index = (size_t)(coder->dec.blockHeaderSize + packSize + checkSize);
-          coder->blockPackTotal = (size_t)blockPackSum;
-          coder->outPreSize = (size_t)block->unpackSize;
-          coder->streamFlags = coder->dec.streamFlags;
-          me->streamFlags = coder->dec.streamFlags;
-          coder->skipMode = True;
-          break;
-        }
-        }
-      }
-    }
-    else
-    // if (coder->inPreSize <= me->props.inBlockMax)
-    {
-      if (!cc->srcFinished)
-        return; // SZ_OK;
-      cc->state =
-      coder->parseState = MTDEC_PARSE_END;
-      return; // SZ_OK;
-    }
-    cc->state = MTDEC_PARSE_OVERFLOW;
-    return; // SZ_OK;
-  }
-
-  // ---------- skipMode ----------
-  {
-    UInt64 rem = coder->blockPackTotal - coder->inPreSize;
-    size_t cur = srcSize;
-    if (cur > rem)
-      cur = (size_t)rem;
-    cc->srcSize += cur;
-    coder->inPreSize += cur;
-    srcSize -= cur;
-
-    if (coder->inPreSize == coder->blockPackTotal)
-    {
-      if (srcSize == 0)
-      {
-        if (!cc->srcFinished)
-          return; // SZ_OK;
-        cc->state = MTDEC_PARSE_END;
-      }
-      else if ((cc->src)[cc->srcSize] == 0) // we check control byte of next block
-        cc->state = MTDEC_PARSE_END;
-      else
-      {
-        cc->state = MTDEC_PARSE_NEW;
-
-        {
-          size_t blockMax = me->unpackBlockMaxSize;
-          if (blockMax < coder->outPreSize)
-            blockMax = coder->outPreSize;
-          {
-            UInt64 required = (UInt64)blockMax * (me->mtc.numStartedThreads + 1) * 2;
-            if (me->props.memUseMax < required)
-              cc->canCreateNewThread = False;
-          }
-        }
-
-        if (me->outSize_Defined)
-        {
-          // next block can be zero size
-          const UInt64 rem2 = me->outSize - me->outProcessed_Parse;
-          if (rem2 < coder->outPreSize)
-          {
-            coder->parsing_Truncated = True;
-            cc->state = MTDEC_PARSE_END;
-          }
-          me->outProcessed_Parse += coder->outPreSize;
-        }
-      }
-    }
-    else if (cc->srcFinished)
-      cc->state = MTDEC_PARSE_END;
-    else
-      return; // SZ_OK;
-
-    coder->parseState = cc->state;
-    cc->outPos = coder->outPreSize;
-    
-    me->numStreams = coder->dec.numStartedStreams;
-    me->numTotalBlocks = coder->dec.numTotalBlocks;
-    me->numBlocks = coder->dec.numBlocks + 1;
-    return; // SZ_OK;
-  }
-}
-
-
-static SRes XzDecMt_Callback_PreCode(void *pp, unsigned coderIndex)
-{
-  CXzDecMt *me = (CXzDecMt *)pp;
-  CXzDecMtThread *coder = &me->coders[coderIndex];
-  Byte *dest;
-
-  if (!coder->dec.headerParsedOk)
-    return SZ_OK;
-
-  dest = coder->outBuf;
-
-  if (!dest || coder->outBufSize < coder->outPreSize)
-  {
-    if (dest)
-    {
-      ISzAlloc_Free(me->allocMid, dest);
-      coder->outBuf = NULL;
-      coder->outBufSize = 0;
-    }
-    {
-      size_t outPreSize = coder->outPreSize;
-      if (outPreSize == 0)
-        outPreSize = 1;
-      dest = (Byte *)ISzAlloc_Alloc(me->allocMid, outPreSize);
-    }
-    if (!dest)
-      return SZ_ERROR_MEM;
-    coder->outBuf = dest;
-    coder->outBufSize = coder->outPreSize;
-
-    if (coder->outBufSize > me->unpackBlockMaxSize)
-      me->unpackBlockMaxSize = coder->outBufSize;
-  }
-
-  // return SZ_ERROR_MEM;
-
-  XzUnpacker_SetOutBuf(&coder->dec, coder->outBuf, coder->outBufSize);
-
-  {
-    SRes res = XzDecMix_Init(&coder->dec.decoder, &coder->dec.block, coder->outBuf, coder->outBufSize);
-    // res = SZ_ERROR_UNSUPPORTED; // to test
-    coder->codeRes = res;
-    if (res != SZ_OK)
-    {
-      // if (res == SZ_ERROR_MEM) return res;
-      if (me->props.ignoreErrors && res != SZ_ERROR_MEM)
-        return S_OK;
-      return res;
-    }
-  }
-
-  return SZ_OK;
-}
-
-
-static SRes XzDecMt_Callback_Code(void *pp, unsigned coderIndex,
-    const Byte *src, size_t srcSize, int srcFinished,
-    // int finished, int blockFinished,
-    UInt64 *inCodePos, UInt64 *outCodePos, int *stop)
-{
-  CXzDecMt *me = (CXzDecMt *)pp;
-  CXzDecMtThread *coder = &me->coders[coderIndex];
-
-  *inCodePos = coder->inCodeSize;
-  *outCodePos = coder->outCodeSize;
-  *stop = True;
-
-  if (coder->inCodeSize < coder->inPreHeaderSize)
-  {
-    UInt64 rem = coder->inPreHeaderSize - coder->inCodeSize;
-    size_t step = srcSize;
-    if (step > rem)
-      step = (size_t)rem;
-    src += step;
-    srcSize -= step;
-    coder->inCodeSize += step;
-    if (coder->inCodeSize < coder->inPreHeaderSize)
-    {
-      *stop = False;
-      return SZ_OK;
-    }
-  }
-
-  if (!coder->dec.headerParsedOk)
-    return SZ_OK;
-  if (!coder->outBuf)
-    return SZ_OK;
-
-  if (coder->codeRes == SZ_OK)
-  {
-    ECoderStatus status;
-    SRes res;
-    size_t srcProcessed = srcSize;
-    size_t outSizeCur = coder->outPreSize - coder->dec.outDataWritten;
-
-    // PRF(printf("\nCallback_Code: Code %d %d\n", (unsigned)srcSize, (unsigned)outSizeCur));
-
-    res = XzUnpacker_Code(&coder->dec,
-        NULL, &outSizeCur,
-        src, &srcProcessed, srcFinished,
-        // coder->finishedWithMark ? CODER_FINISH_END : CODER_FINISH_ANY,
-        CODER_FINISH_END,
-        &status);
-
-    // PRF(printf(" res = %d, srcSize2 = %d, outSizeCur = %d", res, (unsigned)srcProcessed, (unsigned)outSizeCur));
-
-    coder->codeRes = res;
-    coder->status = status;
-    coder->inCodeSize += srcProcessed;
-    coder->outCodeSize = coder->dec.outDataWritten;
-    *inCodePos = coder->inCodeSize;
-    *outCodePos = coder->outCodeSize;
-
-    if (res == SZ_OK)
-    {
-      if (srcProcessed == srcSize)
-        *stop = False;
-      return SZ_OK;
-    }
-  }
-
-  if (me->props.ignoreErrors && coder->codeRes != SZ_ERROR_MEM)
-  {
-    *inCodePos = coder->inPreSize;
-    *outCodePos = coder->outPreSize;
-    return S_OK;
-  }
-  return coder->codeRes;
-}
-
-
-#define XZDECMT_STREAM_WRITE_STEP (1 << 24)
-
-static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
-    BoolInt needWriteToStream,
-    const Byte *src, size_t srcSize,
-    // int srcFinished,
-    BoolInt *needContinue,
-    BoolInt *canRecode)
-{
-  CXzDecMt *me = (CXzDecMt *)pp;
-  const CXzDecMtThread *coder = &me->coders[coderIndex];
-
-  // PRF(printf("\nWrite processed = %d srcSize = %d\n", (unsigned)me->mtc.inProcessed, (unsigned)srcSize));
-  
-  *needContinue = False;
-  *canRecode = True;
-  
-  if (!needWriteToStream)
-    return SZ_OK;
-
-  if (!coder->dec.headerParsedOk || !coder->outBuf)
-  {
-    if (me->finishedDecoderIndex < 0)
-      me->finishedDecoderIndex = coderIndex;
-    return SZ_OK;
-  }
-
-  if (me->finishedDecoderIndex >= 0)
-    return SZ_OK;
-
-  me->mtc.inProcessed += coder->inCodeSize;
-
-  *canRecode = False;
-
-  {
-    SRes res;
-    size_t size = coder->outCodeSize;
-    Byte *data = coder->outBuf;
-    
-    // we use in me->dec: sha, numBlocks, indexSize
-
-    if (!me->isBlockHeaderState_Write)
-    {
-      XzUnpacker_PrepareToRandomBlockDecoding(&me->dec);
-      me->dec.decodeOnlyOneBlock = False;
-      me->dec.numStartedStreams = coder->dec.numStartedStreams;
-      me->dec.streamFlags = coder->streamFlags;
-
-      me->isBlockHeaderState_Write = True;
-    }
-    
-    me->dec.numTotalBlocks = coder->dec.numTotalBlocks;
-    XzUnpacker_UpdateIndex(&me->dec, coder->blockPackSize_for_Index, coder->outPreSize);
-    
-    if (coder->outPreSize != size)
-    {
-      if (me->props.ignoreErrors)
-      {
-        memset(data + size, 0, coder->outPreSize - size);
-        size = coder->outPreSize;
-      }
-      // me->numBadBlocks++;
-      if (me->mainErrorCode == SZ_OK)
-      {
-        if ((int)coder->status == LZMA_STATUS_NEEDS_MORE_INPUT)
-          me->mainErrorCode = SZ_ERROR_INPUT_EOF;
-        else
-          me->mainErrorCode = SZ_ERROR_DATA;
-      }
-    }
-    
-    if (me->writeRes != SZ_OK)
-      return me->writeRes;
-
-    res = SZ_OK;
-    {
-      if (me->outSize_Defined)
-      {
-        const UInt64 rem = me->outSize - me->outProcessed;
-        if (size > rem)
-          size = (SizeT)rem;
-      }
-
-      for (;;)
-      {
-        size_t cur = size;
-        size_t written;
-        if (cur > XZDECMT_STREAM_WRITE_STEP)
-          cur = XZDECMT_STREAM_WRITE_STEP;
-
-        written = ISeqOutStream_Write(me->outStream, data, cur);
-
-        // PRF(printf("\nWritten ask = %d written = %d\n", (unsigned)cur, (unsigned)written));
-        
-        me->outProcessed += written;
-        if (written != cur)
-        {
-          me->writeRes = SZ_ERROR_WRITE;
-          res = me->writeRes;
-          break;
-        }
-        data += cur;
-        size -= cur;
-        // PRF_STR_INT("Written size =", size);
-        if (size == 0)
-          break;
-        res = MtProgress_ProgressAdd(&me->mtc.mtProgress, 0, 0);
-        if (res != SZ_OK)
-          break;
-      }
-    }
-
-    if (coder->codeRes != SZ_OK)
-      if (!me->props.ignoreErrors)
-      {
-        me->finishedDecoderIndex = coderIndex;
-        return res;
-      }
-
-    RINOK(res);
-
-    if (coder->inPreSize != coder->inCodeSize
-        || coder->blockPackTotal != coder->inCodeSize)
-    {
-      me->finishedDecoderIndex = coderIndex;
-      return SZ_OK;
-    }
-
-    if (coder->parseState != MTDEC_PARSE_END)
-    {
-      *needContinue = True;
-      return SZ_OK;
-    }
-  }
-
-  // (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);
-
-  me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
-  {
-    CXzUnpacker *dec = &me->dec;
-    
-    PRF_STR_INT("PostSingle", srcSize);
-    
-    {
-      size_t srcProcessed = srcSize;
-      ECoderStatus status;
-      size_t outSizeCur = 0;
-      SRes res;
-      
-      // dec->decodeOnlyOneBlock = False;
-      dec->decodeToStreamSignature = True;
-
-      me->mainDecoderWasCalled = True;
-
-      if (coder->parsing_Truncated)
-      {
-        me->parsing_Truncated = True;
-        return SZ_OK;
-      }
-      
-      res = XzUnpacker_Code(dec,
-          NULL, &outSizeCur,
-          src, &srcProcessed,
-          me->mtc.readWasFinished, // srcFinished
-          CODER_FINISH_END, // CODER_FINISH_ANY,
-          &status);
-      
-      me->status = status;
-      me->codeRes = res;
-
-      me->mtc.inProcessed += srcProcessed;
-      me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
-
-      if (res != SZ_OK)
-      {
-        return S_OK;
-        // return res;
-      }
-      
-      if (dec->state == XZ_STATE_STREAM_HEADER)
-      {
-        *needContinue = True;
-        me->isBlockHeaderState_Parse = False;
-        me->isBlockHeaderState_Write = False;
-        {
-          Byte *crossBuf = MtDec_GetCrossBuff(&me->mtc);
-          if (!crossBuf)
-            return SZ_ERROR_MEM;
-          memcpy(crossBuf, src + srcProcessed, srcSize - srcProcessed);
-        }
-        me->mtc.crossStart = 0;
-        me->mtc.crossEnd = srcSize - srcProcessed;
-        return SZ_OK;
-      }
-      
-      if (status != CODER_STATUS_NEEDS_MORE_INPUT)
-      {
-        return E_FAIL;
-      }
-      
-      if (me->mtc.readWasFinished)
-      {
-        return SZ_OK;
-      }
-    }
-    
-    {
-      size_t inPos;
-      size_t inLim;
-      const Byte *inData;
-      UInt64 inProgressPrev = me->mtc.inProcessed;
-      
-      // XzDecMt_Prepare_InBuf_ST(p);
-      Byte *crossBuf = MtDec_GetCrossBuff(&me->mtc);
-      if (!crossBuf)
-        return SZ_ERROR_MEM;
-      
-      inPos = 0;
-      inLim = 0;
-      // outProcessed = 0;
-      
-      inData = crossBuf;
-      
-      for (;;)
-      {
-        SizeT inProcessed;
-        SizeT outProcessed;
-        ECoderStatus status;
-        SRes res;
-        
-        if (inPos == inLim)
-        {
-          if (!me->mtc.readWasFinished)
-          {
-            inPos = 0;
-            inLim = me->mtc.inBufSize;
-            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;
-          }
-        }
-        
-        inProcessed = inLim - inPos;
-        outProcessed = 0;
-
-        res = XzUnpacker_Code(dec,
-            NULL, &outProcessed,
-            inData + inPos, &inProcessed,
-            (inProcessed == 0), // srcFinished
-            CODER_FINISH_END, &status);
-        
-        me->codeRes = res;
-        me->status = status;
-        inPos += inProcessed;
-        me->mtc.inProcessed += inProcessed;
-        me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
-
-        if (res != SZ_OK)
-        {
-          return S_OK;
-          // return res;
-        }
-
-        if (dec->state == XZ_STATE_STREAM_HEADER)
-        {
-          *needContinue = True;
-          me->mtc.crossStart = inPos;
-          me->mtc.crossEnd = inLim;
-          me->isBlockHeaderState_Parse = False;
-          me->isBlockHeaderState_Write = False;
-          return SZ_OK;
-        }
-        
-        if (status != CODER_STATUS_NEEDS_MORE_INPUT)
-          return E_FAIL;
-        
-        if (me->mtc.progress)
-        {
-          UInt64 inDelta = me->mtc.inProcessed - inProgressPrev;
-          if (inDelta >= (1 << 22))
-          {
-            RINOK(MtProgress_Progress_ST(&me->mtc.mtProgress));
-            inProgressPrev = me->mtc.inProcessed;
-          }
-        }
-        if (me->mtc.readWasFinished)
-          return SZ_OK;
-      }
-    }
-  }
-}
-
-
-#endif
-
-
-
-void XzStatInfo_Clear(CXzStatInfo *p)
-{
-  p->InSize = 0;
-  p->OutSize = 0;
-  
-  p->NumStreams = 0;
-  p->NumBlocks = 0;
-  
-  p->UnpackSize_Defined = False;
-  
-  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;
-  
-  p->DecodeRes = SZ_OK;
-  p->ReadRes = SZ_OK;
-  p->ProgressRes = SZ_OK;
-
-  p->CombinedRes = SZ_OK;
-  p->CombinedRes_Type = SZ_OK;
-}
-
-
-
-
-static SRes XzDecMt_Decode_ST(CXzDecMt *p
-    #ifndef _7ZIP_ST
-    , BoolInt tMode
-    #endif
-    , CXzStatInfo *stat)
-{
-  size_t outPos;
-  size_t inPos, inLim;
-  const Byte *inData;
-  UInt64 inPrev, outPrev;
-
-  CXzUnpacker *dec;
-
-  #ifndef _7ZIP_ST
-  if (tMode)
-  {
-    XzDecMt_FreeOutBufs(p);
-    tMode = MtDec_PrepareRead(&p->mtc);
-  }
-  #endif
-
-  if (!p->outBuf || p->outBufSize != p->props.outStep_ST)
-  {
-    ISzAlloc_Free(p->allocMid, p->outBuf);
-    p->outBufSize = 0;
-    p->outBuf = (Byte *)ISzAlloc_Alloc(p->allocMid, p->props.outStep_ST);
-    if (!p->outBuf)
-      return SZ_ERROR_MEM;
-    p->outBufSize = p->props.outStep_ST;
-  }
-
-  if (!p->inBuf || p->inBufSize != p->props.inBufSize_ST)
-  {
-    ISzAlloc_Free(p->allocMid, p->inBuf);
-    p->inBufSize = 0;
-    p->inBuf = (Byte *)ISzAlloc_Alloc(p->allocMid, p->props.inBufSize_ST);
-    if (!p->inBuf)
-      return SZ_ERROR_MEM;
-    p->inBufSize = p->props.inBufSize_ST;
-  }
-
-  dec = &p->dec;
-  dec->decodeToStreamSignature = False;
-  // dec->decodeOnlyOneBlock = False;
-
-  XzUnpacker_SetOutBuf(dec, NULL, 0);
-
-  inPrev = p->inProcessed;
-  outPrev = p->outProcessed;
-
-  inPos = 0;
-  inLim = 0;
-  inData = NULL;
-  outPos = 0;
-
-  for (;;)
-  {
-    SizeT outSize;
-    BoolInt finished;
-    ECoderFinishMode finishMode;
-    SizeT inProcessed;
-    ECoderStatus status;
-    SRes res;
-
-    SizeT outProcessed;
-
-
-
-    if (inPos == inLim)
-    {
-      #ifndef _7ZIP_ST
-      if (tMode)
-      {
-        inData = MtDec_Read(&p->mtc, &inLim);
-        inPos = 0;
-        if (inData)
-          continue;
-        tMode = False;
-        inLim = 0;
-      }
-      #endif
-      
-      if (!p->readWasFinished)
-      {
-        inPos = 0;
-        inLim = p->inBufSize;
-        inData = p->inBuf;
-        p->readRes = ISeqInStream_Read(p->inStream, (void *)inData, &inLim);
-        p->readProcessed += inLim;
-        if (inLim == 0 || p->readRes != SZ_OK)
-          p->readWasFinished = True;
-      }
-    }
-
-    outSize = p->props.outStep_ST - outPos;
-
-    finishMode = CODER_FINISH_ANY;
-    if (p->outSize_Defined)
-    {
-      const UInt64 rem = p->outSize - p->outProcessed;
-      if (outSize >= rem)
-      {
-        outSize = (SizeT)rem;
-        if (p->finishMode)
-          finishMode = CODER_FINISH_END;
-      }
-    }
-
-    inProcessed = inLim - inPos;
-    outProcessed = outSize;
-
-    res = XzUnpacker_Code(dec, p->outBuf + outPos, &outProcessed,
-        inData + inPos, &inProcessed,
-        (inPos == inLim), // srcFinished
-        finishMode, &status);
-
-    p->codeRes = res;
-    p->status = status;
-
-    inPos += inProcessed;
-    outPos += outProcessed;
-    p->inProcessed += inProcessed;
-    p->outProcessed += outProcessed;
-
-    finished = ((inProcessed == 0 && outProcessed == 0) || res != SZ_OK);
-
-    if (finished || outProcessed >= outSize)
-      if (outPos != 0)
-      {
-        size_t written = ISeqOutStream_Write(p->outStream, p->outBuf, outPos);
-        p->outProcessed += written;
-        if (written != outPos)
-        {
-          stat->CombinedRes_Type = SZ_ERROR_WRITE;
-          return SZ_ERROR_WRITE;
-        }
-        outPos = 0;
-      }
-
-    if (p->progress && res == SZ_OK)
-    {
-      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)
-        {
-          stat->CombinedRes_Type = SZ_ERROR_PROGRESS;
-          stat->ProgressRes = res;
-          return res;
-        }
-        inPrev = p->inProcessed;
-        outPrev = p->outProcessed;
-      }
-    }
-
-    if (finished)
-      return res;
-  }
-}
-
-static SRes XzStatInfo_SetStat(const CXzUnpacker *dec,
-    int finishMode,
-    UInt64 readProcessed, UInt64 inProcessed,
-    SRes res, ECoderStatus status,
-    BoolInt decodingTruncated,
-    CXzStatInfo *stat)
-{
-  UInt64 extraSize;
-  
-  stat->DecodingTruncated = (Byte)(decodingTruncated ? 1 : 0);
-  stat->InSize = inProcessed;
-  stat->NumStreams = dec->numStartedStreams;
-  stat->NumBlocks = dec->numTotalBlocks;
-  
-  stat->UnpackSize_Defined = True;
-  stat->NumStreams_Defined = True;
-  stat->NumBlocks_Defined = True;
-  
-  extraSize = XzUnpacker_GetExtraSize(dec);
-  
-  if (res == SZ_OK)
-  {
-    if (status == CODER_STATUS_NEEDS_MORE_INPUT)
-    {
-      // CODER_STATUS_NEEDS_MORE_INPUT is expected status for correct xz streams
-      extraSize = 0;
-      if (!XzUnpacker_IsStreamWasFinished(dec))
-        res = SZ_ERROR_INPUT_EOF;
-    }
-    else if (!decodingTruncated || finishMode) // (status == CODER_STATUS_NOT_FINISHED)
-      res = SZ_ERROR_DATA;
-  }
-  else if (res == SZ_ERROR_NO_ARCHIVE)
-  {
-    /*
-    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 / inProcessed don't include "bad" byte
-    */
-    if (inProcessed != extraSize) // if good streams before error
-      if (extraSize != 0 || readProcessed != inProcessed)
-      {
-        stat->DataAfterEnd = True;
-        // there is some good xz stream before. So we set SZ_OK
-        res = SZ_OK;
-      }
-  }
-  
-  stat->DecodeRes = res;
-
-  stat->InSize -= extraSize;
-  return res;
-}
-
-
-SRes XzDecMt_Decode(CXzDecMtHandle pp,
-    const CXzDecMtProps *props,
-    const UInt64 *outDataSize, int finishMode,
-    ISeqOutStream *outStream,
-    // Byte *outBuf, size_t *outBufSize,
-    ISeqInStream *inStream,
-    // const Byte *inData, size_t inDataSize,
-    CXzStatInfo *stat,
-    int *isMT,
-    ICompressProgress *progress)
-{
-  CXzDecMt *p = (CXzDecMt *)pp;
-  #ifndef _7ZIP_ST
-  BoolInt tMode;
-  #endif
-
-  XzStatInfo_Clear(stat);
-
-  p->props = *props;
-
-  p->inStream = inStream;
-  p->outStream = outStream;
-  p->progress = progress;
-  // p->stat = stat;
-
-  p->outSize = 0;
-  p->outSize_Defined = False;
-  if (outDataSize)
-  {
-    p->outSize_Defined = True;
-    p->outSize = *outDataSize;
-  }
-
-  p->finishMode = finishMode;
-
-  // p->outSize = 457; p->outSize_Defined = True; p->finishMode = False; // for test
-
-  p->writeRes = SZ_OK;
-  p->outProcessed = 0;
-  p->inProcessed = 0;
-  p->readProcessed = 0;
-  p->readWasFinished = False;
-
-  p->codeRes = 0;
-  p->status = CODER_STATUS_NOT_SPECIFIED;
-
-  XzUnpacker_Init(&p->dec);
-
-  *isMT = False;
-
-    /*
-    p->outBuf = NULL;
-    p->outBufSize = 0;
-    if (!outStream)
-    {
-      p->outBuf = outBuf;
-      p->outBufSize = *outBufSize;
-      *outBufSize = 0;
-    }
-    */
-
-  
-  #ifndef _7ZIP_ST
-
-  p->isBlockHeaderState_Parse = False;
-  p->isBlockHeaderState_Write = False;
-  // p->numBadBlocks = 0;
-  p->mainErrorCode = SZ_OK;
-  p->mainDecoderWasCalled = False;
-
-  tMode = False;
-
-  if (p->props.numThreads > 1)
-  {
-    IMtDecCallback vt;
-
-    // we just free ST buffers here
-    // but we still keep state variables, that was set in XzUnpacker_Init()
-    XzDecMt_FreeSt(p);
-
-    p->outProcessed_Parse = 0;
-    p->parsing_Truncated = False;
-
-    p->numStreams = 0;
-    p->numTotalBlocks = 0;
-    p->numBlocks = 0;
-    p->finishedDecoderIndex = -1;
-
-    if (!p->mtc_WasConstructed)
-    {
-      p->mtc_WasConstructed = True;
-      MtDec_Construct(&p->mtc);
-    }
-    
-    p->mtc.mtCallback = &vt;
-    p->mtc.mtCallbackObject = p;
-
-    p->mtc.progress = progress;
-    p->mtc.inStream = inStream;
-    p->mtc.alloc = &p->alignOffsetAlloc.vt;
-    // p->mtc.inData = inData;
-    // p->mtc.inDataSize = inDataSize;
-    p->mtc.inBufSize = p->props.inBufSize_MT;
-    // p->mtc.inBlockMax = p->props.inBlockMax;
-    p->mtc.numThreadsMax = p->props.numThreads;
-
-    *isMT = True;
-
-    vt.Parse = XzDecMt_Callback_Parse;
-    vt.PreCode = XzDecMt_Callback_PreCode;
-    vt.Code = XzDecMt_Callback_Code;
-    vt.Write = XzDecMt_Callback_Write;
-
-    {
-      BoolInt needContinue;
-      
-      SRes res = MtDec_Code(&p->mtc);
-
-      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)
-        {
-          res = p->mtc.mtProgress.res;
-          stat->ProgressRes = res;
-          stat->CombinedRes_Type = SZ_ERROR_PROGRESS;
-        }
-        else
-          needContinue = p->mtc.needContinue;
-      }
-
-      if (!needContinue)
-      {
-        SRes codeRes;
-        BoolInt truncated = False;
-        ECoderStatus status;
-        CXzUnpacker *dec;
-
-        stat->OutSize = p->outProcessed;
-       
-        if (p->finishedDecoderIndex >= 0)
-        {
-          CXzDecMtThread *coder = &p->coders[(unsigned)p->finishedDecoderIndex];
-          codeRes = coder->codeRes;
-          dec = &coder->dec;
-          status = coder->status;
-        }
-        else if (p->mainDecoderWasCalled)
-        {
-          codeRes = p->codeRes;
-          dec = &p->dec;
-          status = p->status;
-          truncated = p->parsing_Truncated;
-        }
-        else
-          return E_FAIL;
-
-        XzStatInfo_SetStat(dec, p->finishMode,
-            p->mtc.readProcessed, p->mtc.inProcessed,
-            codeRes, status,
-            truncated,
-            stat);
-
-        if (res == SZ_OK)
-        {
-          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;
-          }
-        }
-
-        stat->CombinedRes = res;
-        if (stat->CombinedRes_Type == SZ_OK)
-          stat->CombinedRes_Type = res;
-        return res;
-      }
-
-      PRF_STR("----- decoding ST -----");
-    }
-  }
-
-  #endif
-
-
-  *isMT = False;
-
-  {
-    SRes res = XzDecMt_Decode_ST(p
-        #ifndef _7ZIP_ST
-        , tMode
-        #endif
-        , stat
-        );
-
-    XzStatInfo_SetStat(&p->dec,
-        p->finishMode,
-        p->readProcessed, p->inProcessed,
-        p->codeRes, p->status,
-        False, // truncated
-        stat);
-
-    if (res == SZ_OK)
-    {
-      /*
-      if (p->writeRes != SZ_OK)
-      {
-        res = p->writeRes;
-        stat->CombinedRes_Type = SZ_ERROR_WRITE;
-      }
-      else
-      */
-      if (p->readRes != SZ_OK && p->inProcessed == p->readProcessed)
-      {
-        res = p->readRes;
-        stat->ReadRes = res;
-        stat->CombinedRes_Type = SZ_ERROR_READ;
-      }
-      #ifndef _7ZIP_ST
-      else if (p->mainErrorCode != SZ_OK)
-        res = p->mainErrorCode;
-      #endif
-    }
-
-    stat->CombinedRes = res;
-    if (stat->CombinedRes_Type == SZ_OK)
-      stat->CombinedRes_Type = res;
-    return res;
-  }
-}