26.02HEAD26.02main

10 files changed, 377 insertions, 459 deletions

diff --git a/C/7zArcIn.c b/C/7zArcIn.c
index 4dc3ba1..f6f6e7c 100644
--- a/C/7zArcIn.c
+++ b/C/7zArcIn.c
@@ -11,7 +11,7 @@
 #include "CpuArch.h"
 
 #define MY_ALLOC(T, p, size, alloc) \
-  { if ((p = (T *)ISzAlloc_Alloc(alloc, (size) * sizeof(T))) == NULL) return SZ_ERROR_MEM; }
+  { if ((p = (T *)ISzAlloc_Alloc(alloc, (size_t)(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) }
@@ -22,8 +22,6 @@
 #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,
@@ -52,15 +50,13 @@ enum EIdEnum
   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; }
 
+Z7_FORCE_INLINE
 static SRes SzBitUi32s_Alloc(CSzBitUi32s *p, size_t num, ISzAllocPtr alloc)
 {
   if (num == 0)
@@ -76,6 +72,7 @@ static SRes SzBitUi32s_Alloc(CSzBitUi32s *p, size_t num, ISzAllocPtr alloc)
   return SZ_OK;
 }
 
+Z7_FORCE_INLINE
 static void SzBitUi32s_Free(CSzBitUi32s *p, ISzAllocPtr alloc)
 {
   ISzAlloc_Free(alloc, p->Defs); p->Defs = NULL;
@@ -84,13 +81,14 @@ static void SzBitUi32s_Free(CSzBitUi32s *p, ISzAllocPtr alloc)
 
 #define SzBitUi64s_INIT(p) { (p)->Defs = NULL; (p)->Vals = NULL; }
 
+Z7_FORCE_INLINE
 static void SzBitUi64s_Free(CSzBitUi64s *p, ISzAllocPtr alloc)
 {
   ISzAlloc_Free(alloc, p->Defs); p->Defs = NULL;
   ISzAlloc_Free(alloc, p->Vals); p->Vals = NULL;
 }
 
-
+Z7_NO_INLINE
 static void SzAr_Init(CSzAr *p)
 {
   p->NumPackStreams = 0;
@@ -110,23 +108,22 @@ static void SzAr_Init(CSzAr *p)
   p->RangeLimit = 0;
 }
 
+Z7_NO_INLINE
 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);
 }
 
-
+Z7_NO_INLINE
 void SzArEx_Init(CSzArEx *p)
 {
   SzAr_Init(&p->db);
@@ -150,6 +147,7 @@ void SzArEx_Init(CSzArEx *p)
   SzBitUi64s_INIT(&p->CTime)
 }
 
+Z7_NO_INLINE
 void SzArEx_Free(CSzArEx *p, ISzAllocPtr alloc)
 {
   ISzAlloc_Free(alloc, p->UnpackPositions);
@@ -172,15 +170,6 @@ void SzArEx_Free(CSzArEx *p, ISzAllocPtr alloc)
 }
 
 
-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_NOCHECK(_sd_, dest) \
@@ -199,14 +188,9 @@ static int TestSignatureCandidate(const Byte *testBytes)
 #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 Z7_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value)
 {
-  Byte firstByte, mask;
-  unsigned i;
-  UInt32 v;
+  unsigned firstByte, mask, i, v;
 
   SZ_READ_BYTE(firstByte)
   if ((firstByte & 0x80) == 0)
@@ -223,18 +207,18 @@ static Z7_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value)
   SZ_READ_BYTE(mask)
   *value = v | ((UInt32)mask << 8);
   mask = 0x20;
-  for (i = 2; i < 8; i++)
+  for (i = 2 * 8; i < 8 * 8; i += 8)
   {
-    Byte b;
+    unsigned b;
     if ((firstByte & mask) == 0)
     {
       const UInt64 highPart = (unsigned)firstByte & (unsigned)(mask - 1);
-      *value |= (highPart << (8 * i));
+      *value |= (highPart << i);
       return SZ_OK;
     }
-    SZ_READ_BYTE(b)
-    *value |= ((UInt64)b << (8 * i));
     mask >>= 1;
+    SZ_READ_BYTE(b)
+    *value |= ((UInt64)b << i);
   }
   return SZ_OK;
 }
@@ -242,7 +226,7 @@ static Z7_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value)
 
 static Z7_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)
 {
-  Byte firstByte;
+  unsigned firstByte;
   UInt64 value64;
   if (sd->Size == 0)
     return SZ_ERROR_ARCHIVE;
@@ -265,6 +249,7 @@ static Z7_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)
 
 #define ReadID(sd, value) ReadNumber(sd, value)
 
+Z7_NO_INLINE
 static SRes SkipData(CSzData *sd)
 {
   UInt64 size;
@@ -275,6 +260,7 @@ static SRes SkipData(CSzData *sd)
   return SZ_OK;
 }
 
+Z7_NO_INLINE
 static SRes WaitId(CSzData *sd, UInt32 id)
 {
   for (;;)
@@ -289,16 +275,8 @@ static SRes WaitId(CSzData *sd, UInt32 id)
   }
 }
 
-static SRes RememberBitVector(CSzData *sd, size_t numItems, const Byte **v)
-{
-  const size_t numBytes = (numItems + 7) >> 3;
-  if (numBytes > sd->Size)
-    return SZ_ERROR_ARCHIVE;
-  *v = sd->Data;
-  SKIP_DATA(sd, numBytes)
-  return SZ_OK;
-}
 
+Z7_NO_INLINE
 static UInt32 CountDefinedBits(const Byte *bits, UInt32 numItems)
 {
   unsigned b = 0;
@@ -339,8 +317,8 @@ static Z7_NO_INLINE SRes ReadBitVector(CSzData *sd, size_t numItems, Byte **v, I
   memset(v2, 0xFF, (size_t)numBytes);
   {
     const unsigned numBits = (unsigned)numItems & 7;
-    if (numBits != 0)
-      v2[(size_t)numBytes - 1] = (Byte)((((UInt32)1 << numBits) - 1) << (8 - numBits));
+    if (numBits)
+      v2[(size_t)numBytes - 1] = (Byte)(0xff00u >> numBits);
   }
   return SZ_OK;
 }
@@ -348,31 +326,40 @@ static Z7_NO_INLINE SRes ReadBitVector(CSzData *sd, size_t numItems, Byte **v, I
 static Z7_NO_INLINE SRes ReadUi32s(CSzData *sd2, size_t numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc)
 {
   size_t i;
-  CSzData sd;
+  const Byte *data;
+  size_t size;
   UInt32 *vals;
   const Byte *defs;
-  MY_ALLOC_ZE(UInt32, crcs->Vals, numItems, alloc)
-  sd = *sd2;
+  MY_ALLOC_ZE(UInt32, vals, numItems, alloc)
+  crcs->Vals = vals;
   defs = crcs->Defs;
-  vals = crcs->Vals;
+  data = sd2->Data;
+  size = sd2->Size;
   for (i = 0; i < numItems; i++)
     if (SzBitArray_Check(defs, i))
     {
-      SZ_READ_32(vals[i])
+      if (size < 4)
+        return SZ_ERROR_ARCHIVE;
+      size -= 4;
+      vals[i] = GetUi32(data);
+      data += 4;
     }
     else
       vals[i] = 0;
-  *sd2 = sd;
+  sd2->Data = data;
+  sd2->Size = size;
   return SZ_OK;
 }
 
 static SRes ReadBitUi32s(CSzData *sd, size_t numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc)
 {
-  SzBitUi32s_Free(crcs, alloc);
+  if (crcs->Defs)
+    return SZ_ERROR_ARCHIVE;
   RINOK(ReadBitVector(sd, numItems, &crcs->Defs, alloc))
   return ReadUi32s(sd, numItems, crcs, alloc);
 }
 
+Z7_NO_INLINE
 static SRes SkipBitUi32s(CSzData *sd, UInt32 numItems)
 {
   Byte allAreDefined;
@@ -395,25 +382,26 @@ static SRes SkipBitUi32s(CSzData *sd, UInt32 numItems)
 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;
-    const UInt32 numPackStreams = p->NumPackStreams;
-    for (i = 0; i < numPackStreams; i++)
+    UInt64 *packPositions;
+    UInt64 sum;
+    size_t num = (size_t)p->NumPackStreams + 1;
+    MY_ALLOC(UInt64, packPositions, num, alloc)
+    p->PackPositions = packPositions;
+    sum = 0;
+    for (;;)
     {
       UInt64 packSize;
-      p->PackPositions[i] = sum;
+      *packPositions++ = sum;
+      if (--num == 0)
+        break;
       RINOK(ReadNumber(sd, &packSize))
       sum += packSize;
       if (sum < packSize)
         return SZ_ERROR_ARCHIVE;
     }
-    p->PackPositions[i] = sum;
   }
-
   for (;;)
   {
     UInt64 type;
@@ -430,85 +418,79 @@ static SRes ReadPackInfo(CSzAr *p, CSzData *sd, ISzAllocPtr alloc)
   }
 }
 
-/*
-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;
+  UInt32 numCoders, i, numInStreams = 0;
+  const Byte * const dataStart = sd->Data;
 
-  f->NumCoders = 0;
-  f->NumBonds = 0;
-  f->NumPackStreams = 0;
+  // 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;
+  f->NumCoders = numCoders;
   
   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++)
+    CSzCoderInfo *coder;
     {
-      id = ((id << 8) | *sd->Data);
-      sd->Data++;
+      unsigned idSize, j;
+      UInt64 id;
+      const Byte *data;
+      
+      if (!sd->Size)
+        return SZ_ERROR_ARCHIVE;
       sd->Size--;
+      data = sd->Data;
+      mainByte = *data++;
+      if (mainByte & 0xC0)
+        return SZ_ERROR_UNSUPPORTED;
+      idSize = mainByte & 0xF;
+      if (idSize > sizeof(id))
+        return SZ_ERROR_UNSUPPORTED;
+      if (idSize > sd->Size)
+        return SZ_ERROR_ARCHIVE;
+      sd->Size -= idSize;
+      id = 0;
+      for (j = 0; j < idSize; j++)
+        id = (id << 8) | *data++;
+      sd->Data = data;
+      if (id > (UInt32)0xFFFFFFFF)
+        return SZ_ERROR_UNSUPPORTED;
+      coder = f->Coders + i;
+      coder->MethodID = (UInt32)id;
     }
-    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)
+    if (mainByte & 0x10)
     {
       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)
+    if (mainByte & 0x20)
     {
-      UInt32 propsSize = 0;
+      UInt32 propsSize;
       RINOK(SzReadNumber32(sd, &propsSize))
       if (propsSize > sd->Size)
         return SZ_ERROR_ARCHIVE;
@@ -521,14 +503,6 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
     }
   }
 
-  /*
-  if (numInStreams == 1 && numCoders == 1)
-  {
-    f->NumPackStreams = 1;
-    f->PackStreams[0] = 0;
-  }
-  else
-  */
   {
     Byte streamUsed[k_NumCodersStreams_in_Folder_MAX];
     UInt32 numBonds, numPackStreams;
@@ -545,14 +519,13 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
       return SZ_ERROR_UNSUPPORTED;
     f->NumPackStreams = numPackStreams;
   
-    for (i = 0; i < numInStreams; i++)
+    for (i = 0; i < Z7_ARRAY_SIZE(streamUsed); i++) // numInStreams
       streamUsed[i] = False;
     
-    if (numBonds != 0)
+    if (numBonds)
     {
       Byte coderUsed[SZ_NUM_CODERS_IN_FOLDER_MAX];
-
-      for (i = 0; i < numCoders; i++)
+      for (i = 0; i < Z7_ARRAY_SIZE(coderUsed); i++) // numCoders
         coderUsed[i] = False;
       
       for (i = 0; i < numBonds; i++)
@@ -570,24 +543,25 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
         coderUsed[bp->OutIndex] = True;
       }
       
-      for (i = 0; i < numCoders; i++)
+      for (i = 0;;)
+      {
         if (!coderUsed[i])
-        {
-          f->UnpackStream = i;
           break;
-        }
-      
-      if (i == numCoders)
-        return SZ_ERROR_ARCHIVE;
+        if (++i == numCoders)
+          return SZ_ERROR_ARCHIVE;
+      }
+      f->UnpackStream = i;
     }
     
     if (numPackStreams == 1)
     {
-      for (i = 0; i < numInStreams; i++)
+      for (i = 0;; i++)
+      {
+        if (i == numInStreams)
+          return SZ_ERROR_ARCHIVE;
         if (!streamUsed[i])
           break;
-      if (i == numInStreams)
-        return SZ_ERROR_ARCHIVE;
+      }
       f->PackStreams[0] = i;
     }
     else
@@ -601,40 +575,30 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
         f->PackStreams[i] = index;
       }
   }
-
-  f->NumCoders = numCoders;
-
   return SZ_OK;
 }
 
 
-static Z7_NO_INLINE SRes SkipNumbers(CSzData *sd2, UInt32 num)
+static SRes SkipNumbers(CSzData *sd2, UInt32 num)
 {
-  CSzData sd;
-  sd = *sd2;
+  const Byte *data = sd2->Data;
+  size_t size = sd2->Size;
   for (; num != 0; num--)
   {
-    Byte firstByte, mask;
+    unsigned firstByte;
     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)
+    if (size == 0)
       return SZ_ERROR_ARCHIVE;
-    SKIP_DATA2(sd, i)
+    firstByte = *data;
+    for (i = 1; firstByte & 0x80; i++)
+      firstByte <<= 1;
+    if (size < i)
+      return SZ_ERROR_ARCHIVE;
+    size -= i;
+    data += i;
   }
-  *sd2 = sd;
+  sd2->Data = data;
+  sd2->Size = size;
   return SZ_OK;
 }
 
@@ -642,15 +606,10 @@ static Z7_NO_INLINE SRes SkipNumbers(CSzData *sd2, UInt32 num)
 #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)
+static SRes ReadUnpackInfo(CSzAr *p, CSzData *sd2, const UInt32 numFoldersMax,
+    const CBuf *tempBufs, UInt32 numTempBufs, ISzAllocPtr alloc)
 {
   CSzData sd;
-  
   UInt32 fo, numFolders, numCodersOutStreams, packStreamIndex;
   const Byte *startBufPtr;
   Byte external;
@@ -742,15 +701,12 @@ static SRes ReadUnpackInfo(CSzAr *p,
       {
         Byte streamUsed[k_Scan_NumCodersStreams_in_Folder_MAX];
         Byte coderUsed[k_Scan_NumCoders_MAX];
-    
         UInt32 i;
         const 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++)
@@ -782,16 +738,15 @@ static SRes ReadUnpackInfo(CSzAr *p,
               return SZ_ERROR_ARCHIVE;
             streamUsed[index] = True;
           }
-          
-        for (i = 0; i < numCoders; i++)
+
+        for (i = 0;;)
+        {
           if (!coderUsed[i])
-          {
-            indexOfMainStream = i;
             break;
-          }
- 
-        if (i == numCoders)
-          return SZ_ERROR_ARCHIVE;
+          if (++i == numCoders)
+            return SZ_ERROR_ARCHIVE;
+        }
+        indexOfMainStream = i;
       }
       
       p->FoStartPackStreamIndex[fo] = packStreamIndex;
@@ -806,31 +761,38 @@ static SRes ReadUnpackInfo(CSzAr *p,
     }
   }
 
+  {
+    const size_t k_numCodersOutStreams_Limit = (size_t)1 << (sizeof(size_t) * 8 - 4);
+    if (numCodersOutStreams >= k_numCodersOutStreams_Limit)
+      return SZ_ERROR_UNSUPPORTED;
+  }
   p->FoToCoderUnpackSizes[fo] = numCodersOutStreams;
-  
+  p->FoStartPackStreamIndex[fo] = packStreamIndex;
   {
     const size_t dataSize = (size_t)(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 (external)
   {
-    if (sd.Size != 0)
+    if (sd.Size)
       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))
-    }
+    UInt64 *sizes;
+    MY_ALLOC_ZE(UInt64, sizes, (size_t)numCodersOutStreams, alloc)
+    p->CoderUnpackSizes = sizes;
+    if (numCodersOutStreams)
+      do
+      {
+        RINOK(ReadNumber(&sd, sizes))
+        sizes++;
+      }
+      while (--numCodersOutStreams);
   }
 
   for (;;)
@@ -838,10 +800,7 @@ static SRes ReadUnpackInfo(CSzAr *p,
     UInt64 type;
     RINOK(ReadID(&sd, &type))
     if (type == k7zIdEnd)
-    {
-      *sd2 = sd;
-      return SZ_OK;
-    }
+      break;
     if (type == k7zIdCRC)
     {
       RINOK(ReadBitUi32s(&sd, numFolders, &p->FolderCRCs, alloc))
@@ -849,6 +808,8 @@ static SRes ReadUnpackInfo(CSzAr *p,
     }
     RINOK(SkipData(&sd))
   }
+  *sd2 = sd;
+  return SZ_OK;
 }
 
 
@@ -868,12 +829,12 @@ typedef struct
 } CSubStreamInfo;
 
 
-static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
+static SRes ReadSubStreamsInfo(const CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
 {
   UInt64 type = 0;
-  UInt32 numSubDigests = 0;
   const UInt32 numFolders = p->NumFolders;
   UInt32 numUnpackStreams = numFolders;
+  UInt32 numSubDigests = numFolders;
   UInt32 numUnpackSizesInData = 0;
 
   for (;;)
@@ -882,6 +843,8 @@ static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
     if (type == k7zIdNumUnpackStream)
     {
       UInt32 i;
+      if (ssi->sdNumSubStreams.Data)
+        return SZ_ERROR_UNSUPPORTED;
       ssi->sdNumSubStreams.Data = sd->Data;
       numUnpackStreams = 0;
       numSubDigests = 0;
@@ -889,10 +852,10 @@ static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
       {
         UInt32 numStreams;
         RINOK(SzReadNumber32(sd, &numStreams))
-        if (numUnpackStreams > numUnpackStreams + numStreams)
-          return SZ_ERROR_UNSUPPORTED;
         numUnpackStreams += numStreams;
-        if (numStreams != 0)
+        if (numUnpackStreams < numStreams)
+          return SZ_ERROR_UNSUPPORTED;
+        if (numStreams)
           numUnpackSizesInData += (numStreams - 1);
         if (numStreams != 1 || !SzBitWithVals_Check(&p->FolderCRCs, i))
           numSubDigests += numStreams;
@@ -905,12 +868,8 @@ static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
     RINOK(SkipData(sd))
   }
 
-  if (!ssi->sdNumSubStreams.Data)
-  {
-    numSubDigests = numFolders;
-    if (p->FolderCRCs.Defs)
-      numSubDigests = numFolders - CountDefinedBits(p->FolderCRCs.Defs, numFolders);
-  }
+  if (!ssi->sdNumSubStreams.Data && p->FolderCRCs.Defs)
+    numSubDigests = numFolders - CountDefinedBits(p->FolderCRCs.Defs, numFolders);
   
   ssi->NumTotalSubStreams = numUnpackStreams;
   ssi->NumSubDigests = numSubDigests;
@@ -929,6 +888,8 @@ static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
       return SZ_OK;
     if (type == k7zIdCRC)
     {
+      if (ssi->sdCRCs.Data)
+        return SZ_ERROR_UNSUPPORTED;
       ssi->sdCRCs.Data = sd->Data;
       RINOK(SkipBitUi32s(sd, numSubDigests))
       ssi->sdCRCs.Size = (size_t)(sd->Data - ssi->sdCRCs.Data);
@@ -941,9 +902,11 @@ static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
   }
 }
 
+
 static SRes SzReadStreamsInfo(CSzAr *p,
     CSzData *sd,
-    UInt32 numFoldersMax, const CBuf *tempBufs, UInt32 numTempBufs,
+    const UInt32 numFoldersMax,
+    const CBuf * const tempBufs, const UInt32 numTempBufs,
     UInt64 *dataOffset,
     CSubStreamInfo *ssi,
     ISzAllocPtr alloc)
@@ -985,12 +948,13 @@ static SRes SzReadStreamsInfo(CSzAr *p,
   return (type == k7zIdEnd ? SZ_OK : SZ_ERROR_UNSUPPORTED);
 }
 
+
 static SRes SzReadAndDecodePackedStreams(
     ILookInStreamPtr inStream,
     CSzData *sd,
-    CBuf *tempBufs,
-    UInt32 numFoldersMax,
-    UInt64 baseOffset,
+    CBuf * const tempBufs,
+    const UInt32 numFoldersMax,
+    const UInt64 baseOffset,
     CSzAr *p,
     ISzAllocPtr allocTemp)
 {
@@ -1027,6 +991,7 @@ static SRes SzReadAndDecodePackedStreams(
   return SZ_OK;
 }
 
+
 // (size & 1) == 0
 // (data) is aligned for 2-bytes
 static SRes SzReadFileNames(const Byte *data, size_t size, UInt32 numFiles, size_t *offsets)
@@ -1053,30 +1018,35 @@ static SRes SzReadFileNames(const Byte *data, size_t size, UInt32 numFiles, size
   return (p == lim) ? SZ_OK : SZ_ERROR_ARCHIVE;
 }
 
-static Z7_NO_INLINE SRes ReadTime(CSzBitUi64s *p, size_t num,
-    CSzData *sd2,
-    const CBuf *tempBufs, UInt32 numTempBufs,
-    ISzAllocPtr alloc)
+
+static SRes ReadTime(CSzBitUi64s *p, size_t num, CSzData *sd2,
+    const CBuf *tempBufs, UInt32 numTempBufs, ISzAllocPtr alloc)
 {
-  CSzData sd;
+  const Byte *data;
+  size_t size;
   size_t i;
   CNtfsFileTime *vals;
   Byte *defs;
   Byte external;
   
+  if (p->Defs)
+    return SZ_ERROR_ARCHIVE;
   RINOK(ReadBitVector(sd2, num, &p->Defs, alloc))
   
   SZ_READ_BYTE_SD(sd2, external)
   if (external == 0)
-    sd = *sd2;
+  {
+    data = sd2->Data;
+    size = sd2->Size;
+  }
   else
   {
     UInt32 index;
     RINOK(SzReadNumber32(sd2, &index))
-    if (index >= numTempBufs)
+    if (index >= numTempBufs || sd2->Size)
       return SZ_ERROR_ARCHIVE;
-    sd.Data = tempBufs[index].data;
-    sd.Size = tempBufs[index].size;
+    data = tempBufs[index].data;
+    size = tempBufs[index].size;
   }
   
   MY_ALLOC_ZE(CNtfsFileTime, p->Vals, num, alloc)
@@ -1085,18 +1055,18 @@ static Z7_NO_INLINE SRes ReadTime(CSzBitUi64s *p, size_t num,
   for (i = 0; i < num; i++)
     if (SzBitArray_Check(defs, i))
     {
-      if (sd.Size < 8)
+      if (size < 8)
         return SZ_ERROR_ARCHIVE;
-      vals[i].Low = GetUi32(sd.Data);
-      vals[i].High = GetUi32(sd.Data + 4);
-      SKIP_DATA2(sd, 8)
+      size -= 8;
+      vals[i].Low = GetUi32(data);
+      vals[i].High = GetUi32(data + 4);
+      data += 8;
     }
     else
       vals[i].High = vals[i].Low = 0;
   
-  if (external == 0)
-    *sd2 = sd;
-  
+  if (size)
+    return SZ_ERROR_ARCHIVE;
   return SZ_OK;
 }
 
@@ -1104,16 +1074,11 @@ static Z7_NO_INLINE SRes ReadTime(CSzBitUi64s *p, size_t num,
 #define NUM_ADDITIONAL_STREAMS_MAX 8
 
 
-static SRes SzReadHeader2(
-    CSzArEx *p,   /* allocMain */
-    CSzData *sd,
-    ILookInStreamPtr inStream,
-    CBuf *tempBufs, UInt32 *numTempBufs,
-    ISzAllocPtr allocMain,
-    ISzAllocPtr allocTemp
-    )
+static SRes SzReadHeader2(CSzArEx *p, CSzData *sd, ILookInStreamPtr inStream,
+    CBuf * const tempBufs, ISzAllocPtr allocMain, ISzAllocPtr allocTemp)
 {
   CSubStreamInfo ssi;
+  UInt32 numTempBufs = 0;
 
 {
   UInt64 type;
@@ -1150,7 +1115,7 @@ static SRes SzReadHeader2(
 
     res = SzReadAndDecodePackedStreams(inStream, sd, tempBufs, NUM_ADDITIONAL_STREAMS_MAX,
         p->startPosAfterHeader, &tempAr, allocTemp);
-    *numTempBufs = tempAr.NumFolders;
+    numTempBufs = tempAr.NumFolders;
     SzAr_Free(&tempAr, allocTemp);
     
     if (res != SZ_OK)
@@ -1160,24 +1125,21 @@ static SRes SzReadHeader2(
 
   if (type == k7zIdMainStreamsInfo)
   {
-    RINOK(SzReadStreamsInfo(&p->db, sd, (UInt32)1 << 30, tempBufs, *numTempBufs,
+    static const UInt32 k_numFoldersMax = (UInt32)1 << 30;
+    RINOK(SzReadStreamsInfo(&p->db, sd, k_numFoldersMax, tempBufs, numTempBufs,
         &p->dataPos, &ssi, allocMain))
     p->dataPos += p->startPosAfterHeader;
     RINOK(ReadID(sd, &type))
   }
 
   if (type == k7zIdEnd)
-  {
     return SZ_OK;
-  }
-
   if (type != k7zIdFilesInfo)
     return SZ_ERROR_ARCHIVE;
 }
 
 {
-  UInt32 numFiles = 0;
-  UInt32 numEmptyStreams = 0;
+  UInt32 numFiles, numEmptyStreams = 0;
   const Byte *emptyStreams = NULL;
   const Byte *emptyFiles = NULL;
   
@@ -1186,44 +1148,68 @@ static SRes SzReadHeader2(
 
   for (;;)
   {
+    CSzData sdSwitch;
     UInt64 type;
-    UInt64 size;
     RINOK(ReadID(sd, &type))
     if (type == k7zIdEnd)
       break;
-    RINOK(ReadNumber(sd, &size))
-    if (size > sd->Size)
-      return SZ_ERROR_ARCHIVE;
-    
-    if (type >= ((UInt32)1 << 8))
     {
+      UInt64 size;
+      RINOK(ReadNumber(sd, &size))
+      if (size > sd->Size)
+        return SZ_ERROR_ARCHIVE;
+      sdSwitch.Data = sd->Data;
+      sdSwitch.Size = (size_t)size;
       SKIP_DATA(sd, size)
     }
-    else switch ((unsigned)type)
+    if (type >= 64)
+      continue;
+    
+    switch ((unsigned)type)
     {
+      case k7zIdEmptyStream:
+      {
+        if (emptyStreams || emptyFiles)
+          return SZ_ERROR_ARCHIVE;
+        if ((numFiles + 7) >> 3 != sdSwitch.Size)
+          return SZ_ERROR_ARCHIVE;
+        emptyStreams = sdSwitch.Data;
+        numEmptyStreams = CountDefinedBits(emptyStreams, numFiles);
+        break;
+      }
+      
+      case k7zIdEmptyFile:
+      {
+        if (emptyFiles)
+          return SZ_ERROR_ARCHIVE;
+        if ((numEmptyStreams + 7) >> 3 != sdSwitch.Size)
+          return SZ_ERROR_ARCHIVE;
+        emptyFiles = sdSwitch.Data;
+        break;
+      }
+      
       case k7zIdName:
       {
         size_t namesSize;
         const Byte *namesData;
         Byte external;
-
-        SZ_READ_BYTE(external)
+        if (p->FileNameOffsets)
+          return SZ_ERROR_ARCHIVE;
+        SZ_READ_BYTE_SD(&sdSwitch, external)
         if (external == 0)
         {
-          namesSize = (size_t)size - 1;
-          namesData = sd->Data;
-          SKIP_DATA(sd, namesSize)
+          namesData = sdSwitch.Data;
+          namesSize = sdSwitch.Size;
         }
         else
         {
           UInt32 index;
-          RINOK(SzReadNumber32(sd, &index))
-          if (index >= *numTempBufs)
+          RINOK(SzReadNumber32(&sdSwitch, &index))
+          if (index >= numTempBufs || sdSwitch.Size)
             return SZ_ERROR_ARCHIVE;
-          namesData = (tempBufs)[index].data;
-          namesSize = (tempBufs)[index].size;
+          namesData = tempBufs[index].data;
+          namesSize = tempBufs[index].size;
         }
-
         if (namesSize & 1)
           return SZ_ERROR_ARCHIVE;
         MY_ALLOC(size_t, p->FileNameOffsets, numFiles + 1, allocMain)
@@ -1231,58 +1217,38 @@ static SRes SzReadHeader2(
         RINOK(SzReadFileNames(p->FileNames, namesSize, numFiles, p->FileNameOffsets))
         break;
       }
-      case k7zIdEmptyStream:
-      {
-        RINOK(RememberBitVector(sd, numFiles, &emptyStreams))
-        numEmptyStreams = CountDefinedBits(emptyStreams, numFiles);
-        emptyFiles = NULL;
-        break;
-      }
-      case k7zIdEmptyFile:
-      {
-        RINOK(RememberBitVector(sd, numEmptyStreams, &emptyFiles))
-        break;
-      }
+      
       case k7zIdWinAttrib:
       {
         Byte external;
-        CSzData sdSwitch;
-        CSzData *sdPtr;
-        SzBitUi32s_Free(&p->Attribs, allocMain);
-        RINOK(ReadBitVector(sd, numFiles, &p->Attribs.Defs, allocMain))
-
-        SZ_READ_BYTE(external)
-        if (external == 0)
-          sdPtr = sd;
-        else
+        if (p->Attribs.Defs)
+          return SZ_ERROR_ARCHIVE;
+        RINOK(ReadBitVector(&sdSwitch, numFiles, &p->Attribs.Defs, allocMain))
+        SZ_READ_BYTE_SD(&sdSwitch, external)
+        if (external)
         {
           UInt32 index;
-          RINOK(SzReadNumber32(sd, &index))
-          if (index >= *numTempBufs)
+          RINOK(SzReadNumber32(&sdSwitch, &index))
+          if (index >= numTempBufs || sdSwitch.Size)
             return SZ_ERROR_ARCHIVE;
-          sdSwitch.Data = (tempBufs)[index].data;
-          sdSwitch.Size = (tempBufs)[index].size;
-          sdPtr = &sdSwitch;
+          sdSwitch.Data = tempBufs[index].data;
+          sdSwitch.Size = tempBufs[index].size;
         }
-        RINOK(ReadUi32s(sdPtr, numFiles, &p->Attribs, allocMain))
+        RINOK(ReadUi32s(&sdSwitch, numFiles, &p->Attribs, allocMain))
+        if (sdSwitch.Size)
+          return SZ_ERROR_ARCHIVE;
         break;
       }
-      /*
-      case k7zParent:
+      
+      case k7zIdMTime:
+      case k7zIdCTime:
       {
-        SzBitUi32s_Free(&p->Parents, allocMain);
-        RINOK(ReadBitVector(sd, numFiles, &p->Parents.Defs, allocMain));
-        RINOK(SzReadSwitch(sd));
-        RINOK(ReadUi32s(sd, numFiles, &p->Parents, allocMain));
+        RINOK(ReadTime((unsigned)type == k7zIdMTime ? &p->MTime: &p->CTime,
+            numFiles, &sdSwitch, tempBufs, numTempBufs, allocMain))
         break;
       }
-      */
-      case k7zIdMTime: RINOK(ReadTime(&p->MTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)) break;
-      case k7zIdCTime: RINOK(ReadTime(&p->CTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)) break;
-      default:
-      {
-        SKIP_DATA(sd, size)
-      }
+      
+      default: break;
     }
   }
 
@@ -1481,25 +1447,19 @@ static SRes SzReadHeader(
     ISzAllocPtr allocTemp)
 {
   UInt32 i;
-  UInt32 numTempBufs = 0;
   SRes res;
   CBuf tempBufs[NUM_ADDITIONAL_STREAMS_MAX];
 
   for (i = 0; i < NUM_ADDITIONAL_STREAMS_MAX; i++)
     Buf_Init(tempBufs + i);
   
-  res = SzReadHeader2(p, sd, inStream,
-      tempBufs, &numTempBufs,
-      allocMain, allocTemp);
+  res = SzReadHeader2(p, sd, inStream, tempBufs, allocMain, allocTemp);
   
   for (i = 0; i < NUM_ADDITIONAL_STREAMS_MAX; i++)
     Buf_Free(tempBufs + i, allocTemp);
 
-  RINOK(res)
-
-  if (sd->Size != 0)
-    return SZ_ERROR_FAIL;
-
+  if (res == SZ_OK && sd->Size != 0)
+    return SZ_ERROR_ARCHIVE;
   return res;
 }
 
@@ -1510,53 +1470,52 @@ static SRes SzArEx_Open2(
     ISzAllocPtr allocTemp)
 {
   Byte header[k7zStartHeaderSize];
-  Int64 startArcPos;
+  Int64 startPosAfterHeader;
   UInt64 nextHeaderOffset, nextHeaderSize;
   size_t nextHeaderSizeT;
   UInt32 nextHeaderCRC;
   CBuf buf;
   SRes res;
 
-  startArcPos = 0;
-  RINOK(ILookInStream_Seek(inStream, &startArcPos, SZ_SEEK_CUR))
-
   RINOK(LookInStream_Read2(inStream, header, k7zStartHeaderSize, SZ_ERROR_NO_ARCHIVE))
-
-  if (!TestSignatureCandidate(header))
-    return SZ_ERROR_NO_ARCHIVE;
-  if (header[6] != k7zMajorVersion)
-    return SZ_ERROR_UNSUPPORTED;
+  startPosAfterHeader = 0; // k7zStartHeaderSize
+  RINOK(ILookInStream_Seek(inStream, &startPosAfterHeader, SZ_SEEK_CUR))
+  p->startPosAfterHeader = (UInt64)startPosAfterHeader;
+  {
+    unsigned i;
+    for (i = 0; i < k7zSignatureSize; i++)
+      if (header[i] != k7zSignature[i])
+        return SZ_ERROR_NO_ARCHIVE;
+    if (header[6] != 0) // k7zMajorVersion
+      return SZ_ERROR_UNSUPPORTED;
+  }
+  if (CrcCalc(header + 12, 20) != GetUi32(header + 8))
+    return SZ_ERROR_CRC;
 
   nextHeaderOffset = GetUi64(header + 12);
   nextHeaderSize = GetUi64(header + 20);
   nextHeaderCRC = GetUi32(header + 28);
 
-  p->startPosAfterHeader = (UInt64)startArcPos + k7zStartHeaderSize;
-  
-  if (CrcCalc(header + 12, 20) != GetUi32(header + 8))
-    return SZ_ERROR_CRC;
-
   p->db.RangeLimit = nextHeaderOffset;
-
+  if (nextHeaderOffset >= (UInt64)1 << 62 ||
+      nextHeaderSize >= (UInt64)1 << 48)
+    return SZ_ERROR_NO_ARCHIVE;
   nextHeaderSizeT = (size_t)nextHeaderSize;
   if (nextHeaderSizeT != nextHeaderSize)
     return SZ_ERROR_MEM;
   if (nextHeaderSizeT == 0)
+  {
+    if (nextHeaderOffset != 0 || nextHeaderCRC != 0)
+      return SZ_ERROR_NO_ARCHIVE;
     return SZ_OK;
-  if (nextHeaderOffset > nextHeaderOffset + nextHeaderSize ||
-      nextHeaderOffset > nextHeaderOffset + nextHeaderSize + k7zStartHeaderSize)
-    return SZ_ERROR_NO_ARCHIVE;
-
+  }
   {
     Int64 pos = 0;
     RINOK(ILookInStream_Seek(inStream, &pos, SZ_SEEK_END))
-    if ((UInt64)pos < (UInt64)startArcPos + nextHeaderOffset ||
-        (UInt64)pos < (UInt64)startArcPos + k7zStartHeaderSize + nextHeaderOffset ||
-        (UInt64)pos < (UInt64)startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)
+    if ((UInt64)(pos - startPosAfterHeader) < nextHeaderOffset + nextHeaderSize)
       return SZ_ERROR_INPUT_EOF;
   }
-
-  RINOK(LookInStream_SeekTo(inStream, (UInt64)startArcPos + k7zStartHeaderSize + nextHeaderOffset))
+  RINOK(LookInStream_SeekTo(inStream, (UInt64)startPosAfterHeader + nextHeaderOffset))
 
   if (!Buf_Create(&buf, nextHeaderSizeT, allocTemp))
     return SZ_ERROR_MEM;
@@ -1720,61 +1679,23 @@ SRes SzArEx_Extract(
 
 size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest)
 {
-  const size_t offs = p->FileNameOffsets[fileIndex];
-  const size_t len = p->FileNameOffsets[fileIndex + 1] - offs;
-  if (dest != 0)
+  const size_t * const offsets = p->FileNameOffsets;
+  if (!offsets)
   {
-    size_t i;
-    const Byte *src = p->FileNames + offs * 2;
-    for (i = 0; i < len; i++)
-      dest[i] = GetUi16(src + i * 2);
-  }
-  return len;
-}
-
-/*
-size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex)
-{
-  size_t len;
-  if (!p->FileNameOffsets)
+    if (dest)
+      *dest = 0;
     return 1;
-  len = 0;
-  for (;;)
-  {
-    UInt32 parent = (UInt32)(Int32)-1;
-    len += p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];
-    if SzBitWithVals_Check(&p->Parents, fileIndex)
-      parent = p->Parents.Vals[fileIndex];
-    if (parent == (UInt32)(Int32)-1)
-      return len;
-    fileIndex = parent;
   }
-}
-
-UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest)
-{
-  BoolInt needSlash;
-  if (!p->FileNameOffsets)
-  {
-    *(--dest) = 0;
-    return dest;
-  }
-  needSlash = False;
-  for (;;)
   {
-    UInt32 parent = (UInt32)(Int32)-1;
-    size_t curLen = p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];
-    SzArEx_GetFileNameUtf16(p, fileIndex, dest - curLen);
-    if (needSlash)
-      *(dest - 1) = '/';
-    needSlash = True;
-    dest -= curLen;
-
-    if SzBitWithVals_Check(&p->Parents, fileIndex)
-      parent = p->Parents.Vals[fileIndex];
-    if (parent == (UInt32)(Int32)-1)
-      return dest;
-    fileIndex = parent;
+    const size_t offs = offsets[fileIndex];
+    const size_t len = offsets[fileIndex + 1] - offs;
+    if (dest)
+    {
+      size_t i;
+      const Byte *src = p->FileNames + offs * 2;
+      for (i = 0; i < len; i++)
+        dest[i] = GetUi16a(src + i * 2);
+    }
+    return len;
   }
 }
-*/
diff --git a/C/7zVersion.h b/C/7zVersion.h
index 387a91c..50ccebb 100644
--- a/C/7zVersion.h
+++ b/C/7zVersion.h
@@ -1,7 +1,7 @@
 #define MY_VER_MAJOR 26
-#define MY_VER_MINOR 1
+#define MY_VER_MINOR 2
 #define MY_VER_BUILD 0
-#define MY_VERSION_NUMBERS "26.01"
+#define MY_VERSION_NUMBERS "26.02"
 #define MY_VERSION MY_VERSION_NUMBERS
 
 #ifdef MY_CPU_NAME
@@ -10,7 +10,7 @@
   #define MY_VERSION_CPU MY_VERSION
 #endif
 
-#define MY_DATE "2026-04-27"
+#define MY_DATE "2026-06-25"
 #undef MY_COPYRIGHT
 #undef MY_VERSION_COPYRIGHT_DATE
 #define MY_AUTHOR_NAME "Igor Pavlov"
diff --git a/C/Compiler.h b/C/Compiler.h
index a3577b2..c06b883 100644
--- a/C/Compiler.h
+++ b/C/Compiler.h
@@ -76,6 +76,11 @@
   #pragma GCC diagnostic ignored "-Wreserved-identifier"
 #endif
 
+#if __clang_major__ >= 22
+// for "StdAfx.h" and "Precomp.h"
+#pragma GCC diagnostic ignored "-Wshadow-header"
+#endif
+
 #endif // __clang__
 
 #if defined(__clang__) && __clang_major__ >= 16
diff --git a/C/DllSecur.c b/C/DllSecur.c
index bbbfc0a..d385259 100644
--- a/C/DllSecur.c
+++ b/C/DllSecur.c
@@ -1,5 +1,5 @@
 /* DllSecur.c -- DLL loading security
-2023-12-03 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -67,7 +67,7 @@ void LoadSecurityDlls(void)
   // at Vista (ver 6.0) : CoCreateInstance(CLSID_ShellLink, ...) doesn't work after SetDefaultDllDirectories() : Check it ???
   IF_NON_VISTA_SET_DLL_DIRS_AND_RETURN
   {
-    wchar_t buf[MAX_PATH + 100];
+    WCHAR buf[MAX_PATH + 100];
     const char *dll;
     unsigned pos = GetSystemDirectoryW(buf, MAX_PATH + 2);
     if (pos == 0 || pos > MAX_PATH)
@@ -76,7 +76,7 @@ void LoadSecurityDlls(void)
       buf[pos++] = '\\';
     for (dll = g_Dlls; *dll != 0;)
     {
-      wchar_t *dest = &buf[pos];
+      WCHAR *dest = &buf[pos];
       for (;;)
       {
         const char c = *dll++;
diff --git a/C/MtDec.c b/C/MtDec.c
index 96274b6..71fc1ee 100644
--- a/C/MtDec.c
+++ b/C/MtDec.c
@@ -1,5 +1,5 @@
 /* MtDec.c -- Multi-thread Decoder
-2024-02-20 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -22,7 +22,7 @@
 #define PRF(x)
 #endif
 
-#define PRF_STR_INT(s, d) PRF(printf("\n" s " %d\n", (unsigned)d))
+#define PRF_STR_INT(s, d) PRF(printf("\n" s " %d\n", (unsigned)d);)
 
 void MtProgress_Init(CMtProgress *p, ICompressProgressPtr progress)
 {
diff --git a/C/Util/7z/7zMain.c b/C/Util/7z/7zMain.c
index 7048b66..300c363 100644
--- a/C/Util/7z/7zMain.c
+++ b/C/Util/7z/7zMain.c
@@ -960,7 +960,12 @@ int Z7_CDECL main(int numargs, char *args[])
         if (listCommand == 0 && isDir && !fullPaths)
           continue;
         len = SzArEx_GetFileNameUtf16(&db, i, NULL);
-        // len = SzArEx_GetFullNameLen(&db, i);
+
+        if (len > (1u << 20))
+        {
+          res = SZ_ERROR_UNSUPPORTED;
+          break;
+        }
 
         if (len > tempSize)
         {
diff --git a/C/Util/7zipInstall/7zipInstall.c b/C/Util/7zipInstall/7zipInstall.c
index 7d8e8c4..ce30732 100644
--- a/C/Util/7zipInstall/7zipInstall.c
+++ b/C/Util/7zipInstall/7zipInstall.c
@@ -1,5 +1,5 @@
 /* 7zipInstall.c - 7-Zip Installer
-2024-04-05 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -142,7 +142,7 @@ static WCHAR path[MAX_PATH * 2 + 40];
 
 
 
-static void CpyAscii(wchar_t *dest, const char *s)
+static void CpyAscii(WCHAR *dest, const char *s)
 {
   for (;;)
   {
@@ -153,13 +153,13 @@ static void CpyAscii(wchar_t *dest, const char *s)
   }
 }
 
-static void CatAscii(wchar_t *dest, const char *s)
+static void CatAscii(WCHAR *dest, const char *s)
 {
   dest += wcslen(dest);
   CpyAscii(dest, s);
 }
 
-static void PrintErrorMessage(const char *s1, const wchar_t *s2)
+static void PrintErrorMessage(const char *s1, const WCHAR *s2)
 {
   WCHAR m[MAX_PATH + 512];
   m[0] = 0;
@@ -196,7 +196,7 @@ static DWORD GetFileVersion(LPCWSTR s)
 
   if (!g_version_dll_hModule)
   {
-    wchar_t buf[MAX_PATH + 100];
+    WCHAR buf[MAX_PATH + 100];
     {
       unsigned len = GetSystemDirectoryW(buf, MAX_PATH + 2);
       if (len == 0 || len > MAX_PATH)
@@ -255,13 +255,13 @@ static WRes MyCreateDir(LPCWSTR name)
 #define IS_LETTER_CHAR(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z'))
 #define IS_DRIVE_PATH(s) (IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]))
 
-static int ReverseFind_PathSepar(const wchar_t *s)
+static int ReverseFind_PathSepar(const WCHAR *s)
 {
   int separ = -1;
   int i;
   for (i = 0;; i++)
   {
-    wchar_t c = s[i];
+    WCHAR c = s[i];
     if (c == 0)
       return separ;
     if (IS_SEPAR(c))
@@ -566,7 +566,7 @@ static void NormalizePrefix(WCHAR *s)
   
   for (;; i++)
   {
-    const wchar_t c = s[i];
+    const WCHAR c = s[i];
     if (c == 0)
       break;
     if (c == '/')
@@ -587,10 +587,10 @@ static char MyCharLower_Ascii(char c)
   return c;
 }
 
-static wchar_t MyWCharLower_Ascii(wchar_t c)
+static WCHAR MyWCharLower_Ascii(WCHAR c)
 {
   if (c >= 'A' && c <= 'Z')
-    return (wchar_t)(c + 0x20);
+    return (WCHAR)(c + 0x20);
   return c;
 }
 
@@ -976,13 +976,13 @@ static void WriteShellEx(void)
 }
 
 
-static const wchar_t *GetCmdParam(const wchar_t *s)
+static const WCHAR *GetCmdParam(const WCHAR *s)
 {
   unsigned pos = 0;
   BoolInt quoteMode = False;
   for (;; s++)
   {
-    wchar_t c = *s;
+    WCHAR c = *s;
     if (c == 0 || (c == L' ' && !quoteMode))
       break;
     if (c == L'\"')
@@ -999,12 +999,12 @@ static const wchar_t *GetCmdParam(const wchar_t *s)
 }
 
 
-static void RemoveQuotes(wchar_t *s)
+static void RemoveQuotes(WCHAR *s)
 {
-  const wchar_t *src = s;
+  const WCHAR *src = s;
   for (;;)
   {
-    wchar_t c = *src++;
+    WCHAR c = *src++;
     if (c == '\"')
       continue;
     *s++ = c;
@@ -1039,7 +1039,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
   CrcGenerateTable();
 
   {
-    const wchar_t *s = GetCommandLineW();
+    const WCHAR *s = GetCommandLineW();
     
     #ifndef UNDER_CE
     s = GetCmdParam(s);
@@ -1048,7 +1048,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
     for (;;)
     {
       {
-        const wchar_t c = *s;
+        const WCHAR c = *s;
         if (c == 0)
           break;
         if (c == ' ')
@@ -1059,7 +1059,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
       }
 
       {
-        const wchar_t *s2 = GetCmdParam(s);
+        const WCHAR *s2 = GetCmdParam(s);
         BoolInt error = True;
         if (cmd[0] == '/')
         {
@@ -1315,7 +1315,7 @@ if (res == SZ_OK)
     
     for (;;)
     {
-      const wchar_t c = path[i++];
+      const WCHAR c = path[i++];
       if (c == 0)
         break;
       if (c != ' ')
diff --git a/C/Util/7zipUninstall/7zipUninstall.c b/C/Util/7zipUninstall/7zipUninstall.c
index e7051e2..2c1333b 100644
--- a/C/Util/7zipUninstall/7zipUninstall.c
+++ b/C/Util/7zipUninstall/7zipUninstall.c
@@ -1,5 +1,5 @@
 /* 7zipUninstall.c - 7-Zip Uninstaller
-2024-03-21 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -147,7 +147,7 @@ static LPCWSTR const kUninstallExe = L"Uninstall.exe";
 #define MAKE_CHAR_UPPER(c) ((((c) >= 'a' && (c) <= 'z') ? (c) - 0x20 : (c)))
 
 
-static void CpyAscii(wchar_t *dest, const char *s)
+static void CpyAscii(WCHAR *dest, const char *s)
 {
   for (;;)
   {
@@ -158,13 +158,13 @@ static void CpyAscii(wchar_t *dest, const char *s)
   }
 }
 
-static void CatAscii(wchar_t *dest, const char *s)
+static void CatAscii(WCHAR *dest, const char *s)
 {
   dest += wcslen(dest);
   CpyAscii(dest, s);
 }
 
-static void PrintErrorMessage(const char *s1, const wchar_t *s2)
+static void PrintErrorMessage(const char *s1, const WCHAR *s2)
 {
   WCHAR m[MAX_PATH + 512];
   m[0] = 0;
@@ -183,12 +183,12 @@ static void PrintErrorMessage(const char *s1, const wchar_t *s2)
 }
 
 
-static BoolInt AreStringsEqual_NoCase(const wchar_t *s1, const wchar_t *s2)
+static BoolInt AreStringsEqual_NoCase(const WCHAR *s1, const WCHAR *s2)
 {
   for (;;)
   {
-    wchar_t c1 = *s1++;
-    wchar_t c2 = *s2++;
+    WCHAR c1 = *s1++;
+    WCHAR c2 = *s2++;
     if (c1 != c2 && MAKE_CHAR_UPPER(c1) != MAKE_CHAR_UPPER(c2))
       return False;
     if (c2 == 0)
@@ -196,12 +196,12 @@ static BoolInt AreStringsEqual_NoCase(const wchar_t *s1, const wchar_t *s2)
   }
 }
 
-static BoolInt IsString1PrefixedByString2_NoCase(const wchar_t *s1, const wchar_t *s2)
+static BoolInt IsString1PrefixedByString2_NoCase(const WCHAR *s1, const WCHAR *s2)
 {
   for (;;)
   {
-    wchar_t c1;
-    const wchar_t c2 = *s2++;
+    WCHAR c1;
+    const WCHAR c2 = *s2++;
     if (c2 == 0)
       return True;
     c1 = *s1++;
@@ -446,7 +446,7 @@ static LPCWSTR const k_AppPaths_7zFm = L"Software\\Microsoft\\Windows\\CurrentVe
 static LPCWSTR const k_Uninstall_7zip = k_REG_Uninstall L"7-Zip";
 
 
-static void RemoveQuotes(wchar_t *s)
+static void RemoveQuotes(WCHAR *s)
 {
   const size_t len = wcslen(s);
   size_t i;
@@ -457,7 +457,7 @@ static void RemoveQuotes(wchar_t *s)
   s[len - 2] = 0;
 }
 
-static BoolInt AreEqual_Path_PrefixName(const wchar_t *s, const wchar_t *prefix, const wchar_t *name)
+static BoolInt AreEqual_Path_PrefixName(const WCHAR *s, const WCHAR *prefix, const WCHAR *name)
 {
   if (!IsString1PrefixedByString2_NoCase(s, prefix))
     return False;
@@ -558,13 +558,13 @@ static void WriteCLSID(void)
 }
 
 
-static const wchar_t *GetCmdParam(const wchar_t *s)
+static const WCHAR *GetCmdParam(const WCHAR *s)
 {
   unsigned pos = 0;
   BoolInt quoteMode = False;
   for (;; s++)
   {
-    const wchar_t c = *s;
+    const WCHAR c = *s;
     if (c == 0 || (c == L' ' && !quoteMode))
       break;
     if (c == L'\"')
@@ -581,12 +581,12 @@ static const wchar_t *GetCmdParam(const wchar_t *s)
 }
 
 /*
-static void RemoveQuotes(wchar_t *s)
+static void RemoveQuotes(WCHAR *s)
 {
-  const wchar_t *src = s;
+  const WCHAR *src = s;
   for (;;)
   {
-    wchar_t c = *src++;
+    WCHAR c = *src++;
     if (c == '\"')
       continue;
     *s++ = c;
@@ -618,11 +618,11 @@ static BOOL RemoveFileAfterReboot(void)
 
 // #define IS_LIMIT_CHAR(c) (c == 0 || c == ' ')
 
-static BoolInt IsThereSpace(const wchar_t *s)
+static BoolInt IsThereSpace(const WCHAR *s)
 {
   for (;;)
   {
-    const wchar_t c = *s++;
+    const WCHAR c = *s++;
     if (c == 0)
       return False;
     if (c == ' ')
@@ -630,7 +630,7 @@ static BoolInt IsThereSpace(const wchar_t *s)
   }
 }
 
-static void AddPathParam(wchar_t *dest, const wchar_t *src)
+static void AddPathParam(WCHAR *dest, const WCHAR *src)
 {
   const BoolInt needQuote = IsThereSpace(src);
   if (needQuote)
@@ -937,7 +937,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
     #endif
     lpCmdLine, int nCmdShow)
 {
-  const wchar_t *cmdParams;
+  const WCHAR *cmdParams;
   BoolInt useTemp = True;
 
   UNUSED_VAR(hPrevInstance)
@@ -957,7 +957,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
 #endif
 
   {
-    const wchar_t *s = GetCommandLineW();
+    const WCHAR *s = GetCommandLineW();
 
     #ifndef UNDER_CE
     s = GetCmdParam(s);
@@ -968,7 +968,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
     for (;;)
     {
       {
-        wchar_t c = *s;
+        WCHAR c = *s;
         if (c == 0)
           break;
         if (c == ' ')
@@ -979,7 +979,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
       }
 
       {
-        const wchar_t *s2 = GetCmdParam(s);
+        const WCHAR *s2 = GetCmdParam(s);
         BoolInt error = True;
         if (cmd[0] == '/')
         {
@@ -1022,7 +1022,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
   }
   
   {
-    wchar_t *name;
+    WCHAR *name;
     const DWORD len = GetModuleFileNameW(NULL, modulePath, MAX_PATH);
     if (len == 0 || len > MAX_PATH)
       return 1;
@@ -1031,10 +1031,10 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
     wcscpy(modulePrefix, modulePath);
 
     {
-      wchar_t *s = modulePrefix;
+      WCHAR *s = modulePrefix;
       for (;;)
       {
-        const wchar_t c = *s++;
+        const WCHAR c = *s++;
         if (c == 0)
           break;
         if (c == WCHAR_PATH_SEPARATOR)
@@ -1079,14 +1079,14 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
         CpyAscii(path + pathLen, "7z");
         
         {
-          wchar_t *s = path + wcslen(path);
+          WCHAR *s = path + wcslen(path);
           UInt32 value = d;
           unsigned k;
           for (k = 0; k < 8; k++)
           {
             const unsigned t = value & 0xF;
             value >>= 4;
-            s[7 - k] = (wchar_t)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
+            s[7 - k] = (WCHAR)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
           }
           s[k] = 0;
         }
diff --git a/C/Util/SfxSetup/SfxSetup.c b/C/Util/SfxSetup/SfxSetup.c
index 9b5c1f9..344aa73 100644
--- a/C/Util/SfxSetup/SfxSetup.c
+++ b/C/Util/SfxSetup/SfxSetup.c
@@ -1,5 +1,5 @@
 /* SfxSetup.c - 7z SFX Setup
-2024-01-24 : Igor Pavlov : Public domain */
+: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -54,7 +54,7 @@ static const char * const kNames[] =
   , "start"
 };
 
-static unsigned FindExt(const wchar_t *s, unsigned *extLen)
+static unsigned FindExt(const WCHAR *s, unsigned *extLen)
 {
   unsigned len = (unsigned)wcslen(s);
   unsigned i;
@@ -72,7 +72,7 @@ static unsigned FindExt(const wchar_t *s, unsigned *extLen)
 
 #define MAKE_CHAR_UPPER(c) ((((c) >= 'a' && (c) <= 'z') ? (c) - 0x20 : (c)))
 
-static unsigned FindItem(const char * const *items, unsigned num, const wchar_t *s, unsigned len)
+static unsigned FindItem(const char * const *items, unsigned num, const WCHAR *s, unsigned len)
 {
   unsigned i;
   for (i = 0; i < num; i++)
@@ -268,7 +268,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
   #endif
   size_t pathLen;
   DWORD winRes;
-  const wchar_t *cmdLineParams;
+  const WCHAR *cmdLineParams;
   const char *errorMessage = NULL;
   BoolInt useShellExecute = True;
   DWORD exitCode = 0;
@@ -306,7 +306,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
       BoolInt quoteMode = False;
       for (;; cmdLineParams++)
       {
-        const wchar_t c = *cmdLineParams;
+        const WCHAR c = *cmdLineParams;
         if (c == L'\"')
           quoteMode = !quoteMode;
         else if (c == 0 || (c == L' ' && !quoteMode))
@@ -335,14 +335,14 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
       wcscpy(path + pathLen, L"7z");
 
       {
-        wchar_t *s = path + wcslen(path);
+        WCHAR *s = path + wcslen(path);
         UInt32 value = d;
         unsigned k;
         for (k = 0; k < 8; k++)
         {
           const unsigned t = value & 0xF;
           value >>= 4;
-          s[7 - k] = (wchar_t)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
+          s[7 - k] = (WCHAR)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
         }
         s[k] = '\0';
       }
diff --git a/C/XzDec.c b/C/XzDec.c
index fe6b425..e4ae144 100644
--- a/C/XzDec.c
+++ b/C/XzDec.c
@@ -25,8 +25,8 @@
 #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))
+#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>
@@ -574,7 +574,7 @@ static SRes MixCoder_ResetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 m
 output (status) can be :
   CODER_STATUS_NOT_FINISHED
   CODER_STATUS_FINISHED_WITH_MARK
-  CODER_STATUS_NEEDS_MORE_INPUT - not implemented still
+  CODER_STATUS_NEEDS_MORE_INPUT
 */
 
 static SRes MixCoder_Code(CMixCoder *p,
@@ -582,8 +582,8 @@ static SRes MixCoder_Code(CMixCoder *p,
     const Byte *src, SizeT *srcLen, int srcWasFinished,
     ECoderFinishMode finishMode)
 {
-  SizeT destLenOrig = *destLen;
-  SizeT srcLenOrig = *srcLen;
+  const SizeT destLenOrig = *destLen;
+  const SizeT srcLenOrig = *srcLen;
 
   *destLen = 0;
   *srcLen = 0;
@@ -597,39 +597,26 @@ static SRes MixCoder_Code(CMixCoder *p,
   if (p->outBuf)
   {
     SRes res;
-    SizeT destLen2, srcLen2;
+    SizeT destLen2;
     int wasFinished;
     
     PRF_STR("------- MixCoder Single ----------")
       
-    srcLen2 = srcLenOrig;
     destLen2 = destLenOrig;
-    
+    if (p->numCoders != 1)
     {
-      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);
+      if (destLen2 < p->outWritten)
+        return SZ_ERROR_FAIL;
+      destLen2 -= p->outWritten;
     }
-    
-    p->res = res;
-    
-    /*
-    if (wasFinished)
-      p->status = CODER_STATUS_FINISHED_WITH_MARK;
-    else
+    *srcLen = srcLenOrig;
     {
-      if (res == SZ_OK)
-        if (destLen2 != destLenOrig)
-          p->status = CODER_STATUS_NEEDS_MORE_INPUT;
+      IStateCoder *coder = &p->coders[0];
+      res = coder->Code2(coder->p, NULL, &destLen2, src, srcLen, srcWasFinished, finishMode, &p->status);
     }
-    */
-
-    
-    *srcLen = srcLen2;
-    src += srcLen2;
+    p->res = res;
     p->outWritten += destLen2;
+    wasFinished = (p->status == CODER_STATUS_FINISHED_WITH_MARK);
     
     if (res != SZ_OK || srcWasFinished || wasFinished)
       p->wasFinished = True;
@@ -1016,8 +1003,8 @@ 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;
+  const SizeT destLenOrig = *destLen;
+  const SizeT srcLenOrig = *srcLen;
   *destLen = 0;
   *srcLen = 0;
   *status = CODER_STATUS_NOT_SPECIFIED;