/* 7zArcIn.c -- 7z Input functions

2018-12-31 : Igor Pavlov : Public domain */

#include "Precomp.h"

#include <string.h>

#include "7z.h"

#include "7zBuf.h"

#include "7zCrc.h"

#include "CpuArch.h"

#define MY_ALLOC(T, p, size, alloc) { \

  if ((p = (T *)ISzAlloc_Alloc(alloc, (size) * sizeof(T))) == NULL) return SZ_ERROR_MEM; }

#define MY_ALLOC_ZE(T, p, size, alloc) { if ((size) == 0) p = NULL; else MY_ALLOC(T, p, size, alloc) }

#define MY_ALLOC_AND_CPY(to, size, from, alloc) \

  { MY_ALLOC(Byte, to, size, alloc); memcpy(to, from, size); }

#define MY_ALLOC_ZE_AND_CPY(to, size, from, alloc) \

  { if ((size) == 0) to = NULL; else { MY_ALLOC_AND_CPY(to, size, from, alloc) } }

#define k7zMajorVersion 0

enum EIdEnum

{

  k7zIdEnd,

  k7zIdHeader,

  k7zIdArchiveProperties,

  k7zIdAdditionalStreamsInfo,

  k7zIdMainStreamsInfo,

  k7zIdFilesInfo,

  k7zIdPackInfo,

  k7zIdUnpackInfo,

  k7zIdSubStreamsInfo,

  k7zIdSize,

  k7zIdCRC,

  k7zIdFolder,

  k7zIdCodersUnpackSize,

  k7zIdNumUnpackStream,

  k7zIdEmptyStream,

  k7zIdEmptyFile,

  k7zIdAnti,

  k7zIdName,

  k7zIdCTime,

  k7zIdATime,

  k7zIdMTime,

  k7zIdWinAttrib,

  k7zIdComment,

  k7zIdEncodedHeader,

  k7zIdStartPos,

  k7zIdDummy

  // k7zNtSecure,

  // k7zParent,

  // k7zIsReal

};

const Byte k7zSignature[k7zSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};

#define SzBitUi32s_Init(p) { (p)->Defs = NULL; (p)->Vals = NULL; }

static SRes SzBitUi32s_Alloc(CSzBitUi32s *p, size_t num, ISzAllocPtr alloc)

{

  if (num == 0)

  {

    p->Defs = NULL;

    p->Vals = NULL;

  }

  else

  {

    MY_ALLOC(Byte, p->Defs, (num + 7) >> 3, alloc);

    MY_ALLOC(UInt32, p->Vals, num, alloc);

  }

  return SZ_OK;

}

void SzBitUi32s_Free(CSzBitUi32s *p, ISzAllocPtr alloc)

{

  ISzAlloc_Free(alloc, p->Defs); p->Defs = NULL;

  ISzAlloc_Free(alloc, p->Vals); p->Vals = NULL;

}

#define SzBitUi64s_Init(p) { (p)->Defs = NULL; (p)->Vals = NULL; }

void SzBitUi64s_Free(CSzBitUi64s *p, ISzAllocPtr alloc)

{

  ISzAlloc_Free(alloc, p->Defs); p->Defs = NULL;

  ISzAlloc_Free(alloc, p->Vals); p->Vals = NULL;

}

static void SzAr_Init(CSzAr *p)

{

  p->NumPackStreams = 0;

  p->NumFolders = 0;

  p->PackPositions = NULL;

  SzBitUi32s_Init(&p->FolderCRCs);

  p->FoCodersOffsets = NULL;

  p->FoStartPackStreamIndex = NULL;

  p->FoToCoderUnpackSizes = NULL;

  p->FoToMainUnpackSizeIndex = NULL;

  p->CoderUnpackSizes = NULL;

  p->CodersData = NULL;

}

static void SzAr_Free(CSzAr *p, ISzAllocPtr alloc)

{

  ISzAlloc_Free(alloc, p->PackPositions);

  SzBitUi32s_Free(&p->FolderCRCs, alloc);

  ISzAlloc_Free(alloc, p->FoCodersOffsets);

  ISzAlloc_Free(alloc, p->FoStartPackStreamIndex);

  ISzAlloc_Free(alloc, p->FoToCoderUnpackSizes);

  ISzAlloc_Free(alloc, p->FoToMainUnpackSizeIndex);

  ISzAlloc_Free(alloc, p->CoderUnpackSizes);

  ISzAlloc_Free(alloc, p->CodersData);

  SzAr_Init(p);

}

void SzArEx_Init(CSzArEx *p)

{

  SzAr_Init(&p->db);

  p->NumFiles = 0;

  p->dataPos = 0;

  p->UnpackPositions = NULL;

  p->IsDirs = NULL;

  p->FolderToFile = NULL;

  p->FileToFolder = NULL;

  p->FileNameOffsets = NULL;

  p->FileNames = NULL;

  SzBitUi32s_Init(&p->CRCs);

  SzBitUi32s_Init(&p->Attribs);

  // SzBitUi32s_Init(&p->Parents);

  SzBitUi64s_Init(&p->MTime);

  SzBitUi64s_Init(&p->CTime);

}

void SzArEx_Free(CSzArEx *p, ISzAllocPtr alloc)

{

  ISzAlloc_Free(alloc, p->UnpackPositions);

  ISzAlloc_Free(alloc, p->IsDirs);

  ISzAlloc_Free(alloc, p->FolderToFile);

  ISzAlloc_Free(alloc, p->FileToFolder);

  ISzAlloc_Free(alloc, p->FileNameOffsets);

  ISzAlloc_Free(alloc, p->FileNames);

  SzBitUi32s_Free(&p->CRCs, alloc);

  SzBitUi32s_Free(&p->Attribs, alloc);

  // SzBitUi32s_Free(&p->Parents, alloc);

  SzBitUi64s_Free(&p->MTime, alloc);

  SzBitUi64s_Free(&p->CTime, alloc);

  SzAr_Free(&p->db, alloc);

  SzArEx_Init(p);

}

static int TestSignatureCandidate(const Byte *testBytes)

{

  unsigned i;

  for (i = 0; i < k7zSignatureSize; i++)

    if (testBytes[i] != k7zSignature[i])

      return 0;

  return 1;

}

#define SzData_Clear(p) { (p)->Data = NULL; (p)->Size = 0; }

#define SZ_READ_BYTE_SD(_sd_, dest) if ((_sd_)->Size == 0) return SZ_ERROR_ARCHIVE; (_sd_)->Size--; dest = *(_sd_)->Data++;

#define SZ_READ_BYTE(dest) SZ_READ_BYTE_SD(sd, dest)

#define SZ_READ_BYTE_2(dest) if (sd.Size == 0) return SZ_ERROR_ARCHIVE; sd.Size--; dest = *sd.Data++;

#define SKIP_DATA(sd, size) { sd->Size -= (size_t)(size); sd->Data += (size_t)(size); }

#define SKIP_DATA2(sd, size) { sd.Size -= (size_t)(size); sd.Data += (size_t)(size); }

#define SZ_READ_32(dest) if (sd.Size < 4) return SZ_ERROR_ARCHIVE; \

   dest = GetUi32(sd.Data); SKIP_DATA2(sd, 4);

static MY_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value)

{

  Byte firstByte, mask;

  unsigned i;

  UInt32 v;

  SZ_READ_BYTE(firstByte);

  if ((firstByte & 0x80) == 0)

  {

    *value = firstByte;

    return SZ_OK;

  }

  SZ_READ_BYTE(v);

  if ((firstByte & 0x40) == 0)

  {

    *value = (((UInt32)firstByte & 0x3F) << 8) | v;

    return SZ_OK;

  }

  SZ_READ_BYTE(mask);

  *value = v | ((UInt32)mask << 8);

  mask = 0x20;

  for (i = 2; i < 8; i++)

  {

    Byte b;

    if ((firstByte & mask) == 0)

    {

      UInt64 highPart = (unsigned)firstByte & (unsigned)(mask - 1);

      *value |= (highPart << (8 * i));

      return SZ_OK;

    }

    SZ_READ_BYTE(b);

    *value |= ((UInt64)b << (8 * i));

    mask >>= 1;

  }

  return SZ_OK;

}

static MY_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)

{

  Byte firstByte;

  UInt64 value64;

  if (sd->Size == 0)

    return SZ_ERROR_ARCHIVE;

  firstByte = *sd->Data;

  if ((firstByte & 0x80) == 0)

  {

    *value = firstByte;

    sd->Data++;

    sd->Size--;

    return SZ_OK;

  }

  RINOK(ReadNumber(sd, &value64));

  if (value64 >= (UInt32)0x80000000 - 1)

    return SZ_ERROR_UNSUPPORTED;

  if (value64 >= ((UInt64)(1) << ((sizeof(size_t) - 1) * 8 + 4)))

    return SZ_ERROR_UNSUPPORTED;

  *value = (UInt32)value64;

  return SZ_OK;

}

#define ReadID(sd, value) ReadNumber(sd, value)

static SRes SkipData(CSzData *sd)

{

  UInt64 size;

  RINOK(ReadNumber(sd, &size));

  if (size > sd->Size)

    return SZ_ERROR_ARCHIVE;

  SKIP_DATA(sd, size);

  return SZ_OK;

}

static SRes WaitId(CSzData *sd, UInt32 id)

{

  for (;;)

  {

    UInt64 type;

    RINOK(ReadID(sd, &type));

    if (type == id)

      return SZ_OK;

    if (type == k7zIdEnd)

      return SZ_ERROR_ARCHIVE;

    RINOK(SkipData(sd));

  }

}

static SRes RememberBitVector(CSzData *sd, UInt32 numItems, const Byte **v)

{

  UInt32 numBytes = (numItems + 7) >> 3;

  if (numBytes > sd->Size)

    return SZ_ERROR_ARCHIVE;

  *v = sd->Data;

  SKIP_DATA(sd, numBytes);

  return SZ_OK;

}

static UInt32 CountDefinedBits(const Byte *bits, UInt32 numItems)

{

  Byte b = 0;

  unsigned m = 0;

  UInt32 sum = 0;

  for (; numItems != 0; numItems--)

  {

    if (m == 0)

    {

      b = *bits++;

      m = 8;

    }

    m--;

    sum += ((b >> m) & 1);

  }

  return sum;

}

static MY_NO_INLINE SRes ReadBitVector(CSzData *sd, UInt32 numItems, Byte **v, ISzAllocPtr alloc)

{

  Byte allAreDefined;

  Byte *v2;

  UInt32 numBytes = (numItems + 7) >> 3;

  *v = NULL;

  SZ_READ_BYTE(allAreDefined);

  if (numBytes == 0)

    return SZ_OK;

  if (allAreDefined == 0)

  {

    if (numBytes > sd->Size)

      return SZ_ERROR_ARCHIVE;

    MY_ALLOC_AND_CPY(*v, numBytes, sd->Data, alloc);

    SKIP_DATA(sd, numBytes);

    return SZ_OK;

  }

  MY_ALLOC(Byte, *v, numBytes, alloc);

  v2 = *v;

  memset(v2, 0xFF, (size_t)numBytes);

  {

    unsigned numBits = (unsigned)numItems & 7;

    if (numBits != 0)

      v2[(size_t)numBytes - 1] = (Byte)((((UInt32)1 << numBits) - 1) << (8 - numBits));

  }

  return SZ_OK;

}

static MY_NO_INLINE SRes ReadUi32s(CSzData *sd2, UInt32 numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc)

{

  UInt32 i;

  CSzData sd;

  UInt32 *vals;

  const Byte *defs;

  MY_ALLOC_ZE(UInt32, crcs->Vals, numItems, alloc);

  sd = *sd2;

  defs = crcs->Defs;

  vals = crcs->Vals;

  for (i = 0; i < numItems; i++)

    if (SzBitArray_Check(defs, i))

    {

      SZ_READ_32(vals[i]);

    }

    else

      vals[i] = 0;

  *sd2 = sd;

  return SZ_OK;

}

static SRes ReadBitUi32s(CSzData *sd, UInt32 numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc)

{

  SzBitUi32s_Free(crcs, alloc);

  RINOK(ReadBitVector(sd, numItems, &crcs->Defs, alloc));

  return ReadUi32s(sd, numItems, crcs, alloc);

}

static SRes SkipBitUi32s(CSzData *sd, UInt32 numItems)

{

  Byte allAreDefined;

  UInt32 numDefined = numItems;

  SZ_READ_BYTE(allAreDefined);

  if (!allAreDefined)

  {

    size_t numBytes = (numItems + 7) >> 3;

    if (numBytes > sd->Size)

      return SZ_ERROR_ARCHIVE;

    numDefined = CountDefinedBits(sd->Data, numItems);

    SKIP_DATA(sd, numBytes);

  }

  if (numDefined > (sd->Size >> 2))

    return SZ_ERROR_ARCHIVE;

  SKIP_DATA(sd, (size_t)numDefined * 4);

  return SZ_OK;

}

static SRes ReadPackInfo(CSzAr *p, CSzData *sd, ISzAllocPtr alloc)

{

  RINOK(SzReadNumber32(sd, &p->NumPackStreams));

  RINOK(WaitId(sd, k7zIdSize));

  MY_ALLOC(UInt64, p->PackPositions, (size_t)p->NumPackStreams + 1, alloc);

  {

    UInt64 sum = 0;

    UInt32 i;

    UInt32 numPackStreams = p->NumPackStreams;

    for (i = 0; i < numPackStreams; i++)

    {

      UInt64 packSize;

      p->PackPositions[i] = sum;

      RINOK(ReadNumber(sd, &packSize));

      sum += packSize;

      if (sum < packSize)

        return SZ_ERROR_ARCHIVE;

    }

    p->PackPositions[i] = sum;

  }

  for (;;)

  {

    UInt64 type;

    RINOK(ReadID(sd, &type));

    if (type == k7zIdEnd)

      return SZ_OK;

    if (type == k7zIdCRC)

    {

      /* CRC of packed streams is unused now */

      RINOK(SkipBitUi32s(sd, p->NumPackStreams));

      continue;

    }

    RINOK(SkipData(sd));

  }

}

/*

static SRes SzReadSwitch(CSzData *sd)

{

  Byte external;

  RINOK(SzReadByte(sd, &external));

  return (external == 0) ? SZ_OK: SZ_ERROR_UNSUPPORTED;

}

*/

#define k_NumCodersStreams_in_Folder_MAX (SZ_NUM_BONDS_IN_FOLDER_MAX + SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX)

SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)

{

  UInt32 numCoders, i;

  UInt32 numInStreams = 0;

  const Byte *dataStart = sd->Data;

  f->NumCoders = 0;

  f->NumBonds = 0;

  f->NumPackStreams = 0;

  f->UnpackStream = 0;

  RINOK(SzReadNumber32(sd, &numCoders));

  if (numCoders == 0 || numCoders > SZ_NUM_CODERS_IN_FOLDER_MAX)

    return SZ_ERROR_UNSUPPORTED;

  for (i = 0; i < numCoders; i++)

  {

    Byte mainByte;

    CSzCoderInfo *coder = f->Coders + i;

    unsigned idSize, j;

    UInt64 id;

    SZ_READ_BYTE(mainByte);

    if ((mainByte & 0xC0) != 0)

      return SZ_ERROR_UNSUPPORTED;

    idSize = (unsigned)(mainByte & 0xF);

    if (idSize > sizeof(id))

      return SZ_ERROR_UNSUPPORTED;

    if (idSize > sd->Size)

      return SZ_ERROR_ARCHIVE;

    id = 0;

    for (j = 0; j < idSize; j++)

    {

      id = ((id << 8) | *sd->Data);

      sd->Data++;

      sd->Size--;

    }

    if (id > (UInt32)0xFFFFFFFF)

      return SZ_ERROR_UNSUPPORTED;

    coder->MethodID = (UInt32)id;

    coder->NumStreams = 1;

    coder->PropsOffset = 0;

    coder->PropsSize = 0;

    if ((mainByte & 0x10) != 0)

    {

      UInt32 numStreams;

      RINOK(SzReadNumber32(sd, &numStreams));

      if (numStreams > k_NumCodersStreams_in_Folder_MAX)

        return SZ_ERROR_UNSUPPORTED;

      coder->NumStreams = (Byte)numStreams;

      RINOK(SzReadNumber32(sd, &numStreams));

      if (numStreams != 1)

        return SZ_ERROR_UNSUPPORTED;

    }

    numInStreams += coder->NumStreams;

    if (numInStreams > k_NumCodersStreams_in_Folder_MAX)

      return SZ_ERROR_UNSUPPORTED;

    if ((mainByte & 0x20) != 0)

    {

      UInt32 propsSize = 0;

      RINOK(SzReadNumber32(sd, &propsSize));

      if (propsSize > sd->Size)

        return SZ_ERROR_ARCHIVE;

      if (propsSize >= 0x80)

        return SZ_ERROR_UNSUPPORTED;

      coder->PropsOffset = sd->Data - dataStart;

      coder->PropsSize = (Byte)propsSize;

      sd->Data += (size_t)propsSize;

      sd->Size -= (size_t)propsSize;

    }

  }

  /*

  if (numInStreams == 1 && numCoders == 1)

  {

    f->NumPackStreams = 1;

    f->PackStreams[0] = 0;

  }

  else

  */

  {

    Byte streamUsed[k_NumCodersStreams_in_Folder_MAX];

    UInt32 numBonds, numPackStreams;

    numBonds = numCoders - 1;

    if (numInStreams < numBonds)

      return SZ_ERROR_ARCHIVE;

    if (numBonds > SZ_NUM_BONDS_IN_FOLDER_MAX)

      return SZ_ERROR_UNSUPPORTED;

    f->NumBonds = numBonds;

    numPackStreams = numInStreams - numBonds;

    if (numPackStreams > SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX)

      return SZ_ERROR_UNSUPPORTED;

    f->NumPackStreams = numPackStreams;

    for (i = 0; i < numInStreams; i++)

      streamUsed[i] = False;

    if (numBonds != 0)

    {

      Byte coderUsed[SZ_NUM_CODERS_IN_FOLDER_MAX];

      for (i = 0; i < numCoders; i++)

        coderUsed[i] = False;

      for (i = 0; i < numBonds; i++)

      {

        CSzBond *bp = f->Bonds + i;

        RINOK(SzReadNumber32(sd, &bp->InIndex));

        if (bp->InIndex >= numInStreams || streamUsed[bp->InIndex])

          return SZ_ERROR_ARCHIVE;

        streamUsed[bp->InIndex] = True;

        RINOK(SzReadNumber32(sd, &bp->OutIndex));

        if (bp->OutIndex >= numCoders || coderUsed[bp->OutIndex])

          return SZ_ERROR_ARCHIVE;

        coderUsed[bp->OutIndex] = True;

      }

      for (i = 0; i < numCoders; i++)

        if (!coderUsed[i])

        {

          f->UnpackStream = i;

          break;

        }

      if (i == numCoders)

        return SZ_ERROR_ARCHIVE;

    }

    if (numPackStreams == 1)

    {

      for (i = 0; i < numInStreams; i++)

        if (!streamUsed[i])

          break;

      if (i == numInStreams)

        return SZ_ERROR_ARCHIVE;

      f->PackStreams[0] = i;

    }

    else

      for (i = 0; i < numPackStreams; i++)

      {

        UInt32 index;

        RINOK(SzReadNumber32(sd, &index));

        if (index >= numInStreams || streamUsed[index])

          return SZ_ERROR_ARCHIVE;

        streamUsed[index] = True;

        f->PackStreams[i] = index;

      }

  }

  f->NumCoders = numCoders;

  return SZ_OK;

}

static MY_NO_INLINE SRes SkipNumbers(CSzData *sd2, UInt32 num)

{

  CSzData sd;

  sd = *sd2;

  for (; num != 0; num--)

  {

    Byte firstByte, mask;

    unsigned i;

    SZ_READ_BYTE_2(firstByte);

    if ((firstByte & 0x80) == 0)

      continue;

    if ((firstByte & 0x40) == 0)

    {

      if (sd.Size == 0)

        return SZ_ERROR_ARCHIVE;

      sd.Size--;

      sd.Data++;

      continue;

    }

    mask = 0x20;

    for (i = 2; i < 8 && (firstByte & mask) != 0; i++)

      mask >>= 1;

    if (i > sd.Size)

      return SZ_ERROR_ARCHIVE;

    SKIP_DATA2(sd, i);

  }

  *sd2 = sd;

  return SZ_OK;

}

#define k_Scan_NumCoders_MAX 64

#define k_Scan_NumCodersStreams_in_Folder_MAX 64

static SRes ReadUnpackInfo(CSzAr *p,

    CSzData *sd2,

    UInt32 numFoldersMax,

    const CBuf *tempBufs, UInt32 numTempBufs,

    ISzAllocPtr alloc)

{

  CSzData sd;

  UInt32 fo, numFolders, numCodersOutStreams, packStreamIndex;

  const Byte *startBufPtr;

  Byte external;

  RINOK(WaitId(sd2, k7zIdFolder));

  RINOK(SzReadNumber32(sd2, &numFolders));

  if (numFolders > numFoldersMax)

    return SZ_ERROR_UNSUPPORTED;

  p->NumFolders = numFolders;

  SZ_READ_BYTE_SD(sd2, external);

  if (external == 0)

    sd = *sd2;

  else

  {

    UInt32 index;

    RINOK(SzReadNumber32(sd2, &index));

    if (index >= numTempBufs)

      return SZ_ERROR_ARCHIVE;

    sd.Data = tempBufs[index].data;

    sd.Size = tempBufs[index].size;

  }

  MY_ALLOC(size_t, p->FoCodersOffsets, (size_t)numFolders + 1, alloc);

  MY_ALLOC(UInt32, p->FoStartPackStreamIndex, (size_t)numFolders + 1, alloc);

  MY_ALLOC(UInt32, p->FoToCoderUnpackSizes, (size_t)numFolders + 1, alloc);

  MY_ALLOC_ZE(Byte, p->FoToMainUnpackSizeIndex, (size_t)numFolders, alloc);

  startBufPtr = sd.Data;

  packStreamIndex = 0;

  numCodersOutStreams = 0;

  for (fo = 0; fo < numFolders; fo++)

  {

    UInt32 numCoders, ci, numInStreams = 0;

    p->FoCodersOffsets[fo] = sd.Data - startBufPtr;

    RINOK(SzReadNumber32(&sd, &numCoders));

    if (numCoders == 0 || numCoders > k_Scan_NumCoders_MAX)

      return SZ_ERROR_UNSUPPORTED;

    for (ci = 0; ci < numCoders; ci++)

    {

      Byte mainByte;

      unsigned idSize;

      UInt32 coderInStreams;

      SZ_READ_BYTE_2(mainByte);

      if ((mainByte & 0xC0) != 0)

        return SZ_ERROR_UNSUPPORTED;

      idSize = (mainByte & 0xF);

      if (idSize > 8)

        return SZ_ERROR_UNSUPPORTED;

      if (idSize > sd.Size)

        return SZ_ERROR_ARCHIVE;

      SKIP_DATA2(sd, idSize);

      coderInStreams = 1;

      if ((mainByte & 0x10) != 0)

      {

        UInt32 coderOutStreams;

        RINOK(SzReadNumber32(&sd, &coderInStreams));

        RINOK(SzReadNumber32(&sd, &coderOutStreams));

        if (coderInStreams > k_Scan_NumCodersStreams_in_Folder_MAX || coderOutStreams != 1)

          return SZ_ERROR_UNSUPPORTED;

      }

      numInStreams += coderInStreams;

      if ((mainByte & 0x20) != 0)

      {

        UInt32 propsSize;

        RINOK(SzReadNumber32(&sd, &propsSize));

        if (propsSize > sd.Size)

          return SZ_ERROR_ARCHIVE;

        SKIP_DATA2(sd, propsSize);

      }

    }

    {

      UInt32 indexOfMainStream = 0;

      UInt32 numPackStreams = 1;

      if (numCoders != 1 || numInStreams != 1)

      {

        Byte streamUsed[k_Scan_NumCodersStreams_in_Folder_MAX];

        Byte coderUsed[k_Scan_NumCoders_MAX];

        UInt32 i;

        UInt32 numBonds = numCoders - 1;

        if (numInStreams < numBonds)

          return SZ_ERROR_ARCHIVE;

        if (numInStreams > k_Scan_NumCodersStreams_in_Folder_MAX)

          return SZ_ERROR_UNSUPPORTED;

        for (i = 0; i < numInStreams; i++)

          streamUsed[i] = False;

        for (i = 0; i < numCoders; i++)

          coderUsed[i] = False;

        for (i = 0; i < numBonds; i++)

        {

          UInt32 index;

          RINOK(SzReadNumber32(&sd, &index));

          if (index >= numInStreams || streamUsed[index])

            return SZ_ERROR_ARCHIVE;

          streamUsed[index] = True;

          RINOK(SzReadNumber32(&sd, &index));

          if (index >= numCoders || coderUsed[index])

            return SZ_ERROR_ARCHIVE;

          coderUsed[index] = True;

        }

        numPackStreams = numInStreams - numBonds;

        if (numPackStreams != 1)

          for (i = 0; i < numPackStreams; i++)

          {

            UInt32 index;

            RINOK(SzReadNumber32(&sd, &index));

            if (index >= numInStreams || streamUsed[index])

              return SZ_ERROR_ARCHIVE;

            streamUsed[index] = True;

          }

        for (i = 0; i < numCoders; i++)

          if (!coderUsed[i])

          {

            indexOfMainStream = i;

            break;

          }

        if (i == numCoders)

          return SZ_ERROR_ARCHIVE;

      }

      p->FoStartPackStreamIndex[fo] = packStreamIndex;

      p->FoToCoderUnpackSizes[fo] = numCodersOutStreams;

      p->FoToMainUnpackSizeIndex[fo] = (Byte)indexOfMainStream;

      numCodersOutStreams += numCoders;

      if (numCodersOutStreams < numCoders)

        return SZ_ERROR_UNSUPPORTED;

      if (numPackStreams > p->NumPackStreams - packStreamIndex)

        return SZ_ERROR_ARCHIVE;

      packStreamIndex += numPackStreams;

    }

  }

  p->FoToCoderUnpackSizes[fo] = numCodersOutStreams;

  {

    size_t dataSize = sd.Data - startBufPtr;

    p->FoStartPackStreamIndex[fo] = packStreamIndex;

    p->FoCodersOffsets[fo] = dataSize;

    MY_ALLOC_ZE_AND_CPY(p->CodersData, dataSize, startBufPtr, alloc);

  }

  if (external != 0)

  {

    if (sd.Size != 0)

      return SZ_ERROR_ARCHIVE;

    sd = *sd2;

  }

  RINOK(WaitId(&sd, k7zIdCodersUnpackSize));

  MY_ALLOC_ZE(UInt64, p->CoderUnpackSizes, (size_t)numCodersOutStreams, alloc);

  {

    UInt32 i;

    for (i = 0; i < numCodersOutStreams; i++)

    {

      RINOK(ReadNumber(&sd, p->CoderUnpackSizes + i));

    }

  }

  for (;;)

  {

    UInt64 type;

    RINOK(ReadID(&sd, &type));

    if (type == k7zIdEnd)

    {

      *sd2 = sd;

      return SZ_OK;

    }

    if (type == k7zIdCRC)

    {

      RINOK(ReadBitUi32s(&sd, numFolders, &p->FolderCRCs, alloc));

      continue;

    }

    RINOK(SkipData(&sd));

  }

}

UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex)

{

  return p->CoderUnpackSizes[p->FoToCoderUnpackSizes[folderIndex] + p->FoToMainUnpackSizeIndex[folderIndex]];

}

typedef struct

{

  UInt32 NumTotalSubStreams;

  UInt32 NumSubDigests;

  CSzData sdNumSubStreams;

  CSzData sdSizes;

  CSzData sdCRCs;

} CSubStreamInfo;

static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)

{

  UInt64 type = 0;

  UInt32 numSubDigests = 0;

  UInt32 numFolders = p->NumFolders;

  UInt32 numUnpackStreams = numFolders;

  UInt32 numUnpackSizesInData = 0;

  for (;;)

  {

    RINOK(ReadID(sd, &type));

    if (type == k7zIdNumUnpackStream)

    {

      UInt32 i;

      ssi->sdNumSubStreams.Data = sd->Data;

      numUnpackStreams = 0;

      numSubDigests = 0;

      for (i = 0; i < numFolders; i++)

      {

        UInt32 numStreams;

        RINOK(SzReadNumber32(sd, &numStreams));

        if (numUnpackStreams > numUnpackStreams + numStreams)

          return SZ_ERROR_UNSUPPORTED;

        numUnpackStreams += numStreams;

        if (numStreams != 0)

          numUnpackSizesInData += (numStreams - 1);

        if (numStreams != 1 || !SzBitWithVals_Check(&p->FolderCRCs, i))

          numSubDigests += numStreams;

      }

      ssi->sdNumSubStreams.Size = sd->Data - ssi->sdNumSubStreams.Data;

      continue;

    }

    if (type == k7zIdCRC || type == k7zIdSize || type == k7zIdEnd)

      break;

    RINOK(SkipData(sd));

  }

  if (!ssi->sdNumSubStreams.Data)

  {

    numSubDigests = numFolders;

    if (p->FolderCRCs.Defs)

      numSubDigests = numFolders - CountDefinedBits(p->FolderCRCs.Defs, numFolders);

  }

  ssi->NumTotalSubStreams = numUnpackStreams;

  ssi->NumSubDigests = numSubDigests;

  if (type == k7zIdSize)

  {

    ssi->sdSizes.Data = sd->Data;

    RINOK(SkipNumbers(sd, numUnpackSizesInData));

    ssi->sdSizes.Size = sd->Data - ssi->sdSizes.Data;

    RINOK(ReadID(sd, &type));

  }

  for (;;)

  {

    if (type == k7zIdEnd)

      return SZ_OK;

    if (type == k7zIdCRC)

    {

      ssi->sdCRCs.Data = sd->Data;

      RINOK(SkipBitUi32s(sd, numSubDigests));

      ssi->sdCRCs.Size = sd->Data - ssi->sdCRCs.Data;

    }

    else

    {

      RINOK(SkipData(sd));

    }

    RINOK(ReadID(sd, &type));

  }

}

static SRes SzReadStreamsInfo(CSzAr *p,

    CSzData *sd,

    UInt32 numFoldersMax, const CBuf *tempBufs, UInt32 numTempBufs,

    UInt64 *dataOffset,

    CSubStreamInfo *ssi,

    ISzAllocPtr alloc)

{

  UInt64 type;

  SzData_Clear(&ssi->sdSizes);

  SzData_Clear(&ssi->sdCRCs);

  SzData_Clear(&ssi->sdNumSubStreams);

  *dataOffset = 0;

  RINOK(ReadID(sd, &type));

  if (type == k7zIdPackInfo)

  {

    RINOK(ReadNumber(sd, dataOffset));

    RINOK(ReadPackInfo(p, sd, alloc));

    RINOK(ReadID(sd, &type));

  }

  if (type == k7zIdUnpackInfo)

  {

    RINOK(ReadUnpackInfo(p, sd, numFoldersMax, tempBufs, numTempBufs, alloc));

    RINOK(ReadID(sd, &type));

  }

  if (type == k7zIdSubStreamsInfo)

  {

    RINOK(ReadSubStreamsInfo(p, sd, ssi));

    RINOK(ReadID(sd, &type));

  }

  else

  {

    ssi->NumTotalSubStreams = p->NumFolders;

    // ssi->NumSubDigests = 0;

  }

  return (type == k7zIdEnd ? SZ_OK : SZ_ERROR_UNSUPPORTED);

}

static SRes SzReadAndDecodePackedStreams(

    ILookInStream *inStream,

    CSzData *sd,

    CBuf *tempBufs,

    UInt32 numFoldersMax,

    UInt64 baseOffset,

    CSzAr *p,

    ISzAllocPtr allocTemp)

{

  UInt64 dataStartPos;

  UInt32 fo;

  CSubStreamInfo ssi;

  RINOK(SzReadStreamsInfo(p, sd, numFoldersMax, NULL, 0, &dataStartPos, &ssi, allocTemp));

  dataStartPos += baseOffset;

  if (p->NumFolders == 0)

    return SZ_ERROR_ARCHIVE;

  for (fo = 0; fo < p->NumFolders; fo++)

    Buf_Init(tempBufs + fo);

  for (fo = 0; fo < p->NumFolders; fo++)

  {

    CBuf *tempBuf = tempBufs + fo;

    UInt64 unpackSize = SzAr_GetFolderUnpackSize(p, fo);

    if ((size_t)unpackSize != unpackSize)

      return SZ_ERROR_MEM;

    if (!Buf_Create(tempBuf, (size_t)unpackSize, allocTemp))

      return SZ_ERROR_MEM;

  }

  for (fo = 0; fo < p->NumFolders; fo++)

  {

    const CBuf *tempBuf = tempBufs + fo;