96 files changed, 3079 insertions, 1670 deletions
diff --git a/CPP/7zip/7zip_gcc.mak b/CPP/7zip/7zip_gcc.mak
index bcb06a0..12f1ef2 100644
--- a/CPP/7zip/7zip_gcc.mak
+++ b/CPP/7zip/7zip_gcc.mak
@@ -1245,8 +1245,6 @@ $O/Sha512.o: ../../../../C/Sha512.c
        $(CC) $(CFLAGS) $<
 $O/Sha512Opt.o: ../../../../C/Sha512Opt.c
        $(CC) $(CFLAGS) $<
-$O/Sort.o: ../../../../C/Sort.c
-        $(CC) $(CFLAGS) $<
 $O/SwapBytes.o: ../../../../C/SwapBytes.c
        $(CC) $(CFLAGS) $<
 $O/Xxh64.o: ../../../../C/Xxh64.c
@@ -1285,6 +1283,8 @@ $O/Sha1Opt.o: ../../../../Asm/x86/Sha1Opt.asm
        $(MY_ASM) $(AFLAGS) $<
 $O/Sha256Opt.o: ../../../../Asm/x86/Sha256Opt.asm
        $(MY_ASM) $(AFLAGS) $<
+$O/Sort.o: ../../../../Asm/x86/Sort.asm
+        $(MY_ASM) $(AFLAGS) $<
 ifndef USE_JWASM
 USE_X86_ASM_AES=1
@@ -1299,6 +1299,8 @@ $O/Sha1Opt.o: ../../../../C/Sha1Opt.c
        $(CC) $(CFLAGS) $<
 $O/Sha256Opt.o: ../../../../C/Sha256Opt.c
        $(CC) $(CFLAGS) $<
+$O/Sort.o: ../../../../C/Sort.c
+        $(CC) $(CFLAGS) $<
 endif
diff --git a/CPP/7zip/Archive/7z/7zCompressionMode.h b/CPP/7zip/Archive/7z/7zCompressionMode.h
index 737722d..ecfee7c 100644
--- a/CPP/7zip/Archive/7z/7zCompressionMode.h
+++ b/CPP/7zip/Archive/7z/7zCompressionMode.h
@@ -59,6 +59,7 @@ struct CCompressionMethodMode
  bool NumThreads_WasForced;
  bool MultiThreadMixer;
  UInt32 NumThreads;
+  UInt32 NumThreadGroups;
  #endif
  UString Password; // _Wipe
@@ -74,6 +75,7 @@ struct CCompressionMethodMode
      , NumThreads_WasForced(false)
      , MultiThreadMixer(true)
      , NumThreads(1)
+      , NumThreadGroups(0)
      #endif
      , MemoryUsageLimit((UInt64)1 << 30)
  {}
diff --git a/CPP/7zip/Archive/7z/7zHandlerOut.cpp b/CPP/7zip/Archive/7z/7zHandlerOut.cpp
index ea5ea0f..c1c2b63 100644
--- a/CPP/7zip/Archive/7z/7zHandlerOut.cpp
+++ b/CPP/7zip/Archive/7z/7zHandlerOut.cpp
@@ -111,8 +111,8 @@ HRESULT CHandler::SetMainMethod(CCompressionMethodMode &methodMode)
    }
  }
-  const UInt64 kSolidBytes_Min = (1 << 24);
+  const UInt64 kSolidBytes_Min = 1 << 24;
-  const UInt64 kSolidBytes_Max = ((UInt64)1 << 32);
+  const UInt64 kSolidBytes_Max = (UInt64)1 << 32;  // for non-LZMA2 methods
  bool needSolid = false;
  
@@ -122,22 +122,24 @@ HRESULT CHandler::SetMainMethod(CCompressionMethodMode &methodMode)
    SetGlobalLevelTo(oneMethodInfo);
-    #ifndef Z7_ST
+#ifndef Z7_ST
    const bool numThreads_WasSpecifiedInMethod = (oneMethodInfo.Get_NumThreads() >= 0);
    if (!numThreads_WasSpecifiedInMethod)
    {
      // here we set the (NCoderPropID::kNumThreads) property in each method, only if there is no such property already
      CMultiMethodProps::SetMethodThreadsTo_IfNotFinded(oneMethodInfo, methodMode.NumThreads);
    }
-    #endif
+    if (methodMode.NumThreadGroups > 1)
+      CMultiMethodProps::Set_Method_NumThreadGroups_IfNotFinded(oneMethodInfo, methodMode.NumThreadGroups);
+#endif
    CMethodFull &methodFull = methodMode.Methods.AddNew();
    RINOK(PropsMethod_To_FullMethod(methodFull, oneMethodInfo))
-    #ifndef Z7_ST
+#ifndef Z7_ST
    methodFull.Set_NumThreads = true;
    methodFull.NumThreads = methodMode.NumThreads;
-    #endif
+#endif
    if (methodFull.Id != k_Copy)
      needSolid = true;
@@ -217,19 +219,18 @@ HRESULT CHandler::SetMainMethod(CCompressionMethodMode &methodMode)
      // here we get real chunkSize
      cs = oneMethodInfo.Get_Xz_BlockSize();
      if (dicSize > cs)
-        dicSize = cs;
+          dicSize = cs;
-      const UInt64 kSolidBytes_Lzma2_Max = ((UInt64)1 << 34);
+      const UInt64 kSolidBytes_Lzma2_Max = (UInt64)1 << 34;
      if (numSolidBytes > kSolidBytes_Lzma2_Max)
-        numSolidBytes = kSolidBytes_Lzma2_Max;
+          numSolidBytes = kSolidBytes_Lzma2_Max;
      methodFull.Set_NumThreads = false; // we don't use ICompressSetCoderMt::SetNumberOfThreads() for LZMA2 encoder
      #ifndef Z7_ST
      if (!numThreads_WasSpecifiedInMethod
          && !methodMode.NumThreads_WasForced
-          && methodMode.MemoryUsageLimit_WasSet
+          && methodMode.MemoryUsageLimit_WasSet)
-          )
      {
        const UInt32 lzmaThreads = oneMethodInfo.Get_Lzma_NumThreads();
        const UInt32 numBlockThreads_Original = methodMode.NumThreads / lzmaThreads;
@@ -273,14 +274,14 @@ HRESULT CHandler::SetMainMethod(CCompressionMethodMode &methodMode)
    {
      numSolidBytes = (UInt64)dicSize << 7;
      if (numSolidBytes > kSolidBytes_Max)
-        numSolidBytes = kSolidBytes_Max;
+          numSolidBytes = kSolidBytes_Max;
    }
    if (_numSolidBytesDefined)
      continue;
    if (numSolidBytes < kSolidBytes_Min)
-      numSolidBytes = kSolidBytes_Min;
+        numSolidBytes = kSolidBytes_Min;
    _numSolidBytes = numSolidBytes;
    _numSolidBytesDefined = true;
  }
@@ -704,6 +705,9 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
    methodMode.NumThreads = numThreads;
    methodMode.NumThreads_WasForced = _numThreads_WasForced;
    methodMode.MultiThreadMixer = _useMultiThreadMixer;
+#ifdef _WIN32
+    methodMode.NumThreadGroups = _numThreadGroups; // _change it
+#endif
    // headerMethod.NumThreads = 1;
    headerMethod.MultiThreadMixer = _useMultiThreadMixer;
  }
diff --git a/CPP/7zip/Archive/ArHandler.cpp b/CPP/7zip/Archive/ArHandler.cpp
index 95e4719..944eec4 100644
--- a/CPP/7zip/Archive/ArHandler.cpp
+++ b/CPP/7zip/Archive/ArHandler.cpp
@@ -325,7 +325,7 @@ HRESULT CHandler::ParseLongNames(IInStream *stream)
 {
  unsigned i;
  for (i = 0; i < _items.Size(); i++)
-    if (_items[i].Name == "//")
+    if (_items[i].Name.IsEqualTo("//"))
      break;
  if (i == _items.Size())
    return S_OK;
@@ -378,7 +378,7 @@ void CHandler::ChangeDuplicateNames()
    if (item.Name[0] == '/')
      continue;
    CItem &prev = _items[i - 1];
-    if (item.Name == prev.Name)
+    if (item.Name.IsEqualTo(prev.Name))
    {
      if (prev.SameNameIndex < 0)
        prev.SameNameIndex = 0;
@@ -448,9 +448,9 @@ static UInt32 Get32(const Byte *p, unsigned be) { if (be) return GetBe32(p); ret
 HRESULT CHandler::ParseLibSymbols(IInStream *stream, unsigned fileIndex)
 {
  CItem &item = _items[fileIndex];
-  if (item.Name != "/" &&
+  if (!item.Name.IsEqualTo("/") &&
-      item.Name != "__.SYMDEF"  &&
+      !item.Name.IsEqualTo("__.SYMDEF")  &&
-      item.Name != "__.SYMDEF SORTED")
+      !item.Name.IsEqualTo("__.SYMDEF SORTED"))
    return S_OK;
  if (item.Size > ((UInt32)1 << 30) ||
      item.Size < 4)
@@ -462,7 +462,7 @@ HRESULT CHandler::ParseLibSymbols(IInStream *stream, unsigned fileIndex)
 
  size_t pos = 0;
-  if (item.Name != "/")
+  if (!item.Name.IsEqualTo("/"))
  {
    // "__.SYMDEF" parsing (BSD)
    unsigned be;
@@ -603,7 +603,7 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
    if (_longNames_FileIndex >= 0)
      _items.Delete((unsigned)_longNames_FileIndex);
-    if (!_items.IsEmpty() && _items[0].Name == "debian-binary")
+    if (!_items.IsEmpty() && _items[0].Name.IsEqualTo("debian-binary"))
    {
      _type = kType_Deb;
      _items.DeleteFrontal(1);
diff --git a/CPP/7zip/Archive/Bz2Handler.cpp b/CPP/7zip/Archive/Bz2Handler.cpp
index ffd7ad0..02eeee6 100644
--- a/CPP/7zip/Archive/Bz2Handler.cpp
+++ b/CPP/7zip/Archive/Bz2Handler.cpp
@@ -427,9 +427,13 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
    }
    CMethodProps props2 = _props;
-    #ifndef Z7_ST
+#ifndef Z7_ST
    props2.AddProp_NumThreads(_props._numThreads);
-    #endif
+#ifdef _WIN32
+    if (_props._numThreadGroups > 1)
+      props2.AddProp32(NCoderPropID::kNumThreadGroups, _props._numThreadGroups);
+#endif
+#endif
    return UpdateArchive(size, outStream, props2, updateCallback);
  }
diff --git a/CPP/7zip/Archive/ComHandler.cpp b/CPP/7zip/Archive/ComHandler.cpp
index 82d939d..144369e 100644
--- a/CPP/7zip/Archive/ComHandler.cpp
+++ b/CPP/7zip/Archive/ComHandler.cpp
@@ -68,7 +68,7 @@ namespace NItemType
  static const Byte kRootStorage = 5;
 }
-static const UInt32 kNameSizeMax = 64;
+static const unsigned kNameSizeMax = 64;
 struct CItem
 {
@@ -98,30 +98,30 @@ struct CRef
 class CDatabase
 {
-  UInt32 NumSectorsInMiniStream;
  CObjArray<UInt32> MiniSids;
  HRESULT AddNode(int parent, UInt32 did);
-public:
+public:
  CObjArray<UInt32> Fat;
-  UInt32 FatSize;
-  
  CObjArray<UInt32> Mat;
-  UInt32 MatSize;
  CObjectVector<CItem> Items;
  CRecordVector<CRef> Refs;
+private:
+  UInt32 NumSectorsInMiniStream;
+public:
+  UInt32 MatSize;
+  UInt32 FatSize;
  UInt32 LongStreamMinSize;
  unsigned SectorSizeBits;
  unsigned MiniSectorSizeBits;
  Int32 MainSubfile;
+  EType Type;
  UInt64 PhySize;
  UInt64 PhySize_Aligned;
-  EType Type;
  bool IsNotArcType() const
  {
@@ -148,14 +148,14 @@ public:
  UInt64 GetItemPackSize(UInt64 size) const
  {
-    UInt64 mask = ((UInt64)1 << (IsLargeStream(size) ? SectorSizeBits : MiniSectorSizeBits)) - 1;
+    const UInt64 mask = ((UInt32)1 << (IsLargeStream(size) ? SectorSizeBits : MiniSectorSizeBits)) - 1;
    return (size + mask) & ~mask;
  }
  bool GetMiniCluster(UInt32 sid, UInt64 &res) const
  {
-    unsigned subBits = SectorSizeBits - MiniSectorSizeBits;
+    const unsigned subBits = SectorSizeBits - MiniSectorSizeBits;
-    UInt32 fid = sid >> subBits;
+    const UInt32 fid = sid >> subBits;
    if (fid >= NumSectorsInMiniStream)
      return false;
    res = (((UInt64)MiniSids[fid] + 1) << subBits) + (sid & ((1 << subBits) - 1));
@@ -177,7 +177,7 @@ HRESULT CDatabase::ReadSector(IInStream *inStream, Byte *buf, unsigned sectorSiz
 HRESULT CDatabase::ReadIDs(IInStream *inStream, Byte *buf, unsigned sectorSizeBits, UInt32 sid, UInt32 *dest)
 {
  RINOK(ReadSector(inStream, buf, sectorSizeBits, sid))
-  UInt32 sectorSize = (UInt32)1 << sectorSizeBits;
+  const UInt32 sectorSize = (UInt32)1 << sectorSizeBits;
  for (UInt32 t = 0; t < sectorSize; t += 4)
    *dest++ = Get32(buf + t);
  return S_OK;
@@ -373,7 +373,7 @@ UString CDatabase::GetItemPath(UInt32 index) const
 HRESULT CDatabase::Update_PhySize_WithItem(unsigned index)
 {
  const CItem &item = Items[index];
-  bool isLargeStream = (index == 0 || IsLargeStream(item.Size));
+  const bool isLargeStream = (index == 0 || IsLargeStream(item.Size));
  if (!isLargeStream)
    return S_OK;
  const unsigned bsLog = isLargeStream ? SectorSizeBits : MiniSectorSizeBits;
@@ -527,6 +527,10 @@ HRESULT CDatabase::Open(IInStream *inStream)
      {
        CItem item;
        item.Parse(sect + i, mode64bit);
+        // we use (item.Size) check here.
+        // so we don't need additional overflow checks for (item.Size +) in another code
+        if (item.Size >= ((UInt64)1 << 63))
+          return S_FALSE;
        Items.Add(item);
      }
      sid = Fat[sid];
@@ -767,11 +771,8 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
  UInt64 totalPackSize;
  totalSize = totalPackSize = 0;
  
-  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+  CMyComPtr2_Create<ICompressCoder, NCompress::CCopyCoder> copyCoder;
-  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+  CMyComPtr2_Create<ICompressProgressInfo, CLocalProgress> lps;
-  CLocalProgress *lps = new CLocalProgress;
-  CMyComPtr<ICompressProgressInfo> progress = lps;
  lps->Init(extractCallback, false);
  for (i = 0; i < numItems; i++)
@@ -781,7 +782,8 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
    RINOK(lps->SetCur())
    const UInt32 index = allFilesMode ? i : indices[i];
    const CItem &item = _db.Items[_db.Refs[index].Did];
+    Int32 res;
+   {
    CMyComPtr<ISequentialOutStream> outStream;
    const Int32 askMode = testMode ?
        NExtract::NAskMode::kTest :
@@ -801,7 +803,7 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
    if (!testMode && !outStream)
      continue;
    RINOK(extractCallback->PrepareOperation(askMode))
-    Int32 res = NExtract::NOperationResult::kDataError;
+    res = NExtract::NOperationResult::kDataError;
    CMyComPtr<ISequentialInStream> inStream;
    HRESULT hres = GetStream(index, &inStream);
    if (hres == S_FALSE)
@@ -813,12 +815,12 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
      RINOK(hres)
      if (inStream)
      {
-        RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
+        RINOK(copyCoder.Interface()->Code(inStream, outStream, NULL, NULL, lps))
-        if (copyCoderSpec->TotalSize == item.Size)
+        if (copyCoder->TotalSize == item.Size)
          res = NExtract::NOperationResult::kOK;
      }
    }
-    outStream.Release();
+   }
    RINOK(extractCallback->SetOperationResult(res))
  }
  return S_OK;
diff --git a/CPP/7zip/Archive/Common/HandlerOut.cpp b/CPP/7zip/Archive/Common/HandlerOut.cpp
index 17fed67..5a11e30 100644
--- a/CPP/7zip/Archive/Common/HandlerOut.cpp
+++ b/CPP/7zip/Archive/Common/HandlerOut.cpp
@@ -4,8 +4,6 @@
 #include "../../../Common/StringToInt.h"
-#include "../Common/ParseProperties.h"
 #include "HandlerOut.h"
 namespace NArchive {
@@ -82,6 +80,7 @@ bool ParseSizeString(const wchar_t *s, const PROPVARIANT &prop, UInt64 percentsB
  return true;
 }
 bool CCommonMethodProps::SetCommonProperty(const UString &name, const PROPVARIANT &value, HRESULT &hres)
 {
  hres = S_OK;
@@ -151,6 +150,11 @@ void CMultiMethodProps::SetMethodThreadsTo_Replace(CMethodProps &oneMethodInfo,
  SetMethodProp32_Replace(oneMethodInfo, NCoderPropID::kNumThreads, numThreads);
 }
+void CMultiMethodProps::Set_Method_NumThreadGroups_IfNotFinded(CMethodProps &oneMethodInfo, UInt32 numThreadGroups)
+{
+  SetMethodProp32(oneMethodInfo, NCoderPropID::kNumThreadGroups, numThreadGroups);
+}
 #endif // Z7_ST
diff --git a/CPP/7zip/Archive/Common/HandlerOut.h b/CPP/7zip/Archive/Common/HandlerOut.h
index 9340e1b..3122b05 100644
--- a/CPP/7zip/Archive/Common/HandlerOut.h
+++ b/CPP/7zip/Archive/Common/HandlerOut.h
@@ -17,11 +17,21 @@ protected:
  void InitCommon()
  {
    // _Write_MTime = true;
-    #ifndef Z7_ST
+    {
-    _numProcessors = _numThreads = NWindows::NSystem::GetNumberOfProcessors();
+#ifndef Z7_ST
-    _numThreads_WasForced = false;
+      _numThreads_WasForced = false;
-    #endif
+      UInt32 numThreads;
+#ifdef _WIN32
+      NWindows::NSystem::CProcessAffinity aff;
+      numThreads = aff.Load_and_GetNumberOfThreads();
+      _numThreadGroups = aff.IsGroupMode ? aff.Groups.GroupSizes.Size() : 0;
+#else
+      numThreads = NWindows::NSystem::GetNumberOfProcessors();
+#endif // _WIN32
+      _numProcessors = _numThreads = numThreads;
+#endif // Z7_ST
+    }
+    
    size_t memAvail = (size_t)sizeof(size_t) << 28;
    _memAvail = memAvail;
    _memUsage_Compress = memAvail;
@@ -46,11 +56,14 @@ protected:
  }
 public:
-  #ifndef Z7_ST
+#ifndef Z7_ST
  UInt32 _numThreads;
  UInt32 _numProcessors;
+#ifdef _WIN32
+  UInt32 _numThreadGroups;
+#endif
  bool _numThreads_WasForced;
-  #endif
+#endif
  bool _memUsage_WasSet;
  UInt64 _memUsage_Compress;
@@ -80,10 +93,12 @@ public:
  
  void SetGlobalLevelTo(COneMethodInfo &oneMethodInfo) const;
-  #ifndef Z7_ST
+#ifndef Z7_ST
  static void SetMethodThreadsTo_IfNotFinded(CMethodProps &props, UInt32 numThreads);
  static void SetMethodThreadsTo_Replace(CMethodProps &props, UInt32 numThreads);
-  #endif
+  
+  static void Set_Method_NumThreadGroups_IfNotFinded(CMethodProps &props, UInt32 numThreadGroups);
+#endif
  unsigned GetNumEmptyMethods() const
diff --git a/CPP/7zip/Archive/Common/ItemNameUtils.cpp b/CPP/7zip/Archive/Common/ItemNameUtils.cpp
index 8caf1d1..150efc9 100644
--- a/CPP/7zip/Archive/Common/ItemNameUtils.cpp
+++ b/CPP/7zip/Archive/Common/ItemNameUtils.cpp
@@ -47,6 +47,25 @@ UString GetOsPath_Remove_TailSlash(const UString &name)
 }
+#if WCHAR_PATH_SEPARATOR != L'/'
+void ReplaceToWinSlashes(UString &name, bool useBackslashReplacement)
+{
+  // name.Replace(kUnixPathSepar, kOsPathSepar);
+  const unsigned len = name.Len();
+  for (unsigned i = 0; i < len; i++)
+  {
+    wchar_t c = name[i];
+    if (c == L'/')
+      c = WCHAR_PATH_SEPARATOR;
+    else if (useBackslashReplacement && c == L'\\')
+      c = WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT; // WSL scheme
+    else
+      continue;
+    name.ReplaceOneCharAtPos(i, c);
+  }
+}
+#endif
 void ReplaceToOsSlashes_Remove_TailSlash(UString &name, bool
    #if WCHAR_PATH_SEPARATOR != L'/'
      useBackslashReplacement
@@ -57,21 +76,7 @@ void ReplaceToOsSlashes_Remove_TailSlash(UString &name, bool
    return;
  #if WCHAR_PATH_SEPARATOR != L'/'
-  {
+  ReplaceToWinSlashes(name, useBackslashReplacement);
-    // name.Replace(kUnixPathSepar, kOsPathSepar);
-    const unsigned len = name.Len();
-    for (unsigned i = 0; i < len; i++)
-    {
-      wchar_t c = name[i];
-      if (c == L'/')
-        c = WCHAR_PATH_SEPARATOR;
-      else if (useBackslashReplacement && c == L'\\')
-        c = WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT; // WSL scheme
-      else
-        continue;
-      name.ReplaceOneCharAtPos(i, c);
-    }
-  }
  #endif
    
  if (name.Back() == kOsPathSepar)
diff --git a/CPP/7zip/Archive/Common/ItemNameUtils.h b/CPP/7zip/Archive/Common/ItemNameUtils.h
index 8ab9b61..cea8dcc 100644
--- a/CPP/7zip/Archive/Common/ItemNameUtils.h
+++ b/CPP/7zip/Archive/Common/ItemNameUtils.h
@@ -13,6 +13,9 @@ void ReplaceSlashes_OsToUnix(UString &name);
 UString GetOsPath(const UString &name);
 UString GetOsPath_Remove_TailSlash(const UString &name);
  
+#if WCHAR_PATH_SEPARATOR != L'/'
+void ReplaceToWinSlashes(UString &name, bool useBackslashReplacement);
+#endif
 void ReplaceToOsSlashes_Remove_TailSlash(UString &name, bool useBackslashReplacement = false);
 void NormalizeSlashes_in_FileName_for_OsPath(wchar_t *s, unsigned len);
 void NormalizeSlashes_in_FileName_for_OsPath(UString &name);
diff --git a/CPP/7zip/Archive/CpioHandler.cpp b/CPP/7zip/Archive/CpioHandler.cpp
index 2228040..62184f0 100644
--- a/CPP/7zip/Archive/CpioHandler.cpp
+++ b/CPP/7zip/Archive/CpioHandler.cpp
@@ -437,7 +437,14 @@ HRESULT CInArchive::GetNextItem()
    return S_OK;
  /* v23.02: we have disabled rDevMinor check because real file
-     from Apple contains rDevMinor==255 by some unknown reason */
+     from Apple contains rDevMinor==255 by some unknown reason
+     cpio 2.13 and older versions: it copies stat::st_rdev to archive.
+        and stat::st_rdev can be non-zero for some old linux/filesystems cases for regular files.
+     cpio 2.14 (2023) copies st_rdev to archive only if (S_ISBLK (st->st_mode) || S_ISCHR (st->st_mode))
+     v25.00: we have disabled RDevMajor check here to support some rare case created by cpio 2.13- with old linux.
+     But we still keep full check in IsArc_Cpio() to reduce false cpio detection cases.
+  */
+#if 0 // 0 : to disable check to support some old linux cpio archives.
  if (item.RDevMajor != 0
      // || item.RDevMinor != 0
      )
@@ -446,6 +453,7 @@ HRESULT CInArchive::GetNextItem()
        !MY_LIN_S_ISBLK(item.Mode))
      return S_OK;
  }
+#endif
  // Size must be 0 for FIFOs and directories
  if (item.IsDir() || MY_LIN_S_ISFIFO(item.Mode))
@@ -873,17 +881,13 @@ Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
  {
    case kpidPath:
    {
-      UString res;
+#ifdef _WIN32
-      bool needConvert = true;
+      UString u;
-      #ifdef _WIN32
+      ConvertUTF8ToUnicode(item.Name, u);
-      // if (
+#else
-      ConvertUTF8ToUnicode(item.Name, res);
+      const UString u = MultiByteToUnicodeString(item.Name, CP_OEMCP);
-      // )
+#endif
-        needConvert = false;
+      prop = NItemName::GetOsPath(u);
-      #endif
-      if (needConvert)
-        res = MultiByteToUnicodeString(item.Name, CP_OEMCP);
-      prop = NItemName::GetOsPath(res);
      break;
    }
    case kpidIsDir: prop = item.IsDir(); break;
@@ -921,16 +925,12 @@ Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
        s.SetFrom_CalcLen((const char *)(const void *)(const Byte *)item.Data, (unsigned)item.Data.Size());
        if (s.Len() == item.Data.Size())
        {
+#ifdef _WIN32
          UString u;
-          bool needConvert = true;
+          ConvertUTF8ToUnicode(item.Name, u);
-          #ifdef _WIN32
+#else
-            // if (
+          const UString u = MultiByteToUnicodeString(s, CP_OEMCP);
-            ConvertUTF8ToUnicode(item.Name, u);
+#endif
-            // )
-            needConvert = false;
-          #endif
-          if (needConvert)
-            u = MultiByteToUnicodeString(s, CP_OEMCP);
          prop = u;
        }
      }
diff --git a/CPP/7zip/Archive/DmgHandler.cpp b/CPP/7zip/Archive/DmgHandler.cpp
index 3901192..9079dc7 100644
--- a/CPP/7zip/Archive/DmgHandler.cpp
+++ b/CPP/7zip/Archive/DmgHandler.cpp
@@ -444,7 +444,7 @@ const char *Find_Apple_FS_Ext(const AString &name)
  {
    const CAppleName &a = k_Names[i];
    if (a.Ext)
-      if (name == a.AppleName)
+      if (name.IsEqualTo(a.AppleName))
        return a.Ext;
  }
  return NULL;
@@ -784,7 +784,7 @@ static const CXmlItem *FindKeyPair(const CXmlItem &item, const char *key, const
  for (unsigned i = 0; i + 1 < item.SubItems.Size(); i++)
  {
    const CXmlItem &si = item.SubItems[i];
-    if (si.IsTagged("key") && si.GetSubString() == key)
+    if (si.IsTagged("key") && si.GetSubString().IsEqualTo(key))
    {
      const CXmlItem *si_1 = &item.SubItems[i + 1];
      if (si_1->IsTagged(nextTag))
@@ -1251,7 +1251,7 @@ HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *openArchiveCall
 #endif
    }
    
-    if (xml.Root.Name != "plist")
+    if (!xml.Root.Name.IsEqualTo("plist"))
      return S_FALSE;
    
    const CXmlItem *dictItem = xml.Root.FindSubTag_GetPtr("dict");
diff --git a/CPP/7zip/Archive/FatHandler.cpp b/CPP/7zip/Archive/FatHandler.cpp
index b31ee4f..18fce91 100644
--- a/CPP/7zip/Archive/FatHandler.cpp
+++ b/CPP/7zip/Archive/FatHandler.cpp
@@ -2,13 +2,12 @@
 #include "StdAfx.h"
-// #include <stdio.h>
 #include "../../../C/CpuArch.h"
 #include "../../Common/ComTry.h"
 #include "../../Common/IntToString.h"
 #include "../../Common/MyBuffer.h"
+#include "../../Common/MyBuffer2.h"
 #include "../../Common/MyCom.h"
 #include "../../Common/StringConvert.h"
@@ -22,14 +21,19 @@
 #include "../Compress/CopyCoder.h"
-#include "Common/DummyOutStream.h"
+#include "Common/ItemNameUtils.h"
 #define Get16(p) GetUi16(p)
 #define Get32(p) GetUi32(p)
 #define Get16a(p) GetUi16a(p)
 #define Get32a(p) GetUi32a(p)
-#define PRF(x) /* x */
+#if 0
+#include <stdio.h>
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
 namespace NArchive {
 namespace NFat {
@@ -38,35 +42,34 @@ static const UInt32 kFatItemUsedByDirMask = (UInt32)1 << 31;
 struct CHeader
 {
-  UInt32 NumSectors;
+  Byte NumFatBits;
-  UInt16 NumReservedSectors;
+  Byte SectorSizeLog;
+  Byte SectorsPerClusterLog;
+  Byte ClusterSizeLog;
  Byte NumFats;
+  Byte MediaType;
+  bool VolFieldsDefined;
+  bool HeadersWarning;
+  UInt32 FatSize;
+  UInt32 BadCluster;
+  UInt16 NumReservedSectors;
+  UInt32 NumSectors;
  UInt32 NumFatSectors;
  UInt32 RootDirSector;
  UInt32 NumRootDirSectors;
  UInt32 DataSector;
-  UInt32 FatSize;
-  UInt32 BadCluster;
-  Byte NumFatBits;
-  Byte SectorSizeLog;
-  Byte SectorsPerClusterLog;
-  Byte ClusterSizeLog;
-  
  UInt16 SectorsPerTrack;
  UInt16 NumHeads;
  UInt32 NumHiddenSectors;
-  bool VolFieldsDefined;
-  bool HeadersWarning;
  
  UInt32 VolId;
  // Byte VolName[11];
  // Byte FileSys[8];
  // Byte OemName[5];
-  Byte MediaType;
  // 32-bit FAT
  UInt16 Flags;
@@ -104,15 +107,8 @@ struct CHeader
  bool Parse(const Byte *p);
 };
-static int GetLog(UInt32 num)
-{
-  for (int i = 0; i < 31; i++)
-    if (((UInt32)1 << i) == num)
-      return i;
-  return -1;
-}
-static const UInt32 kHeaderSize = 512;
+static const unsigned kHeaderSize = 512;
 API_FUNC_IsArc IsArc_Fat(const Byte *p, size_t size);
 API_FUNC_IsArc IsArc_Fat(const Byte *p, size_t size)
@@ -125,7 +121,7 @@ API_FUNC_IsArc IsArc_Fat(const Byte *p, size_t size)
 bool CHeader::Parse(const Byte *p)
 {
-  if (p[0x1FE] != 0x55 || p[0x1FF] != 0xAA)
+  if (Get16(p + 0x1FE) != 0xAA55)
    return false;
  HeadersWarning = false;
@@ -139,22 +135,40 @@ bool CHeader::Parse(const Byte *p)
  }
  {
    {
-      const UInt32 val32 = Get16(p + 11);
+      const unsigned num = Get16(p + 11);
-      const int s = GetLog(val32);
+      unsigned i = 9;
-      if (s < 9 || s > 12)
+      unsigned m = 1 << i;
-        return false;
+      for (;;)
-      SectorSizeLog = (Byte)s;
+      {
+        if (m == num)
+          break;
+        m <<= 1;
+        if (++i > 12)
+          return false;
+      }
+      SectorSizeLog = (Byte)i;
    }
    {
-      const UInt32 val32 = p[13];
+      const unsigned num = p[13];
-      const int s = GetLog(val32);
+      unsigned i = 0;
-      if (s < 0)
+      unsigned m = 1 << i;
+      for (;;)
+      {
+        if (m == num)
+          break;
+        m <<= 1;
+        if (++i > 7)
+          return false;
+      }
+      SectorsPerClusterLog = (Byte)i;
+      i += SectorSizeLog;
+      ClusterSizeLog = (Byte)i;
+      // (2^15 = 32 KB is safe cluster size that is suported by all system.
+      // (2^16 = 64 KB is supported by some systems
+      // (128 KB / 256 KB) can be created by some tools, but it is not supported by many tools.
+      if (i > 18) // 256 KB
        return false;
-      SectorsPerClusterLog = (Byte)s;
    }
-    ClusterSizeLog = (Byte)(SectorSizeLog + SectorsPerClusterLog);
-    if (ClusterSizeLog > 24)
-      return false;
  }
  NumReservedSectors = Get16(p + 14);
@@ -169,7 +183,7 @@ bool CHeader::Parse(const Byte *p)
  const bool isOkOffset = (codeOffset == 0)
      || (codeOffset == (p[0] == 0xEB ? 2 : 3));
-  const UInt16 numRootDirEntries = Get16(p + 17);
+  const unsigned numRootDirEntries = Get16(p + 17);
  if (numRootDirEntries == 0)
  {
    if (codeOffset < 90 && !isOkOffset)
@@ -183,10 +197,10 @@ bool CHeader::Parse(const Byte *p)
    if (codeOffset < 62 - 24 && !isOkOffset)
      return false;
    NumFatBits = 0;
-    const UInt32 mask = (1 << (SectorSizeLog - 5)) - 1;
+    const unsigned mask = (1u << (SectorSizeLog - 5)) - 1;
-    if ((numRootDirEntries & mask) != 0)
+    if (numRootDirEntries & mask)
      return false;
-    NumRootDirSectors = (numRootDirEntries + mask) >> (SectorSizeLog - 5);
+    NumRootDirSectors = (numRootDirEntries /* + mask */) >> (SectorSizeLog - 5);
  }
  NumSectors = Get16(p + 19);
@@ -198,7 +212,6 @@ bool CHeader::Parse(const Byte *p)
  else if (IsFat32())
    return false;
  */
  MediaType = p[21];
  NumFatSectors = Get16(p + 22);
  SectorsPerTrack = Get16(p + 24);
@@ -222,7 +235,7 @@ bool CHeader::Parse(const Byte *p)
      return false;
    RootCluster = Get32(p + 8);
    FsInfoSector = Get16(p + 12);
-    for (int i = 16; i < 28; i++)
+    for (unsigned i = 16; i < 28; i++)
      if (p[i] != 0)
        return false;
    p += 28;
@@ -260,7 +273,7 @@ bool CHeader::Parse(const Byte *p)
    if (numClusters >= 0xFFF5)
      return false;
    NumFatBits = (Byte)(numClusters < 0xFF5 ? 12 : 16);
-    BadCluster &= ((1 << NumFatBits) - 1);
+    BadCluster &= (((UInt32)1 << NumFatBits) - 1);
  }
  FatSize = numClusters + 2;
@@ -283,103 +296,157 @@ bool CHeader::Parse(const Byte *p)
  return true;
 }
-struct CItem
+class CItem
 {
-  UString UName;
+  Z7_CLASS_NO_COPY(CItem)
-  char DosName[11];
+public:
+  UInt32 Size;
+  Byte Attrib;
  Byte CTime2;
-  UInt32 CTime;
-  UInt32 MTime;
  UInt16 ADate;
-  Byte Attrib;
+  CByteBuffer LongName; // if LongName.Size() == 0 : no long name
+                        // if LongName.Size() != 0 : it's NULL terminated UTF16-LE string.
+  char DosName[11];
  Byte Flags;
-  UInt32 Size;
+  UInt32 MTime;
+  UInt32 CTime;
  UInt32 Cluster;
  Int32 Parent;
+  CItem() {}
  // NT uses Flags to store Low Case status
  bool NameIsLow() const { return (Flags & 0x8) != 0; }
  bool ExtIsLow() const { return (Flags & 0x10) != 0; }
  bool IsDir() const { return (Attrib & 0x10) != 0; }
-  UString GetShortName() const;
+  void GetShortName(UString &dest) const;
-  UString GetName() const;
+  void GetName(UString &name) const;
-  UString GetVolName() const;
 };
-static unsigned CopyAndTrim(char *dest, const char *src, unsigned size, bool toLower)
+static char *CopyAndTrim(char *dest, const char *src,
+    unsigned size, unsigned toLower)
 {
-  memcpy(dest, src, size);
+  do
-  if (toLower)
  {
-    for (unsigned i = 0; i < size; i++)
+    if (src[(size_t)size - 1] != ' ')
    {
-      char c = dest[i];
+      const unsigned range = toLower ? 'Z' - 'A' + 1 : 0;
-      if (c >= 'A' && c <= 'Z')
+      do
-        dest[i] = (char)(c + 0x20);
+      {
+        unsigned c = (Byte)*src++;
+        if ((unsigned)(c - 'A') < range)
+          c += 0x20;
+        *dest++ = (char)c;
+      }
+      while (--size);
+      break;
    }
  }
-  
+  while (--size);
-  for (unsigned i = size;;)
+  *dest = 0;
-  {
+  return dest;
-    if (i == 0)
-      return 0;
-    if (dest[i - 1] != ' ')
-      return i;
-    i--;
-  }
 }
-static UString FatStringToUnicode(const char *s)
+static void FatStringToUnicode(UString &dest, const char *s)
 {
-  return MultiByteToUnicodeString(s, CP_OEMCP);
+  MultiByteToUnicodeString2(dest, AString(s), CP_OEMCP);
 }
-UString CItem::GetShortName() const
+void CItem::GetShortName(UString &shortName) const
 {
  char s[16];
-  unsigned i = CopyAndTrim(s, DosName, 8, NameIsLow());
+  char *dest = CopyAndTrim(s, DosName, 8, NameIsLow());
-  s[i++] = '.';
+  *dest++ = '.';
-  unsigned j = CopyAndTrim(s + i, DosName + 8, 3, ExtIsLow());
+  char *dest2 = CopyAndTrim(dest, DosName + 8, 3, ExtIsLow());
-  if (j == 0)
+  if (dest == dest2)
-    i--;
+    dest[-1] = 0;
-  s[i + j] = 0;
+  FatStringToUnicode(shortName, s);
-  return FatStringToUnicode(s);
 }
-UString CItem::GetName() const
+// numWords != 0
+static unsigned ParseLongName(UInt16 *buf, unsigned numWords)
 {
-  if (!UName.IsEmpty())
+  unsigned i;
-    return UName;
+  for (i = 0; i < numWords; i++)
-  return GetShortName();
+  {
+    const unsigned c = buf[i];
+    if (c == 0)
+      break;
+    if (c == 0xFFFF)
+      return 0;
+  }
+  if (i == 0)
+    return 0;
+  buf[i] = 0;
+  numWords -= i;
+  i++;
+  if (numWords > 1)
+  {
+    numWords--;
+    buf += i;
+    do
+      if (*buf++ != 0xFFFF)
+        return 0;
+    while (--numWords);
+  }
+  return i; // it includes NULL terminator
+}
+void CItem::GetName(UString &name) const
+{
+  if (LongName.Size() >= 2)
+  {
+    const Byte * const p = LongName;
+    const unsigned numWords = ((unsigned)LongName.Size() - 2) / 2;
+    wchar_t *dest = name.GetBuf(numWords);
+    for (unsigned i = 0; i < numWords; i++)
+      dest[i] = (wchar_t)Get16(p + (size_t)i * 2);
+    name.ReleaseBuf_SetEnd(numWords);
+  }
+  else
+    GetShortName(name);
+  if (name.IsEmpty()) // it's unexpected
+    name = '_';
+  NItemName::NormalizeSlashes_in_FileName_for_OsPath(name);
 }
-UString CItem::GetVolName() const
+static void GetVolName(const char dosName[11], NWindows::NCOM::CPropVariant &prop)
 {
-  if (!UName.IsEmpty())
-    return UName;
  char s[12];
-  unsigned i = CopyAndTrim(s, DosName, 11, false);
+  CopyAndTrim(s, dosName, 11, false);
-  s[i] = 0;
+  UString u;
-  return FatStringToUnicode(s);
+  FatStringToUnicode(u, AString(s));
+  prop = u;
 }
 struct CDatabase
 {
-  CHeader Header;
  CObjectVector<CItem> Items;
  UInt32 *Fat;
+  CHeader Header;
  CMyComPtr<IInStream> InStream;
  IArchiveOpenCallback *OpenCallback;
+  CAlignedBuffer ByteBuf;
+  CByteBuffer LfnBuf;
  UInt32 NumFreeClusters;
-  bool VolItemDefined;
-  CItem VolItem;
  UInt32 NumDirClusters;
-  CByteBuffer ByteBuf;
  UInt64 NumCurUsedBytes;
  UInt64 PhySize;
+  UInt32 Vol_MTime;
+  char VolLabel[11];
+  bool VolItem_Defined;
  CDatabase(): Fat(NULL) {}
  ~CDatabase() { ClearAndClose(); }
@@ -388,7 +455,7 @@ struct CDatabase
  HRESULT OpenProgressFat(bool changeTotal = true);
  HRESULT OpenProgress();
-  UString GetItemPath(UInt32 index) const;
+  void GetItemPath(UInt32 index, UString &s) const;
  HRESULT Open();
  HRESULT ReadDir(Int32 parent, UInt32 cluster, unsigned level);
@@ -400,6 +467,7 @@ struct CDatabase
  HRESULT SeekToCluster(UInt32 cluster) { return SeekToSector(Header.ClusterToSector(cluster)); }
 };
 HRESULT CDatabase::SeekToSector(UInt32 sector)
 {
  return InStream_SeekSet(InStream, (UInt64)sector << Header.SectorSizeLog);
@@ -408,7 +476,7 @@ HRESULT CDatabase::SeekToSector(UInt32 sector)
 void CDatabase::Clear()
 {
  PhySize = 0;
-  VolItemDefined = false;
+  VolItem_Defined = false;
  NumDirClusters = 0;
  NumCurUsedBytes = 0;
@@ -440,49 +508,35 @@ HRESULT CDatabase::OpenProgress()
 {
  if (!OpenCallback)
    return S_OK;
-  UInt64 numItems = Items.Size();
+  const UInt64 numItems = Items.Size();
  return OpenCallback->SetCompleted(&numItems, &NumCurUsedBytes);
 }
-UString CDatabase::GetItemPath(UInt32 index) const
+void CDatabase::GetItemPath(UInt32 index, UString &s) const
 {
-  const CItem *item = &Items[index];
+  UString name;
-  UString name = item->GetName();
  for (;;)
  {
-    index = (UInt32)item->Parent;
+    const CItem &item = Items[index];
-    if (item->Parent < 0)
+    item.GetName(name);
-      return name;
+    if (item.Parent >= 0)
-    item = &Items[index];
+      name.InsertAtFront(WCHAR_PATH_SEPARATOR);
-    name.InsertAtFront(WCHAR_PATH_SEPARATOR);
+    s.Insert(0, name);
-    if (item->UName.IsEmpty())
+    index = (UInt32)item.Parent;
-      name.Insert(0, item->GetShortName());
+    if (item.Parent < 0)
-    else
+      break;
-      name.Insert(0, item->UName);
  }
 }
-static wchar_t *AddSubStringToName(wchar_t *dest, const Byte *p, unsigned numChars)
-{
-  for (unsigned i = 0; i < numChars; i++)
-  {
-    wchar_t c = Get16(p + i * 2);
-    if (c != 0 && c != 0xFFFF)
-      *dest++ = c;
-  }
-  *dest = 0;
-  return dest;
-}
 HRESULT CDatabase::ReadDir(Int32 parent, UInt32 cluster, unsigned level)
 {
-  unsigned startIndex = Items.Size();
+  const unsigned startIndex = Items.Size();
  if (startIndex >= (1 << 30) || level > 256)
    return S_FALSE;
-  UInt32 sectorIndex = 0;
  UInt32 blockSize = Header.ClusterSize();
-  bool clusterMode = (Header.IsFat32() || parent >= 0);
+  const bool clusterMode = (Header.IsFat32() || parent >= 0);
  if (!clusterMode)
  {
    blockSize = Header.SectorSize();
@@ -490,21 +544,26 @@ HRESULT CDatabase::ReadDir(Int32 parent, UInt32 cluster, unsigned level)
  }
  ByteBuf.Alloc(blockSize);
-  UString curName;
-  int checkSum = -1;
+  const unsigned k_NumLfnRecords_MAX = 20; // 260 symbols limit (strict limit)
-  int numLongRecords = -1;
+  // const unsigned k_NumLfnRecords_MAX = 0x40 - 1; // 1260 symbols limit (relaxed limit)
+  const unsigned k_NumLfnBytes_in_Record = 13 * 2;
+  // we reserve 2 additional bytes for NULL terminator
+  LfnBuf.Alloc(k_NumLfnRecords_MAX * k_NumLfnBytes_in_Record + 2 * 1);
  
+  UInt32 curDirBytes_read = 0;
+  UInt32 sectorIndex = 0;
+  unsigned num_lfn_records = 0;
+  unsigned lfn_RecordIndex = 0;
+  int checkSum = -1;
+  bool is_record_error = false;
  for (UInt32 pos = blockSize;; pos += 32)
  {
    if (pos == blockSize)
    {
      pos = 0;
-      if ((NumDirClusters & 0xFF) == 0)
-      {
-        RINOK(OpenProgress())
-      }
      if (clusterMode)
      {
        if (Header.IsEoc(cluster))
@@ -514,21 +573,37 @@ HRESULT CDatabase::ReadDir(Int32 parent, UInt32 cluster, unsigned level)
        PRF(printf("\nCluster = %4X", cluster));
        RINOK(SeekToCluster(cluster))
        const UInt32 newCluster = Fat[cluster];
-        if ((newCluster & kFatItemUsedByDirMask) != 0)
+        if (newCluster & kFatItemUsedByDirMask)
          return S_FALSE;
        Fat[cluster] |= kFatItemUsedByDirMask;
        cluster = newCluster;
        NumDirClusters++;
+        if ((NumDirClusters & 0xFF) == 0)
+        {
+          RINOK(OpenProgress())
+        }
        NumCurUsedBytes += Header.ClusterSize();
      }
      else if (sectorIndex++ >= Header.NumRootDirSectors)
        break;
      
+      // if (curDirBytes_read > (1u << 28)) // do we need some relaxed limit for non-MS FATs?
+      if (curDirBytes_read >= (1u << 21)) // 2MB limit from FAT specification.
+        return S_FALSE;
      RINOK(ReadStream_FALSE(InStream, ByteBuf, blockSize))
+      curDirBytes_read += blockSize;
    }
  
-    const Byte *p = ByteBuf + pos;
+    if (is_record_error)
-    
+    {
+      Header.HeadersWarning = true;
+      num_lfn_records = 0;
+      lfn_RecordIndex = 0;
+      checkSum = -1;
+    }
+    const Byte * const p = ByteBuf + pos;
+   
    if (p[0] == 0)
    {
      /*
@@ -538,125 +613,191 @@ HRESULT CDatabase::ReadDir(Int32 parent, UInt32 cluster, unsigned level)
      */
      break;
    }
-    
+    is_record_error = true;
    if (p[0] == 0xE5)
    {
-      if (numLongRecords > 0)
+      // deleted entry
-        return S_FALSE;
+      if (num_lfn_records == 0)
+        is_record_error = false;
      continue;
    }
-    
+    // else
-    Byte attrib = p[11];
-    if ((attrib & 0x3F) == 0xF)
    {
-      if (p[0] > 0x7F || Get16(p + 26) != 0)
+      const Byte attrib = p[11];
-        return S_FALSE;
+      // maybe we can use more strick check : (attrib == 0xF) ?
-      int longIndex = p[0] & 0x3F;
+      if ((attrib & 0x3F) == 0xF)
-      if (longIndex == 0)
-        return S_FALSE;
-      bool isLast = (p[0] & 0x40) != 0;
-      if (numLongRecords < 0)
      {
-        if (!isLast)
+        // long file name (LFN) entry
+        const unsigned longIndex = p[0] & 0x3F;
+        if (longIndex == 0
+            || longIndex > k_NumLfnRecords_MAX
+            || p[0] > 0x7F
+            || Get16a(p + 26) != 0 // LDIR_FstClusLO
+            )
+        {
          return S_FALSE;
-        numLongRecords = longIndex;
+          // break;
+        }
+        const bool isLast = (p[0] & 0x40) != 0;
+        if (num_lfn_records == 0)
+        {
+          if (!isLast)
+            continue; // orphan
+          num_lfn_records = longIndex;
+        }
+        else if (isLast || longIndex != lfn_RecordIndex)
+        {
+          return S_FALSE;
+          // break;
+        }
+        
+        lfn_RecordIndex = longIndex - 1;
+        
+        if (p[12] == 0)
+        {
+          Byte * const dest = LfnBuf + k_NumLfnBytes_in_Record * lfn_RecordIndex;
+          memcpy(dest,          p +  1, 5 * 2);
+          memcpy(dest +  5 * 2, p + 14, 6 * 2);
+          memcpy(dest + 11 * 2, p + 28, 2 * 2);
+          if (isLast)
+            checkSum = p[13];
+          if (checkSum == p[13])
+            is_record_error = false;
+          // else return S_FALSE;
+          continue;
+        }
+        // else
+        checkSum = -1; // we will ignore LfnBuf in this case
+        continue;
      }
-      else if (isLast || numLongRecords != longIndex)
-        return S_FALSE;
-      numLongRecords--;
      
-      if (p[12] == 0)
+      if (lfn_RecordIndex)
      {
-        wchar_t nameBuf[14];
+        Header.HeadersWarning = true;
-        wchar_t *dest;
+        // return S_FALSE;
-        
-        dest = AddSubStringToName(nameBuf, p + 1, 5);
-        dest = AddSubStringToName(dest, p + 14, 6);
-        AddSubStringToName(dest, p + 28, 2);
-        curName = nameBuf + curName;
-        if (isLast)
-          checkSum = p[13];
-        if (checkSum != p[13])
-          return S_FALSE;
      }
-    }
+      // lfn_RecordIndex = 0;
-    else
-    {
-      if (numLongRecords > 0)
-        return S_FALSE;
-      CItem item;
-      memcpy(item.DosName, p, 11);
-      if (checkSum >= 0)
+      const unsigned type_in_attrib = attrib & 0x18;
+      if (type_in_attrib == 0x18)
      {
-        Byte sum = 0;
+        // invalid directory record (both flags are set: dir_flag and volume_flag)
-        for (unsigned i = 0; i < 11; i++)
+        return S_FALSE;
-          sum = (Byte)(((sum & 1) ? 0x80 : 0) + (sum >> 1) + (Byte)item.DosName[i]);
+        // break;
-        if (sum == checkSum)
+        // continue;
-          item.UName = curName;
      }
+      if (type_in_attrib == 8) // volume_flag
-      if (item.DosName[0] == 5)
-        item.DosName[0] = (char)(Byte)0xE5;
-      item.Attrib = attrib;
-      item.Flags = p[12];
-      item.Size = Get32(p + 28);
-      item.Cluster = Get16(p + 26);
-      if (Header.NumFatBits > 16)
-        item.Cluster |= ((UInt32)Get16(p + 20) << 16);
-      else
      {
-        // OS/2 and WinNT probably can store EA (extended atributes) in that field.
+        if (!VolItem_Defined && level == 0)
+        {
+          VolItem_Defined = true;
+          memcpy(VolLabel, p, 11);
+          Vol_MTime = Get32(p + 22);
+          is_record_error = false;
+        }
      }
+      else if (memcmp(p, ".          ", 11) == 0
-      item.CTime = Get32(p + 14);
+            || memcmp(p, "..         ", 11) == 0)
-      item.CTime2 = p[13];
-      item.ADate = Get16(p + 18);
-      item.MTime = Get32(p + 22);
-      item.Parent = parent;
-      if (attrib == 8)
      {
-        VolItem = item;
+        if (num_lfn_records == 0 && type_in_attrib == 0x10) // dir_flag
-        VolItemDefined = true;
+          is_record_error = false;
      }
      else
-        if (memcmp(item.DosName, ".          ", 11) != 0 &&
-            memcmp(item.DosName, "..         ", 11) != 0)
      {
-        if (!item.IsDir())
+        CItem &item = Items.AddNew();
-          NumCurUsedBytes += Header.GetFilePackSize(item.Size);
+        memcpy(item.DosName, p, 11);
-        Items.Add(item);
+        if (item.DosName[0] == 5)
-        PRF(printf("\n%7d: %S", Items.Size(), GetItemPath(Items.Size() - 1)));
+          item.DosName[0] = (char)(Byte)0xE5; // 0xE5 is valid KANJI lead byte value.
+        item.Attrib = attrib;
+        item.Flags = p[12];
+        item.Size = Get32a(p + 28);
+        item.Cluster = Get16a(p + 26);
+        if (Header.NumFatBits > 16)
+          item.Cluster |= ((UInt32)Get16a(p + 20) << 16);
+        else
+        {
+          // OS/2 and WinNT probably can store EA (extended atributes) in that field.
+        }
+        item.CTime = Get32(p + 14);
+        item.CTime2 = p[13];
+        item.ADate = Get16a(p + 18);
+        item.MTime = Get32(p + 22);
+        item.Parent = parent;
+        {
+          if (!item.IsDir())
+            NumCurUsedBytes += Header.GetFilePackSize(item.Size);
+          // PRF(printf("\n%7d: %S", Items.Size(), GetItemPath(Items.Size() - 1)));
+          PRF(printf("\n%7d" /* ": %S" */, Items.Size() /* , item.GetShortName() */ );)
+        }
+        if (num_lfn_records == 0)
+          is_record_error = false;
+        else if (checkSum >= 0 && lfn_RecordIndex == 0)
+        {
+          Byte sum = 0;
+          for (unsigned i = 0; i < 11; i++)
+            sum = (Byte)((sum << 7) + (sum >> 1) + (Byte)item.DosName[i]);
+          if (sum == checkSum)
+          {
+            const unsigned numWords = ParseLongName((UInt16 *)(void *)(Byte *)LfnBuf,
+                num_lfn_records * k_NumLfnBytes_in_Record / 2);
+            if (numWords > 1)
+            {
+              // numWords includes NULL terminator
+              item.LongName.CopyFrom(LfnBuf, numWords * 2);
+              is_record_error = false;
+            }
+          }
+        }
+        
+        if (
+            // item.LongName.Size() < 20 ||  // for debug
+            item.LongName.Size() <= 2 * 1
+            && memcmp(p, "           ", 11) == 0)
+        {
+          char s[16 + 16];
+          const size_t numChars = (size_t)(ConvertUInt32ToString(
+              Items.Size() - 1 - startIndex,
+              MyStpCpy(s, "[NONAME]-")) - s) + 1;
+          item.LongName.Alloc(numChars * 2);
+          for (size_t i = 0; i < numChars; i++)
+          {
+            SetUi16a(item.LongName + i * 2, (Byte)s[i])
+          }
+          Header.HeadersWarning = true;
+        }
      }
-      numLongRecords = -1;
+      num_lfn_records = 0;
-      curName.Empty();
-      checkSum = -1;
    }
  }
-  unsigned finishIndex = Items.Size();
+  if (is_record_error)
+    Header.HeadersWarning = true;
+  const unsigned finishIndex = Items.Size();
  for (unsigned i = startIndex; i < finishIndex; i++)
  {
    const CItem &item = Items[i];
    if (item.IsDir())
    {
-      PRF(printf("\n%S", GetItemPath(i)));
+      PRF(printf("\n---- %c%c%c%c%c", item.DosName[0], item.DosName[1], item.DosName[2], item.DosName[3], item.DosName[4]));
-      RINOK(CDatabase::ReadDir((int)i, item.Cluster, level + 1))
+      RINOK(ReadDir((int)i, item.Cluster, level + 1))
    }
  }
  return S_OK;
 }
 HRESULT CDatabase::Open()
 {
  Clear();
-  bool numFreeClustersDefined = false;
+  bool numFreeClusters_Defined = false;
  {
-    Byte buf[kHeaderSize];
+    UInt32 buf32[kHeaderSize / 4];
-    RINOK(ReadStream_FALSE(InStream, buf, kHeaderSize))
+    RINOK(ReadStream_FALSE(InStream, buf32, kHeaderSize))
-    if (!Header.Parse(buf))
+    if (!Header.Parse((Byte *)(void *)buf32))
      return S_FALSE;
    UInt64 fileSize;
    RINOK(InStream_GetSize_SeekToEnd(InStream, fileSize))
@@ -671,21 +812,21 @@ HRESULT CDatabase::Open()
    {
      if (((UInt32)Header.FsInfoSector << Header.SectorSizeLog) + kHeaderSize <= fileSize
          && SeekToSector(Header.FsInfoSector) == S_OK
-          && ReadStream_FALSE(InStream, buf, kHeaderSize) == S_OK
+          && ReadStream_FALSE(InStream, buf32, kHeaderSize) == S_OK
-          && 0xaa550000 == Get32(buf + 508)
+          && 0xaa550000 == Get32a(buf32 + 508 / 4)
-          && 0x41615252 == Get32(buf)
+          && 0x41615252 == Get32a(buf32)
-          && 0x61417272 == Get32(buf + 484))
+          && 0x61417272 == Get32a(buf32 + 484 / 4))
      {
-        NumFreeClusters = Get32(buf + 488);
+        NumFreeClusters = Get32a(buf32 + 488 / 4);
-        numFreeClustersDefined = (NumFreeClusters <= Header.FatSize);
+        numFreeClusters_Defined = (NumFreeClusters <= Header.FatSize);
      }
      else
        Header.HeadersWarning = true;
    }
  }
-  // numFreeClustersDefined = false; // to recalculate NumFreeClusters
+  // numFreeClusters_Defined = false; // to recalculate NumFreeClusters
-  if (!numFreeClustersDefined)
+  if (!numFreeClusters_Defined)
    NumFreeClusters = 0;
  CByteBuffer byteBuf;
@@ -695,7 +836,7 @@ HRESULT CDatabase::Open()
  RINOK(SeekToSector(Header.GetFatSector()))
  if (Header.NumFatBits == 32)
  {
-    const UInt32 kBufSize = (1 << 15);
+    const UInt32 kBufSize = 1 << 15;
    byteBuf.Alloc(kBufSize);
    for (UInt32 i = 0;;)
    {
@@ -712,7 +853,7 @@ HRESULT CDatabase::Open()
      const UInt32 *src = (const UInt32 *)(const void *)(const Byte *)byteBuf;
      UInt32 *dest = Fat + i;
      const UInt32 *srcLim = src + size;
-      if (numFreeClustersDefined)
+      if (numFreeClusters_Defined)
        do
          *dest++ = Get32a(src) & 0x0FFFFFFF;
        while (++src != srcLim);
@@ -731,7 +872,7 @@ HRESULT CDatabase::Open()
      i += size;
      if ((i & 0xFFFFF) == 0)
      {
-        RINOK(OpenProgressFat(!numFreeClustersDefined))
+        RINOK(OpenProgressFat(!numFreeClusters_Defined))
      }
    }
  }
@@ -751,7 +892,7 @@ HRESULT CDatabase::Open()
      for (UInt32 j = 0; j < fatSize; j++)
        fat[j] = (Get16(p + j * 3 / 2) >> ((j & 1) << 2)) & 0xFFF;
-    if (!numFreeClustersDefined)
+    if (!numFreeClusters_Defined)
    {
      UInt32 numFreeClusters = 0;
      for (UInt32 i = 0; i < fatSize; i++)
@@ -781,11 +922,12 @@ HRESULT CDatabase::Open()
 Z7_class_CHandler_final:
  public IInArchive,
+  public IArchiveGetRawProps,
  public IInArchiveGetStream,
  public CMyUnknownImp,
  CDatabase
 {
-  Z7_IFACES_IMP_UNK_2(IInArchive, IInArchiveGetStream)
+  Z7_IFACES_IMP_UNK_3(IInArchive, IArchiveGetRawProps, IInArchiveGetStream)
 };
 Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
@@ -831,6 +973,8 @@ Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
  COM_TRY_END
 }
 static const Byte kProps[] =
 {
  kpidPath,
@@ -842,6 +986,7 @@ static const Byte kProps[] =
  kpidATime,
  kpidAttrib,
  kpidShortName
+  // , kpidCharacts
 };
 enum
@@ -922,15 +1067,16 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
    case kpidPhySize: prop = PhySize; break;
    case kpidFreeSpace: prop = (UInt64)NumFreeClusters << Header.ClusterSizeLog; break;
    case kpidHeadersSize: prop = GetHeadersSize(); break;
-    case kpidMTime: if (VolItemDefined) PropVariant_SetFrom_DosTime(prop, VolItem.MTime); break;
+    case kpidMTime: if (VolItem_Defined) PropVariant_SetFrom_DosTime(prop, Vol_MTime); break;
    case kpidShortComment:
-    case kpidVolumeName: if (VolItemDefined) prop = VolItem.GetVolName(); break;
+    case kpidVolumeName: if (VolItem_Defined) GetVolName(VolLabel, prop); break;
    case kpidNumFats: if (Header.NumFats != 2) prop = Header.NumFats; break;
    case kpidSectorSize: prop = (UInt32)1 << Header.SectorSizeLog; break;
    // case kpidSectorsPerTrack: prop = Header.SectorsPerTrack; break;
    // case kpidNumHeads: prop = Header.NumHeads; break;
    // case kpidOemName: STRING_TO_PROP(Header.OemName, prop); break;
    case kpidId: if (Header.VolFieldsDefined) prop = Header.VolId; break;
+    case kpidIsTree: prop = true; break;
    // case kpidVolName: if (Header.VolFieldsDefined) STRING_TO_PROP(Header.VolName, prop); break;
    // case kpidFileSysType: if (Header.VolFieldsDefined) STRING_TO_PROP(Header.FileSys, prop); break;
    // case kpidHiddenSectors: prop = Header.NumHiddenSectors; break;
@@ -948,6 +1094,52 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
  COM_TRY_END
 }
+Z7_COM7F_IMF(CHandler::GetNumRawProps(UInt32 *numProps))
+{
+  *numProps = 0;
+  return S_OK;
+}
+Z7_COM7F_IMF(CHandler::GetRawPropInfo(UInt32 /* index */ , BSTR *name, PROPID *propID))
+{
+  *name = NULL;
+  *propID = 0;
+  return S_OK;
+}
+Z7_COM7F_IMF(CHandler::GetParent(UInt32 index, UInt32 *parent, UInt32 *parentType))
+{
+  *parentType = NParentType::kDir;
+  int par = -1;
+  if (index < Items.Size())
+    par = Items[index].Parent;
+  *parent = (UInt32)(Int32)par;
+  return S_OK;
+}
+Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+  *data = NULL;
+  *dataSize = 0;
+  *propType = 0;
+  if (index < Items.Size()
+      && propID == kpidName)
+  {
+    CByteBuffer &buf = Items[index].LongName;
+    const UInt32 size = (UInt32)buf.Size();
+    if (size != 0)
+    {
+      *dataSize = size;
+      *propType = NPropDataType::kUtf16z;
+      *data = (const void *)(const Byte *)buf;
+    }
+  }
+  return S_OK;
+}
 Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
 {
  COM_TRY_BEGIN
@@ -955,8 +1147,28 @@ Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
  const CItem &item = Items[index];
  switch (propID)
  {
-    case kpidPath: prop = GetItemPath(index); break;
+    case kpidPath:
-    case kpidShortName: prop = item.GetShortName(); break;
+    case kpidName:
+    case kpidShortName:
+    {
+      UString s;
+      if (propID == kpidPath)
+        GetItemPath(index, s);
+      else if (propID == kpidName)
+        item.GetName(s);
+      else
+        item.GetShortName(s);
+      prop = s;
+      break;
+    }
+/*
+    case kpidCharacts:
+    {
+      if (item.LongName.Size())
+        prop = "LFN";
+      break;
+    }
+*/
    case kpidIsDir: prop = item.IsDir(); break;
    case kpidMTime: PropVariant_SetFrom_DosTime(prop, item.MTime); break;
    case kpidCTime: FatTimeToProp(item.CTime, item.CTime2, prop); break;
@@ -1004,34 +1216,44 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
    Int32 testMode, IArchiveExtractCallback *extractCallback))
 {
  COM_TRY_BEGIN
-  const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+  if (numItems == (UInt32)(Int32)-1)
-  if (allFilesMode)
+  {
+    indices = NULL;
    numItems = Items.Size();
-  if (numItems == 0)
+    if (numItems == 0)
-    return S_OK;
+      return S_OK;
-  UInt32 i;
+  }
+  else
+  {
+    if (numItems == 0)
+      return S_OK;
+    if (!indices)
+      return E_INVALIDARG;
+  }
  UInt64 totalSize = 0;
-  for (i = 0; i < numItems; i++)
  {
-    const CItem &item = Items[allFilesMode ? i : indices[i]];
+    UInt32 i = 0;
-    if (!item.IsDir())
+    do
-      totalSize += item.Size;
+    {
+      UInt32 index = i;
+      if (indices)
+        index = indices[i];
+      const CItem &item = Items[index];
+      if (!item.IsDir())
+        totalSize += item.Size;
+    }
+    while (++i != numItems);
  }
  RINOK(extractCallback->SetTotal(totalSize))
-  UInt64 totalPackSize;
+  CMyComPtr2_Create<ICompressProgressInfo, CLocalProgress> lps;
-  totalSize = totalPackSize = 0;
-  
-  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
-  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
-  CLocalProgress *lps = new CLocalProgress;
-  CMyComPtr<ICompressProgressInfo> progress = lps;
  lps->Init(extractCallback, false);
+  CMyComPtr2_Create<ICompressCoder, NCompress::CCopyCoder> copyCoder;
-  CDummyOutStream *outStreamSpec = new CDummyOutStream;
+  UInt64 totalPackSize;
-  CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+  totalSize = totalPackSize = 0;
+  UInt32 i;
  for (i = 0;; i++)
  {
    lps->InSize = totalPackSize;
@@ -1039,46 +1261,45 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
    RINOK(lps->SetCur())
    if (i == numItems)
      break;
-    CMyComPtr<ISequentialOutStream> realOutStream;
+    int res;
-    const Int32 askMode = testMode ?
-        NExtract::NAskMode::kTest :
-        NExtract::NAskMode::kExtract;
-    const UInt32 index = allFilesMode ? i : indices[i];
-    const CItem &item = Items[index];
-    RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
-    if (item.IsDir())
    {
+      CMyComPtr<ISequentialOutStream> realOutStream;
+      const Int32 askMode = testMode ?
+          NExtract::NAskMode::kTest :
+          NExtract::NAskMode::kExtract;
+      UInt32 index = i;
+      if (indices)
+        index = indices[i];
+      const CItem &item = Items[index];
+      RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+        
+      if (item.IsDir())
+      {
+        RINOK(extractCallback->PrepareOperation(askMode))
+        RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+        continue;
+      }
+      
+      totalPackSize += Header.GetFilePackSize(item.Size);
+      totalSize += item.Size;
+      
+      if (!testMode && !realOutStream)
+        continue;
      RINOK(extractCallback->PrepareOperation(askMode))
-      RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+      res = NExtract::NOperationResult::kDataError;
-      continue;
+      CMyComPtr<ISequentialInStream> inStream;
-    }
+      const HRESULT hres = GetStream(index, &inStream);
+      if (hres != S_FALSE)
-    totalPackSize += Header.GetFilePackSize(item.Size);
-    totalSize += item.Size;
-    if (!testMode && !realOutStream)
-      continue;
-    RINOK(extractCallback->PrepareOperation(askMode))
-    outStreamSpec->SetStream(realOutStream);
-    realOutStream.Release();
-    outStreamSpec->Init();
-    int res = NExtract::NOperationResult::kDataError;
-    CMyComPtr<ISequentialInStream> inStream;
-    HRESULT hres = GetStream(index, &inStream);
-    if (hres != S_FALSE)
-    {
-      RINOK(hres)
-      if (inStream)
      {
-        RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
+        RINOK(hres)
-        if (copyCoderSpec->TotalSize == item.Size)
+        if (inStream)
-          res = NExtract::NOperationResult::kOK;
+        {
+          RINOK(copyCoder.Interface()->Code(inStream, realOutStream, NULL, NULL, lps))
+          if (copyCoder->TotalSize == item.Size)
+            res = NExtract::NOperationResult::kOK;
+        }
      }
    }
-    outStreamSpec->ReleaseStream();
    RINOK(extractCallback->SetOperationResult(res))
  }
  return S_OK;
diff --git a/CPP/7zip/Archive/Nsis/NsisIn.cpp b/CPP/7zip/Archive/Nsis/NsisIn.cpp
index c9e2c01..194e5bf 100644
--- a/CPP/7zip/Archive/Nsis/NsisIn.cpp
+++ b/CPP/7zip/Archive/Nsis/NsisIn.cpp
@@ -4005,7 +4005,7 @@ HRESULT CInArchive::ReadEntries(const CBlockHeader &bh)
        AddParam_Var(params[0]);
        AString temp;
        ReadString2(temp, params[1]);
-        if (temp != "$TEMP")
+        if (!temp.IsEqualTo("$TEMP"))
          SpaceQuStr(temp);
        break;
      }
@@ -4410,7 +4410,7 @@ HRESULT CInArchive::ReadEntries(const CBlockHeader &bh)
        }
        else
        {
-          if (func == "DllUnregisterServer")
+          if (func.IsEqualTo("DllUnregisterServer"))
          {
            s += "UnRegDLL";
            printFunc = false;
@@ -4418,7 +4418,7 @@ HRESULT CInArchive::ReadEntries(const CBlockHeader &bh)
          else
          {
            s += "RegDLL";
-            if (func == "DllRegisterServer")
+            if (func.IsEqualTo("DllRegisterServer"))
              printFunc = false;
          }
          AddParam(params[0]);
@@ -4886,7 +4886,7 @@ HRESULT CInArchive::ReadEntries(const CBlockHeader &bh)
            AddParam_Var(params[1]);
            AddParam(params[2]);
            AddParam(params[4]);
-            // if (params[2] == "0") AddCommentAndString("GetWinVer");
+            // if (params[2].IsEqualTo("0")) AddCommentAndString("GetWinVer");
          }
          else
            s += "GetOsInfo";
diff --git a/CPP/7zip/Archive/NtfsHandler.cpp b/CPP/7zip/Archive/NtfsHandler.cpp
index d55521d..05c177f 100644
--- a/CPP/7zip/Archive/NtfsHandler.cpp
+++ b/CPP/7zip/Archive/NtfsHandler.cpp
@@ -1907,7 +1907,7 @@ HRESULT CDatabase::Open()
  for (i = 0; i < SecurityAttrs.Size(); i++)
  {
    const CAttr &attr = SecurityAttrs[i];
-    if (attr.Name == L"$SII")
+    if (attr.Name.IsEqualTo("$SII"))
    {
      if (attr.Type == ATTR_TYPE_INDEX_ROOT)
      {
diff --git a/CPP/7zip/Archive/PeHandler.cpp b/CPP/7zip/Archive/PeHandler.cpp
index 8a0ff05..79f89ef 100644
--- a/CPP/7zip/Archive/PeHandler.cpp
+++ b/CPP/7zip/Archive/PeHandler.cpp
@@ -2638,7 +2638,7 @@ HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *callback)
  {
    const CSection &sect = _sections[i];
    if (IsOpt())
-    if (_parseResources && sect.Name == ".rsrc")
+    if (_parseResources && sect.Name.IsEqualTo(".rsrc"))
    {
      // 20.01: we try to parse only first copy of .rsrc section.
      _parseResources = false;
@@ -2727,7 +2727,7 @@ HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *callback)
  for (i = 0; i < _mixItems.Size(); i++)
  {
    const CMixItem &mixItem = _mixItems[i];
-    if (mixItem.StringIndex < 0 && mixItem.ResourceIndex < 0 && _sections[mixItem.SectionIndex].Name == "_winzip_")
+    if (mixItem.StringIndex < 0 && mixItem.ResourceIndex < 0 && _sections[mixItem.SectionIndex].Name.IsEqualTo("_winzip_"))
    {
      _mainSubfile = (Int32)(int)i;
      break;
diff --git a/CPP/7zip/Archive/Rar/Rar5Handler.cpp b/CPP/7zip/Archive/Rar/Rar5Handler.cpp
index 7d75aae..a639d8b 100644
--- a/CPP/7zip/Archive/Rar/Rar5Handler.cpp
+++ b/CPP/7zip/Archive/Rar/Rar5Handler.cpp
@@ -393,6 +393,7 @@ void CItem::Link_to_Prop(unsigned linkType, NWindows::NCOM::CPropVariant &prop)
  if (!FindExtra_Link(link))
    return;
+  bool isWindows = (HostOS == kHost_Windows);
  if (link.Type != linkType)
  {
    if (linkType != NLinkType::kUnixSymLink)
@@ -400,8 +401,11 @@ void CItem::Link_to_Prop(unsigned linkType, NWindows::NCOM::CPropVariant &prop)
    switch ((unsigned)link.Type)
    {
      case NLinkType::kUnixSymLink:
+        isWindows = false;
+        break;
      case NLinkType::kWinSymLink:
      case NLinkType::kWinJunction:
+        isWindows = true;
        break;
      default: return;
    }
@@ -409,10 +413,15 @@ void CItem::Link_to_Prop(unsigned linkType, NWindows::NCOM::CPropVariant &prop)
  AString s;
  s.SetFrom_CalcLen((const char *)(Extra + link.NameOffset), link.NameLen);
  UString unicode;
  ConvertUTF8ToUnicode(s, unicode);
-  prop = NItemName::GetOsPath(unicode);
+  // rar5.0  used '\\' separator for windows symlinks and \??\ prefix for abs paths.
+  // rar5.1+ uses '/'  separator for windows symlinks and /??/ prefix for abs paths.
+  // v25.00: we convert Windows slashes to Linux slashes:
+  if (isWindows)
+    unicode.Replace(L'\\', L'/');
+  prop = unicode;
+  // prop = NItemName::GetOsPath(unicode);
 }
 bool CItem::GetAltStreamName(AString &name) const
diff --git a/CPP/7zip/Archive/Rar/Rar5Handler.h b/CPP/7zip/Archive/Rar/Rar5Handler.h
index 8f6581a..913ba85 100644
--- a/CPP/7zip/Archive/Rar/Rar5Handler.h
+++ b/CPP/7zip/Archive/Rar/Rar5Handler.h
@@ -286,10 +286,10 @@ struct CItem
  bool IsService() const { return RecordType == NHeaderType::kService; }
  
-  bool Is_STM() const { return IsService() && Name == "STM"; }
+  bool Is_STM() const { return IsService() && Name.IsEqualTo("STM"); }
-  bool Is_CMT() const { return IsService() && Name == "CMT"; }
+  bool Is_CMT() const { return IsService() && Name.IsEqualTo("CMT"); }
-  bool Is_ACL() const { return IsService() && Name == "ACL"; }
+  bool Is_ACL() const { return IsService() && Name.IsEqualTo("ACL"); }
-  // bool Is_QO()  const { return IsService() && Name == "QO"; }
+  // bool Is_QO()  const { return IsService() && Name.IsEqualTo("QO"); }
  int FindExtra(unsigned extraID, unsigned &recordDataSize) const;
  void PrintInfo(AString &s) const;
diff --git a/CPP/7zip/Archive/Rar/RarHandler.cpp b/CPP/7zip/Archive/Rar/RarHandler.cpp
index 9157acc..dfbad33 100644
--- a/CPP/7zip/Archive/Rar/RarHandler.cpp
+++ b/CPP/7zip/Archive/Rar/RarHandler.cpp
@@ -435,13 +435,13 @@ bool CInArchive::ReadHeaderReal(const Byte *p, unsigned size, CItem &item)
      size -= sizeof(item.Salt);
      p += sizeof(item.Salt);
    }
-    if (item.Name == "ACL" && size == 0)
+    if (item.Name.IsEqualTo("ACL") && size == 0)
    {
      item.IsAltStream = true;
      item.Name.Empty();
      item.UnicodeName.SetFromAscii(".ACL");
    }
-    else if (item.Name == "STM" && size != 0 && (size & 1) == 0)
+    else if (item.Name.IsEqualTo("STM") && size != 0 && (size & 1) == 0)
    {
      item.IsAltStream = true;
      item.Name.Empty();
diff --git a/CPP/7zip/Archive/RpmHandler.cpp b/CPP/7zip/Archive/RpmHandler.cpp
index da2b6ee..4f8aaaa 100644
--- a/CPP/7zip/Archive/RpmHandler.cpp
+++ b/CPP/7zip/Archive/RpmHandler.cpp
@@ -330,11 +330,11 @@ void CHandler::AddSubFileExtension(AString &res) const
  if (!_compressor.IsEmpty())
  {
    s = _compressor;
-    if (_compressor == "bzip2")
+    if (_compressor.IsEqualTo("bzip2"))
      s = "bz2";
-    else if (_compressor == "gzip")
+    else if (_compressor.IsEqualTo("gzip"))
      s = "gz";
-    else if (_compressor == "zstd")
+    else if (_compressor.IsEqualTo("zstd"))
      s = "zst";
  }
  else
diff --git a/CPP/7zip/Archive/VmdkHandler.cpp b/CPP/7zip/Archive/VmdkHandler.cpp
index 9c293a3..221af21 100644
--- a/CPP/7zip/Archive/VmdkHandler.cpp
+++ b/CPP/7zip/Archive/VmdkHandler.cpp
@@ -202,9 +202,12 @@ struct CExtentInfo
  // PartitionUUID
  // DeviceIdentifier
-  bool IsType_ZERO() const { return Type == "ZERO"; }
+  bool IsType_ZERO() const { return Type.IsEqualTo("ZERO"); }
-  // bool IsType_FLAT() const { return Type == "FLAT"; }
+  // bool IsType_FLAT() const { return Type.IsEqualTo("FLAT"); }
-  bool IsType_Flat() const { return Type == "FLAT" || Type == "VMFS" || Type == "VMFSRAW"; }
+  bool IsType_Flat() const
+    { return Type.IsEqualTo("FLAT")
+          || Type.IsEqualTo("VMFS")
+          || Type.IsEqualTo("VMFSRAW"); }
  
  bool Parse(const char *s);
 };
diff --git a/CPP/7zip/Archive/Wim/WimIn.cpp b/CPP/7zip/Archive/Wim/WimIn.cpp
index 614755a..a748e99 100644
--- a/CPP/7zip/Archive/Wim/WimIn.cpp
+++ b/CPP/7zip/Archive/Wim/WimIn.cpp
@@ -1814,7 +1814,7 @@ bool CWimXml::Parse()
  if (!Xml.Parse(utf))
    return false;
-  if (Xml.Root.Name != "WIM")
+  if (!Xml.Root.Name.IsEqualTo("WIM"))
    return false;
  FOR_VECTOR (i, Xml.Root.SubItems)
diff --git a/CPP/7zip/Archive/XarHandler.cpp b/CPP/7zip/Archive/XarHandler.cpp
index 6ef8941..cba546e 100644
--- a/CPP/7zip/Archive/XarHandler.cpp
+++ b/CPP/7zip/Archive/XarHandler.cpp
@@ -266,7 +266,7 @@ struct CFile
  bool IsCopyMethod() const
  {
-    return Method.IsEmpty() || Method == "octet-stream";
+    return Method.IsEmpty() || Method.IsEqualTo("octet-stream");
  }
  void UpdateTotalPackSize(UInt64 &totalSize) const
@@ -416,7 +416,7 @@ static bool AddItem(const CXmlItem &item, CObjectVector<CFile> &files, int paren
    return true;
  if (level >= 1024)
    return false;
-  if (item.Name == "file")
+  if (item.Name.IsEqualTo("file"))
  {
    CFile file(parent);
    parent = (int)files.Size();
@@ -435,19 +435,19 @@ static bool AddItem(const CXmlItem &item, CObjectVector<CFile> &files, int paren
      {
        file.Type = typeItem->GetSubString();
        // file.LinkFrom = typeItem->GetPropVal("link");
-        if (file.Type == "directory")
+        if (file.Type.IsEqualTo("directory"))
          file.IsDir = true;
        else
        {
          // file.IsDir = false;
          /*
-          else if (file.Type == "file")
+          else if (file.Type.IsEqualTo("file"))
          {}
-          else if (file.Type == "hardlink")
+          else if (file.Type.IsEqualTo("hardlink"))
          {}
          else
          */
-          if (file.Type == "symlink")
+          if (file.Type.IsEqualTo("symlink"))
            file.Is_SymLink = true;
          // file.IsDir = false;
        }
@@ -489,7 +489,7 @@ static bool AddItem(const CXmlItem &item, CObjectVector<CFile> &files, int paren
            if (s.IsPrefixedBy(xx))
            {
              s.DeleteFrontal(xx.Len());
-              if (s == "gzip")
+              if (s.IsEqualTo("gzip"))
                s = METHOD_NAME_ZLIB;
            }
          }
@@ -692,12 +692,13 @@ HRESULT CHandler::Open2(IInStream *stream)
    file.UpdateTotalPackSize(totalPackSize);
    if (file.Parent == -1)
    {
-      if (file.Name == "Payload" || file.Name == "Content")
+      if (file.Name.IsEqualTo("Payload") ||
+          file.Name.IsEqualTo("Content"))
      {
        _mainSubfile = (Int32)(int)i;
        numMainFiles++;
      }
-      else if (file.Name == "PackageInfo")
+      else if (file.Name.IsEqualTo("PackageInfo"))
        _is_pkg = true;
    }
  }
@@ -1210,9 +1211,9 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
          else
            opRes = NExtract::NOperationResult::kUnsupportedMethod;
        }
-        else if (item.Method == METHOD_NAME_ZLIB)
+        else if (item.Method.IsEqualTo(METHOD_NAME_ZLIB))
          coder = zlibCoder;
-        else if (item.Method == "bzip2")
+        else if (item.Method.IsEqualTo("bzip2"))
          coder = bzip2Coder;
        else
          opRes = NExtract::NOperationResult::kUnsupportedMethod;
diff --git a/CPP/7zip/Archive/XzHandler.cpp b/CPP/7zip/Archive/XzHandler.cpp
index 907376c..5aaa405 100644
--- a/CPP/7zip/Archive/XzHandler.cpp
+++ b/CPP/7zip/Archive/XzHandler.cpp
@@ -446,7 +446,7 @@ void COpenCallbackWrap::Init(IArchiveOpenCallback *callback)
 struct CXzsCPP
 {
  CXzs p;
-  CXzsCPP() { Xzs_Construct(&p); }
+  CXzsCPP() { Xzs_CONSTRUCT(&p) }
  ~CXzsCPP() { Xzs_Free(&p, &g_Alloc); }
 };
@@ -536,6 +536,9 @@ HRESULT CHandler::Open2(IInStream *inStream, /* UInt32 flags, */ IArchiveOpenCal
        if (res2 == SZ_ERROR_ARCHIVE)
          return S_FALSE;
+        // what codes are possible here ?
+        // ?? res2 == SZ_ERROR_MEM           : is possible here
+        // ?? res2 == SZ_ERROR_UNSUPPORTED   : is possible here
      }
      else if (!isIndex)
      {
@@ -1159,6 +1162,13 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
    */
    #ifndef Z7_ST
+#ifdef _WIN32
+    // we don't use chunk multithreading inside lzma2 stream.
+    // so we don't set xzProps.lzma2Props.numThreadGroups.
+    if (_numThreadGroups > 1)
+      xzProps.numThreadGroups = _numThreadGroups;
+#endif
    
    UInt32 numThreads = _numThreads;
@@ -1183,6 +1193,8 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
        CMultiMethodProps::SetMethodThreadsTo_IfNotFinded(oneMethodInfo, numThreads);
      }
+      // printf("\n====== GetProcessGroupAffinity : \n");
      UInt64 cs = _numSolidBytes;
      if (cs != XZ_PROPS_BLOCK_SIZE_AUTO)
        oneMethodInfo.AddProp_BlockSize2(cs);
diff --git a/CPP/7zip/Archive/Zip/ZipUpdate.cpp b/CPP/7zip/Archive/Zip/ZipUpdate.cpp
index bc047b7..b2684dc 100644
--- a/CPP/7zip/Archive/Zip/ZipUpdate.cpp
+++ b/CPP/7zip/Archive/Zip/ZipUpdate.cpp
@@ -250,13 +250,26 @@ struct CThreadInfo
  
  HRESULT CreateEvents()
  {
-    WRes wres = CompressEvent.CreateIfNotCreated_Reset();
+    const WRes wres = CompressEvent.CreateIfNotCreated_Reset();
    return HRESULT_FROM_WIN32(wres);
  }
  
-  HRESULT CreateThread()
+  // (group < 0) means no_group.
+  HRESULT CreateThread_with_group(
+#ifdef _WIN32
+      int group
+#endif
+      )
  {
-    WRes wres = Thread.Create(CoderThread, this);
+    // tested in win10: If thread is created by another thread,
+    // child thread probably uses same group as parent thread.
+    // So we don't need to send (group) to encoder in created thread.
+    const WRes wres =
+#ifdef _WIN32
+      group >= 0 ?
+        Thread.Create_With_Group(CoderThread, this, (unsigned)group) :
+#endif
+        Thread.Create(CoderThread, this);
    return HRESULT_FROM_WIN32(wres);
  }
@@ -450,8 +463,12 @@ static HRESULT UpdateItemOldData(
  if (ui.NewProps)
  {
    if (item.HasDescriptor())
-      return E_NOTIMPL;
+    {
-    
+      // we know compressed / uncompressed sizes and crc.
+      // so we remove descriptor here
+      item.Flags = (UInt16)(item.Flags & ~NFileHeader::NFlags::kDescriptorUsedMask);
+      // return E_NOTIMPL;
+    }
    // we keep ExternalAttrib and some another properties from old archive
    // item.ExternalAttrib = ui.Attrib;
    // if we don't change Comment, we keep Comment from OldProperties
@@ -1000,6 +1017,9 @@ static HRESULT Update2(
  #ifndef Z7_ST
  UInt32 numThreads = options._numThreads;
+#ifdef _WIN32
+  const UInt32 numThreadGroups = options._numThreadGroups;
+#endif
  UInt32 numZipThreads_limit = numThreads;
  if (numZipThreads_limit > numFilesToCompress)
@@ -1014,12 +1034,10 @@ static HRESULT Update2(
  }
  {
+    // we reduce number of threads for 32-bit to reduce memory usege to 256 MB
    const UInt32 kNumMaxThreads =
-      #ifdef _WIN32
+        // _WIN32 (64-bit) supports only 64 threads in one group.
-        64; // _WIN32 supports only 64 threads in one group. So no need for more threads here
+        8 << (sizeof(size_t) / 2); // 32 threads for 32-bit : 128 threads for 64-bit
-      #else
-        128;
-      #endif
    if (numThreads > kNumMaxThreads)
      numThreads = kNumMaxThreads;
  }
@@ -1264,7 +1282,14 @@ static HRESULT Update2(
      threadInfo.Progress = threadInfo.ProgressSpec;
      threadInfo.ProgressSpec->Init(&mtCompressProgressMixer, i);
      threadInfo.MtSem = &mtSem;
-      RINOK(threadInfo.CreateThread())
+      const HRESULT hres =
+        threadInfo.CreateThread_with_group(
+#ifdef _WIN32
+          (numThreadGroups > 1 && numThreads > 1) ?
+            (int)(i % numThreadGroups) : -1
+#endif
+        );
+      RINOK(hres)
    }
  }
diff --git a/CPP/7zip/Bundles/Alone/makefile b/CPP/7zip/Bundles/Alone/makefile
index 7547590..9f81f9e 100644
--- a/CPP/7zip/Bundles/Alone/makefile
+++ b/CPP/7zip/Bundles/Alone/makefile
@@ -5,6 +5,7 @@ CFLAGS = $(CFLAGS) -DZ7_ZIP_LZFSE_DISABLE
 # CONSOLE_VARIANT_FLAGS=-DZ7_PROG_VARIANT_A
 # ZIP_FLAGS=-DZ7_ZIP_LZFSE_DISABLE
+# USE_C_SORT=1
 # USE_C_AES = 1
 # USE_C_SHA = 1
 # USE_C_LZFINDOPT = 1
@@ -221,7 +222,6 @@ C_OBJS = \
  $O\Ppmd8.obj \
  $O\Ppmd8Dec.obj \
  $O\Ppmd8Enc.obj \
-  $O\Sort.obj \
  $O\SwapBytes.obj \
  $O\Threads.obj \
  $O\Xxh64.obj \
@@ -240,5 +240,6 @@ C_OBJS = \
 !include "../../LzmaDec.mak"
 !include "../../Sha1.mak"
 !include "../../Sha256.mak"
+!include "../../Sort.mak"
 !include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Alone7z/makefile b/CPP/7zip/Bundles/Alone7z/makefile
index 89584e1..f0a813a 100644
--- a/CPP/7zip/Bundles/Alone7z/makefile
+++ b/CPP/7zip/Bundles/Alone7z/makefile
@@ -148,7 +148,6 @@ C_OBJS = \
  $O\LzmaEnc.obj \
  $O\MtCoder.obj \
  $O\MtDec.obj \
-  $O\Sort.obj \
  $O\SwapBytes.obj \
  $O\Threads.obj \
  $O\Xz.obj \
@@ -164,5 +163,6 @@ C_OBJS = \
 !include "../../LzFindOpt.mak"
 !include "../../LzmaDec.mak"
 !include "../../Sha256.mak"
+!include "../../Sort.mak"
 !include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Format7z/makefile b/CPP/7zip/Bundles/Format7z/makefile
index fe6f94d..3d4754c 100644
--- a/CPP/7zip/Bundles/Format7z/makefile
+++ b/CPP/7zip/Bundles/Format7z/makefile
@@ -135,7 +135,6 @@ C_OBJS = \
  $O\Ppmd7.obj \
  $O\Ppmd7Dec.obj \
  $O\Ppmd7Enc.obj \
-  $O\Sort.obj \
  $O\SwapBytes.obj \
  $O\Threads.obj \
@@ -144,5 +143,6 @@ C_OBJS = \
 !include "../../LzFindOpt.mak"
 !include "../../LzmaDec.mak"
 !include "../../Sha256.mak"
+!include "../../Sort.mak"
 !include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Format7zF/Arc.mak b/CPP/7zip/Bundles/Format7zF/Arc.mak
index 7166ab3..b1c6fe2 100644
--- a/CPP/7zip/Bundles/Format7zF/Arc.mak
+++ b/CPP/7zip/Bundles/Format7zF/Arc.mak
@@ -291,7 +291,6 @@ C_OBJS = \
  $O\Sha3.obj \
  $O\Sha512.obj \
  $O\Sha512Opt.obj \
-  $O\Sort.obj \
  $O\SwapBytes.obj \
  $O\Threads.obj \
  $O\Xxh64.obj \
@@ -308,3 +307,4 @@ C_OBJS = \
 !include "../../LzmaDec.mak"
 !include "../../Sha1.mak"
 !include "../../Sha256.mak"
+!include "../../Sort.mak"
diff --git a/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp b/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
index eb28f5d..0c09807 100644
--- a/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
+++ b/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
@@ -229,7 +229,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
  }
  const FString tempDirPath = tempDir.GetPath();
-  // tempDirPath = L"M:\\1\\"; // to test low disk space
+  // tempDirPath = "M:\\1\\"; // to test low disk space
  {
    bool isCorrupt = false;
    UString errorMessage;
@@ -308,7 +308,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
  {
    if (appLaunched.IsEmpty())
    {
-      appLaunched = L"setup.exe";
+      appLaunched = "setup.exe";
      if (!NFind::DoesFileExist_FollowLink(us2fs(appLaunched)))
      {
        if (!assumeYes)
diff --git a/CPP/7zip/Common/InBuffer.h b/CPP/7zip/Common/InBuffer.h
index a8ccb40..13ec088 100644
--- a/CPP/7zip/Common/InBuffer.h
+++ b/CPP/7zip/Common/InBuffer.h
@@ -97,6 +97,16 @@ public:
  
  size_t ReadBytesPart(Byte *buf, size_t size);
  size_t ReadBytes(Byte *buf, size_t size);
+  const Byte *Lookahead(size_t &rem)
+  {
+    rem = (size_t)(_bufLim - _buf);
+    if (!rem)
+    {
+      ReadBlock();
+      rem = (size_t)(_bufLim - _buf);
+    }
+    return _buf;
+  }
  size_t Skip(size_t size);
 };
diff --git a/CPP/7zip/Common/MethodProps.cpp b/CPP/7zip/Common/MethodProps.cpp
index d87884c..a5d90cf 100644
--- a/CPP/7zip/Common/MethodProps.cpp
+++ b/CPP/7zip/Common/MethodProps.cpp
@@ -324,15 +324,22 @@ void CCoderProps::AddProp(const CProp &prop)
 HRESULT CProps::SetCoderProps(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce) const
 {
-  return SetCoderProps_DSReduce_Aff(scp, dataSizeReduce, NULL);
+  return SetCoderProps_DSReduce_Aff(scp, dataSizeReduce, NULL, NULL, NULL);
 }
 HRESULT CProps::SetCoderProps_DSReduce_Aff(
    ICompressSetCoderProperties *scp,
    const UInt64 *dataSizeReduce,
-    const UInt64 *affinity) const
+    const UInt64 *affinity,
-{
+    const UInt32 *affinityGroup,
-  CCoderProps coderProps(Props.Size() + (dataSizeReduce ? 1 : 0) + (affinity ? 1 : 0) );
+    const UInt64 *affinityInGroup) const
+{
+  CCoderProps coderProps(Props.Size()
+      + (dataSizeReduce ? 1 : 0)
+      + (affinity ? 1 : 0)
+      + (affinityGroup ? 1 : 0)
+      + (affinityInGroup ? 1 : 0)
+      );
  FOR_VECTOR (i, Props)
    coderProps.AddProp(Props[i]);
  if (dataSizeReduce)
@@ -349,6 +356,20 @@ HRESULT CProps::SetCoderProps_DSReduce_Aff(
    prop.Value = *affinity;
    coderProps.AddProp(prop);
  }
+  if (affinityGroup)
+  {
+    CProp prop;
+    prop.Id = NCoderPropID::kThreadGroup;
+    prop.Value = *affinityGroup;
+    coderProps.AddProp(prop);
+  }
+  if (affinityInGroup)
+  {
+    CProp prop;
+    prop.Id = NCoderPropID::kAffinityInGroup;
+    prop.Value = *affinityInGroup;
+    coderProps.AddProp(prop);
+  }
  return coderProps.SetProps(scp);
 }
@@ -409,6 +430,11 @@ static const CNameToPropID g_NameToPropID[] =
  { VT_UI4, "offset" },
  { VT_UI4, "zhb" }
  /*
+  , { VT_UI4, "tgn" }, // kNumThreadGroups
+  , { VT_UI4, "tgi" }, // kThreadGroup
+  , { VT_UI8, "tga" }, // kAffinityInGroup
+  */
+  /*
  ,
  // { VT_UI4, "zhc" },
  // { VT_UI4, "zhd" },
diff --git a/CPP/7zip/Common/MethodProps.h b/CPP/7zip/Common/MethodProps.h
index a52f4bc..be108fa 100644
--- a/CPP/7zip/Common/MethodProps.h
+++ b/CPP/7zip/Common/MethodProps.h
@@ -80,7 +80,11 @@ struct CProps
  }
  HRESULT SetCoderProps(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce = NULL) const;
-  HRESULT SetCoderProps_DSReduce_Aff(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce, const UInt64 *affinity) const;
+  HRESULT SetCoderProps_DSReduce_Aff(ICompressSetCoderProperties *scp,
+      const UInt64 *dataSizeReduce,
+      const UInt64 *affinity,
+      const UInt32 *affinityGroup,
+      const UInt64 *affinityInGroup) const;
 };
 class CMethodProps: public CProps
diff --git a/CPP/7zip/Common/OutBuffer.h b/CPP/7zip/Common/OutBuffer.h
index 88f5787..af78c4f 100644
--- a/CPP/7zip/Common/OutBuffer.h
+++ b/CPP/7zip/Common/OutBuffer.h
@@ -45,6 +45,7 @@ public:
  HRESULT Flush() throw();
  void FlushWithCheck();
+  Z7_FORCE_INLINE
  void WriteByte(Byte b)
  {
    UInt32 pos = _pos;
@@ -54,10 +55,34 @@ public:
    if (pos == _limitPos)
      FlushWithCheck();
  }
+  
  void WriteBytes(const void *data, size_t size)
  {
-    for (size_t i = 0; i < size; i++)
+    while (size)
-      WriteByte(((const Byte *)data)[i]);
+    {
+      UInt32 pos = _pos;
+      size_t cur = (size_t)(_limitPos - pos);
+      if (cur >= size)
+        cur = size;
+      size -= cur;
+      Byte *dest = _buf + pos;
+      pos += (UInt32)cur;
+      _pos = pos;
+#if 0
+      memcpy(dest, data, cur);
+      data = (const void *)((const Byte *)data + cur);
+#else
+      const Byte * const lim = (const Byte *)data + cur;
+      do
+      {
+        *dest++ = *(const Byte *)data;
+        data = (const void *)((const Byte *)data + 1);
+      }
+      while (data != lim);
+#endif
+      if (pos == _limitPos)
+        FlushWithCheck();
+    }
  }
  Byte *GetOutBuffer(size_t &avail)
diff --git a/CPP/7zip/Compress/BZip2Const.h b/CPP/7zip/Compress/BZip2Const.h
index 0dfcfe5..3380aaf 100644
--- a/CPP/7zip/Compress/BZip2Const.h
+++ b/CPP/7zip/Compress/BZip2Const.h
@@ -46,7 +46,7 @@ const UInt32 kBlockSizeStep = 100000;
 const UInt32 kBlockSizeMax = kBlockSizeMultMax * kBlockSizeStep;
 const unsigned kNumSelectorsBits = 15;
-const UInt32 kNumSelectorsMax = (2 + (kBlockSizeMax / kGroupSize));
+const unsigned kNumSelectorsMax = 2 + kBlockSizeMax / kGroupSize;
 const unsigned kRleModeRepSize = 4;
diff --git a/CPP/7zip/Compress/BZip2Encoder.cpp b/CPP/7zip/Compress/BZip2Encoder.cpp
index ef2555a..f8ee0c9 100644
--- a/CPP/7zip/Compress/BZip2Encoder.cpp
+++ b/CPP/7zip/Compress/BZip2Encoder.cpp
@@ -6,18 +6,20 @@
 #include "../../../C/BwtSort.h"
 #include "../../../C/HuffEnc.h"
-#include "BZip2Crc.h"
 #include "BZip2Encoder.h"
-#include "Mtf8.h"
 namespace NCompress {
 namespace NBZip2 {
-const unsigned kMaxHuffmanLenForEncoding = 16; // it must be < kMaxHuffmanLen = 20
+#define HUFFMAN_LEN 16
+#if HUFFMAN_LEN > Z7_HUFFMAN_LEN_MAX
-static const UInt32 kBufferSize = (1 << 17);
+  #error Stop_Compiling_Bad_HUFFMAN_LEN_BZip2Encoder
+#endif
+  
+static const size_t kBufferSize = 1 << 17;
 static const unsigned kNumHuffPasses = 4;
 bool CThreadInfo::Alloc()
 {
  if (!m_BlockSorterIndex)
@@ -27,11 +29,15 @@ bool CThreadInfo::Alloc()
      return false;
  }
-  if (!m_Block)
+  if (!m_Block_Base)
  {
-    m_Block = (Byte *)::MidAlloc(kBlockSizeMax * 5 + kBlockSizeMax / 10 + (20 << 10));
+    const unsigned kPadSize = 1 << 7; // we need at least 1 byte backward padding, becuase we use (m_Block - 1) pointer;
-    if (!m_Block)
+    m_Block_Base = (Byte *)::MidAlloc(kBlockSizeMax * 5
+        + kBlockSizeMax / 10 + (20 << 10)
+        + kPadSize);
+    if (!m_Block_Base)
      return false;
+    m_Block = m_Block_Base + kPadSize;
    m_MtfArray = m_Block + kBlockSizeMax;
    m_TempArray = m_MtfArray + kBlockSizeMax * 2 + 2;
  }
@@ -42,8 +48,8 @@ void CThreadInfo::Free()
 {
  ::BigFree(m_BlockSorterIndex);
  m_BlockSorterIndex = NULL;
-  ::MidFree(m_Block);
+  ::MidFree(m_Block_Base);
-  m_Block = NULL;
+  m_Block_Base = NULL;
 }
 #ifndef Z7_ST
@@ -60,6 +66,14 @@ HRESULT CThreadInfo::Create()
  if (wres == 0) { wres = CanWriteEvent.Create();
  if (wres == 0)
  {
+#ifdef _WIN32
+    if (Encoder->_props.NumThreadGroups != 0)
+    {
+       const UInt32 group = ThreadNextGroup_GetNext(&Encoder->ThreadNextGroup);
+      wres = Thread.Create_With_Group(MFThread, this, group, 0); // affinity
+    }
+    else
+#endif
    if (Encoder->_props.Affinity != 0)
      wres = Thread.Create_With_Affinity(MFThread, this, (CAffinityMask)Encoder->_props.Affinity);
    else
@@ -216,94 +230,251 @@ void CEncoder::Free()
 }
 #endif
+struct CRleEncoder
+{
+  const Byte *_src;
+  const Byte *_srcLim;
+  Byte *_dest;
+  const Byte *_destLim;
+  Byte _prevByte;
+  unsigned _numReps;
+  void Encode();
+};
+Z7_NO_INLINE
+void CRleEncoder::Encode()
+{
+  const Byte *src = _src;
+  const Byte * const srcLim = _srcLim;
+  Byte *dest = _dest;
+  const Byte * const destLim = _destLim;
+  Byte prev = _prevByte;
+  unsigned numReps = _numReps;
+  // (dest < destLim)
+  // src = srcLim; // for debug
+  while (dest < destLim)
+  {
+    if (src == srcLim)
+      break;
+    const Byte b = *src++;
+    if (b != prev)
+    {
+      if (numReps >= kRleModeRepSize)
+        *dest++ = (Byte)(numReps - kRleModeRepSize);
+      *dest++ = b;
+      numReps = 1;
+      prev = b;
+      /*
+      { // speed optimization code:
+        if (dest >= destLim || src == srcLim)
+          break;
+        const Byte b2 = *src++;
+        *dest++ = b2;
+        numReps += (prev == b2);
+        prev = b2;
+      }
+      */
+      continue;
+    }
+    numReps++;
+    if (numReps <= kRleModeRepSize)
+      *dest++ = b;
+    else if (numReps == kRleModeRepSize + 255)
+    {
+      *dest++ = (Byte)(numReps - kRleModeRepSize);
+      numReps = 0;
+    }
+  }
+  _src = src;
+  _dest = dest;
+  _prevByte = prev;
+  _numReps = numReps;
+  // (dest <= destLim + 1)
+}
+// out: return value is blockSize: size of data filled in buffer[]:
+// (returned_blockSize <= _props.BlockSizeMult * kBlockSizeStep)
 UInt32 CEncoder::ReadRleBlock(Byte *buffer)
 {
+  CRleEncoder rle;
  UInt32 i = 0;
-  Byte prevByte;
+  if (m_InStream.ReadByte(rle._prevByte))
-  if (m_InStream.ReadByte(prevByte))
  {
    NumBlocks++;
-    const UInt32 blockSize = _props.BlockSizeMult * kBlockSizeStep - 1;
+    const UInt32 blockSize = _props.BlockSizeMult * kBlockSizeStep - 1; // -1 for RLE
-    unsigned numReps = 1;
+    rle._destLim = buffer + blockSize;
-    buffer[i++] = prevByte;
+    rle._numReps = 1;
-    while (i < blockSize) // "- 1" to support RLE
+    buffer[i++] = rle._prevByte;
+    while (i < blockSize)
    {
-      Byte b;
+      rle._dest = buffer + i;
-      if (!m_InStream.ReadByte(b))
+      size_t rem;
+      const Byte * const ptr = m_InStream.Lookahead(rem);
+      if (rem == 0)
        break;
-      if (b != prevByte)
+      rle._src = ptr;
-      {
+      rle._srcLim = ptr + rem;
-        if (numReps >= kRleModeRepSize)
+      rle.Encode();
-          buffer[i++] = (Byte)(numReps - kRleModeRepSize);
+      m_InStream.Skip((size_t)(rle._src - ptr));
-        buffer[i++] = b;
+      i = (UInt32)(size_t)(rle._dest - buffer);
-        numReps = 1;
+      // (i <= blockSize + 1)
-        prevByte = b;
-        continue;
-      }
-      numReps++;
-      if (numReps <= kRleModeRepSize)
-        buffer[i++] = b;
-      else if (numReps == kRleModeRepSize + 255)
-      {
-        buffer[i++] = (Byte)(numReps - kRleModeRepSize);
-        numReps = 0;
-      }
    }
-    // it's to support original BZip2 decoder
+    const int n = (int)rle._numReps - (int)kRleModeRepSize;
-    if (numReps >= kRleModeRepSize)
+    if (n >= 0)
-      buffer[i++] = (Byte)(numReps - kRleModeRepSize);
+      buffer[i++] = (Byte)n;
  }
  return i;
 }
-void CThreadInfo::WriteBits2(UInt32 value, unsigned numBits) { m_OutStreamCurrent->WriteBits(value, numBits); }
-void CThreadInfo::WriteByte2(Byte b) { WriteBits2(b, 8); }
-void CThreadInfo::WriteBit2(Byte v) { WriteBits2(v, 1); }
+Z7_NO_INLINE
-void CThreadInfo::WriteCrc2(UInt32 v)
+void CThreadInfo::WriteBits2(UInt32 value, unsigned numBits)
-{
+  { m_OutStreamCurrent.WriteBits(value, numBits); }
-  for (unsigned i = 0; i < 4; i++)
+/*
-    WriteByte2(((Byte)(v >> (24 - i * 8))));
+Z7_NO_INLINE
+void CThreadInfo::WriteByte2(unsigned b)
+  { m_OutStreamCurrent.WriteByte(b); }
+*/
+// void CEncoder::WriteBits(UInt32 value, unsigned numBits) { m_OutStream.WriteBits(value, numBits); }
+Z7_NO_INLINE
+void CEncoder::WriteByte(Byte b) { m_OutStream.WriteByte(b); }
+#define WRITE_BITS_UPDATE(value, numBits) \
+{ \
+  numBits -= _bitPos; \
+  const UInt32 hi = value >> numBits; \
+  *_buf++ = (Byte)(_curByte | hi); \
+  value -= hi << numBits; \
+  _bitPos = 8; \
+  _curByte = 0; \
 }
-void CEncoder::WriteBits(UInt32 value, unsigned numBits) { m_OutStream.WriteBits(value, numBits); }
+#if HUFFMAN_LEN > 16
-void CEncoder::WriteByte(Byte b) { WriteBits(b, 8); }
-// void CEncoder::WriteBit(Byte v) { WriteBits(v, 1); }
+#define WRITE_BITS_HUFF(value2, numBits2) \
-void CEncoder::WriteCrc(UInt32 v)
+{ \
-{
+  UInt32 value = value2; \
-  for (unsigned i = 0; i < 4; i++)
+  unsigned numBits = numBits2; \
-    WriteByte(((Byte)(v >> (24 - i * 8))));
+  while (numBits >= _bitPos) { \
+    WRITE_BITS_UPDATE(value, numBits) \
+  } \
+  _bitPos -= numBits; \
+  _curByte |= (value << _bitPos); \
+}
+#else // HUFFMAN_LEN <= 16
+// numBits2 <= 16 is supported
+#define WRITE_BITS_HUFF(value2, numBits2) \
+{ \
+  UInt32 value = value2; \
+  unsigned numBits = numBits2; \
+  if (numBits >= _bitPos) \
+  { \
+    WRITE_BITS_UPDATE(value, numBits) \
+    if (numBits >= _bitPos) \
+    { \
+      numBits -= _bitPos; \
+      const UInt32 hi = value >> numBits; \
+      *_buf++ = (Byte)hi; \
+      value -= hi << numBits; \
+    } \
+  } \
+  _bitPos -= numBits; \
+  _curByte |= (value << _bitPos); \
+}
+#endif
+#define WRITE_BITS_8(value2, numBits2) \
+{ \
+  UInt32 value = value2; \
+  unsigned numBits = numBits2; \
+  if (numBits >= _bitPos) \
+  { \
+    WRITE_BITS_UPDATE(value, numBits) \
+  } \
+  _bitPos -= numBits; \
+  _curByte |= (value << _bitPos); \
+}
+#define WRITE_BIT_PRE \
+  { _bitPos--; }
+#define WRITE_BIT_POST \
+{ \
+  if (_bitPos == 0) \
+  { \
+    *_buf++ = (Byte)_curByte; \
+    _curByte = 0; \
+    _bitPos = 8; \
+  } \
+}
+#define WRITE_BIT_0 \
+{ \
+  WRITE_BIT_PRE \
+  WRITE_BIT_POST \
+}
+#define WRITE_BIT_1 \
+{ \
+  WRITE_BIT_PRE \
+  _curByte |= 1u << _bitPos; \
+  WRITE_BIT_POST \
 }
 // blockSize > 0
 void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
 {
-  WriteBit2(0); // Randomised = false
+  // WriteBit2(0); // Randomised = false
-  
  {
-    UInt32 origPtr = BlockSort(m_BlockSorterIndex, block, blockSize);
+    const UInt32 origPtr = BlockSort(m_BlockSorterIndex, block, blockSize);
    // if (m_BlockSorterIndex[origPtr] != 0) throw 1;
    m_BlockSorterIndex[origPtr] = blockSize;
-    WriteBits2(origPtr, kNumOrigBits);
+    WriteBits2(origPtr, kNumOrigBits + 1); // + 1 for additional high bit flag (Randomised = false)
  }
+  Byte mtfBuf[256];
-  CMtf8Encoder mtf;
+  // memset(mtfBuf, 0, sizeof(mtfBuf)); // to disable MSVC warning
-  unsigned numInUse = 0;
+  unsigned numInUse;
  {
    Byte inUse[256];
    Byte inUse16[16];
-    UInt32 i;
+    unsigned i;
    for (i = 0; i < 256; i++)
      inUse[i] = 0;
    for (i = 0; i < 16; i++)
      inUse16[i] = 0;
-    for (i = 0; i < blockSize; i++)
+    {
-      inUse[block[i]] = 1;
+      const Byte *       cur = block;
+      block = block + (size_t)blockSize - 1;
+      if (cur != block)
+      {
+        do
+        {
+          const unsigned b0 = cur[0];
+          const unsigned b1 = cur[1];
+          cur += 2;
+          inUse[b0] = 1;
+          inUse[b1] = 1;
+        }
+        while (cur < block);
+      }
+      if (cur == block)
+        inUse[cur[0]] = 1;
+      block -= blockSize; // block pointer is (original_block - 1)
+    }
+    numInUse = 0;
    for (i = 0; i < 256; i++)
      if (inUse[i])
      {
        inUse16[i >> 4] = 1;
-        mtf.Buf[numInUse++] = (Byte)i;
+        mtfBuf[numInUse++] = (Byte)i;
      }
    for (i = 0; i < 16; i++)
      WriteBit2(inUse16[i]);
@@ -311,65 +482,88 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
      if (inUse16[i >> 4])
        WriteBit2(inUse[i]);
  }
-  unsigned alphaSize = numInUse + 2;
+  const unsigned alphaSize = numInUse + 2;
-  Byte *mtfs = m_MtfArray;
-  UInt32 mtfArraySize = 0;
  UInt32 symbolCounts[kMaxAlphaSize];
  {
    for (unsigned i = 0; i < kMaxAlphaSize; i++)
      symbolCounts[i] = 0;
+    symbolCounts[(size_t)alphaSize - 1] = 1;
  }
+  Byte *mtfs = m_MtfArray;
  {
-    UInt32 rleSize = 0;
-    UInt32 i = 0;
    const UInt32 *bsIndex = m_BlockSorterIndex;
-    block--;
+    const UInt32 *bsIndex_rle = bsIndex;
+    const UInt32 * const bsIndex_end = bsIndex + blockSize;
+    // block--; // backward fix
+    // block pointer is (original_block - 1)
    do
    {
-      unsigned pos = mtf.FindAndMove(block[bsIndex[i]]);
+      const Byte v = block[*bsIndex++];
-      if (pos == 0)
+      Byte a = mtfBuf[0];
-        rleSize++;
+      if (v != a)
-      else
      {
-        while (rleSize != 0)
+        mtfBuf[0] = v;
        {
-          rleSize--;
+          UInt32 rleSize = (UInt32)(size_t)(bsIndex - bsIndex_rle) - 1;
-          mtfs[mtfArraySize++] = (Byte)(rleSize & 1);
+          bsIndex_rle = bsIndex;
-          symbolCounts[rleSize & 1]++;
+          while (rleSize)
-          rleSize >>= 1;
+          {
+            const unsigned sym = (unsigned)(--rleSize & 1);
+            *mtfs++ = (Byte)sym;
+            symbolCounts[sym]++;
+            rleSize >>= 1;
+          }
        }
-        if (pos >= 0xFE)
+        unsigned pos1 = 2; // = real_pos + 1
+        Byte b;
+               b = mtfBuf[1];  mtfBuf[1] = a;  if (v != b)
+             { a = mtfBuf[2];  mtfBuf[2] = b;  if (v == a) pos1 = 3;
+        else { b = mtfBuf[3];  mtfBuf[3] = a;  if (v == b) pos1 = 4;
+        else
+        {
+          Byte *m = mtfBuf + 7;
+          for (;;)
+          {
+            a = m[-3];  m[-3] = b;           if (v == a) { pos1 = (unsigned)(size_t)(m - (mtfBuf + 2)); break; }
+            b = m[-2];  m[-2] = a;           if (v == b) { pos1 = (unsigned)(size_t)(m - (mtfBuf + 1)); break; }
+            a = m[-1];  m[-1] = b;           if (v == a) { pos1 = (unsigned)(size_t)(m - (mtfBuf    )); break; }
+            b = m[ 0];  m[ 0] = a;  m += 4;  if (v == b) { pos1 = (unsigned)(size_t)(m - (mtfBuf + 3)); break; }
+          }
+        }}}
+        symbolCounts[pos1]++;
+        if (pos1 >= 0xff)
        {
-          mtfs[mtfArraySize++] = 0xFF;
+          *mtfs++ = 0xff;
-          mtfs[mtfArraySize++] = (Byte)(pos - 0xFE);
+          // pos1 -= 0xff;
+          pos1++; // we need only low byte
        }
-        else
+        *mtfs++ = (Byte)pos1;
-          mtfs[mtfArraySize++] = (Byte)(pos + 1);
-        symbolCounts[(size_t)pos + 1]++;
      }
    }
-    while (++i < blockSize);
+    while (bsIndex < bsIndex_end);
-    while (rleSize != 0)
+    UInt32 rleSize = (UInt32)(size_t)(bsIndex - bsIndex_rle);
+    while (rleSize)
    {
-      rleSize--;
+      const unsigned sym = (unsigned)(--rleSize & 1);
-      mtfs[mtfArraySize++] = (Byte)(rleSize & 1);
+      *mtfs++ = (Byte)sym;
-      symbolCounts[rleSize & 1]++;
+      symbolCounts[sym]++;
      rleSize >>= 1;
    }
+    
-    if (alphaSize < 256)
+    unsigned d = alphaSize - 1;
-      mtfs[mtfArraySize++] = (Byte)(alphaSize - 1);
+    if (alphaSize >= 256)
-    else
    {
-      mtfs[mtfArraySize++] = 0xFF;
+      *mtfs++ = 0xff;
-      mtfs[mtfArraySize++] = (Byte)(alphaSize - 256);
+      d = alphaSize; // (-256)
    }
-    symbolCounts[(size_t)alphaSize - 1]++;
+    *mtfs++ = (Byte)d;
  }
+  const Byte * const mtf_lim = mtfs;
  UInt32 numSymbols = 0;
  {
    for (unsigned i = 0; i < kMaxAlphaSize; i++)
@@ -378,34 +572,30 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
  unsigned bestNumTables = kNumTablesMin;
  UInt32 bestPrice = 0xFFFFFFFF;
-  UInt32 startPos = m_OutStreamCurrent->GetPos();
+  const UInt32 startPos = m_OutStreamCurrent.GetPos();
-  Byte startCurByte = m_OutStreamCurrent->GetCurByte();
+  const unsigned startCurByte = m_OutStreamCurrent.GetCurByte();
  for (unsigned nt = kNumTablesMin; nt <= kNumTablesMax + 1; nt++)
  {
    unsigned numTables;
    if (m_OptimizeNumTables)
    {
-      m_OutStreamCurrent->SetPos(startPos);
+      m_OutStreamCurrent.SetPos(startPos);
-      m_OutStreamCurrent->SetCurState((startPos & 7), startCurByte);
+      m_OutStreamCurrent.SetCurState(startPos & 7, startCurByte);
-      if (nt <= kNumTablesMax)
+      numTables = (nt <= kNumTablesMax ? nt : bestNumTables);
-        numTables = nt;
-      else
-        numTables = bestNumTables;
    }
    else
    {
-      if (numSymbols < 200)  numTables = 2;
+           if (numSymbols <  200) numTables = 2;
-      else if (numSymbols < 600) numTables = 3;
+      else if (numSymbols <  600) numTables = 3;
      else if (numSymbols < 1200) numTables = 4;
      else if (numSymbols < 2400) numTables = 5;
-      else numTables = 6;
+      else                        numTables = 6;
    }
    WriteBits2(numTables, kNumTablesBits);
-    
+    const unsigned numSelectors = (numSymbols + kGroupSize - 1) / kGroupSize;
-    UInt32 numSelectors = (numSymbols + kGroupSize - 1) / kGroupSize;
+    WriteBits2((UInt32)numSelectors, kNumSelectorsBits);
-    WriteBits2(numSelectors, kNumSelectorsBits);
    
    {
      UInt32 remFreq = numSymbols;
@@ -436,28 +626,23 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
    
    for (unsigned pass = 0; pass < kNumHuffPasses; pass++)
    {
+      memset(Freqs, 0, sizeof(Freqs[0]) * numTables);
+      // memset(Freqs, 0, sizeof(Freqs));
      {
-        unsigned t = 0;
+        mtfs = m_MtfArray;
-        do
-          memset(Freqs[t], 0, sizeof(Freqs[t]));
-        while (++t < numTables);
-      }
-      
-      {
-        UInt32 mtfPos = 0;
        UInt32 g = 0;
        do
        {
-          UInt32 symbols[kGroupSize];
+          unsigned symbols[kGroupSize];
          unsigned i = 0;
          do
          {
-            UInt32 symbol = mtfs[mtfPos++];
+            UInt32 symbol = *mtfs++;
            if (symbol >= 0xFF)
-              symbol += mtfs[mtfPos++];
+              symbol += *mtfs++;
            symbols[i] = symbol;
          }
-          while (++i < kGroupSize && mtfPos < mtfArraySize);
+          while (++i < kGroupSize && mtfs < mtf_lim);
          
          UInt32 bestPrice2 = 0xFFFFFFFF;
          unsigned t = 0;
@@ -482,7 +667,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
            freqs[symbols[j]]++;
          while (++j < i);
        }
-        while (mtfPos < mtfArraySize);
+        while (mtfs < mtf_lim);
      }
      
      unsigned t = 0;
@@ -494,11 +679,15 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
          if (freqs[i] == 0)
            freqs[i] = 1;
        while (++i < alphaSize);
-        Huffman_Generate(freqs, Codes[t], Lens[t], kMaxAlphaSize, kMaxHuffmanLenForEncoding);
+        Huffman_Generate(freqs, Codes[t], Lens[t], kMaxAlphaSize, HUFFMAN_LEN);
      }
      while (++t < numTables);
    }
    
+    unsigned _bitPos;  // 0 < _bitPos <= 8 : number of non-filled low bits in _curByte
+    unsigned _curByte; // low (_bitPos) bits are zeros
+                       // high (8 - _bitPos) bits are filled
+    Byte *_buf;
    {
      Byte mtfSel[kNumTablesMax];
      {
@@ -507,81 +696,97 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
          mtfSel[t] = (Byte)t;
        while (++t < numTables);
      }
+      _bitPos = m_OutStreamCurrent._bitPos;
+      _curByte = m_OutStreamCurrent._curByte;
+      _buf = m_OutStreamCurrent._buf;
+      // stream.Init_from_Global(m_OutStreamCurrent);
      
-      UInt32 i = 0;
+      const Byte *selectors = m_Selectors;
+      const Byte * const selectors_lim = selectors + numSelectors;
+      Byte prev = 0; // mtfSel[0];
      do
      {
-        Byte sel = m_Selectors[i];
+        const Byte sel = *selectors++;
-        unsigned pos;
+        if (prev != sel)
-        for (pos = 0; mtfSel[pos] != sel; pos++)
+        {
-          WriteBit2(1);
+          Byte *mtfSel_cur = &mtfSel[1];
-        WriteBit2(0);
+          for (;;)
-        for (; pos > 0; pos--)
+          {
-          mtfSel[pos] = mtfSel[(size_t)pos - 1];
+            WRITE_BIT_1
-        mtfSel[0] = sel;
+            const Byte next = *mtfSel_cur;
+            *mtfSel_cur++ = prev;
+            prev = next;
+            if (next == sel)
+              break;
+          }
+          // mtfSel[0] = sel;
+        }
+        WRITE_BIT_0
      }
-      while (++i < numSelectors);
+      while (selectors != selectors_lim);
    }
-    
    {
      unsigned t = 0;
      do
      {
        const Byte *lens = Lens[t];
-        UInt32 len = lens[0];
+        unsigned len = lens[0];
-        WriteBits2(len, kNumLevelsBits);
+        WRITE_BITS_8(len, kNumLevelsBits)
        unsigned i = 0;
        do
        {
-          UInt32 level = lens[i];
+          const unsigned level = lens[i];
          while (len != level)
          {
-            WriteBit2(1);
+            WRITE_BIT_1
            if (len < level)
            {
-              WriteBit2(0);
              len++;
+              WRITE_BIT_0
            }
            else
            {
-              WriteBit2(1);
              len--;
+              WRITE_BIT_1
            }
          }
-          WriteBit2(0);
+          WRITE_BIT_0
        }
        while (++i < alphaSize);
      }
      while (++t < numTables);
    }
-    
    {
-      UInt32 groupSize = 0;
+      UInt32 groupSize = 1;
-      UInt32 groupIndex = 0;
+      const Byte *selectors = m_Selectors;
      const Byte *lens = NULL;
      const UInt32 *codes = NULL;
-      UInt32 mtfPos = 0;
+      mtfs = m_MtfArray;
      do
      {
-        UInt32 symbol = mtfs[mtfPos++];
+        unsigned symbol = *mtfs++;
        if (symbol >= 0xFF)
-          symbol += mtfs[mtfPos++];
+          symbol += *mtfs++;
-        if (groupSize == 0)
+        if (--groupSize == 0)
        {
          groupSize = kGroupSize;
-          unsigned t = m_Selectors[groupIndex++];
+          const unsigned t = *selectors++;
          lens = Lens[t];
          codes = Codes[t];
        }
-        groupSize--;
+        WRITE_BITS_HUFF(codes[symbol], lens[symbol])
-        m_OutStreamCurrent->WriteBits(codes[symbol], lens[symbol]);
      }
-      while (mtfPos < mtfArraySize);
+      while (mtfs < mtf_lim);
    }
+    // Restore_from_Local:
+    m_OutStreamCurrent._bitPos = _bitPos;
+    m_OutStreamCurrent._curByte = _curByte;
+    m_OutStreamCurrent._buf = _buf;
    if (!m_OptimizeNumTables)
      break;
-    UInt32 price = m_OutStreamCurrent->GetPos() - startPos;
+    const UInt32 price = m_OutStreamCurrent.GetPos() - startPos;
    if (price <= bestPrice)
    {
      if (nt == kNumTablesMax)
@@ -592,6 +797,7 @@ void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
  }
 }
 // blockSize > 0
 UInt32 CThreadInfo::EncodeBlockWithHeaders(const Byte *block, UInt32 blockSize)
 {
@@ -603,148 +809,134 @@ UInt32 CThreadInfo::EncodeBlockWithHeaders(const Byte *block, UInt32 blockSize)
  WriteByte2(kBlockSig5);
  CBZip2Crc crc;
-  unsigned numReps = 0;
+  const Byte * const lim = block + blockSize;
-  Byte prevByte = block[0];
+  unsigned b = *block++;
-  UInt32 i = 0;
+  crc.UpdateByte(b);
-  do
+  for (;;)
  {
-    Byte b = block[i];
+    const unsigned prev = b;
-    if (numReps == kRleModeRepSize)
+    if (block >= lim) { break; } b = *block++;  crc.UpdateByte(b);  if (prev != b) continue;
-    {
+    if (block >= lim) { break; } b = *block++;  crc.UpdateByte(b);  if (prev != b) continue;
-      for (; b > 0; b--)
+    if (block >= lim) { break; } b = *block++;  crc.UpdateByte(b);  if (prev != b) continue;
-        crc.UpdateByte(prevByte);
+    if (block >= lim) { break; } b = *block++;  if (b) do crc.UpdateByte(prev); while (--b);
-      numReps = 0;
+    if (block >= lim) { break; } b = *block++;  crc.UpdateByte(b);
-      continue;
-    }
-    if (prevByte == b)
-      numReps++;
-    else
-    {
-      numReps = 1;
-      prevByte = b;
-    }
-    crc.UpdateByte(b);
  }
-  while (++i < blockSize);
+  const UInt32 crcRes = crc.GetDigest();
-  UInt32 crcRes = crc.GetDigest();
+  for (int i = 24; i >= 0; i -= 8)
-  WriteCrc2(crcRes);
+    WriteByte2((Byte)(crcRes >> i));
-  EncodeBlock(block, blockSize);
+  EncodeBlock(lim - blockSize, blockSize);
  return crcRes;
 }
 void CThreadInfo::EncodeBlock2(const Byte *block, UInt32 blockSize, UInt32 numPasses)
 {
-  UInt32 numCrcs = m_NumCrcs;
+  const UInt32 numCrcs = m_NumCrcs;
-  bool needCompare = false;
+  const UInt32 startBytePos = m_OutStreamCurrent.GetBytePos();
-  UInt32 startBytePos = m_OutStreamCurrent->GetBytePos();
+  const UInt32 startPos = m_OutStreamCurrent.GetPos();
-  UInt32 startPos = m_OutStreamCurrent->GetPos();
+  const unsigned startCurByte = m_OutStreamCurrent.GetCurByte();
-  Byte startCurByte = m_OutStreamCurrent->GetCurByte();
+  unsigned endCurByte = 0;
-  Byte endCurByte = 0;
+  UInt32 endPos = 0; // 0 means no no additional passes
-  UInt32 endPos = 0;
  if (numPasses > 1 && blockSize >= (1 << 10))
  {
-    UInt32 blockSize0 = blockSize / 2; // ????
+    UInt32 bs0 = blockSize / 2;
-    
+    for (; bs0 < blockSize &&
-    for (; (block[blockSize0] == block[(size_t)blockSize0 - 1]
+           (block[        bs0    ] ==
-            || block[(size_t)blockSize0 - 1] == block[(size_t)blockSize0 - 2])
+            block[(size_t)bs0 - 1] ||
-          && blockSize0 < blockSize;
+            block[(size_t)bs0 - 1] ==
-        blockSize0++);
+            block[(size_t)bs0 - 2]);
+      bs0++)
+    {}
    
-    if (blockSize0 < blockSize)
+    if (bs0 < blockSize)
    {
-      EncodeBlock2(block, blockSize0, numPasses - 1);
+      EncodeBlock2(block, bs0, numPasses - 1);
-      EncodeBlock2(block + blockSize0, blockSize - blockSize0, numPasses - 1);
+      EncodeBlock2(block + bs0, blockSize - bs0, numPasses - 1);
-      endPos = m_OutStreamCurrent->GetPos();
+      endPos = m_OutStreamCurrent.GetPos();
-      endCurByte = m_OutStreamCurrent->GetCurByte();
+      endCurByte = m_OutStreamCurrent.GetCurByte();
-      if ((endPos & 7) > 0)
+      // we prepare next byte as identical byte to starting byte for main encoding attempt:
+      if (endPos & 7)
        WriteBits2(0, 8 - (endPos & 7));
-      m_OutStreamCurrent->SetCurState((startPos & 7), startCurByte);
+      m_OutStreamCurrent.SetCurState((startPos & 7), startCurByte);
-      needCompare = true;
    }
  }
-  UInt32 startBytePos2 = m_OutStreamCurrent->GetBytePos();
+  const UInt32 startBytePos2 = m_OutStreamCurrent.GetBytePos();
-  UInt32 startPos2 = m_OutStreamCurrent->GetPos();
+  const UInt32 startPos2 = m_OutStreamCurrent.GetPos();
-  UInt32 crcVal = EncodeBlockWithHeaders(block, blockSize);
+  const UInt32 crcVal = EncodeBlockWithHeaders(block, blockSize);
-  UInt32 endPos2 = m_OutStreamCurrent->GetPos();
-  if (needCompare)
+  if (endPos)
  {
-    UInt32 size2 = endPos2 - startPos2;
+    const UInt32 size2 = m_OutStreamCurrent.GetPos() - startPos2;
-    if (size2 < endPos - startPos)
+    if (size2 >= endPos - startPos)
-    {
-      UInt32 numBytes = m_OutStreamCurrent->GetBytePos() - startBytePos2;
-      Byte *buffer = m_OutStreamCurrent->GetStream();
-      for (UInt32 i = 0; i < numBytes; i++)
-        buffer[startBytePos + i] = buffer[startBytePos2 + i];
-      m_OutStreamCurrent->SetPos(startPos + endPos2 - startPos2);
-      m_NumCrcs = numCrcs;
-      m_CRCs[m_NumCrcs++] = crcVal;
-    }
-    else
    {
-      m_OutStreamCurrent->SetPos(endPos);
+      m_OutStreamCurrent.SetPos(endPos);
-      m_OutStreamCurrent->SetCurState((endPos & 7), endCurByte);
+      m_OutStreamCurrent.SetCurState((endPos & 7), endCurByte);
+      return;
    }
+    const UInt32 numBytes = m_OutStreamCurrent.GetBytePos() - startBytePos2;
+    Byte * const buffer = m_OutStreamCurrent.GetStream();
+    memmove(buffer + startBytePos, buffer + startBytePos2, numBytes);
+    m_OutStreamCurrent.SetPos(startPos + size2);
+    // we don't call m_OutStreamCurrent.SetCurState() here because
+    // m_OutStreamCurrent._curByte is correct already
  }
-  else
+  m_CRCs[numCrcs] = crcVal;
-  {
+  m_NumCrcs = numCrcs + 1;
-    m_NumCrcs = numCrcs;
-    m_CRCs[m_NumCrcs++] = crcVal;
-  }
 }
 HRESULT CThreadInfo::EncodeBlock3(UInt32 blockSize)
 {
-  CMsbfEncoderTemp outStreamTemp;
+  CMsbfEncoderTemp &outStreamTemp = m_OutStreamCurrent;
  outStreamTemp.SetStream(m_TempArray);
  outStreamTemp.Init();
-  m_OutStreamCurrent = &outStreamTemp;
  m_NumCrcs = 0;
  EncodeBlock2(m_Block, blockSize, Encoder->_props.NumPasses);
-  #ifndef Z7_ST
+#ifndef Z7_ST
  if (Encoder->MtMode)
    Encoder->ThreadsInfo[m_BlockIndex].CanWriteEvent.Lock();
-  #endif
+#endif
  for (UInt32 i = 0; i < m_NumCrcs; i++)
    Encoder->CombinedCrc.Update(m_CRCs[i]);
-  Encoder->WriteBytes(m_TempArray, outStreamTemp.GetPos(), outStreamTemp.GetCurByte());
+  Encoder->WriteBytes(m_TempArray, outStreamTemp.GetPos(), outStreamTemp.GetNonFlushedByteBits());
  HRESULT res = S_OK;
-  #ifndef Z7_ST
+#ifndef Z7_ST
  if (Encoder->MtMode)
  {
    UInt32 blockIndex = m_BlockIndex + 1;
    if (blockIndex == Encoder->NumThreads)
      blockIndex = 0;
    if (Encoder->Progress)
    {
      const UInt64 packSize = Encoder->m_OutStream.GetProcessedSize();
      res = Encoder->Progress->SetRatioInfo(&m_UnpackSize, &packSize);
    }
    Encoder->ThreadsInfo[blockIndex].CanWriteEvent.Set();
  }
-  #endif
+#endif
  return res;
 }
-void CEncoder::WriteBytes(const Byte *data, UInt32 sizeInBits, Byte lastByte)
+void CEncoder::WriteBytes(const Byte *data, UInt32 sizeInBits, unsigned lastByteBits)
 {
-  UInt32 bytesSize = (sizeInBits >> 3);
+  m_OutStream.WriteBytes(data, sizeInBits >> 3);
-  for (UInt32 i = 0; i < bytesSize; i++)
+  sizeInBits &= 7;
-    m_OutStream.WriteBits(data[i], 8);
+  if (sizeInBits)
-  WriteBits(lastByte, (sizeInBits & 7));
+    m_OutStream.WriteBits(lastByteBits, sizeInBits);
 }
 HRESULT CEncoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
    const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
 {
+  ThreadNextGroup_Init(&ThreadNextGroup, _props.NumThreadGroups, 0); // startGroup
  NumBlocks = 0;
  #ifndef Z7_ST
  Progress = progress;
@@ -823,11 +1015,11 @@ HRESULT CEncoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
    {
      CThreadInfo &ti =
      #ifndef Z7_ST
-      ThreadsInfo[0];
+          ThreadsInfo[0];
      #else
-      ThreadsInfo;
+          ThreadsInfo;
      #endif
-      UInt32 blockSize = ReadRleBlock(ti.m_Block);
+      const UInt32 blockSize = ReadRleBlock(ti.m_Block);
      if (blockSize == 0)
        break;
      RINOK(ti.EncodeBlock3(blockSize))
@@ -845,8 +1037,11 @@ HRESULT CEncoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
  WriteByte(kFinSig3);
  WriteByte(kFinSig4);
  WriteByte(kFinSig5);
+  {
-  WriteCrc(CombinedCrc.GetDigest());
+    const UInt32 v = CombinedCrc.GetDigest();
+    for (int i = 24; i >= 0; i -= 8)
+      WriteByte((Byte)(v >> i));
+  }
  RINOK(Flush())
  if (!m_InStream.WasFinished())
    return E_FAIL;
@@ -869,14 +1064,21 @@ Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIA
  for (UInt32 i = 0; i < numProps; i++)
  {
    const PROPVARIANT &prop = coderProps[i];
-    PROPID propID = propIDs[i];
+    const PROPID propID = propIDs[i];
    if (propID == NCoderPropID::kAffinity)
    {
-      if (prop.vt == VT_UI8)
+      if (prop.vt != VT_UI8)
-        props.Affinity = prop.uhVal.QuadPart;
+        return E_INVALIDARG;
-      else
+      props.Affinity = prop.uhVal.QuadPart;
+      continue;
+    }
+    if (propID == NCoderPropID::kNumThreadGroups)
+    {
+      if (prop.vt != VT_UI4)
        return E_INVALIDARG;
+      props.NumThreadGroups = (UInt32)prop.ulVal;
      continue;
    }
@@ -884,7 +1086,7 @@ Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIA
      continue;
    if (prop.vt != VT_UI4)
      return E_INVALIDARG;
-    UInt32 v = (UInt32)prop.ulVal;
+    const UInt32 v = (UInt32)prop.ulVal;
    switch (propID)
    {
      case NCoderPropID::kNumPasses: props.NumPasses = v; break;
diff --git a/CPP/7zip/Compress/BZip2Encoder.h b/CPP/7zip/Compress/BZip2Encoder.h
index 4a04fbd..bcb4025 100644
--- a/CPP/7zip/Compress/BZip2Encoder.h
+++ b/CPP/7zip/Compress/BZip2Encoder.h
@@ -3,7 +3,6 @@
 #ifndef ZIP7_INC_COMPRESS_BZIP2_ENCODER_H
 #define ZIP7_INC_COMPRESS_BZIP2_ENCODER_H
-#include "../../Common/Defs.h"
 #include "../../Common/MyCom.h"
 #ifndef Z7_ST
@@ -23,80 +22,114 @@
 namespace NCompress {
 namespace NBZip2 {
-class CMsbfEncoderTemp
+const unsigned kNumPassesMax = 10;
+struct CMsbfEncoderTemp
 {
-  UInt32 _pos;
+  unsigned _bitPos;  // 0 < _bitPos <= 8 : number of non-filled low bits in _curByte
-  unsigned _bitPos;
+  unsigned _curByte; // low (_bitPos) bits are zeros
-  Byte _curByte;
+                     // high (8 - _bitPos) bits are filled
  Byte *_buf;
-public:
+  Byte *_buf_base;
-  void SetStream(Byte *buf) { _buf = buf;  }
+  void SetStream(Byte *buf) { _buf_base = _buf = buf;  }
-  Byte *GetStream() const { return _buf; }
+  Byte *GetStream() const { return _buf_base; }
  void Init()
  {
-    _pos = 0;
    _bitPos = 8;
    _curByte = 0;
+    _buf = _buf_base;
  }
-  void Flush()
+  // required condition: (value >> numBits) == 0
-  {
+  // numBits == 0 is allowed
-    if (_bitPos < 8)
-      WriteBits(0, _bitPos);
-  }
  void WriteBits(UInt32 value, unsigned numBits)
  {
-    while (numBits > 0)
+    do
    {
-      unsigned numNewBits = MyMin(numBits, _bitPos);
+      unsigned bp = _bitPos;
-      numBits -= numNewBits;
+      unsigned curByte = _curByte;
-      
+      if (numBits < bp)
-      _curByte = (Byte)(_curByte << numNewBits);
-      UInt32 newBits = value >> numBits;
-      _curByte |= Byte(newBits);
-      value -= (newBits << numBits);
-      
-      _bitPos -= numNewBits;
-      
-      if (_bitPos == 0)
      {
-       _buf[_pos++] = _curByte;
+        bp -= numBits;
-        _bitPos = 8;
+        _curByte = curByte | (value << bp);
+        _bitPos = bp;
+        return;
      }
+      numBits -= bp;
+      const UInt32 hi = value >> numBits;
+      value -= (hi << numBits);
+      Byte *buf = _buf;
+      _bitPos = 8;
+      _curByte = 0;
+      *buf++ = (Byte)(curByte | hi);
+      _buf = buf;
    }
+    while (numBits);
  }
-  
-  UInt32 GetBytePos() const { return _pos ; }
+  void WriteBit(unsigned value)
-  UInt32 GetPos() const { return _pos * 8 + (8 - _bitPos); }
+  {
-  Byte GetCurByte() const { return _curByte; }
+    const unsigned bp = _bitPos - 1;
+    const unsigned curByte = _curByte | (value << bp);
+    _curByte = curByte;
+    _bitPos = bp;
+    if (bp == 0)
+    {
+      *_buf++ = (Byte)curByte;
+      _curByte = 0;
+      _bitPos = 8;
+    }
+  }
+  void WriteByte(unsigned b)
+  {
+    const unsigned bp = _bitPos;
+    const unsigned a = _curByte | (b >> (8 - bp));
+    _curByte = b << bp;
+    Byte *buf = _buf;
+    *buf++ = (Byte)a;
+    _buf = buf;
+  }
+  UInt32 GetBytePos() const { return (UInt32)(size_t)(_buf - _buf_base); }
+  UInt32 GetPos() const { return GetBytePos() * 8 + 8 - _bitPos; }
+  unsigned GetCurByte() const { return _curByte; }
+  unsigned GetNonFlushedByteBits() const { return _curByte >> _bitPos; }
  void SetPos(UInt32 bitPos)
  {
-    _pos = bitPos >> 3;
+    _buf = _buf_base + (bitPos >> 3);
    _bitPos = 8 - ((unsigned)bitPos & 7);
  }
-  void SetCurState(unsigned bitPos, Byte curByte)
+  void SetCurState(unsigned bitPos, unsigned curByte)
  {
    _bitPos = 8 - bitPos;
    _curByte = curByte;
  }
 };
-class CEncoder;
-const unsigned kNumPassesMax = 10;
+class CEncoder;
 class CThreadInfo
 {
+private:
+  CMsbfEncoderTemp m_OutStreamCurrent;
 public:
+  CEncoder *Encoder;
  Byte *m_Block;
 private:
  Byte *m_MtfArray;
  Byte *m_TempArray;
  UInt32 *m_BlockSorterIndex;
-  CMsbfEncoderTemp *m_OutStreamCurrent;
+public:
+  bool m_OptimizeNumTables;
+  UInt32 m_NumCrcs;
+  UInt32 m_BlockIndex;
+  UInt64 m_UnpackSize;
+  Byte *m_Block_Base;
  Byte Lens[kNumTablesMax][kMaxAlphaSize];
  UInt32 Freqs[kNumTablesMax][kMaxAlphaSize];
@@ -105,20 +138,16 @@ private:
  Byte m_Selectors[kNumSelectorsMax];
  UInt32 m_CRCs[1 << kNumPassesMax];
-  UInt32 m_NumCrcs;
  void WriteBits2(UInt32 value, unsigned numBits);
-  void WriteByte2(Byte b);
+  void WriteByte2(unsigned b) { WriteBits2(b, 8); }
-  void WriteBit2(Byte v);
+  void WriteBit2(unsigned v)  { m_OutStreamCurrent.WriteBit(v); }
-  void WriteCrc2(UInt32 v);
  void EncodeBlock(const Byte *block, UInt32 blockSize);
  UInt32 EncodeBlockWithHeaders(const Byte *block, UInt32 blockSize);
  void EncodeBlock2(const Byte *block, UInt32 blockSize, UInt32 numPasses);
 public:
-  bool m_OptimizeNumTables;
+#ifndef Z7_ST
-  CEncoder *Encoder;
- #ifndef Z7_ST
  NWindows::CThread Thread;
  NWindows::NSynchronization::CAutoResetEvent StreamWasFinishedEvent;
@@ -127,17 +156,14 @@ public:
  // it's not member of this thread. We just need one event per thread
  NWindows::NSynchronization::CAutoResetEvent CanWriteEvent;
-private:
-  UInt32 m_BlockIndex;
-  UInt64 m_UnpackSize;
 public:
  Byte MtPad[1 << 8]; // It's pad for Multi-Threading. Must be >= Cache_Line_Size.
  HRESULT Create();
  void FinishStream(bool needLeave);
  THREAD_FUNC_RET_TYPE ThreadFunc();
- #endif
+#endif
-  CThreadInfo(): m_Block(NULL), m_BlockSorterIndex(NULL)  {}
+  CThreadInfo(): m_BlockSorterIndex(NULL), m_Block_Base(NULL) {}
  ~CThreadInfo() { Free(); }
  bool Alloc();
  void Free();
@@ -145,16 +171,19 @@ public:
  HRESULT EncodeBlock3(UInt32 blockSize);
 };
 struct CEncProps
 {
  UInt32 BlockSizeMult;
  UInt32 NumPasses;
+  UInt32 NumThreadGroups;
  UInt64 Affinity;
  
  CEncProps()
  {
    BlockSizeMult = (UInt32)(Int32)-1;
    NumPasses = (UInt32)(Int32)-1;
+    NumThreadGroups = 0;
    Affinity = 0;
  }
  void Normalize(int level);
@@ -206,6 +235,7 @@ public:
  bool CloseThreads;
  bool StreamWasFinished;
  NWindows::NSynchronization::CManualResetEvent CanStartWaitingEvent;
+  CThreadNextGroup ThreadNextGroup;
  HRESULT Result;
  ICompressProgressInfo *Progress;
@@ -218,12 +248,8 @@ public:
  UInt64 GetInProcessedSize() const { return m_InStream.GetProcessedSize(); }
  UInt32 ReadRleBlock(Byte *buf);
-  void WriteBytes(const Byte *data, UInt32 sizeInBits, Byte lastByte);
+  void WriteBytes(const Byte *data, UInt32 sizeInBits, unsigned lastByteBits);
-  void WriteBits(UInt32 value, unsigned numBits);
  void WriteByte(Byte b);
-  // void WriteBit(Byte v);
-  void WriteCrc(UInt32 v);
 #ifndef Z7_ST
  HRESULT Create();
diff --git a/CPP/7zip/Compress/BitlEncoder.h b/CPP/7zip/Compress/BitlEncoder.h
index 67b1428..364f84d 100644
--- a/CPP/7zip/Compress/BitlEncoder.h
+++ b/CPP/7zip/Compress/BitlEncoder.h
@@ -33,6 +33,7 @@ public:
    _bitPos = 8;
    _curByte = 0;
  }
+  Z7_FORCE_INLINE
  void WriteBits(UInt32 value, unsigned numBits)
  {
    while (numBits > 0)
diff --git a/CPP/7zip/Compress/BitmEncoder.h b/CPP/7zip/Compress/BitmEncoder.h
index 978ee1c..f7448cd 100644
--- a/CPP/7zip/Compress/BitmEncoder.h
+++ b/CPP/7zip/Compress/BitmEncoder.h
@@ -8,8 +8,9 @@
 template<class TOutByte>
 class CBitmEncoder
 {
-  unsigned _bitPos;
+  unsigned _bitPos;  // 0 < _bitPos <= 8 : number of non-filled low bits in _curByte
-  Byte _curByte;
+  unsigned _curByte; // low (_bitPos) bits are zeros
+                     // high (8 - _bitPos) bits are filled
  TOutByte _stream;
 public:
  bool Create(UInt32 bufferSize) { return _stream.Create(bufferSize); }
@@ -24,25 +25,65 @@ public:
  HRESULT Flush()
  {
    if (_bitPos < 8)
-      WriteBits(0, _bitPos);
+    {
+      _stream.WriteByte((Byte)_curByte);
+      _bitPos = 8;
+      _curByte = 0;
+    }
    return _stream.Flush();
  }
+  // required condition: (value >> numBits) == 0
+  // numBits == 0 is allowed
  void WriteBits(UInt32 value, unsigned numBits)
  {
-    while (numBits > 0)
+    do
    {
-      if (numBits < _bitPos)
+      unsigned bp = _bitPos;
+      unsigned curByte = _curByte;
+      if (numBits < bp)
      {
-        _curByte = (Byte)(_curByte | (value << (_bitPos -= numBits)));
+        bp -= numBits;
+        _curByte = curByte | (value << bp);
+        _bitPos = bp;
        return;
      }
-      numBits -= _bitPos;
+      numBits -= bp;
-      UInt32 newBits = (value >> numBits);
+      const UInt32 hi = (value >> numBits);
-      value -= (newBits << numBits);
+      value -= (hi << numBits);
-      _stream.WriteByte((Byte)(_curByte | newBits));
+      _stream.WriteByte((Byte)(curByte | hi));
      _bitPos = 8;
      _curByte = 0;
    }
+    while (numBits);
+  }
+  void WriteByte(unsigned b)
+  {
+    const unsigned bp = _bitPos;
+    const unsigned a = _curByte | (b >> (8 - bp));
+    _curByte = b << bp;
+   _stream.WriteByte((Byte)a);
+  }
+  void WriteBytes(const Byte *data, size_t num)
+  {
+    const unsigned bp = _bitPos;
+#if 1 // 1 for optional speed-optimized code branch
+    if (bp == 8)
+    {
+      _stream.WriteBytes(data, num);
+      return;
+    }
+#endif
+    unsigned c = _curByte;
+    const unsigned bp_rev = 8 - bp;
+    for (size_t i = 0; i < num; i++)
+    {
+      const unsigned b = data[i];
+      _stream.WriteByte((Byte)(c | (b >> bp_rev)));
+      c = b << bp;
+    }
+    _curByte = c;
  }
 };
diff --git a/CPP/7zip/Compress/DeflateDecoder.cpp b/CPP/7zip/Compress/DeflateDecoder.cpp
index 73895fe..7993176 100644
--- a/CPP/7zip/Compress/DeflateDecoder.cpp
+++ b/CPP/7zip/Compress/DeflateDecoder.cpp
@@ -117,15 +117,13 @@ bool CCoder::ReadTables(void)
      if (_numDistLevels > kDistTableSize32)
        return false;
    
-    Byte levelLevels[kLevelTableSize];
+    const unsigned kLevelTableSize_aligned4 = kLevelTableSize + 1;
-    for (unsigned i = 0; i < kLevelTableSize; i++)
+    Byte levelLevels[kLevelTableSize_aligned4];
-    {
+    memset (levelLevels, 0, sizeof(levelLevels));
-      const unsigned position = kCodeLengthAlphabetOrder[i];
+    unsigned i = 0;
-      if (i < numLevelCodes)
+    do
-        levelLevels[position] = (Byte)ReadBits(kLevelFieldSize);
+      levelLevels[kCodeLengthAlphabetOrder[i++]] = (Byte)ReadBits(kLevelFieldSize);
-      else
+    while (i != numLevelCodes);
-        levelLevels[position] = 0;
-    }
    
    if (m_InBitStream.ExtraBitsWereRead())
      return false;
diff --git a/CPP/7zip/Compress/DeflateEncoder.cpp b/CPP/7zip/Compress/DeflateEncoder.cpp
index 87b4f83..afc5f12 100644
--- a/CPP/7zip/Compress/DeflateEncoder.cpp
+++ b/CPP/7zip/Compress/DeflateEncoder.cpp
@@ -19,12 +19,16 @@
 #define NO_INLINE
 #endif
+#define MAX_HUF_LEN_12  12
 namespace NCompress {
 namespace NDeflate {
 namespace NEncoder {
+static const unsigned k_CodeValue_Len_Is_Literal_Flag = 1u << 15;
 static const unsigned kNumDivPassesMax = 10; // [0, 16); ratio/speed/ram tradeoff; use big value for better compression ratio.
-static const UInt32 kNumTables = (1 << kNumDivPassesMax);
+static const unsigned kNumTables = 1u << kNumDivPassesMax;
 static const UInt32 kFixedHuffmanCodeBlockSizeMax = (1 << 8); // [0, (1 << 32)); ratio/speed tradeoff; use big value for better compression ratio.
 static const UInt32 kDivideCodeBlockSizeMin = (1 << 7); // [1, (1 << 32)); ratio/speed tradeoff; use small value for better compression ratio.
@@ -77,7 +81,7 @@ public:
 static CFastPosInit g_FastPosInit;
-inline UInt32 GetPosSlot(UInt32 pos)
+inline unsigned GetPosSlot(UInt32 pos)
 {
  /*
  if (pos < 0x200)
@@ -162,13 +166,13 @@ HRESULT CCoder::Create()
  // COM_TRY_BEGIN
  if (!m_Values)
  {
-    m_Values = (CCodeValue *)MyAlloc((kMaxUncompressedBlockSize) * sizeof(CCodeValue));
+    m_Values = (CCodeValue *)MyAlloc(kMaxUncompressedBlockSize * sizeof(CCodeValue));
    if (!m_Values)
      return E_OUTOFMEMORY;
  }
  if (!m_Tables)
  {
-    m_Tables = (CTables *)MyAlloc((kNumTables) * sizeof(CTables));
+    m_Tables = (CTables *)MyAlloc(kNumTables * sizeof(CTables));
    if (!m_Tables)
      return E_OUTOFMEMORY;
  }
@@ -268,19 +272,21 @@ NO_INLINE void CCoder::GetMatches()
  UInt32 distanceTmp[kMatchMaxLen * 2 + 3];
  
-  const UInt32 numPairs = (UInt32)((_btMode ?
+  const size_t numPairs = (size_t)((_btMode ?
      Bt3Zip_MatchFinder_GetMatches(&_lzInWindow, distanceTmp):
      Hc3Zip_MatchFinder_GetMatches(&_lzInWindow, distanceTmp)) - distanceTmp);
-  *m_MatchDistances = (UInt16)numPairs;
+  UInt16 *matchDistances = m_MatchDistances;
+  *matchDistances++ = (UInt16)numPairs;
   
  if (numPairs != 0)
  {
-    UInt32 i;
+    size_t i;
    for (i = 0; i < numPairs; i += 2)
    {
-      m_MatchDistances[(size_t)i + 1] = (UInt16)distanceTmp[i];
+      matchDistances[0] = (UInt16)distanceTmp[i];
-      m_MatchDistances[(size_t)i + 2] = (UInt16)distanceTmp[(size_t)i + 1];
+      matchDistances[1] = (UInt16)distanceTmp[(size_t)i + 1];
+      matchDistances += 2;
    }
    UInt32 len = distanceTmp[(size_t)numPairs - 2];
    if (len == m_NumFastBytes && m_NumFastBytes != m_MatchMaxLen)
@@ -291,11 +297,11 @@ NO_INLINE void CCoder::GetMatches()
      if (numAvail > m_MatchMaxLen)
        numAvail = m_MatchMaxLen;
      for (; len < numAvail && pby[len] == pby2[len]; len++);
-      m_MatchDistances[(size_t)i - 1] = (UInt16)len;
+      matchDistances[-2] = (UInt16)len;
    }
  }
  if (m_IsMultiPass)
-    m_Pos += numPairs + 1;
+    m_Pos += (UInt32)numPairs + 1;
  if (!m_SecondPass)
    m_AdditionalOffset++;
 }
@@ -535,6 +541,7 @@ NO_INLINE void CCoder::WriteBits(UInt32 value, unsigned numBits)
 }
 #define WRITE_HF2(codes, lens, i) m_OutStream.WriteBits(codes[i], lens[i])
+#define WRITE_HF2_NO_INLINE(codes, lens, i)   WriteBits(codes[i], lens[i])
 #define WRITE_HF(i) WriteBits(codes[i], lens[i])
 NO_INLINE void CCoder::LevelTableCode(const Byte *levels, unsigned numLevels, const Byte *lens, const UInt32 *codes)
@@ -619,17 +626,22 @@ static NO_INLINE UInt32 Huffman_GetPrice(const UInt32 *freqs, const Byte *lens,
  return price;
 }
-static NO_INLINE UInt32 Huffman_GetPrice_Spec(const UInt32 *freqs, const Byte *lens, UInt32 num, const Byte *extraBits, UInt32 extraBase)
+static NO_INLINE UInt32 Huffman_GetPrice_Spec(
+    const UInt32 *freqs, const Byte *lens, UInt32 num,
+    const Byte *extraBits, UInt32 extraBase)
 {
-  return Huffman_GetPrice(freqs, lens, num) +
+  return
+    Huffman_GetPrice(freqs, lens, num) +
    Huffman_GetPrice(freqs + extraBase, extraBits, num - extraBase);
 }
 NO_INLINE UInt32 CCoder::GetLzBlockPrice() const
 {
  return
-    Huffman_GetPrice_Spec(mainFreqs, m_NewLevels.litLenLevels, kFixedMainTableSize, m_LenDirectBits, kSymbolMatch) +
+    Huffman_GetPrice_Spec(mainFreqs, m_NewLevels.litLenLevels,
-    Huffman_GetPrice_Spec(distFreqs, m_NewLevels.distLevels, kDistTableSize64, kDistDirectBits, 0);
+        kFixedMainTableSize, m_LenDirectBits, kSymbolMatch) +
+    Huffman_GetPrice_Spec(distFreqs, m_NewLevels.distLevels,
+        kDistTableSize64, kDistDirectBits, 0);
 }
 NO_INLINE void CCoder::TryBlock()
@@ -658,7 +670,7 @@ NO_INLINE void CCoder::TryBlock()
    CCodeValue &codeValue = m_Values[m_ValueIndex++];
    if (len >= kMatchMinLen)
    {
-      UInt32 newLen = len - kMatchMinLen;
+      const UInt32 newLen = len - kMatchMinLen;
      codeValue.Len = (UInt16)newLen;
      mainFreqs[kSymbolMatch + (size_t)g_LenSlots[newLen]]++;
      codeValue.Pos = (UInt16)pos;
@@ -666,10 +678,10 @@ NO_INLINE void CCoder::TryBlock()
    }
    else
    {
-      Byte b = *(Inline_MatchFinder_GetPointerToCurrentPos(&_lzInWindow) - m_AdditionalOffset);
+      const unsigned b = *(Inline_MatchFinder_GetPointerToCurrentPos(&_lzInWindow) - m_AdditionalOffset);
      mainFreqs[b]++;
-      codeValue.SetAsLiteral();
+      codeValue.Len = k_CodeValue_Len_Is_Literal_Flag;
-      codeValue.Pos = b;
+      codeValue.Pos = (UInt16)b;
    }
    m_AdditionalOffset -= len;
    BlockSizeRes += len;
@@ -704,16 +716,24 @@ NO_INLINE void CCoder::SetPrices(const CLevels &levels)
  }
 }
+#if MAX_HUF_LEN_12 > 12
+// Huffman_ReverseBits() now supports 12-bits values only.
+#error Stop_Compiling_Bad_MAX_HUF_LEN_12
+#endif
 static NO_INLINE void Huffman_ReverseBits(UInt32 *codes, const Byte *lens, UInt32 num)
 {
-  for (UInt32 i = 0; i < num; i++)
+  const Byte * const lens_lim = lens + num;
+  do
  {
-    UInt32 x = codes[i];
+    // we should change constants, if lens[*] can be larger than 12.
-    x = ((x & 0x5555) << 1) | ((x & 0xAAAA) >> 1);
+    UInt32 x = *codes;
-    x = ((x & 0x3333) << 2) | ((x & 0xCCCC) >> 2);
+    x = ((x & (0x555     )) << 2) + (x & (0xAAA     ));
-    x = ((x & 0x0F0F) << 4) | ((x & 0xF0F0) >> 4);
+    x = ((x & (0x333 << 1)) << 4) | (x & (0xCCC << 1));
-    codes[i] = (((x & 0x00FF) << 8) | ((x & 0xFF00) >> 8)) >> (16 - lens[i]);
+    x = ((x & (0xF0F << 3)) << 8) | (x & (0x0F0 << 3));
+    // we can use (x) instead of (x & (0xFF << 7)), if we support garabage data after (*lens) bits.
+    *codes++ = (((x & (0xFF << 7)) << 16) | x) >> (*lens ^ 31);
  }
+  while (++lens != lens_lim);
 }
 NO_INLINE void CCoder::WriteBlock()
@@ -721,24 +741,28 @@ NO_INLINE void CCoder::WriteBlock()
  Huffman_ReverseBits(mainCodes, m_NewLevels.litLenLevels, kFixedMainTableSize);
  Huffman_ReverseBits(distCodes, m_NewLevels.distLevels, kDistTableSize64);
-  for (UInt32 i = 0; i < m_ValueIndex; i++)
+  CCodeValue *values = m_Values;
+  const CCodeValue * const values_lim = values + m_ValueIndex;
+  if (values != values_lim)
+  do
  {
-    const CCodeValue &codeValue = m_Values[i];
+    const UInt32 len = values->Len;
-    if (codeValue.IsLiteral())
+    const UInt32 dist = values->Pos;
-      WRITE_HF2(mainCodes, m_NewLevels.litLenLevels, codeValue.Pos);
+    if (len == k_CodeValue_Len_Is_Literal_Flag)
+      WRITE_HF2(mainCodes, m_NewLevels.litLenLevels, dist);
    else
    {
-      UInt32 len = codeValue.Len;
+      const unsigned lenSlot = g_LenSlots[len];
-      UInt32 lenSlot = g_LenSlots[len];
      WRITE_HF2(mainCodes, m_NewLevels.litLenLevels, kSymbolMatch + lenSlot);
      m_OutStream.WriteBits(len - m_LenStart[lenSlot], m_LenDirectBits[lenSlot]);
-      UInt32 dist = codeValue.Pos;
+      const unsigned posSlot = GetPosSlot(dist);
-      UInt32 posSlot = GetPosSlot(dist);
      WRITE_HF2(distCodes, m_NewLevels.distLevels, posSlot);
      m_OutStream.WriteBits(dist - kDistStart[posSlot], kDistDirectBits[posSlot]);
    }
  }
-  WRITE_HF2(mainCodes, m_NewLevels.litLenLevels, kSymbolEndOfBlock);
+  while (++values != values_lim);
+  WRITE_HF2_NO_INLINE(mainCodes, m_NewLevels.litLenLevels, kSymbolEndOfBlock);
 }
 static UInt32 GetStorePrice(UInt32 blockSize, unsigned bitPosition)
@@ -787,10 +811,10 @@ NO_INLINE UInt32 CCoder::TryDynBlock(unsigned tableIndex, UInt32 numPasses)
  {
    m_Pos = posTemp;
    TryBlock();
-    unsigned numHuffBits =
+    const unsigned numHuffBits =
-        (m_ValueIndex > 18000 ? 12 :
+        m_ValueIndex > 18000 ? MAX_HUF_LEN_12 :
-        (m_ValueIndex >  7000 ? 11 :
+        m_ValueIndex >  7000 ? 11 :
-        (m_ValueIndex >  2000 ? 10 : 9)));
+        m_ValueIndex >  2000 ? 10 : 9;
    MakeTables(numHuffBits);
    SetPrices(m_NewLevels);
  }
diff --git a/CPP/7zip/Compress/Lzma2Encoder.cpp b/CPP/7zip/Compress/Lzma2Encoder.cpp
index 0dc7e23..ffe1152 100644
--- a/CPP/7zip/Compress/Lzma2Encoder.cpp
+++ b/CPP/7zip/Compress/Lzma2Encoder.cpp
@@ -52,7 +52,15 @@ HRESULT SetLzma2Prop(PROPID propID, const PROPVARIANT &prop, CLzma2EncProps &lzm
    case NCoderPropID::kNumThreads:
      if (prop.vt != VT_UI4)
        return E_INVALIDARG;
-      lzma2Props.numTotalThreads = (int)(prop.ulVal);
+      lzma2Props.numTotalThreads = (int)prop.ulVal;
+      break;
+    case NCoderPropID::kNumThreadGroups:
+      if (prop.vt != VT_UI4)
+        return E_INVALIDARG;
+      // 16-bit value supported by Windows
+      if (prop.ulVal >= (1u << 16))
+        return E_INVALIDARG;
+      lzma2Props.numThreadGroups = (unsigned)prop.ulVal;
      break;
    default:
      RINOK(NLzma::SetLzmaProp(propID, prop, lzma2Props.lzmaProps))
diff --git a/CPP/7zip/Compress/LzmaEncoder.cpp b/CPP/7zip/Compress/LzmaEncoder.cpp
index 08e3ba5..bca2eee 100644
--- a/CPP/7zip/Compress/LzmaEncoder.cpp
+++ b/CPP/7zip/Compress/LzmaEncoder.cpp
@@ -101,6 +101,24 @@ HRESULT SetLzmaProp(PROPID propID, const PROPVARIANT &prop, CLzmaEncProps &ep)
    return S_OK;
  }
+  if (propID == NCoderPropID::kAffinityInGroup)
+  {
+    if (prop.vt == VT_UI8)
+      ep.affinityInGroup = prop.uhVal.QuadPart;
+    else
+      return E_INVALIDARG;
+    return S_OK;
+  }
+  if (propID == NCoderPropID::kThreadGroup)
+  {
+    if (prop.vt == VT_UI4)
+      ep.affinityGroup = (Int32)(UInt32)prop.ulVal;
+    else
+      return E_INVALIDARG;
+    return S_OK;
+  }
  if (propID == NCoderPropID::kHashBits)
  {
    if (prop.vt == VT_UI4)
diff --git a/CPP/7zip/Compress/Mtf8.h b/CPP/7zip/Compress/Mtf8.h
index 1b44d00..5fce30e 100644
--- a/CPP/7zip/Compress/Mtf8.h
+++ b/CPP/7zip/Compress/Mtf8.h
@@ -13,6 +13,18 @@ struct CMtf8Encoder
  unsigned FindAndMove(Byte v) throw()
  {
+#if 1
+    Byte b = Buf[0];
+    if (v == b)
+      return 0;
+    Buf[0] = v;
+    for (unsigned pos = 0;;)
+    {
+      Byte a;
+      a = Buf[++pos];  Buf[pos] = b;  if (v == a) return pos;
+      b = Buf[++pos];  Buf[pos] = a;  if (v == b) return pos;
+    }
+#else
    size_t pos;
    for (pos = 0; Buf[pos] != v; pos++);
    const unsigned resPos = (unsigned)pos;
@@ -31,6 +43,7 @@ struct CMtf8Encoder
      Buf[pos] = Buf[pos - 1];
    Buf[0] = v;
    return resPos;
+#endif
  }
 };
diff --git a/CPP/7zip/Compress/Rar5Decoder.cpp b/CPP/7zip/Compress/Rar5Decoder.cpp
index 8be24e2..7279b5a 100644
--- a/CPP/7zip/Compress/Rar5Decoder.cpp
+++ b/CPP/7zip/Compress/Rar5Decoder.cpp
@@ -936,31 +936,30 @@ HRESULT CDecoder::ExecuteFilter(const CFilter &f)
 HRESULT CDecoder::WriteBuf()
 {
  DeleteUnusedFilters();
  const UInt64 lzSize = _lzSize + _winPos;
  for (unsigned i = 0; i < _numFilters;)
  {
-    const CFilter &f = _filters[i];
-    const UInt64 blockStart = f.Start;
    const size_t lzAvail = (size_t)(lzSize - _lzWritten);
    if (lzAvail == 0)
      break;
-    
+    // (lzAvail != 0)
+    const CFilter &f = _filters[i];
+    const UInt64 blockStart = f.Start;
    if (blockStart > _lzWritten)
    {
      const UInt64 rem = blockStart - _lzWritten;
+      // (rem != 0)
      size_t size = lzAvail;
      if (size > rem)
        size = (size_t)rem;
-      if (size != 0) // is it true always ?
+      // (size != 0)
-      {
+      RINOK(WriteData(_window + _winPos - lzAvail, size))
-        RINOK(WriteData(_window + _winPos - lzAvail, size))
+      _lzWritten += size;
-        _lzWritten += size;
-      }
      continue;
    }
-    
+    // (blockStart <= _lzWritten)
    const UInt32 blockSize = f.Size;
    size_t offset = (size_t)(_lzWritten - blockStart);
    if (offset == 0)
@@ -987,10 +986,8 @@ HRESULT CDecoder::WriteBuf()
  }
      
  DeleteUnusedFilters();
  if (_numFilters)
    return S_OK;
-  
  const size_t lzAvail = (size_t)(lzSize - _lzWritten);
  RINOK(WriteData(_window + _winPos - lzAvail, lzAvail))
  _lzWritten += lzAvail;
@@ -1367,6 +1364,12 @@ enum enum_exit_type
  Z7_HUFF_DECODE_CHECK(sym, huf, kNumHufBits, kNumTableBits, bitStream, { LZ_LOOP_BREAK_ERROR })
+/*
+  DecodeLZ2() will stop decoding if it reaches limit when (_winPos >= _limit)
+  at return:
+    (_winPos < _limit + kMaxMatchLen)
+    also it can write up to (COPY_CHUNK_SIZE - 1) additional junk bytes after (_winPos).
+*/
 HRESULT CDecoder::DecodeLZ2(const CBitDecoder &bitStream) throw()
 {
 #if 0
@@ -1656,6 +1659,13 @@ decode_error:
+/*
+input conditions:
+  _winPos < _winSize
+return:
+  _winPos <  _winSize is expected, if (return_res == S_OK)
+  _winPos >= _winSize is possible in (return_res != S_OK)
+*/
 HRESULT CDecoder::DecodeLZ()
 {
  CBitDecoder _bitStream;
@@ -1679,6 +1689,8 @@ HRESULT CDecoder::DecodeLZ()
    if (winPos >= limit)
    {
      _winPos = winPos < _winSize ? winPos : _winSize;
+      // _winPos == min(winPos, _winSize)
+      // we will not write data after _winSize
      RINOK(WriteBuf())
      if (_unpackSize_Defined && _writtenFileSize > _unpackSize)
        break; // return S_FALSE;
@@ -1854,7 +1866,15 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
  {
    // if (_winPos > 100) _winPos -= 100; // for debug: corruption
    const UInt64 lzSize = _lzSize + _winPos;
-    if (!_isSolid || !_wasInit
+/*
+    if previous file was decoded with error or for some another cases, then
+        (lzSize > _lzEnd)    is possible
+        (_winPos > _winSize) is possible
+        (_winPos < _winSize + kMaxMatchLen)
+*/
+    if (!_window
+        || !_isSolid
+        || !_wasInit
        || (lzSize < _lzEnd
 #if Z7_RAR_RECOVER_SOLID_LIMIT != 0
         && lzSize + Z7_RAR_RECOVER_SOLID_LIMIT < _lzEnd
@@ -1863,9 +1883,9 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
    {
      if (_isSolid)
        _lzError = LZ_ERROR_TYPE_HEADER;
-      _lzEnd = 0;
      _lzSize = 0;
-      _lzWritten = 0;
+      // _lzEnd = 0;     // it will be set later
+      // _lzWritten = 0; // it will be set later
      _winPos = 0;
      for (unsigned i = 0; i < kNumReps; i++)
        _reps[i] = (size_t)0 - 1;
@@ -1873,51 +1893,67 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
      _tableWasFilled = false;
      _wasInit = true;
    }
-#if Z7_RAR_RECOVER_SOLID_LIMIT != 0
+    else
-    else if (lzSize < _lzEnd)
    {
+      const size_t ws = _winSize;
+      if (_winPos >= ws)
+      {
+        // we must normalize (_winPos) and data in _window,
+        _winPos -= ws;
+        _lzSize += ws;
+        // (_winPos < kMaxMatchLen < _winSize)
+        // if (_window)
+          memcpy(_window, _window + ws, _winPos); // memmove is not required here
+      }
+#if Z7_RAR_RECOVER_SOLID_LIMIT != 0
+      if (lzSize < _lzEnd)
+      {
 #if 0
-      return S_FALSE;
+        return S_FALSE;
 #else
-      // we can report that recovering was made:
+        // we can report that recovering was made:
-      // _lzError = LZ_ERROR_TYPE_HEADER;
+        // _lzError = LZ_ERROR_TYPE_HEADER;
-      // We write zeros to area after corruption:
+        // We write zeros to area after corruption:
-      if (_window)
+        // if (_window)
-      {
-        UInt64 rem = _lzEnd - lzSize;
-        const size_t ws = _winSize;
-        if (rem >= ws)
        {
-          My_ZeroMemory(_window, ws);
+          UInt64 rem = _lzEnd - lzSize;
-          _lzSize = ws;
+          if (rem >= ws)
-          _winPos = 0;
-        }
-        else
-        {
-          const size_t cur = ws - _winPos;
-          if (cur <= rem)
          {
-            rem -= cur;
+            My_ZeroMemory(_window, ws);
-            My_ZeroMemory(_window + _winPos, cur);
+            _lzSize = ws;
-            _lzSize += _winPos;
            _winPos = 0;
          }
-          My_ZeroMemory(_window + _winPos, (size_t)rem);
+          else
-          _winPos += (size_t)rem;
+          {
+            // rem < _winSize
+            // _winPos <= ws
+            const size_t cur = ws - _winPos;
+            if (cur <= rem)
+            {
+              rem -= cur;
+              My_ZeroMemory(_window + _winPos, cur);
+              _lzSize = ws;
+              _winPos = 0;
+            }
+            My_ZeroMemory(_window + _winPos, (size_t)rem);
+            _winPos += (size_t)rem;
+          }
        }
-      }
+        // else return S_FALSE;
-      // else return S_FALSE;
 #endif
+      }
    }
 #endif
  }
+  // _winPos < _winSize
  // we don't want _lzSize overflow
  if (_lzSize >= DICT_SIZE_MAX)
      _lzSize  = DICT_SIZE_MAX;
  _lzEnd = _lzSize + _winPos;
  // _lzSize <= DICT_SIZE_MAX
-  // _lzEnd  <= DICT_SIZE_MAX * 2
+  // _lzEnd  <  DICT_SIZE_MAX + _winSize
  size_t newSize = _dictSize;
  if (newSize < kWinSize_Min)
@@ -1941,10 +1977,11 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
      // If dictionary was increased in solid, we don't want grow.
      return S_FALSE; // E_OUTOFMEMORY
    }
-    // (newSize <= _winSize)
+    // (newSize <= _dictSize_forCheck)
  }
  else
  {
+    // !_isSolid || !_window
    _dictSize_forCheck = newSize;
    {
      size_t newSize_small = newSize;
@@ -1964,7 +2001,7 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
    if (!_window || allocSize > _winSize_Allocated)
    {
      Z7_RAR_FREE_WINDOW
-        _window = NULL;
+      _window = NULL;
      _winSize_Allocated = 0;
      Byte *win = (Byte *)::BigAlloc(allocSize);
      if (!win)
diff --git a/CPP/7zip/Crypto/MyAes.cpp b/CPP/7zip/Crypto/MyAes.cpp
index f84bca8..0ae0e16 100644
--- a/CPP/7zip/Crypto/MyAes.cpp
+++ b/CPP/7zip/Crypto/MyAes.cpp
@@ -153,7 +153,26 @@ Z7_COM7F_IMF2(UInt32, CAesCtrCoder::Filter(Byte *data, UInt32 size))
 #ifndef Z7_EXTRACT_ONLY
 #ifdef MY_CPU_X86_OR_AMD64
-  #define USE_HW_AES
+  #if defined(__INTEL_COMPILER)
+    #if (__INTEL_COMPILER >= 1110)
+      #define USE_HW_AES
+      #if (__INTEL_COMPILER >= 1900)
+        #define USE_HW_VAES
+      #endif
+    #endif
+  #elif defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 30800) \
+     || defined(Z7_GCC_VERSION)   && (Z7_GCC_VERSION   >= 40400)
+    #define USE_HW_AES
+      #if defined(__clang__) && (__clang_major__ >= 8) \
+          || defined(__GNUC__) && (__GNUC__ >= 8)
+        #define USE_HW_VAES
+      #endif
+  #elif defined(_MSC_VER)
+    #define USE_HW_AES
+    #define USE_HW_VAES
+  #endif
 #elif defined(MY_CPU_ARM_OR_ARM64) && defined(MY_CPU_LE)
  
  #if   defined(__ARM_FEATURE_AES) \
@@ -186,15 +205,15 @@ Z7_COM7F_IMF2(UInt32, CAesCtrCoder::Filter(Byte *data, UInt32 size))
    #define SET_AES_FUNC_2(f2) \
      if (algo == 2) if (g_Aes_SupportedFunctions_Flags & k_Aes_SupportedFunctions_HW) \
      { f = f2; }
-  #ifdef MY_CPU_X86_OR_AMD64
+  #ifdef USE_HW_VAES
    #define SET_AES_FUNC_23(f2, f3) \
      SET_AES_FUNC_2(f2) \
      if (algo == 3) if (g_Aes_SupportedFunctions_Flags & k_Aes_SupportedFunctions_HW_256) \
      { f = f3; }
-  #else  // MY_CPU_X86_OR_AMD64
+  #else  // USE_HW_VAES
    #define SET_AES_FUNC_23(f2, f3) \
      SET_AES_FUNC_2(f2)
-  #endif // MY_CPU_X86_OR_AMD64
+  #endif // USE_HW_VAES
 #else  // USE_HW_AES
    #define SET_AES_FUNC_23(f2, f3)
 #endif // USE_HW_AES
diff --git a/CPP/7zip/ICoder.h b/CPP/7zip/ICoder.h
index aec2834..20d0ff7 100644
--- a/CPP/7zip/ICoder.h
+++ b/CPP/7zip/ICoder.h
@@ -136,6 +136,9 @@ namespace NCoderPropID
    kAffinity,          // VT_UI8
    kBranchOffset,      // VT_UI4
    kHashBits,          // VT_UI4
+    kNumThreadGroups,   // VT_UI4
+    kThreadGroup,       // VT_UI4
+    kAffinityInGroup,   // VT_UI8
    /*
    // kHash3Bits,          // VT_UI4
    // kHash2Bits,          // VT_UI4
diff --git a/CPP/7zip/Sort.mak b/CPP/7zip/Sort.mak
new file mode 100644
index 0000000..ca0ff59
--- /dev/null
+++ b/CPP/7zip/Sort.mak
@@ -0,0 +1,6 @@
+!IF defined(USE_NO_ASM) || defined(USE_C_SORT) || "$(PLATFORM)" == "ia64" || "$(PLATFORM)" == "mips" || "$(PLATFORM)" == "arm" || "$(PLATFORM)" == "arm64"
+C_OBJS = $(C_OBJS) \
+!ELSE
+ASM_OBJS = $(ASM_OBJS) \
+!ENDIF
+  $O\Sort.obj
diff --git a/CPP/7zip/UI/Common/ArchiveCommandLine.cpp b/CPP/7zip/UI/Common/ArchiveCommandLine.cpp
index 556b25a..de9f43e 100644
--- a/CPP/7zip/UI/Common/ArchiveCommandLine.cpp
+++ b/CPP/7zip/UI/Common/ArchiveCommandLine.cpp
@@ -63,17 +63,46 @@ EXTERN_C_END
 #else
-// #define MY_isatty_fileno(x) (isatty(fileno(x)))
+static bool MY_IS_TERMINAL(FILE *x)
-// #define MY_IS_TERMINAL(x) (MY_isatty_fileno(x) != 0);
-static inline bool MY_IS_TERMINAL(FILE *x)
 {
-  return (
+#ifdef _WIN32
-    #if defined(_MSC_VER) && (_MSC_VER >= 1400)
+  /*
-      _isatty(_fileno(x))
+crt/stdio.h:
-    #else
+typedef struct _iobuf FILE;
-      isatty(fileno(x))
+#define stdin  (&_iob[0])
-    #endif
+#define stdout (&_iob[1])
-      != 0);
+#define stderr (&_iob[2])
+*/
+  // fprintf(stderr, "\nMY_IS_TERMINAL = %p", x);
+  const int fd = _fileno(x);
+  /* (fd) is 0, 1 or 2 in console program.
+     docs: If stdout or stderr is not associated with
+     an output stream (for example, in a Windows application
+     without a console window), the file descriptor returned is -2.
+     In previous versions, the file descriptor returned was -1.
+  */
+  if (fd < 0) // is not associated with an output stream application (without a console window)
+    return false;
+  // fprintf(stderr, "\n\nstderr _fileno(%p) = %d", x, fd);
+  if (!_isatty(fd))
+    return false;
+  // fprintf(stderr, "\nisatty_val = true");
+  const HANDLE h = (HANDLE)_get_osfhandle(fd);
+  /* _get_osfhandle() returns intptr_t in new SDK, or long in MSVC6.
+     Also it can return (INVALID_HANDLE_VALUE).
+     docs: _get_osfhandle also returns the special value -2 when
+     the file descriptor is not associated with a stream
+     in old msvcrt.dll: it returns (-1) for incorrect value
+  */
+  // fprintf(stderr, "\n_get_osfhandle() = %p", (void *)h);
+  if (h == NULL || h == INVALID_HANDLE_VALUE)
+    return false;
+  DWORD st;
+  // fprintf(stderr, "\nGetConsoleMode() = %u", (unsigned)GetConsoleMode(h, &st));
+  return GetConsoleMode(h, &st) != 0;
+#else
+  return isatty(fileno(x)) != 0;
+#endif
 }
 #endif
@@ -1088,7 +1117,7 @@ void CArcCmdLineParser::Parse1(const UStringVector &commandStrings,
    const UString &s = parser[NKey::kLargePages].PostStrings[0];
    if (s.IsEmpty())
      slp = 1;
-    else if (s != L"-")
+    else if (!s.IsEqualTo("-"))
    {
      if (!StringToUInt32(s, slp))
        throw CArcCmdLineException("Unsupported switch postfix for -slp", s);
@@ -1338,7 +1367,7 @@ void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)
    const UString &s = parser[NKey::kFullPathMode].PostStrings[0];
    if (!s.IsEmpty())
    {
-      if (s == L"2")
+      if (s.IsEqualTo("2"))
        censorPathMode = NWildcard::k_FullPath;
      else
        throw CArcCmdLineException("Unsupported -spf:", s);
@@ -1400,6 +1429,7 @@ void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)
  const bool isExtractGroupCommand = options.Command.IsFromExtractGroup();
  const bool isExtractOrList = isExtractGroupCommand || options.Command.CommandType == NCommandType::kList;
  const bool isRename = options.Command.CommandType == NCommandType::kRename;
+  options.UpdateOptions.RenameMode = isRename;
  if ((isExtractOrList || isRename) && options.StdInMode)
    thereIsArchiveName = false;
@@ -1516,9 +1546,9 @@ void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)
      const UString &s = parser[NKey::kZoneFile].PostStrings[0];
      if (!s.IsEmpty())
      {
-             if (s == L"0") eo.ZoneMode = NExtract::NZoneIdMode::kNone;
+             if (s.IsEqualTo("0")) eo.ZoneMode = NExtract::NZoneIdMode::kNone;
-        else if (s == L"1") eo.ZoneMode = NExtract::NZoneIdMode::kAll;
+        else if (s.IsEqualTo("1")) eo.ZoneMode = NExtract::NZoneIdMode::kAll;
-        else if (s == L"2") eo.ZoneMode = NExtract::NZoneIdMode::kOffice;
+        else if (s.IsEqualTo("2")) eo.ZoneMode = NExtract::NZoneIdMode::kOffice;
        else
          throw CArcCmdLineException("Unsupported -snz:", s);
      }
diff --git a/CPP/7zip/UI/Common/ArchiveExtractCallback.cpp b/CPP/7zip/UI/Common/ArchiveExtractCallback.cpp
index 67ea29c..3abcd2d 100644
--- a/CPP/7zip/UI/Common/ArchiveExtractCallback.cpp
+++ b/CPP/7zip/UI/Common/ArchiveExtractCallback.cpp
@@ -6,12 +6,10 @@
 #undef printf
 // #include <stdio.h>
-// #include "../../../../C/CpuTicks.h"
 #include "../../../../C/Alloc.h"
 #include "../../../../C/CpuArch.h"
 #include "../../../Common/ComTry.h"
 #include "../../../Common/IntToString.h"
 #include "../../../Common/StringConvert.h"
@@ -33,6 +31,8 @@
 #include "../../Common/FilePathAutoRename.h"
 #include "../../Common/StreamUtils.h"
+#include "../../Archive/Common/ItemNameUtils.h"
 #include "../Common/ExtractingFilePath.h"
 #include "../Common/PropIDUtils.h"
@@ -56,6 +56,19 @@ static const char * const kCantCreateHardLink = "Cannot create hard link";
 static const char * const kCantCreateSymLink = "Cannot create symbolic link";
 #endif
+static const unsigned k_LinkDataSize_LIMIT = 1 << 12;
+#if WCHAR_PATH_SEPARATOR != L'/'
+  // we convert linux slashes to windows slashes for further processing.
+  // also we convert linux backslashes to BackslashReplacement character.
+  #define REPLACE_SLASHES_from_Linux_to_Sys(s) \
+    { NArchive::NItemName::ReplaceToWinSlashes(s, true); }  // useBackslashReplacement
+      // { s.Replace(L'/', WCHAR_PATH_SEPARATOR); }
+#else
+  #define REPLACE_SLASHES_from_Linux_to_Sys(s)
+#endif
 #ifndef Z7_SFX
 Z7_COM7F_IMF(COutStreamWithHash::Write(const void *data, UInt32 size, UInt32 *processedSize))
@@ -217,7 +230,7 @@ HRESULT CArchiveExtractCallback::PrepareHardLinks(const CRecordVector<UInt32> *r
  if (!_arc->Ask_INode)
    return S_OK;
  
-  IInArchive *archive = _arc->Archive;
+  IInArchive * const archive = _arc->Archive;
  CRecordVector<CHardLinkNode> &hardIDs = _hardLinks.IDs;
  {
@@ -574,6 +587,13 @@ HRESULT CArchiveExtractCallback::SendMessageError2(HRESULT errorCode, const char
  return _extractCallback2->MessageError(s);
 }
+HRESULT CArchiveExtractCallback::SendMessageError2_with_LastError(
+    const char *message, const FString &path1, const FString &path2)
+{
+  const HRESULT errorCode = GetLastError_noZero_HRESULT();
+  return SendMessageError2(errorCode, message, path1, path2);
+}
 #ifndef Z7_SFX
 Z7_CLASS_IMP_COM_1(
@@ -604,36 +624,20 @@ Z7_COM7F_IMF(CGetProp::GetProp(PROPID propID, PROPVARIANT *value))
 #endif // Z7_SFX
-#ifdef SUPPORT_LINKS
-static UString GetDirPrefixOf(const UString &src)
-{
-  UString s (src);
-  if (!s.IsEmpty())
-  {
-    if (IsPathSepar(s.Back()))
-      s.DeleteBack();
-    int pos = s.ReverseFind_PathSepar();
-    s.DeleteFrom((unsigned)(pos + 1));
-  }
-  return s;
-}
-#endif // SUPPORT_LINKS
 struct CLinkLevelsInfo
 {
  bool IsAbsolute;
  int LowLevel;
  int FinalLevel;
-  void Parse(const UString &path);
+  void Parse(const UString &path, bool isWSL);
 };
-void CLinkLevelsInfo::Parse(const UString &path)
+void CLinkLevelsInfo::Parse(const UString &path, bool isWSL)
 {
-  IsAbsolute = NName::IsAbsolutePath(path);
+  IsAbsolute = isWSL ?
+      IS_PATH_SEPAR(path[0]) :
+      NName::IsAbsolutePath(path);
  LowLevel = 0;
  FinalLevel = 0;
@@ -650,9 +654,9 @@ void CLinkLevelsInfo::Parse(const UString &path)
        IsAbsolute = true;
      continue;
    }
-    if (s == L".")
+    if (s.IsEqualTo("."))
      continue;
-    if (s == L"..")
+    if (s.IsEqualTo(".."))
    {
      level--;
      if (LowLevel > level)
@@ -666,16 +670,20 @@ void CLinkLevelsInfo::Parse(const UString &path)
 }
-bool IsSafePath(const UString &path);
+static bool IsSafePath(const UString &path, bool isWSL)
-bool IsSafePath(const UString &path)
 {
  CLinkLevelsInfo levelsInfo;
-  levelsInfo.Parse(path);
+  levelsInfo.Parse(path, isWSL);
  return !levelsInfo.IsAbsolute
      && levelsInfo.LowLevel >= 0
      && levelsInfo.FinalLevel > 0;
 }
+bool IsSafePath(const UString &path);
+bool IsSafePath(const UString &path)
+{
+  return IsSafePath(path, false); // isWSL
+}
 bool CensorNode_CheckPath2(const NWildcard::CCensorNode &node, const CReadArcItem &item, bool &include);
 bool CensorNode_CheckPath2(const NWildcard::CCensorNode &node, const CReadArcItem &item, bool &include)
@@ -791,159 +799,113 @@ HRESULT CArchiveExtractCallback::MyCopyFile(ISequentialOutStream *outStream)
 HRESULT CArchiveExtractCallback::ReadLink()
 {
-  IInArchive *archive = _arc->Archive;
+  IInArchive * const archive = _arc->Archive;
  const UInt32 index = _index;
-  _link.Clear();
+  // _link.Clear(); // _link.Clear() was called already.
  {
    NCOM::CPropVariant prop;
    RINOK(archive->GetProperty(index, kpidHardLink, &prop))
    if (prop.vt == VT_BSTR)
    {
-      _link.isHardLink = true;
+      _link.LinkType = k_LinkType_HardLink;
-      // _link.isCopyLink = false;
      _link.isRelative = false; // RAR5, TAR: hard links are from root folder of archive
-      _link.linkPath.SetFromBstr(prop.bstrVal);
+      _link.LinkPath.SetFromBstr(prop.bstrVal);
+      // 7-Zip 24-: tar handler returned original path (with linux slash in most case)
+      // 7-Zip 24-: rar5 handler returned path with system slash.
+      // 7-Zip 25+: tar/rar5 handlers return linux path in most cases.
    }
    else if (prop.vt != VT_EMPTY)
      return E_FAIL;
  }
-  
  /*
  {
    NCOM::CPropVariant prop;
    RINOK(archive->GetProperty(index, kpidCopyLink, &prop));
    if (prop.vt == VT_BSTR)
    {
-      _link.isHardLink = false;
+      _link.LinkType = k_LinkType_CopyLink;
-      _link.isCopyLink = true;
      _link.isRelative = false; // RAR5: copy links are from root folder of archive
-      _link.linkPath.SetFromBstr(prop.bstrVal);
+      _link.LinkPath.SetFromBstr(prop.bstrVal);
    }
    else if (prop.vt != VT_EMPTY)
      return E_FAIL;
  }
  */
  {
    NCOM::CPropVariant prop;
    RINOK(archive->GetProperty(index, kpidSymLink, &prop))
    if (prop.vt == VT_BSTR)
    {
-      _link.isHardLink = false;
+      _link.LinkType = k_LinkType_PureSymLink;
-      // _link.isCopyLink = false;
+      _link.isRelative = true; // RAR5, TAR: symbolic links are relative by default
-      _link.isRelative = true; // RAR5, TAR: symbolic links can be relative
+      _link.LinkPath.SetFromBstr(prop.bstrVal);
-      _link.linkPath.SetFromBstr(prop.bstrVal);
+      // 7-Zip 24-: (tar, cpio, xar, ext, iso) handlers returned returned original path (with linux slash in most case)
+      // 7-Zip 24-: rar5 handler returned path with system slash.
+      // 7-Zip 25+: all handlers return linux path in most cases.
    }
    else if (prop.vt != VT_EMPTY)
      return E_FAIL;
  }
-  NtReparse_Data = NULL;
+  // linux path separator in (_link.LinkPath) is expected for most cases,
-  NtReparse_Size = 0;
+  // if new handler code is used, and if data in archive is correct.
+  // NtReparse_Data = NULL;
-  if (_link.linkPath.IsEmpty() && _arc->GetRawProps)
+  // NtReparse_Size = 0;
+  if (!_link.LinkPath.IsEmpty())
+  {
+    REPLACE_SLASHES_from_Linux_to_Sys(_link.LinkPath)
+  }
+  else if (_arc->GetRawProps)
  {
    const void *data;
-    UInt32 dataSize;
+    UInt32 dataSize, propType;
-    UInt32 propType;
+    if (_arc->GetRawProps->GetRawProp(_index, kpidNtReparse, &data, &dataSize, &propType) == S_OK
-    
+        // && dataSize == 1234567 // for debug: unpacking without reparse
-    _arc->GetRawProps->GetRawProp(_index, kpidNtReparse, &data, &dataSize, &propType);
+        && dataSize)
-    
-    // if (dataSize == 1234567) // for debug: unpacking without reparse
-    if (dataSize != 0)
    {
      if (propType != NPropDataType::kRaw)
        return E_FAIL;
-  
      // 21.06: we need kpidNtReparse in linux for wim archives created in Windows
-      // #ifdef _WIN32
+      // NtReparse_Data = data;
+      // NtReparse_Size = dataSize;
-      NtReparse_Data = data;
+      // we ignore error code here, if there is failure of parsing:
-      NtReparse_Size = dataSize;
+      _link.Parse_from_WindowsReparseData((const Byte *)data, dataSize);
-      CReparseAttr reparse;
-      bool isOkReparse = reparse.Parse((const Byte *)data, dataSize);
-      if (isOkReparse)
-      {
-        _link.isHardLink = false;
-        // _link.isCopyLink = false;
-        _link.linkPath = reparse.GetPath();
-        _link.isJunction = reparse.IsMountPoint();
-        if (reparse.IsSymLink_WSL())
-        {
-          _link.isWSL = true;
-          _link.isRelative = reparse.IsRelative_WSL();
-        }
-        else
-          _link.isRelative = reparse.IsRelative_Win();
-        // const AString s = GetAnsiString(_link.linkPath);
-        // printf("\n_link.linkPath: %s\n", s.Ptr());
-        #ifndef _WIN32
-        _link.linkPath.Replace(L'\\', WCHAR_PATH_SEPARATOR);
-        #endif
-      }
-      // #endif
    }
  }
-  if (_link.linkPath.IsEmpty())
+  if (_link.LinkPath.IsEmpty())
    return S_OK;
+  // (_link.LinkPath) uses system path separator.
+  // windows: (_link.LinkPath) doesn't contain linux separator (slash).
  {
-    #ifdef _WIN32
+    // _link.LinkPath = "\\??\\r:\\1\\2"; // for debug
-    _link.linkPath.Replace(L'/', WCHAR_PATH_SEPARATOR);
+    // rar5+ returns kpidSymLink absolute link path with "\??\" prefix.
-    #endif
+    // we normalize such prefix:
+    if (_link.LinkPath.IsPrefixedBy(STRING_PATH_SEPARATOR "??" STRING_PATH_SEPARATOR))
-    // rar5 uses "\??\" prefix for absolute links
-    if (_link.linkPath.IsPrefixedBy(WSTRING_PATH_SEPARATOR L"??" WSTRING_PATH_SEPARATOR))
    {
      _link.isRelative = false;
-      _link.linkPath.DeleteFrontal(4);
+       // we normalize prefix from "\??\" to "\\?\":
-    }
+      _link.LinkPath.ReplaceOneCharAtPos(1, WCHAR_PATH_SEPARATOR);
-    
+      _link.isWindowsPath = true;
-    for (;;)
+      if (_link.LinkPath.IsPrefixedBy_Ascii_NoCase(
-    // while (NName::IsAbsolutePath(linkPath))
+          STRING_PATH_SEPARATOR
-    {
+          STRING_PATH_SEPARATOR "?"
-      unsigned n = NName::GetRootPrefixSize(_link.linkPath);
+          STRING_PATH_SEPARATOR "UNC"
-      if (n == 0)
+          STRING_PATH_SEPARATOR))
-        break;
-      _link.isRelative = false;
-      _link.linkPath.DeleteFrontal(n);
-    }
-  }
-  if (_link.linkPath.IsEmpty())
-    return S_OK;
-  if (!_link.isRelative && _removePathParts.Size() != 0)
-  {
-    UStringVector pathParts;
-    SplitPathToParts(_link.linkPath, pathParts);
-    bool badPrefix = false;
-    FOR_VECTOR (i, _removePathParts)
-    {
-      if (CompareFileNames(_removePathParts[i], pathParts[i]) != 0)
      {
-        badPrefix = true;
+         // we normalize prefix from "\\?\UNC\path" to "\\path":
-        break;
+        _link.LinkPath.DeleteFrontal(6);
+        _link.LinkPath.ReplaceOneCharAtPos(0, WCHAR_PATH_SEPARATOR);
+      }
+      else
+      {
+        const unsigned k_prefix_Size = 4;
+        if (NName::IsDrivePath(_link.LinkPath.Ptr(k_prefix_Size)))
+          _link.LinkPath.DeleteFrontal(k_prefix_Size);
      }
    }
-    if (!badPrefix)
-      pathParts.DeleteFrontal(_removePathParts.Size());
-    _link.linkPath = MakePathFromParts(pathParts);
  }
+  _link.Normalize_to_RelativeSafe(_removePathParts);
-  /*
-  if (!_link.linkPath.IsEmpty())
-  {
-    printf("\n_link %s to -> %s\n", GetOemString(_item.Path).Ptr(), GetOemString(_link.linkPath).Ptr());
-  }
-  */
  return S_OK;
 }
@@ -961,7 +923,7 @@ static HRESULT GetOwner(IInArchive *archive,
    if (prop.vt == VT_UI4)
    {
      res.Id_Defined = true;
-      res.Id = prop.ulVal; // for debug
+      res.Id = prop.ulVal;
      // res.Id++; // for debug
      // if (pidId == kpidGroupId) res.Id += 7; // for debug
      // res.Id = 0; // for debug
@@ -993,7 +955,7 @@ static HRESULT GetOwner(IInArchive *archive,
 HRESULT CArchiveExtractCallback::Read_fi_Props()
 {
-  IInArchive *archive = _arc->Archive;
+  IInArchive * const archive = _arc->Archive;
  const UInt32 index = _index;
  _fi.Attrib_Defined = false;
@@ -1134,7 +1096,7 @@ void CArchiveExtractCallback::CreateFolders()
    if (!_item.IsDir
        #ifdef SUPPORT_LINKS
        #ifndef WIN32
-          || !_link.linkPath.IsEmpty()
+          || !_link.LinkPath.IsEmpty()
        #endif
        #endif
       )
@@ -1273,8 +1235,7 @@ HRESULT CArchiveExtractCallback::CheckExistFile(FString &fullProcessedPath, bool
      // MyMoveFile can rename folders. So it's OK to use it for folders too
      if (!MyMoveFile(fullProcessedPath, existPath))
      {
-        HRESULT errorCode = GetLastError_noZero_HRESULT();
+        RINOK(SendMessageError2_with_LastError(kCantRenameFile, existPath, fullProcessedPath))
-        RINOK(SendMessageError2(errorCode, kCantRenameFile, existPath, fullProcessedPath))
        return E_FAIL;
      }
    }
@@ -1341,7 +1302,7 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
  RINOK(Read_fi_Props())
  #ifdef SUPPORT_LINKS
-  IInArchive *archive = _arc->Archive;
+  IInArchive * const archive = _arc->Archive;
  #endif
  const UInt32 index = _index;
@@ -1387,7 +1348,7 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
    if (isAnti)
      RemoveDir(_diskFilePath);
    #ifdef SUPPORT_LINKS
-    if (_link.linkPath.IsEmpty())
+    if (_link.LinkPath.IsEmpty())
    #endif
    {
      if (!isAnti)
@@ -1416,15 +1377,15 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
  #ifdef SUPPORT_LINKS
  
-  if (!_link.linkPath.IsEmpty())
+  if (!_link.LinkPath.IsEmpty())
  {
    #ifndef UNDER_CE
    {
      bool linkWasSet = false;
-      RINOK(SetFromLinkPath(fullProcessedPath, _link, linkWasSet))
+      RINOK(SetLink(fullProcessedPath, _link, linkWasSet))
      if (linkWasSet)
      {
-        _isSymLinkCreated = _link.IsSymLink();
+        _isSymLinkCreated = _link.Is_AnySymLink();
        SetAttrib();
        // printf("\nlinkWasSet %s\n", GetAnsiString(_diskFilePath));
      }
@@ -1454,12 +1415,7 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
        else
        {
          if (!MyCreateHardLink(fullProcessedPath, hl))
-          {
+            return SendMessageError2_with_LastError(kCantCreateHardLink, fullProcessedPath, hl);
-            const HRESULT errorCode = GetLastError_noZero_HRESULT();
-            RINOK(SendMessageError2(errorCode, kCantCreateHardLink, fullProcessedPath, hl))
-            return S_OK;
-          }
-          
          // printf("\nHard linkWasSet Archive_Get_HardLinkNode %s\n", GetAnsiString(_diskFilePath));
          // _needSetAttrib = true; // do we need to set attribute ?
          SetAttrib();
@@ -1491,7 +1447,7 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
  bool is_SymLink_in_Data = false;
-  if (_curSize_Defined && _curSize > 0 && _curSize < (1 << 12))
+  if (_curSize_Defined && _curSize && _curSize < k_LinkDataSize_LIMIT)
  {
    if (_fi.IsLinuxSymLink())
    {
@@ -1513,7 +1469,7 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
    _bufPtrSeqOutStream_Spec->Init(_outMemBuf, _outMemBuf.Size());
    outStreamLoc = _bufPtrSeqOutStream;
  }
-  else // not reprase
+  else // not reparse
  {
    if (_ntOptions.PreAllocateOutFile && !_isSplit && _curSize_Defined && _curSize > (1 << 12))
    {
@@ -1568,7 +1524,7 @@ HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream
      RINOK(outFileStream_Loc->Seek((Int64)_position, STREAM_SEEK_SET, NULL))
    }
    outStreamLoc = outFileStream_Loc;
-  } // if not reprase
+  } // if not reparse
  _outFileStream = outFileStream_Loc;
      
@@ -1620,8 +1576,7 @@ Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index, ISequentialOutStre
  _fileLength_WasSet = false;
  _isRenamed = false;
  // _fi.Clear();
- _extractMode = false;
+  _extractMode = false;
-  // _is_SymLink_in_Data = false;
  _is_SymLink_in_Data_Linux = false;
  _needSetAttrib = false;
  _isSymLinkCreated = false;
@@ -1661,7 +1616,7 @@ Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index, ISequentialOutStre
  }
-  IInArchive *archive = _arc->Archive;
+  IInArchive * const archive = _arc->Archive;
  RINOK(GetItem(index))
@@ -1677,10 +1632,9 @@ Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index, ISequentialOutStre
    }
  }
-  #ifdef SUPPORT_LINKS
+#ifdef SUPPORT_LINKS
  RINOK(ReadLink())
-  #endif // SUPPORT_LINKS
+#endif
-  
  
  RINOK(Archive_GetItemBoolProp(archive, index, kpidEncrypted, _encrypted))
@@ -2016,63 +1970,80 @@ HRESULT CArchiveExtractCallback::CloseFile()
 #ifdef SUPPORT_LINKS
+/*
+in:
+  link.LinkPath : must be relative (non-absolute) path in any case !!!
+  link.isRelative / target path that must stored as created link:
+           == false   / _dirPathPrefix_Full + link.LinkPath
+           == true    / link.LinkPath
+*/
-HRESULT CArchiveExtractCallback::SetFromLinkPath(
+HRESULT CArchiveExtractCallback::SetLink(
-    const FString &fullProcessedPath,
+    const FString &fullProcessedPath_from,
-    const CLinkInfo &linkInfo,
+    const CLinkInfo &link,
    bool &linkWasSet)
 {
  linkWasSet = false;
-  if (!_ntOptions.SymLinks.Val && !linkInfo.isHardLink)
+  if (link.LinkPath.IsEmpty())
+    return S_OK;
+  if (!_ntOptions.SymLinks.Val && link.Is_AnySymLink())
    return S_OK;
-  UString relatPath;
-  /* if (linkInfo.isRelative)
-       linkInfo.linkPath is final link path that must be stored to file link field
-     else
-       linkInfo.linkPath is path from root of archive. So we must add _dirPathPrefix_Full before linkPath.
-  */
-     
-  if (linkInfo.isRelative)
-    relatPath = GetDirPrefixOf(_item.Path);
-  relatPath += linkInfo.linkPath;
-  
-  if (!IsSafePath(relatPath))
  {
-    return SendMessageError2(
+    UString path;
-          0, // errorCode
+    if (link.isRelative)
+    {
+      // _item.PathParts : parts that will be created in output folder.
+      // we want to get directory prefix of link item.
+      // so we remove file name (last non-empty part) from PathParts:
+      UStringVector v = _item.PathParts;
+      while (!v.IsEmpty())
+      {
+        const unsigned len = v.Back().Len();
+        v.DeleteBack();
+        if (len)
+          break;
+      }
+      path = MakePathFromParts(v);
+      NName::NormalizeDirPathPrefix(path);
+    }
+    path += link.LinkPath;
+    /*
+    path is calculated virtual target path of link
+    path is relative to root folder of extracted items
+    if (!link.isRelative), then (path == link.LinkPath)
+    */
+    if (!IsSafePath(path, link.Is_WSL()))
+      return SendMessageError2(0, // errorCode
          "Dangerous link path was ignored",
-          us2fs(_item.Path),
+          us2fs(_item.Path), us2fs(link.LinkPath));
-          us2fs(linkInfo.linkPath)); // us2fs(relatPath)
  }
-  FString existPath;
+  FString target; // target path that will be stored to link field
-  if (linkInfo.isHardLink /* || linkInfo.IsCopyLink */ || !linkInfo.isRelative)
+  if (link.Is_HardLink() /* || link.IsCopyLink */ || !link.isRelative)
  {
-    if (!NName::GetFullPath(_dirPathPrefix_Full, us2fs(relatPath), existPath))
+    // isRelative == false
-    {
+    // all hard links and absolute symbolic links
-      RINOK(SendMessageError("Incorrect path", us2fs(relatPath)))
+    // relatPath == link.LinkPath
-    }
+    // we get absolute link path for target:
+    if (!NName::GetFullPath(_dirPathPrefix_Full, us2fs(link.LinkPath), target))
+      return SendMessageError("Incorrect link path", us2fs(link.LinkPath));
+    // (target) is (_dirPathPrefix_Full + relatPath)
  }
  else
  {
-    existPath = us2fs(linkInfo.linkPath);
+    // link.isRelative == true
-    // printf("\nlinkPath = : %s\n", GetOemString(linkInfo.linkPath).Ptr());
+    // relative symbolic links only
+    target = us2fs(link.LinkPath);
  }
-    
+  if (target.IsEmpty())
-  if (existPath.IsEmpty())
+    return SendMessageError("Empty link", fullProcessedPath_from);
-    return SendMessageError("Empty link", fullProcessedPath);
-  if (linkInfo.isHardLink /* || linkInfo.IsCopyLink */)
+  if (link.Is_HardLink() /* || link.IsCopyLink */)
  {
-    // if (linkInfo.isHardLink)
+    // if (link.isHardLink)
    {
-      if (!MyCreateHardLink(fullProcessedPath, existPath))
+      if (!MyCreateHardLink(fullProcessedPath_from, target))
-      {
+        return SendMessageError2_with_LastError(kCantCreateHardLink, fullProcessedPath_from, target);
-        const HRESULT errorCode = GetLastError_noZero_HRESULT();
-        RINOK(SendMessageError2(errorCode, kCantCreateHardLink, fullProcessedPath, existPath))
-      }
      /*
      RINOK(PrepareOperation(NArchive::NExtract::NAskMode::kExtract))
      _op_WasReported = true;
@@ -2085,19 +2056,19 @@ HRESULT CArchiveExtractCallback::SetFromLinkPath(
    // IsCopyLink
    {
      NFind::CFileInfo fi;
-      if (!fi.Find(existPath))
+      if (!fi.Find(target))
      {
-        RINOK(SendMessageError2("Cannot find the file for copying", existPath, fullProcessedPath));
+        RINOK(SendMessageError2("Cannot find the file for copying", target, fullProcessedPath));
      }
      else
      {
        if (_curSize_Defined && _curSize == fi.Size)
-          _copyFile_Path = existPath;
+          _copyFile_Path = target;
        else
        {
-          RINOK(SendMessageError2("File size collision for file copying", existPath, fullProcessedPath));
+          RINOK(SendMessageError2("File size collision for file copying", target, fullProcessedPath));
        }
-        // RINOK(MyCopyFile(existPath, fullProcessedPath));
+        // RINOK(MyCopyFile(target, fullProcessedPath));
      }
    }
    */
@@ -2111,127 +2082,249 @@ HRESULT CArchiveExtractCallback::SetFromLinkPath(
    // Windows before Vista doesn't support symbolic links.
    // we could convert such symbolic links to Junction Points
    // isJunction = true;
-    // convertToAbs = true;
  }
  */
-  if (!_ntOptions.SymLinks_AllowDangerous.Val)
+#ifdef _WIN32
+  const bool isDir = (_item.IsDir || link.LinkType == k_LinkType_Junction);
+#endif
+  if (!_ntOptions.SymLinks_AllowDangerous.Val && link.isRelative)
  {
-    #ifdef _WIN32
+    /*
-    if (_item.IsDir)
+    We want to use additional check for links that can link to directory.
-    #endif
+      - linux: all symbolic links are files.
-    if (linkInfo.isRelative)
+      - windows: we can have file/directory symbolic link,
-      {
+        but file symbolic link works like directory link in windows.
-        CLinkLevelsInfo levelsInfo;
+    So we use additional check for all relative links.
-        levelsInfo.Parse(linkInfo.linkPath);
-        if (levelsInfo.FinalLevel < 1 || levelsInfo.IsAbsolute)
+    We don't allow decreasing of final level of link.
-        {
+    So if some another extracted file will use this link,
-          return SendMessageError2(
+    then number of real path parts (after link redirection) cannot be
-            0, // errorCode
+    smaller than number of requested path parts from archive records.
-            "Dangerous symbolic link path was ignored",
+    
-            us2fs(_item.Path),
+    Now we check only (link.LinkPath) without (_item.PathParts).
-            us2fs(linkInfo.linkPath));
+    */
-        }
+    CLinkLevelsInfo levelsInfo;
-      }
+    levelsInfo.Parse(link.LinkPath, link.Is_WSL());
+    if (levelsInfo.FinalLevel < 1
+      // || levelsInfo.LowLevel < 0 // we allow negative temporary levels
+        || levelsInfo.IsAbsolute)
+      return SendMessageError2(0, // errorCode
+          "Dangerous symbolic link path was ignored",
+          us2fs(_item.Path), us2fs(link.LinkPath));
  }
  
-  #ifdef _WIN32
+#ifdef _WIN32
-  
  CByteBuffer data;
-  // printf("\nFillLinkData(): %s\n", GetOemString(existPath).Ptr());
+  // printf("\nFillLinkData(): %s\n", GetOemString(target).Ptr());
-  if (!FillLinkData(data, fs2us(existPath), !linkInfo.isJunction, linkInfo.isWSL))
+  if (link.Is_WSL())
+  {
+    Convert_WinPath_to_WslLinuxPath(target, !link.isRelative);
+    FillLinkData_WslLink(data, fs2us(target));
+  }
+  else
+    FillLinkData_WinLink(data, fs2us(target), link.LinkType != k_LinkType_Junction);
+  if (data.Size() == 0)
    return SendMessageError("Cannot fill link data", us2fs(_item.Path));
  /*
  if (NtReparse_Size != data.Size() || memcmp(NtReparse_Data, data, data.Size()) != 0)
-  {
+    SendMessageError("reconstructed Reparse is different", fs2us(target));
-    SendMessageError("reconstructed Reparse is different", fs2us(existPath));
-  }
  */
-  
-  CReparseAttr attr;
-  if (!attr.Parse(data, data.Size()))
  {
-    RINOK(SendMessageError("Internal error for symbolic link file", us2fs(_item.Path)))
+    // we check that reparse data is correct, but we ignore attr.MinorError.
-    return S_OK;
+    CReparseAttr attr;
+    if (!attr.Parse(data, data.Size()))
+      return SendMessageError("Internal error for symbolic link file", us2fs(_item.Path));
  }
-  if (!NFile::NIO::SetReparseData(fullProcessedPath, _item.IsDir, data, (DWORD)data.Size()))
+  if (!NFile::NIO::SetReparseData(fullProcessedPath_from, isDir, data, (DWORD)data.Size()))
+#else // ! _WIN32
+  if (!NFile::NIO::SetSymLink(fullProcessedPath_from, target))
+#endif // ! _WIN32
  {
-    RINOK(SendMessageError_with_LastError(kCantCreateSymLink, fullProcessedPath))
+    return SendMessageError_with_LastError(kCantCreateSymLink, fullProcessedPath_from);
-    return S_OK;
  }
  linkWasSet = true;
  return S_OK;
-  
+}
-  
-  #else // ! _WIN32
-  if (!NFile::NIO::SetSymLink(fullProcessedPath, existPath))
+bool CLinkInfo::Parse_from_WindowsReparseData(const Byte *data, size_t dataSize)
+{
+  CReparseAttr reparse;
+  if (!reparse.Parse(data, dataSize))
+    return false;
+  // const AString s = GetAnsiString(LinkPath);
+  // printf("\nlinkPath: %s\n", s.Ptr());
+  LinkPath = reparse.GetPath();
+  if (reparse.IsSymLink_WSL())
  {
-    RINOK(SendMessageError_with_LastError(kCantCreateSymLink, fullProcessedPath))
+    LinkType = k_LinkType_WSL;
-    return S_OK;
+    isRelative = reparse.IsRelative_WSL(); // detected from LinkPath[0]
+    // LinkPath is original raw name converted to UString from AString
+    // Linux separator '/' is expected here.
+    REPLACE_SLASHES_from_Linux_to_Sys(LinkPath)
  }
-  linkWasSet = true;
+  else
+  {
+    LinkType = reparse.IsMountPoint() ? k_LinkType_Junction : k_LinkType_PureSymLink;
+    isRelative = reparse.IsRelative_Win(); // detected by (Flags == Z7_WIN_SYMLINK_FLAG_RELATIVE)
+    isWindowsPath = true;
+    // LinkPath is original windows link path from raparse data with \??\ prefix removed.
+    // windows '\\' separator is expected here.
+    // linux '/' separator is not expected here.
+    // we translate both types of separators to system separator.
+    LinkPath.Replace(
+#if WCHAR_PATH_SEPARATOR == L'\\'
+        L'/'
+#else
+        L'\\'
+#endif
+        , WCHAR_PATH_SEPARATOR);
+  }
+  // (LinkPath) uses system path separator.
+  // windows: (LinkPath) doesn't contain linux separator (slash).
+  return true;
+}
-  return S_OK;
-  #endif // ! _WIN32
+bool CLinkInfo::Parse_from_LinuxData(const Byte *data, size_t dataSize)
+{
+  // Clear(); // *this object was cleared by constructor already.
+  LinkType = k_LinkType_PureSymLink;
+  AString utf;
+  if (dataSize >= k_LinkDataSize_LIMIT)
+    return false;
+  utf.SetFrom_CalcLen((const char *)data, (unsigned)dataSize);
+  UString u;
+  if (!ConvertUTF8ToUnicode(utf, u))
+    return false;
+  if (u.IsEmpty())
+    return false;
+  const wchar_t c = u[0];
+  isRelative = (c != L'/');
+  // linux path separator is expected
+  REPLACE_SLASHES_from_Linux_to_Sys(u)
+  LinkPath = u;
+  // (LinkPath) uses system path separator.
+  // windows: (LinkPath) doesn't contain linux separator (slash).
+  return true;
+}
+    
+// in/out:          (LinkPath) uses system path separator
+// in/out: windows: (LinkPath) doesn't contain linux separator (slash).
+// out: (LinkPath) is relative path, and LinkPath[0] is not path separator
+// out: isRelative changed to false, if any prefix was removed.
+// note: absolute windows links "c:\" to root will be reduced to empty string:
+void CLinkInfo::Remove_AbsPathPrefixes()
+{
+  while (!LinkPath.IsEmpty())
+  {
+    unsigned n = 0;
+    if (!Is_WSL())
+    {
+      n =
+#ifndef _WIN32
+      isWindowsPath ?
+        NName::GetRootPrefixSize_WINDOWS(LinkPath) :
+#endif
+        NName::GetRootPrefixSize(LinkPath);
+/*
+      // "c:path" will be ignored later as "Dangerous absolute path"
+      // so check is not required
+      if (n == 0
+#ifndef _WIN32
+          && isWindowsPath
+#endif
+          && NName::IsDrivePath2(LinkPath))
+        n = 2;
+*/
+    }
+    if (n == 0)
+    {
+      if (!IS_PATH_SEPAR(LinkPath[0]))
+        break;
+      n = 1;
+    }
+    isRelative = false; // (LinkPath) will be treated as relative to root folder of archive
+    LinkPath.DeleteFrontal(n);
+  }
 }
-bool CLinkInfo::Parse(const Byte *data, size_t dataSize, bool isLinuxData)
+/*
+  it removes redundant separators, if there are double separators,
+  but it keeps double separators at start of string //name/.
+  in/out:    system path separator is used
+    windows: slash character (linux separator) is not treated as separator
+    windows: (path) doesn't contain linux separator (slash).
+*/
+static void RemoveRedundantPathSeparators(UString &path)
 {
-  Clear();
+  wchar_t *dest = path.GetBuf();
-  // this->isLinux = isLinuxData;
+  const wchar_t * const start = dest;
-  
+  const wchar_t *src = dest;
-  if (isLinuxData)
+  for (;;)
  {
-    isJunction = false;
+    wchar_t c = *src++;
-    isHardLink = false;
+    if (c == 0)
-    AString utf;
+      break;
-    if (dataSize >= (1 << 12))
+    // if (IS_PATH_SEPAR(c)) // for Windows: we can change (/) to (\).
-      return false;
+    if (c == WCHAR_PATH_SEPARATOR)
-    utf.SetFrom_CalcLen((const char *)data, (unsigned)dataSize);
+    {
-    UString u;
+      if (dest - start >= 2 && dest[-1] == WCHAR_PATH_SEPARATOR)
-    if (!ConvertUTF8ToUnicode(utf, u))
+        continue;
-      return false;
+      // c = WCHAR_PATH_SEPARATOR; // for Windows: we can change (/) to (\).
-    linkPath = u;
+    }
-    
+    *dest++ = c;
-    // in linux symbolic data: we expect that linux separator '/' is used
-    // if windows link was created, then we also must use linux separator
-    if (u.IsEmpty())
-      return false;
-    const wchar_t c = u[0];
-    isRelative = !IS_PATH_SEPAR(c);
-    return true;
  }
+  *dest = 0;
+  path.ReleaseBuf_SetLen((unsigned)(dest - path.Ptr()));
+}
-  CReparseAttr reparse;
-  if (!reparse.Parse(data, dataSize))
+// in/out: (LinkPath) uses system path separator
-    return false;
+// in/out: windows: (LinkPath) doesn't contain linux separator (slash).
-  isHardLink = false;
+// out: (LinkPath) is relative path, and LinkPath[0] is not path separator
-  // isCopyLink = false;
+void CLinkInfo::Normalize_to_RelativeSafe(UStringVector &removePathParts)
-  linkPath = reparse.GetPath();
+{
-  isJunction = reparse.IsMountPoint();
+  // We WILL NOT WRITE original absolute link path from archive to filesystem.
-  
+  // So here we remove all root prefixes from (LinkPath).
-  if (reparse.IsSymLink_WSL())
+  // If we see any absolute root prefix, then we suppose that this prefix is virtual prefix
+  // that shows that link is relative to root folder of archive
+  RemoveRedundantPathSeparators(LinkPath);
+  // LinkPath = "\\\\?\\r:test\\test2"; // for debug
+  Remove_AbsPathPrefixes();
+  // (LinkPath) now is relative:
+  //  if (isRelative == false), then (LinkPath) is relative to root folder of archive
+  //  if (isRelative == true ), then (LinkPath) is relative to current item
+  if (LinkPath.IsEmpty() || isRelative || removePathParts.Size() == 0)
+    return;
+  // if LinkPath is prefixed by _removePathParts, we remove these paths
+  UStringVector pathParts;
+  SplitPathToParts(LinkPath, pathParts);
+  bool badPrefix = false;
  {
-    isWSL = true;
+    FOR_VECTOR (i, removePathParts)
-    isRelative = reparse.IsRelative_WSL();
+    {
+      if (i >= pathParts.Size()
+        || CompareFileNames(removePathParts[i], pathParts[i]) != 0)
+      {
+        badPrefix = true;
+        break;
+      }
+    }
  }
-  else
+  if (!badPrefix)
-    isRelative = reparse.IsRelative_Win();
+    pathParts.DeleteFrontal(removePathParts.Size());
-    
+  LinkPath = MakePathFromParts(pathParts);
-  // FIXME !!!
+  Remove_AbsPathPrefixes();
-  #ifndef _WIN32
-  linkPath.Replace(L'\\', WCHAR_PATH_SEPARATOR);
-  #endif
-  
-  return true;
 }
-    
 #endif // SUPPORT_LINKS
@@ -2239,12 +2332,12 @@ HRESULT CArchiveExtractCallback::CloseReparseAndFile()
 {
  HRESULT res = S_OK;
-  #ifdef SUPPORT_LINKS
+#ifdef SUPPORT_LINKS
  size_t reparseSize = 0;
  bool repraseMode = false;
  bool needSetReparse = false;
-  CLinkInfo linkInfo;
+  CLinkInfo link;
  
  if (_bufPtrSeqOutStream)
  {
@@ -2258,15 +2351,19 @@ HRESULT CArchiveExtractCallback::CloseReparseAndFile()
      needSetReparse = reparse.Parse(_outMemBuf, reparseSize, errorCode);
      if (needSetReparse)
      {
-        UString linkPath = reparse.GetPath();
+        UString LinkPath = reparse.GetPath();
        #ifndef _WIN32
-        linkPath.Replace(L'\\', WCHAR_PATH_SEPARATOR);
+        LinkPath.Replace(L'\\', WCHAR_PATH_SEPARATOR);
        #endif
      }
      */
-      needSetReparse = linkInfo.Parse(_outMemBuf, reparseSize, _is_SymLink_in_Data_Linux);
+      needSetReparse = _is_SymLink_in_Data_Linux ?
+          link.Parse_from_LinuxData(_outMemBuf, reparseSize) :
+          link.Parse_from_WindowsReparseData(_outMemBuf, reparseSize);
      if (!needSetReparse)
        res = SendMessageError_with_LastError("Incorrect reparse stream", us2fs(_item.Path));
+      // (link.LinkPath) uses system path separator.
+      // windows: (link.LinkPath) doesn't contain linux separator (slash).
    }
    else
    {
@@ -2281,23 +2378,18 @@ HRESULT CArchiveExtractCallback::CloseReparseAndFile()
    _bufPtrSeqOutStream.Release();
  }
-  #endif // SUPPORT_LINKS
+#endif // SUPPORT_LINKS
  const HRESULT res2 = CloseFile();
  if (res == S_OK)
    res = res2;
  RINOK(res)
-  #ifdef SUPPORT_LINKS
+#ifdef SUPPORT_LINKS
  if (repraseMode)
  {
    _curSize = reparseSize;
    _curSize_Defined = true;
-    
-    #ifdef SUPPORT_LINKS
    if (needSetReparse)
    {
      // in Linux   : we must delete empty file before symbolic link creation
@@ -2307,31 +2399,19 @@ HRESULT CArchiveExtractCallback::CloseReparseAndFile()
        RINOK(SendMessageError_with_LastError("can't delete file", _diskFilePath))
      }
      {
-        /*
-        // for DEBUG ONLY: we can extract sym links as WSL links
-        // to eliminate (non-admin) errors for sym links.
-        #ifdef _WIN32
-        if (!linkInfo.isHardLink && !linkInfo.isJunction)
-          linkInfo.isWSL = true;
-        #endif
-        */
        bool linkWasSet = false;
-        RINOK(SetFromLinkPath(_diskFilePath, linkInfo, linkWasSet))
+        // link.LinkPath = "r:\\1\\2"; // for debug
+        // link.isJunction = true; // for debug
+        link.Normalize_to_RelativeSafe(_removePathParts);
+        RINOK(SetLink(_diskFilePath, link, linkWasSet))
        if (linkWasSet)
-          _isSymLinkCreated = linkInfo.IsSymLink();
+          _isSymLinkCreated = true; // link.IsSymLink();
        else
          _needSetAttrib = false;
      }
-      /*
-      if (!NFile::NIO::SetReparseData(_diskFilePath, _item.IsDir, ))
-      {
-        res = SendMessageError_with_LastError(kCantCreateSymLink, _diskFilePath);
-      }
-      */
    }
-    #endif
  }
-  #endif
+#endif // SUPPORT_LINKS
  return res;
 }
diff --git a/CPP/7zip/UI/Common/ArchiveExtractCallback.h b/CPP/7zip/UI/Common/ArchiveExtractCallback.h
index f3ee01c..71fa3ef 100644
--- a/CPP/7zip/UI/Common/ArchiveExtractCallback.h
+++ b/CPP/7zip/UI/Common/ArchiveExtractCallback.h
@@ -178,36 +178,50 @@ struct CDirPathTime: public CFiTimesCAM
 #ifdef SUPPORT_LINKS
+enum ELinkType
+{
+  k_LinkType_HardLink,
+  k_LinkType_PureSymLink,
+  k_LinkType_Junction,
+  k_LinkType_WSL
+  // , k_LinkType_CopyLink;
+};
 struct CLinkInfo
 {
-  // bool isCopyLink;
+  ELinkType LinkType;
-  bool isHardLink;
-  bool isJunction;
  bool isRelative;
-  bool isWSL;
+    //  if (isRelative == false), then (LinkPath) is relative to root folder of archive
-  UString linkPath;
+    //  if (isRelative == true ), then (LinkPath) is relative to current item
+  bool isWindowsPath;
+  UString LinkPath;
+  bool Is_HardLink() const { return LinkType == k_LinkType_HardLink; }
+  bool Is_AnySymLink() const { return LinkType != k_LinkType_HardLink; }
-  bool IsSymLink() const { return !isHardLink; }
+  bool Is_WSL() const { return LinkType == k_LinkType_WSL; }
  CLinkInfo():
-    // IsCopyLink(false),
+    LinkType(k_LinkType_PureSymLink),
-    isHardLink(false),
-    isJunction(false),
    isRelative(false),
-    isWSL(false)
+    isWindowsPath(false)
    {}
  void Clear()
  {
-    // IsCopyLink = false;
+    LinkType = k_LinkType_PureSymLink;
-    isHardLink = false;
-    isJunction = false;
    isRelative = false;
-    isWSL = false;
+    isWindowsPath = false;
-    linkPath.Empty();
+    LinkPath.Empty();
  }
-  bool Parse(const Byte *data, size_t dataSize, bool isLinuxData);
+  bool Parse_from_WindowsReparseData(const Byte *data, size_t dataSize);
+  bool Parse_from_LinuxData(const Byte *data, size_t dataSize);
+  void Normalize_to_RelativeSafe(UStringVector &removePathParts);
+private:
+  void Remove_AbsPathPrefixes();
 };
 #endif // SUPPORT_LINKS
@@ -287,8 +301,8 @@ private:
  bool _isRenamed;
  bool _extractMode;
-  // bool _is_SymLink_in_Data;
+  bool _is_SymLink_in_Data_Linux; // false = WIN32, true = LINUX.
-  bool _is_SymLink_in_Data_Linux; // false = WIN32, true = LINUX
+      // _is_SymLink_in_Data_Linux is detected from Windows/Linux part of attributes of file.
  bool _needSetAttrib;
  bool _isSymLinkCreated;
  bool _itemFailure;
@@ -420,6 +434,7 @@ public:
  HRESULT SendMessageError_with_Error(HRESULT errorCode, const char *message, const FString &path);
  HRESULT SendMessageError_with_LastError(const char *message, const FString &path);
  HRESULT SendMessageError2(HRESULT errorCode, const char *message, const FString &path1, const FString &path2);
+  HRESULT SendMessageError2_with_LastError(const char *message, const FString &path1, const FString &path2);
 #if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
  NExtract::NZoneIdMode::EEnum ZoneMode;
@@ -487,11 +502,16 @@ public:
 private:
  CHardLinks _hardLinks;
  CLinkInfo _link;
+  // const void *NtReparse_Data;
+  // UInt32 NtReparse_Size;
  // FString _copyFile_Path;
  // HRESULT MyCopyFile(ISequentialOutStream *outStream);
-  HRESULT Link(const FString &fullProcessedPath);
  HRESULT ReadLink();
+  HRESULT SetLink(
+      const FString &fullProcessedPath_from,
+      const CLinkInfo &linkInfo,
+      bool &linkWasSet);
 public:
  // call PrepareHardLinks() after Init()
@@ -538,16 +558,6 @@ private:
  HRESULT CloseReparseAndFile();
  HRESULT CloseReparseAndFile2();
  HRESULT SetDirsTimes();
-  const void *NtReparse_Data;
-  UInt32 NtReparse_Size;
-  #ifdef SUPPORT_LINKS
-  HRESULT SetFromLinkPath(
-      const FString &fullProcessedPath,
-      const CLinkInfo &linkInfo,
-      bool &linkWasSet);
-  #endif
 };
diff --git a/CPP/7zip/UI/Common/Bench.cpp b/CPP/7zip/UI/Common/Bench.cpp
index 05d66aa..eb24e7f 100644
--- a/CPP/7zip/UI/Common/Bench.cpp
+++ b/CPP/7zip/UI/Common/Bench.cpp
@@ -871,14 +871,27 @@ struct CAffinityMode
  unsigned NumCoreThreads;
  unsigned NumCores;
  // unsigned DivideNum;
+#ifdef _WIN32
+  unsigned NumGroups;
+#endif
  UInt32 Sizes[NUM_CPU_LEVELS_MAX];
  void SetLevels(unsigned numCores, unsigned numCoreThreads);
  DWORD_PTR GetAffinityMask(UInt32 bundleIndex, CCpuSet *cpuSet) const;
  bool NeedAffinity() const { return NumBundleThreads != 0; }
+#ifdef _WIN32
+  bool NeedGroupsMode() const { return NumGroups > 1; }
+#endif
  WRes CreateThread_WithAffinity(NWindows::CThread &thread, THREAD_FUNC_TYPE startAddress, LPVOID parameter, UInt32 bundleIndex) const
  {
+#ifdef _WIN32
+    if (NeedGroupsMode()) // we need fix for bundleIndex usage
+      return thread.Create_With_Group(startAddress, parameter, bundleIndex % NumGroups);
+#endif
    if (NeedAffinity())
    {
      CCpuSet cpuSet;
@@ -892,6 +905,9 @@ struct CAffinityMode
    NumBundleThreads(0),
    NumLevels(0),
    NumCoreThreads(1)
+#ifdef _WIN32
+    , NumGroups(0)
+#endif
    // DivideNum(1)
    {}
 };
@@ -1288,22 +1304,28 @@ HRESULT CEncoderInfo::Generate()
    if (scp)
    {
      const UInt64 reduceSize = kBufferSize;
-      
+      /* in posix : new thread uses same affinity as parent thread,
-      /* in posix new thread uses same affinity as parent thread,
         so we don't need to send affinity to coder in posix */
-      UInt64 affMask;
+      UInt64 affMask = 0;
-      #if !defined(Z7_ST) && defined(_WIN32)
+      UInt32 affinityGroup = (UInt32)(Int32)-1;
+      // UInt64 affinityInGroup = 0;
+#if !defined(Z7_ST) && defined(_WIN32)
      {
        CCpuSet cpuSet;
-        affMask = AffinityMode.GetAffinityMask(EncoderIndex, &cpuSet);
+        if (AffinityMode.NeedGroupsMode()) // we need fix for affinityInGroup also
+          affinityGroup = EncoderIndex % AffinityMode.NumGroups;
+        else
+          affMask = AffinityMode.GetAffinityMask(EncoderIndex, &cpuSet);
      }
-      #else
+#endif
-        affMask = 0;
+      // affMask <<= 3; // debug line: to test no affinity in coder
-      #endif
+      // affMask = 0; // for debug
-      // affMask <<= 3; // debug line: to test no affinity in coder;
+      // affinityGroup = 0; // for debug
-      // affMask = 0;
+      // affinityInGroup = 1; // for debug
+      RINOK(method.SetCoderProps_DSReduce_Aff(scp, &reduceSize,
-      RINOK(method.SetCoderProps_DSReduce_Aff(scp, &reduceSize, (affMask != 0 ? &affMask : NULL)))
+          affMask != 0 ? &affMask : NULL,
+          affinityGroup != (UInt32)(Int32)-1 ? &affinityGroup : NULL,
+          /* affinityInGroup != 0 ? &affinityInGroup : */ NULL))
    }
    else
    {
@@ -2962,7 +2984,7 @@ AString GetProcessThreadsInfo(const NSystem::CProcessAffinity &ti)
 {
  AString s;
  // s.Add_UInt32(ti.numProcessThreads);
-  unsigned numSysThreads = ti.GetNumSystemThreads();
+  const unsigned numSysThreads = ti.GetNumSystemThreads();
  if (ti.GetNumProcessThreads() != numSysThreads)
  {
    // if (ti.numProcessThreads != ti.numSysThreads)
@@ -2992,6 +3014,35 @@ AString GetProcessThreadsInfo(const NSystem::CProcessAffinity &ti)
    }
    #endif
  }
+#ifdef _WIN32
+  if (ti.Groups.GroupSizes.Size() > 1 ||
+      (ti.Groups.GroupSizes.Size() == 1
+       && ti.Groups.NumThreadsTotal != numSysThreads))
+  {
+    s += " : ";
+    s.Add_UInt32(ti.Groups.GroupSizes.Size());
+    s += " groups : ";
+    if (ti.Groups.NumThreadsTotal == numSysThreads)
+    {
+      s.Add_UInt32(ti.Groups.NumThreadsTotal);
+      s += " c : ";
+    }
+    UInt32 minSize, maxSize;
+    ti.Groups.Get_GroupSize_Min_Max(minSize, maxSize);
+    if (minSize == maxSize)
+    {
+      s.Add_UInt32(ti.Groups.GroupSizes[0]);
+      s += " c/g";
+    }
+    else
+    FOR_VECTOR (i, ti.Groups.GroupSizes)
+    {
+      if (i != 0)
+        s.Add_Char(' ');
+      s.Add_UInt32(ti.Groups.GroupSizes[i]);
+    }
+  }
+#endif
  return s;
 }
@@ -3753,9 +3804,13 @@ HRESULT Bench(
  UInt64 complexInCommands = kComplexInCommands;
  UInt32 numThreads_Start = 1;
  
-  #ifndef Z7_ST
+#ifndef Z7_ST
  CAffinityMode affinityMode;
-  #endif
+#ifdef _WIN32
+  if (threadsInfo.IsGroupMode && threadsInfo.Groups.GroupSizes.Size() > 1)
+    affinityMode.NumGroups = threadsInfo.Groups.GroupSizes.Size();
+#endif
+#endif
  COneMethodInfo method;
@@ -4861,7 +4916,7 @@ HRESULT Bench(
        if (AreSameMethodNames(benchMethod, methodName))
        {
          if (benchProps.IsEmpty()
-              || (benchProps == "x5" && method.PropsString.IsEmpty())
+              || (benchProps.IsEqualTo("x5") && method.PropsString.IsEmpty())
              || method.PropsString.IsPrefixedBy_Ascii_NoCase(benchProps))
          {
            callback.BenchProps.EncComplex = h.EncComplex;
diff --git a/CPP/7zip/UI/Common/EnumDirItems.cpp b/CPP/7zip/UI/Common/EnumDirItems.cpp
index 11643ae..cada2e6 100644
--- a/CPP/7zip/UI/Common/EnumDirItems.cpp
+++ b/CPP/7zip/UI/Common/EnumDirItems.cpp
@@ -1213,11 +1213,13 @@ HRESULT CDirItems::FillFixedReparse()
      // continue; // for debug
      if (!item.Has_Attrib_ReparsePoint())
        continue;
+      /*
+      We want to get properties of target file instead of properies of symbolic link.
+      Probably this code is unused, because
+      CFileInfo::Find(with followLink = true) called Fill_From_ByHandleFileInfo() already.
+      */
      // if (item.IsDir()) continue;
      const FString phyPath = GetPhyPath(i);
      NFind::CFileInfo fi;
      if (fi.Fill_From_ByHandleFileInfo(phyPath)) // item.IsDir()
      {
@@ -1228,38 +1230,13 @@ HRESULT CDirItems::FillFixedReparse()
        item.Attrib = fi.Attrib;
        continue;
      }
-      /*
-      // we request properties of target file instead of properies of symbolic link
-      // here we also can manually parse unsupported links (like WSL links)
-      NIO::CInFile inFile;
-      if (inFile.Open(phyPath))
-      {
-        BY_HANDLE_FILE_INFORMATION info;
-        if (inFile.GetFileInformation(&info))
-        {
-          // Stat.FilesSize doesn't contain item.Size already
-          // Stat.FilesSize -= item.Size;
-          item.Size = (((UInt64)info.nFileSizeHigh) << 32) + info.nFileSizeLow;
-          Stat.FilesSize += item.Size;
-          item.CTime = info.ftCreationTime;
-          item.ATime = info.ftLastAccessTime;
-          item.MTime = info.ftLastWriteTime;
-          item.Attrib = info.dwFileAttributes;
-          continue;
-        }
-      }
-      */
      RINOK(AddError(phyPath))
      continue;
    }
-    // (SymLinks == true) here
+    // (SymLinks == true)
    if (item.ReparseData.Size() == 0)
      continue;
    // if (item.Size == 0)
    {
      // 20.03: we use Reparse Data instead of real data
@@ -1277,7 +1254,7 @@ HRESULT CDirItems::FillFixedReparse()
    /* imagex/WIM reduces absolute paths in links (raparse data),
       if we archive non root folder. We do same thing here */
-    bool isWSL = false;
+    // bool isWSL = false;
    if (attr.IsSymLink_WSL())
    {
      // isWSL = true;
@@ -1314,21 +1291,27 @@ HRESULT CDirItems::FillFixedReparse()
      continue;
    if (rootPrefixSize == prefix.Len())
      continue; // simple case: paths are from root
    if (link.Len() <= prefix.Len())
      continue;
    if (CompareFileNames(link.Left(prefix.Len()), prefix) != 0)
      continue;
    UString newLink = prefix.Left(rootPrefixSize);
    newLink += link.Ptr(prefix.Len());
-    CByteBuffer data;
+    CByteBuffer &data = item.ReparseData2;
-    bool isSymLink = !attr.IsMountPoint();
+/*
-    if (!FillLinkData(data, newLink, isSymLink, isWSL))
+    if (isWSL)
+    {
+      Convert_WinPath_to_WslLinuxPath(newLink, true); // is absolute : change it
+      FillLinkData_WslLink(data, newLink);
+    }
+    else
+*/
+      FillLinkData_WinLink(data, newLink, !attr.IsMountPoint());
+    if (data.Size() == 0)
      continue;
-    item.ReparseData2 = data;
+    // item.ReparseData2 = data;
  }
  return S_OK;
 }
diff --git a/CPP/7zip/UI/Common/Extract.cpp b/CPP/7zip/UI/Common/Extract.cpp
index 010b01c..0301976 100644
--- a/CPP/7zip/UI/Common/Extract.cpp
+++ b/CPP/7zip/UI/Common/Extract.cpp
@@ -389,7 +389,7 @@ HRESULT Extract(
      {
        UString s = arcPath.Ptr(pos + 1);
        int index = codecs->FindFormatForExtension(s);
-        if (index >= 0 && s == L"001")
+        if (index >= 0 && s.IsEqualTo("001"))
        {
          s = arcPath.Left(pos);
          pos = s.ReverseFind(L'.');
diff --git a/CPP/7zip/UI/Common/ExtractingFilePath.cpp b/CPP/7zip/UI/Common/ExtractingFilePath.cpp
index 88da4ad..5ca5e66 100644
--- a/CPP/7zip/UI/Common/ExtractingFilePath.cpp
+++ b/CPP/7zip/UI/Common/ExtractingFilePath.cpp
@@ -208,7 +208,7 @@ void Correct_FsPath(bool absIsAllowed, bool keepAndReplaceEmptyPrefixes, UString
      if (parts.Size() > 1 && parts[1].IsEmpty())
      {
        i = 2;
-        if (parts.Size() > 2 && parts[2] == L"?")
+        if (parts.Size() > 2 && parts[2].IsEqualTo("?"))
        {
          i = 3;
          if (parts.Size() > 3 && NWindows::NFile::NName::IsDrivePath2(parts[3]))
diff --git a/CPP/7zip/UI/Common/HashCalc.cpp b/CPP/7zip/UI/Common/HashCalc.cpp
index 9caac36..f026f80 100644
--- a/CPP/7zip/UI/Common/HashCalc.cpp
+++ b/CPP/7zip/UI/Common/HashCalc.cpp
@@ -62,7 +62,7 @@ HRESULT CHashBundle::SetMethods(DECL_EXTERNAL_CODECS_LOC_VARS const UStringVecto
    if (m.MethodName.IsEmpty())
      m.MethodName = k_DefaultHashMethod;
    
-    if (m.MethodName == "*")
+    if (m.MethodName.IsEqualTo("*"))
    {
      CRecordVector<CMethodId> tempMethods;
      GetHashMethods(EXTERNAL_CODECS_LOC_VARS tempMethods);
@@ -431,6 +431,19 @@ static void WriteLine(CDynLimBuf &hashFileString,
 }
+static void Convert_TagName_to_MethodName(AString &method)
+{
+  // we need to convert at least SHA512/256 to SHA512-256, and SHA512/224 to SHA512-224
+  // but we convert any '/' to '-'.
+  method.Replace('/', '-');
+}
+static void Convert_MethodName_to_TagName(AString &method)
+{
+  if (method.IsPrefixedBy_Ascii_NoCase("SHA512-2"))
+    method.ReplaceOneCharAtPos(6, '/');
+}
 static void WriteLine(CDynLimBuf &hashFileString,
    const CHashOptionsLocal &options,
@@ -440,8 +453,10 @@ static void WriteLine(CDynLimBuf &hashFileString,
 {
  AString methodName;
  if (!hb.Hashers.IsEmpty())
+  {
    methodName = hb.Hashers[0].Name;
-  
+    Convert_MethodName_to_TagName(methodName);
+  }
  AString hashesString;
  AddHashResultLine(hashesString, hb.Hashers);
  WriteLine(hashFileString, options, path, isDir, methodName, hashesString);
@@ -752,7 +767,7 @@ bool CHashPair::ParseCksum(const char *s)
  Name = end;
  
  Hash.Alloc(4);
-  SetBe32(Hash, crc)
+  SetBe32a(Hash, crc)
  Size_from_Arc = size;
  Size_from_Arc_Defined = true;
@@ -773,56 +788,87 @@ static const char * const k_CsumMethodNames[] =
 {
    "sha256"
  , "sha224"
-//  , "sha512-224"
+  , "sha512-224"
-//  , "sha512-256"
+  , "sha512-256"
  , "sha384"
  , "sha512"
-//  , "sha3-224"
+  , "sha3-224"
  , "sha3-256"
-//  , "sha3-384"
+  , "sha3-384"
-//  , "sha3-512"
+  , "sha3-512"
 //  , "shake128"
 //  , "shake256"
  , "sha1"
+  , "sha2"
+  , "sha3"
+  , "sha"
  , "md5"
-  , "blake2sp"
+  , "blake2s"
  , "blake2b"
+  , "blake2sp"
  , "xxh64"
-  , "crc64"
  , "crc32"
+  , "crc64"
  , "cksum"
 };
-static UString GetMethod_from_FileName(const UString &name)
+// returns true, if (method) is known hash method or hash method group name.
+static bool GetMethod_from_FileName(const UString &name, AString &method)
 {
+  method.Empty();
  AString s;
  ConvertUnicodeToUTF8(name, s);
  const int dotPos = s.ReverseFind_Dot();
-  const char *src = s.Ptr();
-  bool isExtension = false;
  if (dotPos >= 0)
  {
-    isExtension = true;
+    method = s.Ptr(dotPos + 1);
-    src = s.Ptr(dotPos + 1);
+    if (method.IsEqualTo_Ascii_NoCase("txt") ||
+        method.IsEqualTo_Ascii_NoCase("asc"))
+    {
+      method.Empty();
+      const int dotPos2 = s.Find('.');
+      if (dotPos2 >= 0)
+        s.DeleteFrom(dotPos2);
+    }
  }
-  const char *m = "";
+  if (method.IsEmpty())
+  {
+    // we support file names with "sum" and "sums" postfixes: "sha256sum", "sha256sums"
+    unsigned size;
+    if (s.Len() > 4 && StringsAreEqualNoCase_Ascii(s.RightPtr(4), "sums"))
+      size = 4;
+    else if (s.Len() > 3 && StringsAreEqualNoCase_Ascii(s.RightPtr(3), "sum"))
+      size = 3;
+    else
+      return false;
+    method = s;
+    method.DeleteFrom(s.Len() - size);
+  }
  unsigned i;
  for (i = 0; i < Z7_ARRAY_SIZE(k_CsumMethodNames); i++)
  {
-    m = k_CsumMethodNames[i];
+    const char *m = k_CsumMethodNames[i];
-    if (isExtension)
+    if (method.IsEqualTo_Ascii_NoCase(m))
    {
-      if (StringsAreEqual_Ascii(src, m))
+      // method = m; // we can get lowcase
-        break;
+      return true;
    }
-    else if (IsString1PrefixedByString2_NoCase_Ascii(src, m))
-      if (StringsAreEqual_Ascii(src + strlen(m), "sums"))
-        break;
  }
-  UString res;
-  if (i != Z7_ARRAY_SIZE(k_CsumMethodNames))
+/*
-    res = m;
+  for (i = 0; i < Z7_ARRAY_SIZE(k_CsumMethodNames); i++)
-  return res;
+  {
+    const char *m = k_CsumMethodNames[i];
+    if (method.IsPrefixedBy_Ascii_NoCase(m))
+    {
+      method = m; // we get lowcase
+      return true;
+    }
+  }
+*/
+  return false;
 }
@@ -1047,7 +1093,7 @@ Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data
  if (propID == kpidChecksum)
  {
    const CHashPair &hp = HashPairs[index];
-    if (hp.Hash.Size() > 0)
+    if (hp.Hash.Size() != 0)
    {
      *data = hp.Hash;
      *dataSize = (UInt32)hp.Hash.Size();
@@ -1100,11 +1146,6 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
        s.Add_UInt32(_hashSize * 8);
        s += "-bit";
      }
-      if (!_nameExtenstion.IsEmpty())
-      {
-        s.Add_Space_if_NotEmpty();
-        s += _nameExtenstion;
-      }
      if (_is_PgpMethod)
      {
        Add_OptSpace_String(s, "PGP");
@@ -1120,6 +1161,18 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
        Add_OptSpace_String(s, "TAG");
      if (_are_there_Dirs)
        Add_OptSpace_String(s, "DIRS");
+      if (!_method_from_FileName.IsEmpty())
+      {
+        Add_OptSpace_String(s, "filename_method:");
+        s += _method_from_FileName;
+        if (!_is_KnownMethod_in_FileName)
+          s += ":UNKNOWN";
+      }
+      if (!_methods.IsEmpty())
+      {
+        Add_OptSpace_String(s, "cmd_method:");
+        s += _methods[0];
+      }
      prop = s;
      break;
    }
@@ -1228,6 +1281,15 @@ static HRESULT ReadStream_to_Buf(IInStream *stream, CByteBuffer &buf, IArchiveOp
 }
+static bool isThere_Zero_Byte(const Byte *data, size_t size)
+{
+  for (size_t i = 0; i < size; i++)
+    if (data[i] == 0)
+      return true;
+  return false;
+}
 Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *openCallback))
 {
  COM_TRY_BEGIN
@@ -1239,17 +1301,9 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallb
    CObjectVector<CHashPair> &pairs = HashPairs;
-    bool zeroMode = false;
+    const bool zeroMode = isThere_Zero_Byte(buf, buf.Size());
-    bool cr_lf_Mode = false;
-    {
-      for (size_t i = 0; i < buf.Size(); i++)
-        if (buf.ConstData()[i] == 0)
-        {
-          zeroMode = true;
-          break;
-        }
-    }
    _is_ZeroMode = zeroMode;
+    bool cr_lf_Mode = false;
    if (!zeroMode)
      cr_lf_Mode = Is_CR_LF_Data(buf, buf.Size());
@@ -1263,13 +1317,21 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallb
        NCOM::CPropVariant prop;
        RINOK(openVolumeCallback->GetProperty(kpidName, &prop))
        if (prop.vt == VT_BSTR)
-          _nameExtenstion = GetMethod_from_FileName(prop.bstrVal);
+          _is_KnownMethod_in_FileName = GetMethod_from_FileName(prop.bstrVal, _method_from_FileName);
      }
    }
-    bool cksumMode = false;
+    if (!_methods.IsEmpty())
-    if (_nameExtenstion.IsEqualTo_Ascii_NoCase("cksum"))
+    {
-      cksumMode = true;
+      ConvertUnicodeToUTF8(_methods[0], _method_for_Extraction);
+    }
+    if (_method_for_Extraction.IsEmpty())
+    {
+      // if (_is_KnownMethod_in_FileName)
+      _method_for_Extraction = _method_from_FileName;
+    }
+    const bool cksumMode = _method_for_Extraction.IsEqualTo_Ascii_NoCase("cksum");
    _is_CksumMode = cksumMode;
    size_t pos = 0;
@@ -1366,6 +1428,7 @@ void CHandler::ClearVars()
  _is_ZeroMode = false;
  _are_there_Tags = false;
  _are_there_Dirs = false;
+  _is_KnownMethod_in_FileName = false;
  _hashSize_Defined = false;
  _hashSize = 0;
 }
@@ -1374,7 +1437,8 @@ void CHandler::ClearVars()
 Z7_COM7F_IMF(CHandler::Close())
 {
  ClearVars();
-  _nameExtenstion.Empty();
+  _method_from_FileName.Empty();
+  _method_for_Extraction.Empty();
  _pgpMethod.Empty();
  HashPairs.Clear();
  return S_OK;
@@ -1401,19 +1465,73 @@ static bool CheckDigests(const Byte *a, const Byte *b, size_t size)
 }
-static void AddDefaultMethod(UStringVector &methods, unsigned size)
+static void AddDefaultMethod(UStringVector &methods,
+    const char *name, unsigned size)
 {
+  int shaVersion = -1;
+  if (name)
+  {
+    if (StringsAreEqualNoCase_Ascii(name, "sha"))
+    {
+      shaVersion = 0;
+      if (size == 0)
+        size = 32;
+    }
+    else if (StringsAreEqualNoCase_Ascii(name, "sha1"))
+    {
+      shaVersion = 1;
+      if (size == 0)
+        size = 20;
+    }
+    else if (StringsAreEqualNoCase_Ascii(name, "sha2"))
+    {
+      shaVersion = 2;
+      if (size == 0)
+        size = 32;
+    }
+    else if (StringsAreEqualNoCase_Ascii(name, "sha3"))
+    {
+      if (size == 0 ||
+               size == 32) name = "sha3-256";
+      else if (size == 28) name = "sha3-224";
+      else if (size == 48) name = "sha3-384";
+      else if (size == 64) name = "sha3-512";
+    }
+    else if (StringsAreEqualNoCase_Ascii(name, "sha512"))
+    {
+      // we allow any sha512 derived hash inside .sha512 file:
+           if (size == 48) name = "sha384";
+      else if (size == 32) name = "sha512-256";
+      else if (size == 28) name = "sha512-224";
+    }
+    if (shaVersion >= 0)
+      name = NULL;
+  }
+  
  const char *m = NULL;
-       if (size == 32) m = "sha256";
+  if (name)
-  else if (size == 20) m = "sha1";
+    m = name;
-  else if (size == 16) m = "md5";
-  else if (size ==  8) m = "crc64";
-  else if (size ==  4) m = "crc32";
  else
+  {
+         if (size == 64) m = "sha512";
+    else if (size == 48) m = "sha384";
+    else if (size == 32) m = "sha256";
+    else if (size == 28) m = "sha224";
+    else if (size == 20) m = "sha1";
+    else if (shaVersion < 0)
+    {
+           if (size == 16) m = "md5";
+      else if (size ==  8) m = "crc64";
+      else if (size ==  4) m = "crc32";
+    }
+  }
+  if (!m)
    return;
-  #ifdef Z7_EXTERNAL_CODECS
+#ifdef Z7_EXTERNAL_CODECS
  const CExternalCodecs *_externalCodecs = g_ExternalCodecs_Ptr;
-  #endif
+#endif
  CMethodId id;
  if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS
      AString(m), id))
@@ -1444,15 +1562,15 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
  CHashBundle hb_Glob;
  // UStringVector methods = options.Methods;
  UStringVector methods;
-  
-  if (methods.IsEmpty() && !_nameExtenstion.IsEmpty())
+/*
+  if (methods.IsEmpty() && !utf_nameExtenstion.IsEmpty() && !_hashSize_Defined)
  {
-    AString utf;
-    ConvertUnicodeToUTF8(_nameExtenstion, utf);
    CMethodId id;
-    if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS utf, id))
+    if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS utf_nameExtenstion, id))
      methods.Add(_nameExtenstion);
  }
+*/
  
  if (methods.IsEmpty() && !_pgpMethod.IsEmpty())
  {
@@ -1461,12 +1579,21 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
      methods.Add(UString(_pgpMethod));
  }
+/*
  if (methods.IsEmpty() && _pgpMethod.IsEmpty() && _hashSize_Defined)
-    AddDefaultMethod(methods, _hashSize);
+  {
+    AddDefaultMethod(methods,
+        utf_nameExtenstion.IsEmpty() ? NULL : utf_nameExtenstion.Ptr(),
+        _hashSize);
+  }
+*/
-  RINOK(hb_Glob.SetMethods(
+  if (!methods.IsEmpty())
+  {
+    RINOK(hb_Glob.SetMethods(
      EXTERNAL_CODECS_LOC_VARS
      methods))
+  }
  Z7_DECL_CMyComPtr_QI_FROM(
      IArchiveUpdateCallbackFile,
@@ -1561,9 +1688,11 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
    {
      hb_Use = &hb_Loc;
      CMethodId id;
-      if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS hp.Method, id))
+      AString methodName = hp.Method;
+      Convert_TagName_to_MethodName(methodName);
+      if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS methodName, id))
      {
-        methods_loc.Add(UString(hp.Method));
+        methods_loc.Add(UString(methodName));
        RINOK(hb_Loc.SetMethods(
            EXTERNAL_CODECS_LOC_VARS
            methods_loc))
@@ -1573,7 +1702,10 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
    }
    else if (methods.IsEmpty())
    {
-      AddDefaultMethod(methods_loc, (unsigned)hp.Hash.Size());
+      AddDefaultMethod(methods_loc,
+          _method_for_Extraction.IsEmpty() ? NULL :
+          _method_for_Extraction.Ptr(),
+          (unsigned)hp.Hash.Size());
      if (!methods_loc.IsEmpty())
      {
        hb_Use = &hb_Loc;
@@ -1621,7 +1753,7 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
    Int32 opRes = NArchive::NExtract::NOperationResult::kUnsupportedMethod;
    if (isSupportedMode
        && res_SetMethods != E_NOTIMPL
-        && hb_Use->Hashers.Size() > 0
+        && !hb_Use->Hashers.IsEmpty()
        )
    {
      const CHasherState &hs = hb_Use->Hashers[0];
@@ -1774,10 +1906,6 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
      methods.Add(_methods[k]);
    }
  }
-  else if (_crcSize_WasSet)
-  {
-    AddDefaultMethod(methods, _crcSize);
-  }
  else
  {
    Z7_DECL_CMyComPtr_QI_FROM(
@@ -1789,12 +1917,23 @@ Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
      RINOK(getRootProps->GetRootProp(kpidArcFileName, &prop))
      if (prop.vt == VT_BSTR)
      {
-        const UString method = GetMethod_from_FileName(prop.bstrVal);
+        AString method;
+        /* const bool isKnownMethod = */ GetMethod_from_FileName(prop.bstrVal, method);
        if (!method.IsEmpty())
-          methods.Add(method);
+        {
+          AddDefaultMethod(methods, method, _crcSize_WasSet ? _crcSize : 0);
+          if (methods.IsEmpty())
+            return E_NOTIMPL;
+        }
      }
    }
  }
+  if (methods.IsEmpty() && _crcSize_WasSet)
+  {
+    AddDefaultMethod(methods,
+        NULL, // name
+        _crcSize);
+  }
  RINOK(hb.SetMethods(EXTERNAL_CODECS_LOC_VARS methods))
@@ -2038,6 +2177,15 @@ HRESULT CHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
 }
+void CHandler::InitProps()
+{
+  _supportWindowsBackslash = true;
+  _crcSize_WasSet = false;
+  _crcSize = 4;
+  _methods.Clear();
+  _options.Init_HashOptionsLocal();
+}
 Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
 {
  COM_TRY_BEGIN
@@ -2088,22 +2236,27 @@ void Codecs_AddHashArcHandler(CCodecs *codecs)
        " sha512"
        " sha384"
        " sha224"
-        // " sha512-224"
+        " sha512-224"
-        // " sha512-256"
+        " sha512-256"
-        // " sha3-224"
+        " sha3-224"
        " sha3-256"
-        // " sha3-384"
+        " sha3-384"
-        // " sha3-512"
+        " sha3-512"
        // " shake128"
        // " shake256"
        " sha1"
+        " sha2"
+        " sha3"
        " sha"
        " md5"
+        " blake2s"
+        " blake2b"
        " blake2sp"
        " xxh64"
-        " crc32 crc64"
+        " crc32"
-        " asc"
+        " crc64"
        " cksum"
+        " asc"
        // " b2sum"
        ),
        UString());
diff --git a/CPP/7zip/UI/Common/HashCalc.h b/CPP/7zip/UI/Common/HashCalc.h
index 1e9dbf4..b8f867f 100644
--- a/CPP/7zip/UI/Common/HashCalc.h
+++ b/CPP/7zip/UI/Common/HashCalc.h
@@ -279,32 +279,25 @@ Z7_CLASS_IMP_CHandler_IInArchive_3(
  bool _isArc;
  bool _supportWindowsBackslash;
  bool _crcSize_WasSet;
-  UInt64 _phySize;
-  CObjectVector<CHashPair> HashPairs;
-  UString _nameExtenstion;
-  // UString _method_fromName;
-  AString _pgpMethod;
  bool _is_CksumMode;
  bool _is_PgpMethod;
  bool _is_ZeroMode;
  bool _are_there_Tags;
  bool _are_there_Dirs;
+  bool _is_KnownMethod_in_FileName;
  bool _hashSize_Defined;
  unsigned _hashSize;
  UInt32 _crcSize;
+  UInt64 _phySize;
+  CObjectVector<CHashPair> HashPairs;
  UStringVector _methods;
+  AString _method_from_FileName;
+  AString _pgpMethod;
+  AString _method_for_Extraction;
  CHashOptionsLocal _options;
  void ClearVars();
+  void InitProps();
-  void InitProps()
-  {
-    _supportWindowsBackslash = true;
-    _crcSize_WasSet = false;
-    _crcSize = 4;
-    _methods.Clear();
-    _options.Init_HashOptionsLocal();
-  }
  bool CanUpdate() const
  {
diff --git a/CPP/7zip/UI/Common/LoadCodecs.cpp b/CPP/7zip/UI/Common/LoadCodecs.cpp
index 6bf53ea..943435a 100644
--- a/CPP/7zip/UI/Common/LoadCodecs.cpp
+++ b/CPP/7zip/UI/Common/LoadCodecs.cpp
@@ -170,7 +170,7 @@ void CArcInfoEx::AddExts(const UString &ext, const UString &addExt)
    if (i < addExts.Size())
    {
      extInfo.AddExt = addExts[i];
-      if (extInfo.AddExt == L"*")
+      if (extInfo.AddExt.IsEqualTo("*"))
        extInfo.AddExt.Empty();
    }
    Exts.Add(extInfo);
@@ -931,8 +931,8 @@ bool CCodecs::FindFormatForArchiveType(const UString &arcType, CIntVector &forma
    const UString name = arcType.Mid(pos, (unsigned)pos2 - pos);
    if (name.IsEmpty())
      return false;
-    int index = FindFormatForArchiveType(name);
+    const int index = FindFormatForArchiveType(name);
-    if (index < 0 && name != L"*")
+    if (index < 0 && !name.IsEqualTo("*"))
    {
      formatIndices.Clear();
      return false;
diff --git a/CPP/7zip/UI/Common/Update.cpp b/CPP/7zip/UI/Common/Update.cpp
index b959a3c..1c2754e 100644
--- a/CPP/7zip/UI/Common/Update.cpp
+++ b/CPP/7zip/UI/Common/Update.cpp
@@ -474,7 +474,7 @@ static HRESULT Compress(
  CArcToDoStat stat2;
-  if (options.RenamePairs.Size() != 0)
+  if (options.RenameMode || options.RenamePairs.Size() != 0)
  {
    FOR_VECTOR (i, arcItems)
    {
@@ -1920,7 +1920,7 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
      if (NFind::DoesDirExist(phyPath))
      {
        RINOK(callback->DeletingAfterArchiving(phyPath, true))
-        RemoveDir(phyPath);
+        RemoveDirAlways_if_Empty(phyPath);
      }
    }
diff --git a/CPP/7zip/UI/Common/Update.h b/CPP/7zip/UI/Common/Update.h
index 216339a..ae141e5 100644
--- a/CPP/7zip/UI/Common/Update.h
+++ b/CPP/7zip/UI/Common/Update.h
@@ -94,6 +94,7 @@ struct CUpdateOptions
  bool DeleteAfterCompressing;
  bool SetArcMTime;
+  bool RenameMode;
  CBoolPair NtSecurity;
  CBoolPair AltStreams;
@@ -139,6 +140,7 @@ struct CUpdateOptions
    
    DeleteAfterCompressing(false),
    SetArcMTime(false),
+    RenameMode(false),
    ArcNameMode(k_ArcNameMode_Smart),
    PathMode(NWildcard::k_RelatPath)
diff --git a/CPP/7zip/UI/Common/UpdateCallback.cpp b/CPP/7zip/UI/Common/UpdateCallback.cpp
index d3ee639..e2f1866 100644
--- a/CPP/7zip/UI/Common/UpdateCallback.cpp
+++ b/CPP/7zip/UI/Common/UpdateCallback.cpp
@@ -32,6 +32,7 @@
 #include "../../../Windows/PropVariant.h"
 #include "../../Common/StreamObjects.h"
+#include "../../Archive/Common/ItemNameUtils.h"
 #include "UpdateCallback.h"
@@ -306,7 +307,7 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetRawProp(UInt32 index, PROPID propID, con
 #if defined(_WIN32) && !defined(UNDER_CE)
-static UString GetRelativePath(const UString &to, const UString &from)
+static UString GetRelativePath(const UString &to, const UString &from, bool isWSL)
 {
  UStringVector partsTo, partsFrom;
  SplitPathToParts(to, partsTo);
@@ -324,11 +325,12 @@ static UString GetRelativePath(const UString &to, const UString &from)
  if (i == 0)
  {
-    #ifdef _WIN32
+#ifdef _WIN32
-    if (NName::IsDrivePath(to) ||
+    if (isWSL ||
-        NName::IsDrivePath(from))
+       (NName::IsDrivePath(to) ||
+        NName::IsDrivePath(from)))
      return to;
-    #endif
+#endif
  }
  UString s;
@@ -373,54 +375,87 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PR
        return S_OK;
      }
      
-      #if !defined(UNDER_CE)
+#if !defined(UNDER_CE)
      if (up.DirIndex >= 0)
      {
        const CDirItem &di = DirItems->Items[(unsigned)up.DirIndex];
-        
+        if (di.ReparseData.Size())
-        #ifdef _WIN32
-        // if (di.IsDir())
        {
+#ifdef _WIN32
          CReparseAttr attr;
          if (attr.Parse(di.ReparseData, di.ReparseData.Size()))
          {
-            const UString simpleName = attr.GetPath();
+            UString path = attr.GetPath();
-            if (!attr.IsSymLink_WSL() && attr.IsRelative_Win())
+            if (!path.IsEmpty())
-              prop = simpleName;
-            else
            {
-              const FString phyPath = DirItems->GetPhyPath((unsigned)up.DirIndex);
+              bool isWSL = attr.IsSymLink_WSL();
-              FString fullPath;
+              if (isWSL)
-              if (NDir::MyGetFullPathName(phyPath, fullPath))
+                NArchive::NItemName::ReplaceToWinSlashes(path, true); // useBackslashReplacement
+              // it's expected that (path) now uses windows slashes.
+              // CReparseAttr::IsRelative_Win() returns true if FLAG_RELATIVE is set
+              // CReparseAttr::IsRelative_Win() returns true for "\dir1\path"
+              // but we want to store real relative paths without "\" root prefix.
+              // so we parse path instead of IsRelative_Win() calling.
+              if (// attr.IsRelative_Win() ||
+                  (isWSL ?
+                   IS_PATH_SEPAR(path[0]) :
+                   NName::IsAbsolutePath(path)))
              {
-                prop = GetRelativePath(simpleName, fs2us(fullPath));
+                // (path) is abolute path or relative to root: "\path"
+                // we try to convert (path) to relative path for writing to archive.
+                const FString phyPath = DirItems->GetPhyPath((unsigned)up.DirIndex);
+                FString fullPath;
+                if (NDir::MyGetFullPathName(phyPath, fullPath))
+                {
+                  if (IS_PATH_SEPAR(path[0]) &&
+                      !IS_PATH_SEPAR(path[1]))
+                  {
+                    // path is relative to root of (fullPath): "\path"
+                    const unsigned prefixSize = NName::GetRootPrefixSize(fullPath);
+                    if (prefixSize)
+                    {
+                      path.DeleteFrontal(1);
+                      path.Insert(0, fs2us(fullPath.Left(prefixSize)));
+                      // we have changed "\" prefix to drive prefix "c:\" in (path).
+                      // (path) is Windows path now.
+                      isWSL = false;
+                    }
+                  }
+                }
+                path = GetRelativePath(path, fs2us(fullPath), isWSL);
              }
+#if WCHAR_PATH_SEPARATOR != L'/'
+              // 7-Zip's TAR handler in Windows replaces windows slashes to linux slashes.
+              // so we can return any slashes to TAR handler.
+              // or we can convert to linux slashes here,
+              // because input IInArchive handler uses linux slashes for kpidSymLink.
+              // path.Replace(WCHAR_PATH_SEPARATOR, L'/');
+#endif
+              if (!path.IsEmpty())
+                prop = path;
            }
-            prop.Detach(value);
-            return S_OK;
          }
-        }
+#else // ! _WIN32
-        
-        #else // _WIN32
-        if (di.ReparseData.Size() != 0)
-        {
          AString utf;
          utf.SetFrom_CalcLen((const char *)(const Byte *)di.ReparseData, (unsigned)di.ReparseData.Size());
+    #if 0 // 0 - for debug
+          // it's expected that link data uses system codepage.
+          // fs2us() ignores conversion errors. But we want correct path
+          UString us (fs2us(utf));
+    #else
          UString us;
          if (ConvertUTF8ToUnicode(utf, us))
+    #endif
          {
-            prop = us;
+            if (!us.IsEmpty())
-            prop.Detach(value);
+              prop = us;
-            return S_OK;
          }
+#endif // ! _WIN32
        }
+        prop.Detach(value);
-        #endif // _WIN32
+        return S_OK;
      }
-      #endif // !defined(UNDER_CE)
+#endif // !defined(UNDER_CE)
    }
    else if (propID == kpidHardLink)
    {
@@ -428,7 +463,12 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PR
      {
        const CKeyKeyValPair &pair = _map[_hardIndex_To];
        const CUpdatePair2 &up2 = (*UpdatePairs)[pair.Value];
-        prop = DirItems->GetLogPath((unsigned)up2.DirIndex);
+        const UString path = DirItems->GetLogPath((unsigned)up2.DirIndex);
+#if WCHAR_PATH_SEPARATOR != L'/'
+        // 7-Zip's TAR handler in Windows replaces windows slashes to linux slashes.
+        // path.Replace(WCHAR_PATH_SEPARATOR, L'/');
+#endif
+        prop = path;
        prop.Detach(value);
        return S_OK;
      }
@@ -438,7 +478,7 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PR
        return S_OK;
      }
    }
-  }
+  } // if (up.NewData)
  
  if (up.IsAnti
      && propID != kpidIsDir
diff --git a/CPP/7zip/UI/Console/Main.cpp b/CPP/7zip/UI/Console/Main.cpp
index dabd696..90e00a4 100644
--- a/CPP/7zip/UI/Console/Main.cpp
+++ b/CPP/7zip/UI/Console/Main.cpp
@@ -908,9 +908,12 @@ int Main2(
  if (options.EnableHeaders)
  {
-    ShowCopyrightAndHelp(g_StdStream, false);
+    if (g_StdStream)
-    if (!parser.Parse1Log.IsEmpty())
+    {
-      *g_StdStream << parser.Parse1Log;
+      ShowCopyrightAndHelp(g_StdStream, false);
+      if (!parser.Parse1Log.IsEmpty())
+        *g_StdStream << parser.Parse1Log;
+    }
  }
  parser.Parse2(options);
diff --git a/CPP/7zip/UI/Console/makefile b/CPP/7zip/UI/Console/makefile
index a20b0cc..d449b38 100644
--- a/CPP/7zip/UI/Console/makefile
+++ b/CPP/7zip/UI/Console/makefile
@@ -59,10 +59,10 @@ COMPRESS_OBJS = \
 C_OBJS = $(C_OBJS) \
  $O\Alloc.obj \
  $O\CpuArch.obj \
-  $O\Sort.obj \
  $O\Threads.obj \
 !include "../../Crc.mak"
+!include "../../Sort.mak"
 !include "Console.mak"
 !include "../../7zip.mak"
diff --git a/CPP/7zip/UI/Explorer/makefile b/CPP/7zip/UI/Explorer/makefile
index 3901d6b..311d70e 100644
--- a/CPP/7zip/UI/Explorer/makefile
+++ b/CPP/7zip/UI/Explorer/makefile
@@ -72,7 +72,7 @@ FM_OBJS = \
 C_OBJS = \
  $O\CpuArch.obj \
-  $O\Sort.obj \
  $O\Threads.obj \
+!include "../../Sort.mak"
 !include "../../7zip.mak"
diff --git a/CPP/7zip/UI/Far/Plugin.cpp b/CPP/7zip/UI/Far/Plugin.cpp
index 2d31b8a..b7f91d6 100644
--- a/CPP/7zip/UI/Far/Plugin.cpp
+++ b/CPP/7zip/UI/Far/Plugin.cpp
@@ -61,7 +61,6 @@ static void MyGetFileTime(IFolderFolder *folder, UInt32 itemIndex,
 }
 #define kDotsReplaceString "[[..]]"
-#define kDotsReplaceStringU L"[[..]]"
  
 static void CopyStrLimited(char *dest, const AString &src, unsigned len)
 {
@@ -84,7 +83,7 @@ void CPlugin::ReadPluginPanelItem(PluginPanelItem &panelItem, UInt32 itemIndex)
    throw 272340;
  AString oemString (UnicodeStringToMultiByte(prop.bstrVal, CP_OEMCP));
-  if (oemString == "..")
+  if (oemString.IsEqualTo(".."))
    oemString = kDotsReplaceString;
  COPY_STR_LIMITED(panelItem.FindData.cFileName, oemString);
@@ -193,7 +192,7 @@ void CPlugin::EnterToDirectory(const UString &dirName)
 {
  CMyComPtr<IFolderFolder> newFolder;
  UString s = dirName;
-  if (dirName == kDotsReplaceStringU)
+  if (dirName.IsEqualTo(kDotsReplaceString))
    s = "..";
  _folder->BindToFolder(s, &newFolder);
  if (!newFolder)
@@ -209,12 +208,12 @@ void CPlugin::EnterToDirectory(const UString &dirName)
 int CPlugin::SetDirectory(const char *aszDir, int /* opMode */)
 {
  UString path = MultiByteToUnicodeString(aszDir, CP_OEMCP);
-  if (path == WSTRING_PATH_SEPARATOR)
+  if (path.IsEqualTo(STRING_PATH_SEPARATOR))
  {
    _folder.Release();
    m_ArchiveHandler->BindToRootFolder(&_folder);
  }
-  else if (path == L"..")
+  else if (path.IsEqualTo(".."))
  {
    CMyComPtr<IFolderFolder> newFolder;
    _folder->BindToParentFolder(&newFolder);
diff --git a/CPP/7zip/UI/Far/makefile b/CPP/7zip/UI/Far/makefile
index a66f9d7..7bc166b 100644
--- a/CPP/7zip/UI/Far/makefile
+++ b/CPP/7zip/UI/Far/makefile
@@ -99,9 +99,9 @@ COMPRESS_OBJS = \
 C_OBJS = \
  $O\Alloc.obj \
  $O\CpuArch.obj \
-  $O\Sort.obj \
  $O\Threads.obj \
 !include "../../Crc.mak"
+!include "../../Sort.mak"
 !include "../../7zip.mak"
diff --git a/CPP/7zip/UI/FileManager/FM.cpp b/CPP/7zip/UI/FileManager/FM.cpp
index 7310802..b2f4c2b 100644
--- a/CPP/7zip/UI/FileManager/FM.cpp
+++ b/CPP/7zip/UI/FileManager/FM.cpp
@@ -651,7 +651,7 @@ static int WINAPI WinMain2(int nCmdShow)
  SplitStringToTwoStrings(commandsString, paramString, tailString);
  paramString.Trim();
  tailString.Trim();
-  if (tailString.IsPrefixedBy(L"-t"))
+  if (tailString.IsPrefixedBy("-t"))
    g_ArcFormat = tailString.Ptr(2);
  /*
diff --git a/CPP/7zip/UI/FileManager/LangUtils.cpp b/CPP/7zip/UI/FileManager/LangUtils.cpp
index 8fcb507..4712192 100644
--- a/CPP/7zip/UI/FileManager/LangUtils.cpp
+++ b/CPP/7zip/UI/FileManager/LangUtils.cpp
@@ -309,15 +309,13 @@ void ReloadLang()
 {
  g_Lang.Clear();
  ReadRegLang(g_LangID);
-  #ifndef _UNICODE
+  if (g_LangID.IsEmpty())
-  if (g_IsNT)
-  #endif
  {
-    if (g_LangID.IsEmpty())
+#ifndef _UNICODE
-    {
+    if (g_IsNT)
+#endif
      OpenDefaultLang();
-      return;
+    return;
-    }
  }
  if (g_LangID.Len() > 1 || g_LangID[0] != L'-')
  {
diff --git a/CPP/7zip/UI/FileManager/LinkDialog.cpp b/CPP/7zip/UI/FileManager/LinkDialog.cpp
index 0f24761..a92ee4d 100644
--- a/CPP/7zip/UI/FileManager/LinkDialog.cpp
+++ b/CPP/7zip/UI/FileManager/LinkDialog.cpp
@@ -45,28 +45,24 @@ static bool GetSymLink(CFSTR path, CReparseAttr &attr, UString &errorMessage)
  CByteBuffer buf;
  if (!NIO::GetReparseData(path, buf, NULL))
    return false;
-  
  if (!attr.Parse(buf, buf.Size()))
  {
    SetLastError(attr.ErrorCode);
    return false;
  }
  CByteBuffer data2;
-  if (!FillLinkData(data2, attr.GetPath(),
+  FillLinkData(data2, attr.GetPath(),
-      !attr.IsMountPoint(), attr.IsSymLink_WSL()))
+      !attr.IsMountPoint(), attr.IsSymLink_WSL());
+  if (data2.Size() == 0)
  {
    errorMessage = "Cannot reproduce reparse point";
    return false;
  }
-    
+  if (data2 != buf)
-  if (data2.Size() != buf.Size() ||
-      memcmp(data2, buf, buf.Size()) != 0)
  {
    errorMessage = "mismatch for reproduced reparse point";
    return false;
  }
  return true;
 }
@@ -113,8 +109,8 @@ bool CLinkDialog::OnInit()
        const bool res = GetSymLink(us2fs(FilePath), attr, error);
        if (!res && error.IsEmpty())
        {
-          DWORD lastError = GetLastError();
+          const DWORD lastError = GetLastError();
-          if (lastError != 0)
+          if (lastError)
            error = NError::MyFormatMessage(lastError);
        }
        
@@ -319,10 +315,10 @@ void CLinkDialog::OnButton_Link()
      return;
    }
-    const bool isSymLink = (idb != IDR_LINK_TYPE_JUNCTION);
-    
    CByteBuffer data;
-    if (!FillLinkData(data, to, isSymLink, isWSL))
+    const bool isSymLink = (idb != IDR_LINK_TYPE_JUNCTION);
+    FillLinkData(data, to, isSymLink, isWSL);
+    if (data.Size() == 0)
    {
      ShowError(L"Incorrect link");
      return;
@@ -386,6 +382,9 @@ void CApp::Link()
        path = destPanel.GetFsPath();
  }
+  CSelectedState srcSelState;
+  srcPanel.SaveSelectedState(srcSelState);
  CLinkDialog dlg;
  dlg.CurDirPrefix = fsPrefix;
  dlg.FilePath = srcPath + itemName;
@@ -394,7 +393,10 @@ void CApp::Link()
  if (dlg.Create(srcPanel.GetParent()) != IDOK)
    return;
-  // fix it: we should refresh panel with changed link
+  // we refresh srcPanel to show changes in "Link" (kpidNtReparse) column.
+  // maybe we should refresh another panel also?
+  if (srcPanel._visibleColumns.FindItem_for_PropID(kpidNtReparse) >= 0)
+    srcPanel.RefreshListCtrl(srcSelState);
  RefreshTitleAlways();
 }
diff --git a/CPP/7zip/UI/FileManager/Panel.h b/CPP/7zip/UI/FileManager/Panel.h
index 9c53048..9ef0926 100644
--- a/CPP/7zip/UI/FileManager/Panel.h
+++ b/CPP/7zip/UI/FileManager/Panel.h
@@ -711,8 +711,8 @@ public:
  }
  // bool IsFsOrDrivesFolder() const { return IsFSFolder() || IsFSDrivesFolder(); }
-  bool IsDeviceDrivesPrefix() const { return _currentFolderPrefix == L"\\\\.\\"; }
+  bool IsDeviceDrivesPrefix() const { return _currentFolderPrefix.IsEqualTo("\\\\.\\"); }
-  bool IsSuperDrivesPrefix() const { return _currentFolderPrefix == L"\\\\?\\"; }
+  bool IsSuperDrivesPrefix() const { return _currentFolderPrefix.IsEqualTo("\\\\?\\"); }
  
  /*
    c:\Dir
diff --git a/CPP/7zip/UI/FileManager/PanelCopy.cpp b/CPP/7zip/UI/FileManager/PanelCopy.cpp
index d4f1db7..f070be9 100644
--- a/CPP/7zip/UI/FileManager/PanelCopy.cpp
+++ b/CPP/7zip/UI/FileManager/PanelCopy.cpp
@@ -284,7 +284,7 @@ HRESULT CPanel::CopyTo(CCopyToOptions &options,
      if (options.hashMethods.Size() == 1)
      {
        const UString &s = options.hashMethods[0];
-        if (s != L"*")
+        if (!s.IsEqualTo("*"))
          title = s;
      }
    }
diff --git a/CPP/7zip/UI/FileManager/PanelFolderChange.cpp b/CPP/7zip/UI/FileManager/PanelFolderChange.cpp
index c34cb74..b0fb53e 100644
--- a/CPP/7zip/UI/FileManager/PanelFolderChange.cpp
+++ b/CPP/7zip/UI/FileManager/PanelFolderChange.cpp
@@ -428,7 +428,7 @@ void CPanel::LoadFullPathAndShow()
      UString name_Computer = RootFolder_GetName_Computer(iconIndex);
      name_Computer.Add_PathSepar();
      if (path == name_Computer
-          || path == L"\\\\?\\")
+          || path.IsEqualTo("\\\\?\\"))
        item.iImage = iconIndex;
      else
      {
@@ -639,7 +639,7 @@ bool CPanel::OnComboBoxCommand(UINT code, LPARAM /* param */, LRESULT &result)
      unsigned indent = 0;
      {
        UString path = _currentFolderPrefix;
-        // path = L"\\\\.\\y:\\"; // for debug
+        // path = "\\\\.\\y:\\"; // for debug
        UString prefix0;
        if (path.IsPrefixedBy_Ascii_NoCase("\\\\"))
        {
@@ -702,7 +702,7 @@ bool CPanel::OnComboBoxCommand(UINT code, LPARAM /* param */, LRESULT &result)
      int iconIndex_Computer;
      const UString name_Computer = RootFolder_GetName_Computer(iconIndex_Computer);
-      // const bool is_devicePrefix = (sumPath == L"\\\\.\\");
+      // const bool is_devicePrefix = (sumPath.IsEqualTo("\\\\.\\"));
      if (pathParts.Size() > 1)
      if (!sumPath.IsEmpty()
@@ -901,8 +901,8 @@ UString CPanel::GetParentDirPrefix() const
    {
      s = _currentFolderPrefix;
      s.DeleteBack();
-      if (s != L"\\\\." &&
+      if (!s.IsEqualTo("\\\\.") &&
-          s != L"\\\\?")
+          !s.IsEqualTo("\\\\?"))
      {
        int pos = s.ReverseFind_PathSepar();
        if (pos >= 0)
@@ -935,8 +935,8 @@ void CPanel::OpenParentFolder()
      }
      else
      */
-      if (focusedName != L"\\\\." &&
+      if (!focusedName.IsEqualTo("\\\\.") &&
-          focusedName != L"\\\\?")
+          !focusedName.IsEqualTo("\\\\?"))
      {
        const int pos = focusedName.ReverseFind_PathSepar();
        if (pos >= 0)
diff --git a/CPP/7zip/UI/FileManager/PanelOperations.cpp b/CPP/7zip/UI/FileManager/PanelOperations.cpp
index 8b16224..427464b 100644
--- a/CPP/7zip/UI/FileManager/PanelOperations.cpp
+++ b/CPP/7zip/UI/FileManager/PanelOperations.cpp
@@ -275,8 +275,8 @@ static bool IsCorrectFsName(const UString &name)
 {
  const UString lastPart = name.Ptr((unsigned)(name.ReverseFind_PathSepar() + 1));
  return
-      lastPart != L"." &&
+      !lastPart.IsEqualTo(".") &&
-      lastPart != L"..";
+      !lastPart.IsEqualTo("..");
 }
 bool CorrectFsPath(const UString &relBase, const UString &path, UString &result);
diff --git a/CPP/7zip/UI/FileManager/RootFolder.cpp b/CPP/7zip/UI/FileManager/RootFolder.cpp
index 192f660..b512f3b 100644
--- a/CPP/7zip/UI/FileManager/RootFolder.cpp
+++ b/CPP/7zip/UI/FileManager/RootFolder.cpp
@@ -249,7 +249,7 @@ Z7_COM7F_IMF(CRootFolder::BindToFolder(const wchar_t *name, IFolderFolder **resu
      AreEqualNames(name2, L"Documents"))
    return BindToFolder((UInt32)ROOT_INDEX_DOCUMENTS, resultFolder);
  #else
-  if (name2 == WSTRING_PATH_SEPARATOR)
+  if (name2.IsEqualTo(STRING_PATH_SEPARATOR))
    return BindToFolder((UInt32)ROOT_INDEX_COMPUTER, resultFolder);
  #endif
  
@@ -257,7 +257,7 @@ Z7_COM7F_IMF(CRootFolder::BindToFolder(const wchar_t *name, IFolderFolder **resu
      AreEqualNames(name2, L"Computer"))
    return BindToFolder((UInt32)ROOT_INDEX_COMPUTER, resultFolder);
  
-  if (name2 == WSTRING_PATH_SEPARATOR)
+  if (name2.IsEqualTo(STRING_PATH_SEPARATOR))
  {
    CMyComPtr<IFolderFolder> subFolder = this;
    *resultFolder = subFolder.Detach();
diff --git a/CPP/7zip/UI/FileManager/makefile b/CPP/7zip/UI/FileManager/makefile
index 0ca5caa..24dc4ca 100644
--- a/CPP/7zip/UI/FileManager/makefile
+++ b/CPP/7zip/UI/FileManager/makefile
@@ -104,7 +104,7 @@ AR_COMMON_OBJS = \
 C_OBJS = $(C_OBJS) \
  $O\Alloc.obj \
  $O\CpuArch.obj \
-  $O\Sort.obj \
  $O\Threads.obj \
+!include "../../Sort.mak"
 !include "../../7zip.mak"
diff --git a/CPP/7zip/UI/GUI/BenchmarkDialog.cpp b/CPP/7zip/UI/GUI/BenchmarkDialog.cpp
index ce5473a..1686c69 100644
--- a/CPP/7zip/UI/GUI/BenchmarkDialog.cpp
+++ b/CPP/7zip/UI/GUI/BenchmarkDialog.cpp
@@ -1856,7 +1856,7 @@ HRESULT Benchmark(
    const CProperty &prop = props[i];
    UString name = prop.Name;
    name.MakeLower_Ascii();
-    if (name.IsEqualTo_Ascii_NoCase("m") && prop.Value == L"*")
+    if (name.IsEqualTo_Ascii_NoCase("m") && prop.Value.IsEqualTo("*"))
    {
      bd.TotalMode = true;
      continue;
@@ -1865,7 +1865,7 @@ HRESULT Benchmark(
    NCOM::CPropVariant propVariant;
    if (!prop.Value.IsEmpty())
      ParseNumberString(prop.Value, propVariant);
-    if (name.IsPrefixedBy(L"mt"))
+    if (name.IsPrefixedBy("mt"))
    {
      #ifndef Z7_ST
      RINOK(ParseMtProp(name.Ptr(2), propVariant, numCPUs, numThreads))
diff --git a/CPP/7zip/UI/GUI/BenchmarkDialog.rc b/CPP/7zip/UI/GUI/BenchmarkDialog.rc
index 3e73e46..5df7ff2 100644
--- a/CPP/7zip/UI/GUI/BenchmarkDialog.rc
+++ b/CPP/7zip/UI/GUI/BenchmarkDialog.rc
@@ -81,7 +81,7 @@ BEGIN
  LTEXT  "&Number of CPU threads:", IDT_BENCH_NUM_THREADS, m, 30, g0xs, 8
  COMBOBOX  IDC_BENCH_NUM_THREADS, g1x, 29, g1xs, 140, MY_COMBO
-  LTEXT  "", IDT_BENCH_HARDWARE_THREADS, gc2x, 30, g7xs, MY_TEXT_NOPREFIX
+  LTEXT  "", IDT_BENCH_HARDWARE_THREADS, gc2x, 30, g7xs, 24, SS_NOPREFIX
  RTEXT  "Size", IDT_BENCH_SIZE,                xSize,   54, sSize,   MY_TEXT_NOPREFIX
  RTEXT  "CPU Usage", IDT_BENCH_USAGE_LABEL,    xUsage,  54, sUsage,  MY_TEXT_NOPREFIX
diff --git a/CPP/7zip/UI/GUI/CompressDialog.cpp b/CPP/7zip/UI/GUI/CompressDialog.cpp
index 58f863e..85d7186 100644
--- a/CPP/7zip/UI/GUI/CompressDialog.cpp
+++ b/CPP/7zip/UI/GUI/CompressDialog.cpp
@@ -2600,11 +2600,17 @@ void CCompressDialog::SetNumThreads2()
  UInt32 numAlgoThreadsMax = numHardwareThreads * 2;
  const int methodID = GetMethodID();
-  switch (methodID)
+  const bool isZip = IsZipFormat();
+  if (isZip)
+    numAlgoThreadsMax =
+        8 << (sizeof(size_t) / 2); // 32 threads for 32-bit : 128 threads for 64-bit
+  else if (IsXzFormat())
+    numAlgoThreadsMax = 256 * 2;
+  else switch (methodID)
  {
    case kLZMA: numAlgoThreadsMax = 2; break;
    case kLZMA2: numAlgoThreadsMax = 256; break;
-    case kBZip2: numAlgoThreadsMax = 32; break;
+    case kBZip2: numAlgoThreadsMax = 64; break;
    // case kZSTD: numAlgoThreadsMax = num_ZSTD_threads_MAX; break;
    case kCopy:
    case kPPMd:
@@ -2613,17 +2619,6 @@ void CCompressDialog::SetNumThreads2()
    case kPPMdZip:
      numAlgoThreadsMax = 1;
  }
-  const bool isZip = IsZipFormat();
-  if (isZip)
-  {
-    numAlgoThreadsMax =
-      #ifdef _WIN32
-        64; // _WIN32 supports only 64 threads in one group. So no need for more threads here
-      #else
-        128;
-      #endif
-  }
  UInt32 autoThreads = numHardwareThreads;
  if (autoThreads > numAlgoThreadsMax)
    autoThreads = numAlgoThreadsMax;
@@ -3008,7 +3003,7 @@ UInt64 CCompressDialog::GetMemoryUsage_Threads_Dict_DecompMem(UInt32 numThreads,
      else
      {
        size += numBlockThreads * (size1 + chunkSize);
-        UInt32 numPackChunks = numBlockThreads + (numBlockThreads / 8) + 1;
+        const UInt32 numPackChunks = numBlockThreads + (numBlockThreads / 8) + 1;
        if (chunkSize < ((UInt32)1 << 26)) numBlockThreads++;
        if (chunkSize < ((UInt32)1 << 24)) numBlockThreads++;
        if (chunkSize < ((UInt32)1 << 22)) numBlockThreads++;
diff --git a/CPP/7zip/UI/GUI/makefile b/CPP/7zip/UI/GUI/makefile
index 22ae095..b879a5d 100644
--- a/CPP/7zip/UI/GUI/makefile
+++ b/CPP/7zip/UI/GUI/makefile
@@ -141,10 +141,9 @@ C_OBJS = \
  $O\Alloc.obj \
  $O\CpuArch.obj \
  $O\DllSecur.obj \
-  $O\Sort.obj \
  $O\Threads.obj \
 !include "../../Crc.mak"
+!include "../../Sort.mak"
 !include "../../7zip.mak"
diff --git a/CPP/Build.mak b/CPP/Build.mak
index afb7ae8..86cc2af 100644
--- a/CPP/Build.mak
+++ b/CPP/Build.mak
@@ -111,7 +111,13 @@ CFLAGS = $(CFLAGS) -Zc:forScope
 !IFNDEF UNDER_CE
 !IF "$(CC)" != "clang-cl"
-CFLAGS = $(CFLAGS) -MP4
+MP_NPROC = 16
+!IFDEF NUMBER_OF_PROCESSORS
+!IF $(NUMBER_OF_PROCESSORS) < $(MP_NPROC)
+MP_NPROC = $(NUMBER_OF_PROCESSORS)
+!ENDIF
+!ENDIF
+CFLAGS = $(CFLAGS) -MP$(MP_NPROC)
 !ENDIF
 !IFNDEF PLATFORM
 # CFLAGS = $(CFLAGS) -arch:IA32
diff --git a/CPP/Common/MyString.cpp b/CPP/Common/MyString.cpp
index b5f7e52..10e2331 100644
--- a/CPP/Common/MyString.cpp
+++ b/CPP/Common/MyString.cpp
@@ -208,35 +208,6 @@ bool StringsAreEqualNoCase(const wchar_t *s1, const wchar_t *s2) throw()
 // ---------- ASCII ----------
-bool AString::IsPrefixedBy_Ascii_NoCase(const char *s) const throw()
-{
-  const char *s1 = _chars;
-  for (;;)
-  {
-    const char c2 = *s++;
-    if (c2 == 0)
-      return true;
-    const char c1 = *s1++;
-    if (MyCharLower_Ascii(c1) !=
-        MyCharLower_Ascii(c2))
-      return false;
-  }
-}
-bool UString::IsPrefixedBy_Ascii_NoCase(const char *s) const throw()
-{
-  const wchar_t *s1 = _chars;
-  for (;;)
-  {
-    const char c2 = *s++;
-    if (c2 == 0)
-      return true;
-    const wchar_t c1 = *s1++;
-    if (MyCharLower_Ascii(c1) != (unsigned char)MyCharLower_Ascii(c2))
-      return false;
-  }
-}
 bool StringsAreEqual_Ascii(const char *u, const char *a) throw()
 {
  for (;;)
diff --git a/CPP/Common/MyString.h b/CPP/Common/MyString.h
index ba9914e..639b874 100644
--- a/CPP/Common/MyString.h
+++ b/CPP/Common/MyString.h
@@ -429,11 +429,11 @@ public:
  // int CompareNoCase(const char *s) const { return MyStringCompareNoCase(_chars, s); }
  // int CompareNoCase(const AString &s) const { return MyStringCompareNoCase(_chars, s._chars); }
  bool IsPrefixedBy(const char *s) const { return IsString1PrefixedByString2(_chars, s); }
-  bool IsPrefixedBy_Ascii_NoCase(const char *s) const throw();
+  bool IsPrefixedBy_Ascii_NoCase(const char *s) const { return IsString1PrefixedByString2_NoCase_Ascii(_chars, s); }
 
  bool IsAscii() const
  {
-    unsigned len = Len();
+    const unsigned len = Len();
    const char *s = _chars;
    for (unsigned i = 0; i < len; i++)
      if ((unsigned char)s[i] >= 0x80)
@@ -727,22 +727,23 @@ public:
  // int CompareNoCase(const wchar_t *s) const { return MyStringCompareNoCase(_chars, s); }
  // int CompareNoCase(const UString &s) const { return MyStringCompareNoCase(_chars, s._chars); }
  bool IsPrefixedBy(const wchar_t *s) const { return IsString1PrefixedByString2(_chars, s); }
+  bool IsPrefixedBy(const char *s) const { return IsString1PrefixedByString2(_chars, s); }
  bool IsPrefixedBy_NoCase(const wchar_t *s) const { return IsString1PrefixedByString2_NoCase(_chars, s); }
-  bool IsPrefixedBy_Ascii_NoCase(const char *s) const throw();
+  bool IsPrefixedBy_Ascii_NoCase(const char *s) const { return IsString1PrefixedByString2_NoCase_Ascii(_chars, s); }
  bool IsAscii() const
  {
-    unsigned len = Len();
+    const unsigned len = Len();
    const wchar_t *s = _chars;
    for (unsigned i = 0; i < len; i++)
-      if (s[i] >= 0x80)
+      if ((unsigned)(int)s[i] >= 0x80)
        return false;
    return true;
  }
  int Find(wchar_t c) const { return FindCharPosInString(_chars, c); }
  int Find(wchar_t c, unsigned startIndex) const
  {
-    int pos = FindCharPosInString(_chars + startIndex, c);
+    const int pos = FindCharPosInString(_chars + startIndex, c);
    return pos < 0 ? -1 : (int)startIndex + pos;
  }
diff --git a/CPP/Common/MyXml.cpp b/CPP/Common/MyXml.cpp
index cc891fc..8364aae 100644
--- a/CPP/Common/MyXml.cpp
+++ b/CPP/Common/MyXml.cpp
@@ -24,7 +24,7 @@ static bool IsSpaceChar(char c)
 int CXmlItem::FindProp(const char *propName) const throw()
 {
  FOR_VECTOR (i, Props)
-    if (Props[i].Name == propName)
+    if (Props[i].Name.IsEqualTo(propName))
      return (int)i;
  return -1;
 }
@@ -39,7 +39,7 @@ AString CXmlItem::GetPropVal(const char *propName) const
 bool CXmlItem::IsTagged(const char *tag) const throw()
 {
-  return (IsTag && Name == tag);
+  return (IsTag && Name.IsEqualTo(tag));
 }
 int CXmlItem::FindSubTag(const char *tag) const throw()
diff --git a/CPP/Common/Sha3Reg.cpp b/CPP/Common/Sha3Reg.cpp
index 95db25e..cd2e288 100644
--- a/CPP/Common/Sha3Reg.cpp
+++ b/CPP/Common/Sha3Reg.cpp
@@ -58,7 +58,7 @@ Z7_COM7F_IMF2(UInt32, CSha3Hasher::GetDigestSize())
  static IHasher *CreateHasherSpec() \
    { return new CSha3Hasher(digestSize / 8, isShake, \
        SHA3_BLOCK_SIZE_FROM_DIGEST_SIZE(digestSize_for_blockSize / 8)); } \
-  static const CHasherInfo g_HasherInfo = { CreateHasherSpec, id, name, digestSize }; \
+  static const CHasherInfo g_HasherInfo = { CreateHasherSpec, id, name, digestSize / 8 }; \
  struct REGISTER_HASHER_NAME(cls) { REGISTER_HASHER_NAME(cls)() { RegisterHasher(&g_HasherInfo); }}; \
  static REGISTER_HASHER_NAME(cls) g_RegisterHasher; }
diff --git a/CPP/Common/Wildcard.cpp b/CPP/Common/Wildcard.cpp
index 798cbd9..b561a89 100644
--- a/CPP/Common/Wildcard.cpp
+++ b/CPP/Common/Wildcard.cpp
@@ -255,7 +255,8 @@ ForDir   nonrec         [0, M)                   same as ForBoth-File
 bool CItem::AreAllAllowed() const
 {
-  return ForFile && ForDir && WildcardMatching && PathParts.Size() == 1 && PathParts.Front() == L"*";
+  return ForFile && ForDir && WildcardMatching
+      && PathParts.Size() == 1 && PathParts.Front().IsEqualTo("*");
 }
 bool CItem::CheckPath(const UStringVector &pathParts, bool isFile) const
@@ -542,7 +543,7 @@ unsigned GetNumPrefixParts_if_DrivePath(UStringVector &pathParts)
  {
    if (pathParts.Size() < 4
        || !pathParts[1].IsEmpty()
-        || pathParts[2] != L"?")
+        || !pathParts[2].IsEqualTo("?"))
      return 0;
    testIndex = 3;
  }
@@ -574,11 +575,11 @@ static unsigned GetNumPrefixParts(const UStringVector &pathParts)
    return 1;
  if (pathParts.Size() == 2)
    return 2;
-  if (pathParts[2] == L".")
+  if (pathParts[2].IsEqualTo("."))
    return 3;
  unsigned networkParts = 2;
-  if (pathParts[2] == L"?")
+  if (pathParts[2].IsEqualTo("?"))
  {
    if (pathParts.Size() == 3)
      return 3;
@@ -642,7 +643,7 @@ void CCensor::AddItem(ECensorPathMode pathMode, bool include, const UString &pat
  if (pathParts.Size() >= 3
      && pathParts[0].IsEmpty()
      && pathParts[1].IsEmpty()
-      && pathParts[2] == L"?")
+      && pathParts[2].IsEqualTo("?"))
    ignoreWildcardIndex = 2;
  // #endif
@@ -665,7 +666,7 @@ void CCensor::AddItem(ECensorPathMode pathMode, bool include, const UString &pat
      for (unsigned i = numPrefixParts; i < pathParts.Size(); i++)
      {
        const UString &part = pathParts[i];
-        if (part == L".." || part == L".")
+        if (part.IsEqualTo("..") || part.IsEqualTo("."))
          dotsIndex = (int)i;
      }
diff --git a/CPP/Windows/FileDir.cpp b/CPP/Windows/FileDir.cpp
index 2cb83b2..10c4e98 100644
--- a/CPP/Windows/FileDir.cpp
+++ b/CPP/Windows/FileDir.cpp
@@ -651,6 +651,35 @@ bool RemoveDirWithSubItems(const FString &path)
  return RemoveDir(path);
 }
+bool RemoveDirAlways_if_Empty(const FString &path)
+{
+  const DWORD attrib = NFind::GetFileAttrib(path);
+  if (attrib != INVALID_FILE_ATTRIBUTES
+      && (attrib & FILE_ATTRIBUTE_READONLY))
+  {
+    bool need_ClearAttrib = true;
+    if ((attrib & FILE_ATTRIBUTE_REPARSE_POINT) == 0)
+    {
+      FString s (path);
+      s.Add_PathSepar();
+      NFind::CEnumerator enumerator;
+      enumerator.SetDirPrefix(s);
+      NFind::CDirEntry fi;
+      if (enumerator.Next(fi))
+      {
+        // we don't want to change attributes, if there are files
+        // in directory, because RemoveDir(path) will fail.
+        need_ClearAttrib = false;
+        // SetLastError(ERROR_DIR_NOT_EMPTY);
+        // return false;
+      }
+    }
+    if (need_ClearAttrib)
+      SetFileAttrib(path, 0); // we clear read-only attrib to remove read-only dir
+  }
+  return RemoveDir(path);
+}
 #endif // _WIN32
 #ifdef UNDER_CE
diff --git a/CPP/Windows/FileDir.h b/CPP/Windows/FileDir.h
index 74675ee..65e6368 100644
--- a/CPP/Windows/FileDir.h
+++ b/CPP/Windows/FileDir.h
@@ -78,6 +78,11 @@ bool CreateComplexDir(CFSTR path);
 bool DeleteFileAlways(CFSTR name);
 bool RemoveDirWithSubItems(const FString &path);
+#ifdef _WIN32
+bool RemoveDirAlways_if_Empty(const FString &path);
+#else
+#define RemoveDirAlways_if_Empty RemoveDir
+#endif
 bool MyGetFullPathName(CFSTR path, FString &resFullPath);
 bool GetFullPathAndSplit(CFSTR path, FString &resDirPrefix, FString &resFileName);
diff --git a/CPP/Windows/FileFind.cpp b/CPP/Windows/FileFind.cpp
index ca387f6..64075ab 100644
--- a/CPP/Windows/FileFind.cpp
+++ b/CPP/Windows/FileFind.cpp
@@ -731,7 +731,7 @@ bool CFileInfo::Find(CFSTR path, bool followLink)
            bool isOK = false;
            if (finder.FindFirst(s, *this))
            {
-              if (Name == FTEXT("."))
+              if (Name.IsEqualTo("."))
              {
                Name = path + prefixSize;
                return true;
@@ -769,6 +769,13 @@ bool CFileInfo::Find(CFSTR path, bool followLink)
  // return FollowReparse(path, IsDir());
  return Fill_From_ByHandleFileInfo(path);
+/*
+  // Fill_From_ByHandleFileInfo returns false (with Access Denied error),
+  // if there is reparse link file (not directory reparse item).
+  if (Fill_From_ByHandleFileInfo(path))
+    return true;
+  return HasReparsePoint();
+*/
 }
 bool CFileInfoBase::Fill_From_ByHandleFileInfo(CFSTR path)
diff --git a/CPP/Windows/FileIO.h b/CPP/Windows/FileIO.h
index 6ba40eb..26edef4 100644
--- a/CPP/Windows/FileIO.h
+++ b/CPP/Windows/FileIO.h
@@ -11,8 +11,7 @@
 #define Z7_WIN_SYMLINK_FLAG_RELATIVE 1
-// what the meaning of that FLAG or field (2)?
+#define Z7_WIN_LX_SYMLINK_VERSION_2 2
-#define Z7_WIN_LX_SYMLINK_FLAG 2
 #ifdef _WIN32
@@ -44,7 +43,33 @@ namespace NWindows {
 namespace NFile {
 #if defined(_WIN32) && !defined(UNDER_CE)
-bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool isWSL);
+/*
+  in:  (CByteBuffer &dest) is empty
+  in:  (path) uses Windows path separator (\).
+  out: (path) uses   Linux path separator (/).
+       if (isAbsPath == true), then "c:\\" prefix is replaced to "/mnt/c/" prefix
+*/
+void Convert_WinPath_to_WslLinuxPath(FString &path, bool convertDrivePath);
+// (path) must use Linux path separator (/).
+void FillLinkData_WslLink(CByteBuffer &dest, const wchar_t *path);
+/*
+  in:  (CByteBuffer &dest) is empty
+  if (isSymLink == false) : MOUNT_POINT : (path) must be absolute.
+  if (isSymLink == true)  : SYMLINK : Windows
+  (path) must use Windows path separator (\).
+  (path) must be without link "\\??\\" prefix.
+  link "\\??\\" prefix will be added inside FillLinkData(), if path is absolute.
+*/
+void FillLinkData_WinLink(CByteBuffer &dest, const wchar_t *path, bool isSymLink);
+// in: (CByteBuffer &dest) is empty
+inline void FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool isWSL)
+{
+  if (isWSL)
+    FillLinkData_WslLink(dest, path);
+  else
+    FillLinkData_WinLink(dest, path, isSymLink);
+}
 #endif
 struct CReparseShortInfo
@@ -61,7 +86,6 @@ struct CReparseAttr
  UInt32 Flags;
  UString SubsName;
  UString PrintName;
  AString WslName;
  bool HeaderError;
@@ -71,8 +95,7 @@ struct CReparseAttr
  CReparseAttr(): Tag(0), Flags(0) {}
-  // Parse()
+  // returns (true) and (ErrorCode = 0), if (it's correct known link)
-  // returns (true) and (ErrorCode = 0), if (it'a correct known link)
  // returns (false) and (ErrorCode = ERROR_REPARSE_TAG_INVALID), if unknown tag
  bool Parse(const Byte *p, size_t size);
@@ -80,18 +103,14 @@ struct CReparseAttr
  bool IsSymLink_Win() const { return Tag == Z7_WIN_IO_REPARSE_TAG_SYMLINK; }
  bool IsSymLink_WSL() const { return Tag == Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK; }
+  // note: "/dir1/path" is marked as relative.
  bool IsRelative_Win() const { return Flags == Z7_WIN_SYMLINK_FLAG_RELATIVE; }
  bool IsRelative_WSL() const
  {
-    if (WslName.IsEmpty())
+    return WslName[0] != '/'; // WSL uses unix path separator
-      return true;
-    char c = WslName[0];
-    return !IS_PATH_SEPAR(c);
  }
-  // bool IsVolume() const;
  bool IsOkNamePair() const;
  UString GetPath() const;
 };
diff --git a/CPP/Windows/FileLink.cpp b/CPP/Windows/FileLink.cpp
index bb380ec..2883c82 100644
--- a/CPP/Windows/FileLink.cpp
+++ b/CPP/Windows/FileLink.cpp
@@ -39,12 +39,24 @@ namespace NFile {
 using namespace NName;
 /*
+Win10 Junctions/SymLinks:
+  - (/) slash doesn't work as path separator
+  - Win10 preinstalled junctions don't use tail backslash, but tail backslashes also work.
+  - double backslash works only after drive prefix "c:\\dir1\dir2\",
+    and doesn't work in another places.
+  - absolute path without \??\ prefix doesn't work
+  - absolute path "c:" doesn't work
+*/
+/*
  Reparse Points (Junctions and Symbolic Links):
  struct
  {
    UInt32 Tag;
    UInt16 Size;     // not including starting 8 bytes
-    UInt16 Reserved; // = 0
+    UInt16 Reserved; // = 0, DOCs: // Length, in bytes, of the unparsed portion of
+       // the file name pointed to by the FileName member of the associated file object.
+       // This member is only valid for create operations when the I/O fails with STATUS_REPARSE.
    
    UInt16 SubstituteOffset; // offset in bytes from  start of namesChars
    UInt16 SubstituteLen;    // size in bytes, it doesn't include tailed NUL
@@ -68,6 +80,16 @@ using namespace NName;
    2) Default Order in table:
         Print Path
         Substitute Path
+DOCS:
+  The print name SHOULD be an informative pathname, suitable for display
+  to a user, that also identifies the target of the mount point.
+  Neither of these pathnames can contain dot directory names.
+reparse tags, with the exception of IO_REPARSE_TAG_SYMLINK,
+are processed on the server and are not processed by a client
+after transmission over the wire.
+Clients SHOULD treat associated reparse data as opaque data.
 */
 /*
@@ -93,7 +115,8 @@ static const UInt32 kReparseFlags_Microsoft   = ((UInt32)1 << 31);
 #define Get16(p) GetUi16(p)
 #define Get32(p) GetUi32(p)
-static const wchar_t * const k_LinkPrefix = L"\\??\\";
+static const char * const k_LinkPrefix = "\\??\\";
+static const char * const k_LinkPrefix_UNC = "\\??\\UNC\\";
 static const unsigned k_LinkPrefix_Size = 4;
 static bool IsLinkPrefix(const wchar_t *s)
@@ -102,7 +125,7 @@ static bool IsLinkPrefix(const wchar_t *s)
 }
 /*
-static const wchar_t * const k_VolumePrefix = L"Volume{";
+static const char * const k_VolumePrefix = "Volume{";
 static const bool IsVolumeName(const wchar_t *s)
 {
  return IsString1PrefixedByString2(s, k_VolumePrefix);
@@ -118,7 +141,7 @@ static void WriteString(Byte *dest, const wchar_t *path)
 {
  for (;;)
  {
-    wchar_t c = *path++;
+    const wchar_t c = *path++;
    if (c == 0)
      return;
    Set16(dest, (UInt16)c)
@@ -126,62 +149,103 @@ static void WriteString(Byte *dest, const wchar_t *path)
  }
 }
-bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool isWSL)
+#ifdef _WIN32
+void Convert_WinPath_to_WslLinuxPath(FString &s, bool convertDrivePath)
 {
-  bool isAbs = IsAbsolutePath(path);
+  if (convertDrivePath && IsDrivePath(s))
-  if (!isAbs && !isSymLink)
-    return false;
-  if (isWSL)
  {
-    // unsupported characters probably use Replacement Character UTF-16 0xFFFD
+    FChar c = s[0];
-    AString utf;
+    c = MyCharLower_Ascii(c);
-    ConvertUnicodeToUTF8(path, utf);
+    s.DeleteFrontal(2);
-    const size_t size = 4 + utf.Len();
+    s.InsertAtFront(c);
-    if (size != (UInt16)size)
+    s.Insert(0, FTEXT("/mnt/"));
-      return false;
-    dest.Alloc(8 + size);
-    Byte *p = dest;
-    Set32(p, Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK)
-    Set16(p + 4, (UInt16)(size))
-    Set16(p + 6, 0)
-    Set32(p + 8, Z7_WIN_LX_SYMLINK_FLAG)
-    memcpy(p + 12, utf.Ptr(), utf.Len());
-    return true;
  }
+  s.Replace(FCHAR_PATH_SEPARATOR, FTEXT('/'));
+}
+#endif
-  // usual symbolic LINK (NOT WSL)
-  bool needPrintName = true;
+static const unsigned k_Link_Size_Limit = 1u << 16; // 16-bit field is used for size.
+void FillLinkData_WslLink(CByteBuffer &dest, const wchar_t *path)
+{
+  // dest.Free(); // it's empty already
+  // WSL probably uses Replacement Character UTF-16 0xFFFD for unsupported characters?
+  AString utf;
+  ConvertUnicodeToUTF8(path, utf);
+  const unsigned size = 4 + utf.Len();
+  if (size >= k_Link_Size_Limit)
+    return;
+  dest.Alloc(8 + size);
+  Byte *p = dest;
+  Set32(p, Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK)
+  // Set32(p + 4, (UInt32)size)
+  Set16(p + 4, (UInt16)size)
+  Set16(p + 6, 0)
+  Set32(p + 8, Z7_WIN_LX_SYMLINK_VERSION_2)
+  memcpy(p + 12, utf.Ptr(), utf.Len());
+}
-  if (IsSuperPath(path))
+void FillLinkData_WinLink(CByteBuffer &dest, const wchar_t *path, bool isSymLink)
+{
+  // dest.Free(); // it's empty already
+  bool isAbs = false;
+  if (IS_PATH_SEPAR(path[0]))
  {
-    path += kSuperPathPrefixSize;
+    // root paths "\dir1\path" are marked as relative
-    if (!IsDrivePath(path))
+    if (IS_PATH_SEPAR(path[1]))
-      needPrintName = false;
+      isAbs = true;
+  }
+  else
+    isAbs = IsAbsolutePath(path);
+  if (!isAbs && !isSymLink)
+  {
+    // Win10 allows us to create relative MOUNT_POINT.
+    // But relative MOUNT_POINT will not work when accessing it.
+    // So we prevent useless creation of a relative MOUNT_POINT.
+    return;
  }
-  const unsigned add_Prefix_Len = isAbs ? k_LinkPrefix_Size : 0;
+  bool needPrintName = true;
-    
+  UString subs (path);
+  if (isAbs)
+  {
+    const bool isSuperPath = IsSuperPath(path);
+    if (!isSuperPath && NName::IsNetworkPath(us2fs(path)))
+    {
+      subs = k_LinkPrefix_UNC;
+      subs += (path + 2);
+    }
+    else
+    {
+      if (isSuperPath)
+      {
+        // we remove super prefix:
+        path += kSuperPathPrefixSize;
+        // we want to get correct abolute path in PrintName still.
+        if (!IsDrivePath(path))
+          needPrintName = false; // we need "\\server\path" for print name.
+      }
+      subs = k_LinkPrefix;
+      subs += path;
+    }
+  }
+  const size_t len1 = subs.Len() * 2;
  size_t len2 = (size_t)MyStringLen(path) * 2;
-  const size_t len1 = len2 + add_Prefix_Len * 2;
  if (!needPrintName)
    len2 = 0;
+  size_t totalNamesSize = len1 + len2;
-  size_t totalNamesSize = (len1 + len2);
  /* some WIM imagex software uses old scheme for symbolic links.
-     so we can old scheme for byte to byte compatibility */
+     so we can use old scheme for byte to byte compatibility */
+  const bool newOrderScheme = isSymLink;
-  bool newOrderScheme = isSymLink;
  // newOrderScheme = false;
  if (!newOrderScheme)
-    totalNamesSize += 2 * 2;
+    totalNamesSize += 2 * 2; // we use NULL terminators in old scheme.
  const size_t size = 8 + 8 + (isSymLink ? 4 : 0) + totalNamesSize;
-  if (size != (UInt16)size)
+  if (size >= k_Link_Size_Limit)
-    return false;
+    return;
  dest.Alloc(size);
  memset(dest, 0, size);
  const UInt32 tag = isSymLink ?
@@ -189,6 +253,7 @@ bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool i
      Z7_WIN_IO_REPARSE_TAG_MOUNT_POINT;
  Byte *p = dest;
  Set32(p, tag)
+  // Set32(p + 4, (UInt32)(size - 8))
  Set16(p + 4, (UInt16)(size - 8))
  Set16(p + 6, 0)
  p += 8;
@@ -204,21 +269,16 @@ bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool i
  Set16(p + 2, (UInt16)len1)
  Set16(p + 4, (UInt16)printOffs)
  Set16(p + 6, (UInt16)len2)
  p += 8;
  if (isSymLink)
  {
-    UInt32 flags = isAbs ? 0 : Z7_WIN_SYMLINK_FLAG_RELATIVE;
+    const UInt32 flags = isAbs ? 0 : Z7_WIN_SYMLINK_FLAG_RELATIVE;
    Set32(p, flags)
    p += 4;
  }
+  WriteString(p + subOffs, subs);
-  if (add_Prefix_Len != 0)
-    WriteString(p + subOffs, k_LinkPrefix);
-  WriteString(p + subOffs + add_Prefix_Len * 2, path);
  if (needPrintName)
    WriteString(p + printOffs, path);
-  return true;
 }
 #endif // defined(_WIN32) && !defined(UNDER_CE)
@@ -230,7 +290,7 @@ static void GetString(const Byte *p, unsigned len, UString &res)
  unsigned i;
  for (i = 0; i < len; i++)
  {
-    wchar_t c = Get16(p + i * 2);
+    const wchar_t c = Get16(p + (size_t)i * 2);
    if (c == 0)
      break;
    s[i] = c;
@@ -239,6 +299,7 @@ static void GetString(const Byte *p, unsigned len, UString &res)
  res.ReleaseBuf_SetLen(i);
 }
 bool CReparseAttr::Parse(const Byte *p, size_t size)
 {
  ErrorCode = (DWORD)ERROR_INVALID_REPARSE_DATA;
@@ -250,7 +311,12 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
    return false;
  Tag = Get32(p);
  if (Get16(p + 6) != 0) // padding
-    return false;
+  {
+    // DOCs: Reserved : the field SHOULD be set to 0
+    // and MUST be ignored (by parser).
+    // Win10 ignores it.
+    MinorError = true; // optional
+  }
  unsigned len = Get16(p + 4);
  p += 8;
  size -= 8;
@@ -262,8 +328,6 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
      (type & kReparseFlags_Microsoft) == 0 ||
      (type & 0xFFFF) != 3)
  */
  HeaderError = false;
  if (   Tag != Z7_WIN_IO_REPARSE_TAG_MOUNT_POINT
@@ -282,8 +346,7 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
  {
    if (len < 4)
      return false;
-    Flags = Get32(p); // maybe it's not Flags
+    if (Get32(p) != Z7_WIN_LX_SYMLINK_VERSION_2)
-    if (Flags != Z7_WIN_LX_SYMLINK_FLAG)
      return false;
    len -= 4;
    p += 4;
@@ -291,12 +354,13 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
    unsigned i;
    for (i = 0; i < len; i++)
    {
-      char c = (char)p[i];
+      const char c = (char)p[i];
      s[i] = c;
      if (c == 0)
        break;
    }
-    WslName.ReleaseBuf_SetEnd(i);
+    s[i] = 0;
+    WslName.ReleaseBuf_SetLen(i);
    MinorError = (i != len);
    ErrorCode = 0;
    return true;
@@ -304,10 +368,10 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
  
  if (len < 8)
    return false;
-  unsigned subOffs = Get16(p);
+  const unsigned subOffs = Get16(p);
-  unsigned subLen = Get16(p + 2);
+  const unsigned subLen = Get16(p + 2);
-  unsigned printOffs = Get16(p + 4);
+  const unsigned printOffs = Get16(p + 4);
-  unsigned printLen = Get16(p + 6);
+  const unsigned printLen = Get16(p + 6);
  len -= 8;
  p += 8;
@@ -335,15 +399,17 @@ bool CReparseAttr::Parse(const Byte *p, size_t size)
 bool CReparseShortInfo::Parse(const Byte *p, size_t size)
 {
-  const Byte *start = p;
+  const Byte * const start = p;
-  Offset= 0;
+  Offset = 0;
  Size = 0;
  if (size < 8)
    return false;
-  UInt32 Tag = Get32(p);
+  const UInt32 Tag = Get32(p);
  UInt32 len = Get16(p + 4);
+  /*
  if (len + 8 > size)
    return false;
+  */
  /*
  if ((type & kReparseFlags_Alias) == 0 ||
      (type & kReparseFlags_Microsoft) == 0 ||
@@ -353,16 +419,14 @@ bool CReparseShortInfo::Parse(const Byte *p, size_t size)
      Tag != Z7_WIN_IO_REPARSE_TAG_SYMLINK)
    // return true;
    return false;
+  /*
  if (Get16(p + 6) != 0) // padding
    return false;
-  
+  */
  p += 8;
  size -= 8;
-  
  if (len != size) // do we need that check?
    return false;
-  
  if (len < 8)
    return false;
  unsigned subOffs = Get16(p);
@@ -396,10 +460,14 @@ bool CReparseAttr::IsOkNamePair() const
 {
  if (IsLinkPrefix(SubsName))
  {
+    if (PrintName == GetPath())
+      return true;
+/*
    if (!IsDrivePath(SubsName.Ptr(k_LinkPrefix_Size)))
      return PrintName.IsEmpty();
    if (wcscmp(SubsName.Ptr(k_LinkPrefix_Size), PrintName) == 0)
      return true;
+*/
  }
  return wcscmp(SubsName, PrintName) == 0;
 }
@@ -415,21 +483,26 @@ bool CReparseAttr::IsVolume() const
 UString CReparseAttr::GetPath() const
 {
+  UString s (SubsName);
  if (IsSymLink_WSL())
  {
-    UString u;
    // if (CheckUTF8(attr.WslName)
-    if (!ConvertUTF8ToUnicode(WslName, u))
+    if (!ConvertUTF8ToUnicode(WslName, s))
-      MultiByteToUnicodeString2(u, WslName);
+      MultiByteToUnicodeString2(s, WslName);
-    return u;
  }
+  else if (IsLinkPrefix(s))
-  UString s (SubsName);
-  if (IsLinkPrefix(s))
  {
-    s.ReplaceOneCharAtPos(1, '\\'); // we normalize prefix from "\??\" to "\\?\"
+    if (IsString1PrefixedByString2_NoCase_Ascii(s.Ptr(), k_LinkPrefix_UNC))
-    if (IsDrivePath(s.Ptr(k_LinkPrefix_Size)))
+    {
-      s.DeleteFrontal(k_LinkPrefix_Size);
+      s.DeleteFrontal(6);
+      s.ReplaceOneCharAtPos(0, '\\');
+    }
+    else
+    {
+      s.ReplaceOneCharAtPos(1, '\\'); // we normalize prefix from "\??\" to "\\?\"
+      if (IsDrivePath(s.Ptr(k_LinkPrefix_Size)))
+        s.DeleteFrontal(k_LinkPrefix_Size);
+    }
  }
  return s;
 }
@@ -468,7 +541,7 @@ bool GetReparseData(CFSTR path, CByteBuffer &reparseData, BY_HANDLE_FILE_INFORMA
 static bool CreatePrefixDirOfFile(CFSTR path)
 {
  FString path2 (path);
-  int pos = path2.ReverseFind_PathSepar();
+  const int pos = path2.ReverseFind_PathSepar();
  if (pos < 0)
    return true;
  #ifdef _WIN32
@@ -494,6 +567,8 @@ static bool OutIoReparseData(DWORD controlCode, CFSTR path, void *data, DWORD si
 }
+// MOUNT_POINT (Junction Point) and LX_SYMLINK (WSL) can be written without administrator rights.
+// SYMLINK requires administrator rights.
 // If there is Reparse data already, it still writes new Reparse data
 bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size)
 {
@@ -540,10 +615,11 @@ bool DeleteReparseData(CFSTR path)
    SetLastError(ERROR_INVALID_REPARSE_DATA);
    return false;
  }
-  BYTE buf[my_REPARSE_DATA_BUFFER_HEADER_SIZE];
+  // BYTE buf[my_REPARSE_DATA_BUFFER_HEADER_SIZE];
-  memset(buf, 0, sizeof(buf));
+  // memset(buf, 0, sizeof(buf));
-  memcpy(buf, reparseData, 4); // tag
+  // memcpy(buf, reparseData, 4); // tag
-  return OutIoReparseData(my_FSCTL_DELETE_REPARSE_POINT, path, buf, sizeof(buf));
+  memset(reparseData + 4, 0, my_REPARSE_DATA_BUFFER_HEADER_SIZE - 4);
+  return OutIoReparseData(my_FSCTL_DELETE_REPARSE_POINT, path, reparseData, my_REPARSE_DATA_BUFFER_HEADER_SIZE);
 }
 }
diff --git a/CPP/Windows/FileName.cpp b/CPP/Windows/FileName.cpp
index 1f4a6da..eb62567 100644
--- a/CPP/Windows/FileName.cpp
+++ b/CPP/Windows/FileName.cpp
@@ -65,8 +65,15 @@ void NormalizeDirPathPrefix(UString &dirPath)
    dirPath.Add_PathSepar();
 }
+#define IS_LETTER_CHAR(c) ((((unsigned)(int)(c) | 0x20) - (unsigned)'a' <= (unsigned)('z' - 'a')))
+bool IsDrivePath (const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]); }
+// bool IsDriveName2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && s[2] == 0; }
 #ifdef _WIN32
+bool IsDrivePath2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':'; }
 #ifndef USE_UNICODE_FSTRING
 #ifdef Z7_LONG_PATH
 static void NormalizeDirSeparators(UString &s)
@@ -87,13 +94,6 @@ void NormalizeDirSeparators(FString &s)
      s.ReplaceOneCharAtPos(i, FCHAR_PATH_SEPARATOR);
 }
-#endif
-#define IS_LETTER_CHAR(c) ((((unsigned)(int)(c) | 0x20) - (unsigned)'a' <= (unsigned)('z' - 'a')))
-bool IsDrivePath(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]); }
 bool IsAltPathPrefix(CFSTR s) throw()
 {
  unsigned len = MyStringLen(s);
@@ -117,16 +117,23 @@ bool IsAltPathPrefix(CFSTR s) throw()
  return true;
 }
-#if defined(_WIN32) && !defined(UNDER_CE)
+#endif // _WIN32
-const char * const kSuperPathPrefix = "\\\\?\\";
+const char * const kSuperPathPrefix =
+    STRING_PATH_SEPARATOR
+    STRING_PATH_SEPARATOR "?"
+    STRING_PATH_SEPARATOR;
 #ifdef Z7_LONG_PATH
-static const char * const kSuperUncPrefix = "\\\\?\\UNC\\";
+static const char * const kSuperUncPrefix =
+    STRING_PATH_SEPARATOR
+    STRING_PATH_SEPARATOR "?"
+    STRING_PATH_SEPARATOR "UNC"
+    STRING_PATH_SEPARATOR;
 #endif
 #define IS_DEVICE_PATH(s)          (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && (s)[2] == '.' && IS_SEPAR((s)[3]))
 #define IS_SUPER_PREFIX(s)         (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && (s)[2] == '?' && IS_SEPAR((s)[3]))
-#define IS_SUPER_OR_DEVICE_PATH(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && ((s)[2] == '?' || (s)[2] == '.') && IS_SEPAR((s)[3]))
 #define IS_UNC_WITH_SLASH(s) ( \
     ((s)[0] == 'U' || (s)[0] == 'u') \
@@ -134,6 +141,16 @@ static const char * const kSuperUncPrefix = "\\\\?\\UNC\\";
  && ((s)[2] == 'C' || (s)[2] == 'c') \
  && IS_SEPAR((s)[3]))
+static const unsigned kDrivePrefixSize = 3; /* c:\ */
+bool IsSuperPath(const wchar_t *s) throw();
+bool IsSuperPath(const wchar_t *s) throw() { return IS_SUPER_PREFIX(s); }
+// bool IsSuperUncPath(const wchar_t *s) throw() { return (IS_SUPER_PREFIX(s) && IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize)); }
+#if defined(_WIN32) && !defined(UNDER_CE)
+#define IS_SUPER_OR_DEVICE_PATH(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && ((s)[2] == '?' || (s)[2] == '.') && IS_SEPAR((s)[3]))
+bool IsSuperOrDevicePath(const wchar_t *s) throw() { return IS_SUPER_OR_DEVICE_PATH(s); }
 bool IsDevicePath(CFSTR s) throw()
 {
  #ifdef UNDER_CE
@@ -154,7 +171,7 @@ bool IsDevicePath(CFSTR s) throw()
  
  if (!IS_DEVICE_PATH(s))
    return false;
-  unsigned len = MyStringLen(s);
+  const unsigned len = MyStringLen(s);
  if (len == 6 && s[5] == ':')
    return true;
  if (len < 18 || len > 22 || !IsString1PrefixedByString2(s + kDevicePathPrefixSize, "PhysicalDrive"))
@@ -174,7 +191,7 @@ bool IsNetworkPath(CFSTR s) throw()
    return false;
  if (IsSuperUncPath(s))
    return true;
-  FChar c = s[2];
+  const FChar c = s[2];
  return (c != '.' && c != '?');
 }
@@ -187,7 +204,7 @@ unsigned GetNetworkServerPrefixSize(CFSTR s) throw()
    prefixSize = kSuperUncPathPrefixSize;
  else
  {
-    FChar c = s[2];
+    const FChar c = s[2];
    if (c == '.' || c == '?')
      return 0;
  }
@@ -209,14 +226,6 @@ bool IsNetworkShareRootPath(CFSTR s) throw()
  return s[(unsigned)pos + 1] == 0;
 }
-static const unsigned kDrivePrefixSize = 3; /* c:\ */
-bool IsDrivePath2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':'; }
-// bool IsDriveName2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && s[2] == 0; }
-bool IsSuperPath(const wchar_t *s) throw() { return IS_SUPER_PREFIX(s); }
-bool IsSuperOrDevicePath(const wchar_t *s) throw() { return IS_SUPER_OR_DEVICE_PATH(s); }
-// bool IsSuperUncPath(const wchar_t *s) throw() { return (IS_SUPER_PREFIX(s) && IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize)); }
 bool IsAltStreamPrefixWithColon(const UString &s) throw()
 {
  if (s.IsEmpty())
@@ -349,14 +358,16 @@ unsigned GetRootPrefixSize(CFSTR s) throw()
 }
 #endif // USE_UNICODE_FSTRING
+#endif // _WIN32
 static unsigned GetRootPrefixSize_Of_NetworkPath(const wchar_t *s) throw()
 {
  // Network path: we look "server\path\" as root prefix
-  int pos = FindSepar(s);
+  const int pos = FindSepar(s);
  if (pos < 0)
    return 0;
-  int pos2 = FindSepar(s + (unsigned)pos + 1);
+  const int pos2 = FindSepar(s + (unsigned)pos + 1);
  if (pos2 < 0)
    return 0;
  return (unsigned)(pos + pos2 + 2);
@@ -370,7 +381,7 @@ static unsigned GetRootPrefixSize_Of_SimplePath(const wchar_t *s) throw()
    return 0;
  if (s[1] == 0 || !IS_SEPAR(s[1]))
    return 1;
-  unsigned size = GetRootPrefixSize_Of_NetworkPath(s + 2);
+  const unsigned size = GetRootPrefixSize_Of_NetworkPath(s + 2);
  return (size == 0) ? 0 : 2 + size;
 }
@@ -378,17 +389,21 @@ static unsigned GetRootPrefixSize_Of_SuperPath(const wchar_t *s) throw()
 {
  if (IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize))
  {
-    unsigned size = GetRootPrefixSize_Of_NetworkPath(s + kSuperUncPathPrefixSize);
+    const unsigned size = GetRootPrefixSize_Of_NetworkPath(s + kSuperUncPathPrefixSize);
    return (size == 0) ? 0 : kSuperUncPathPrefixSize + size;
  }
  // we support \\?\c:\ paths and volume GUID paths \\?\Volume{GUID}\"
-  int pos = FindSepar(s + kSuperPathPrefixSize);
+  const int pos = FindSepar(s + kSuperPathPrefixSize);
  if (pos < 0)
    return 0;
  return kSuperPathPrefixSize + (unsigned)(pos + 1);
 }
+#ifdef _WIN32
 unsigned GetRootPrefixSize(const wchar_t *s) throw()
+#else
+unsigned GetRootPrefixSize_WINDOWS(const wchar_t *s) throw()
+#endif
 {
  if (IS_DEVICE_PATH(s))
    return kDevicePathPrefixSize;
@@ -397,7 +412,7 @@ unsigned GetRootPrefixSize(const wchar_t *s) throw()
  return GetRootPrefixSize_Of_SimplePath(s);
 }
-#else // _WIN32
+#ifndef _WIN32
 bool IsAbsolutePath(const wchar_t *s) throw() { return IS_SEPAR(s[0]); }
diff --git a/CPP/Windows/FileName.h b/CPP/Windows/FileName.h
index 219b656..ce26e78 100644
--- a/CPP/Windows/FileName.h
+++ b/CPP/Windows/FileName.h
@@ -25,13 +25,13 @@ bool IsDrivePath(const wchar_t *s) throw();  // first 3 chars are drive chars li
 bool IsAltPathPrefix(CFSTR s) throw(); /* name: */
-#if defined(_WIN32) && !defined(UNDER_CE)
 extern const char * const kSuperPathPrefix; /* \\?\ */
 const unsigned kDevicePathPrefixSize = 4;
 const unsigned kSuperPathPrefixSize = 4;
 const unsigned kSuperUncPathPrefixSize = kSuperPathPrefixSize + 4;
+#if defined(_WIN32) && !defined(UNDER_CE)
 bool IsDevicePath(CFSTR s) throw();   /* \\.\ */
 bool IsSuperUncPath(CFSTR s) throw(); /* \\?\UNC\ */
 bool IsNetworkPath(CFSTR s) throw();  /* \\?\UNC\ or \\SERVER */
@@ -86,6 +86,15 @@ int FindAltStreamColon(CFSTR path) throw();
 bool IsAbsolutePath(const wchar_t *s) throw();
 unsigned GetRootPrefixSize(const wchar_t *s) throw();
+#ifndef _WIN32
+/* GetRootPrefixSize_WINDOWS() is called in linux, but it parses path by windows rules.
+   It supports only paths system (linux) slash separators (STRING_PATH_SEPARATOR),
+   It doesn't parses paths with backslash (windows) separators.
+   "c:/dir/file" is supported.
+*/
+unsigned GetRootPrefixSize_WINDOWS(const wchar_t *s) throw();
+#endif
 #ifdef Z7_LONG_PATH
 const int kSuperPathType_UseOnlyMain = 0;
diff --git a/CPP/Windows/System.cpp b/CPP/Windows/System.cpp
index 5fa87f3..4745785 100644
--- a/CPP/Windows/System.cpp
+++ b/CPP/Windows/System.cpp
@@ -25,6 +25,69 @@ namespace NSystem {
 #ifdef _WIN32
+/*
+note: returned value in 32-bit version can be limited by value 32.
+      while 64-bit version returns full value.
+GetMaximumProcessorCount(groupNumber) can return higher value than
+GetActiveProcessorCount(groupNumber) in some cases, because CPUs can be added.
+*/
+// typedef DWORD (WINAPI *Func_GetMaximumProcessorCount)(WORD GroupNumber);
+typedef DWORD (WINAPI *Func_GetActiveProcessorCount)(WORD GroupNumber);
+typedef WORD (WINAPI *Func_GetActiveProcessorGroupCount)(VOID);
+/*
+#if 0 && defined(ALL_PROCESSOR_GROUPS)
+#define MY_ALL_PROCESSOR_GROUPS   ALL_PROCESSOR_GROUPS
+#else
+#define MY_ALL_PROCESSOR_GROUPS   0xffff
+#endif
+*/
+Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
+bool CCpuGroups::Load()
+{
+  NumThreadsTotal = 0;
+  GroupSizes.Clear();
+  const HMODULE hmodule = ::GetModuleHandleA("kernel32.dll");
+  // Is_Win11_Groups = GetProcAddress(hmodule, "SetThreadSelectedCpuSetMasks") != NULL;
+  const
+      Func_GetActiveProcessorGroupCount
+        fn_GetActiveProcessorGroupCount = Z7_GET_PROC_ADDRESS(
+      Func_GetActiveProcessorGroupCount, hmodule,
+          "GetActiveProcessorGroupCount");
+  const
+      Func_GetActiveProcessorCount
+        fn_GetActiveProcessorCount = Z7_GET_PROC_ADDRESS(
+      Func_GetActiveProcessorCount, hmodule,
+          "GetActiveProcessorCount");
+  if (!fn_GetActiveProcessorGroupCount ||
+      !fn_GetActiveProcessorCount)
+    return false;
+  const unsigned numGroups = fn_GetActiveProcessorGroupCount();
+  if (numGroups == 0)
+    return false;
+  UInt32 sum = 0;
+  for (unsigned i = 0; i < numGroups; i++)
+  {
+    const UInt32 num = fn_GetActiveProcessorCount((WORD)i);
+    /*
+    if (num == 0)
+    {
+      // it means error
+      // but is it possible that some group is empty by some reason?
+      // GroupSizes.Clear();
+      // return false;
+    }
+    */
+    sum += num;
+    GroupSizes.Add(num);
+  }
+  NumThreadsTotal = sum;
+  // NumThreadsTotal = fn_GetActiveProcessorCount(MY_ALL_PROCESSOR_GROUPS);
+  return true;
+}
 UInt32 CountAffinity(DWORD_PTR mask)
 {
  UInt32 num = 0;
@@ -38,31 +101,62 @@ UInt32 CountAffinity(DWORD_PTR mask)
 BOOL CProcessAffinity::Get()
 {
-  #ifndef UNDER_CE
+  IsGroupMode = false;
-  return GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask);
+  Groups.Load();
-  #else
+  // SetThreadAffinityMask(GetCurrentThread(), 1);
-  return FALSE;
+  // SetProcessAffinityMask(GetCurrentProcess(), 1);
-  #endif
+  BOOL res = GetProcessAffinityMask(GetCurrentProcess(),
+      &processAffinityMask, &systemAffinityMask);
+  /* DOCs: On a system with more than 64 processors, if the threads
+     of the calling process  are in a single processor group, the
+     function sets the variables pointed to by lpProcessAffinityMask
+     and lpSystemAffinityMask to the process affinity mask and the
+     processor mask of active logical processors for that group.
+     If the calling process contains threads in multiple groups,
+     the function returns zero for both affinity masks
+     note: tested in Win10: GetProcessAffinityMask() doesn't return 0
+           in (processAffinityMask) and (systemAffinityMask) masks.
+     We need to test it in Win11: how to get mask==0 from GetProcessAffinityMask()?
+  */
+  if (!res)
+  {
+    processAffinityMask = 0;
+    systemAffinityMask = 0;
+  }
+  if (Groups.GroupSizes.Size() > 1 && Groups.NumThreadsTotal)
+    if (// !res ||
+        processAffinityMask == 0 || // to support case described in DOCs and for (!res) case
+        processAffinityMask == systemAffinityMask) // for default nonchanged affinity
+    {
+      // we set IsGroupMode only if processAffinity is default (not changed).
+      res = TRUE;
+      IsGroupMode = true;
+    }
+  return res;
 }
+UInt32 CProcessAffinity::Load_and_GetNumberOfThreads()
+{
+  if (Get())
+  {
+    const UInt32 numProcessors = GetNumProcessThreads();
+    if (numProcessors)
+      return numProcessors;
+  }
+  SYSTEM_INFO systemInfo;
+  GetSystemInfo(&systemInfo);
+  // the number of logical processors in the current group
+  return systemInfo.dwNumberOfProcessors;
+}
 UInt32 GetNumberOfProcessors()
 {
  // We need to know how many threads we can use.
  // By default the process is assigned to one group.
-  // So we get the number of logical processors (threads)
-  // assigned to current process in the current group.
-  // Group size can be smaller than total number logical processors, for exammple, 2x36
  CProcessAffinity pa;
+  return pa.Load_and_GetNumberOfThreads();
-  if (pa.Get() && pa.processAffinityMask != 0)
-    return pa.GetNumProcessThreads();
-  SYSTEM_INFO systemInfo;
-  GetSystemInfo(&systemInfo);
-  // the number of logical processors in the current group
-  return (UInt32)systemInfo.dwNumberOfProcessors;
 }
 #else
diff --git a/CPP/Windows/System.h b/CPP/Windows/System.h
index 9951b8b..0c80373 100644
--- a/CPP/Windows/System.h
+++ b/CPP/Windows/System.h
@@ -9,6 +9,7 @@
 #endif
 #include "../Common/MyTypes.h"
+#include "../Common/MyVector.h"
 #include "../Common/MyWindows.h"
 namespace NWindows {
@@ -16,6 +17,34 @@ namespace NSystem {
 #ifdef _WIN32
+struct CCpuGroups
+{
+  CRecordVector<UInt32> GroupSizes;
+  UInt32 NumThreadsTotal; // sum of threads in all groups
+  // bool Is_Win11_Groups; // useless
+  
+  void Get_GroupSize_Min_Max(UInt32 &minSize, UInt32 &maxSize) const
+  {
+    unsigned num = GroupSizes.Size();
+    UInt32 minSize2 = 0, maxSize2 = 0;
+    if (num)
+    {
+      minSize2 = (UInt32)0 - 1;
+      do
+      {
+        const UInt32 v = GroupSizes[--num];
+        if (minSize2 > v) minSize2 = v;
+        if (maxSize2 < v) maxSize2 = v;
+      }
+      while (num);
+    }
+    minSize = minSize2;
+    maxSize = maxSize2;
+  }
+  bool Load();
+  CCpuGroups(): NumThreadsTotal(0) {}
+};
 UInt32 CountAffinity(DWORD_PTR mask);
 struct CProcessAffinity
@@ -25,14 +54,28 @@ struct CProcessAffinity
  DWORD_PTR processAffinityMask;
  DWORD_PTR systemAffinityMask;
+  CCpuGroups Groups;
+  bool IsGroupMode;
+    /*
+      IsGroupMode == true, if
+          Groups.GroupSizes.Size() > 1) && { dafalt affinity was not changed }
+      IsGroupMode == false, if single group or affinity was changed
+    */
+  
+  UInt32 Load_and_GetNumberOfThreads();
  void InitST()
  {
    // numProcessThreads = 1;
    // numSysThreads = 1;
    processAffinityMask = 1;
    systemAffinityMask = 1;
+    IsGroupMode = false;
+    // Groups.NumThreadsTotal = 0;
+    // Groups.Is_Win11_Groups = false;
  }
+/*
  void CpuZero()
  {
    processAffinityMask = 0;
@@ -42,9 +85,23 @@ struct CProcessAffinity
  {
    processAffinityMask |= ((DWORD_PTR)1 << cpuIndex);
  }
+*/
-  UInt32 GetNumProcessThreads() const { return CountAffinity(processAffinityMask); }
+  UInt32 GetNumProcessThreads() const
-  UInt32 GetNumSystemThreads() const { return CountAffinity(systemAffinityMask); }
+  {
+    if (IsGroupMode)
+      return Groups.NumThreadsTotal;
+    // IsGroupMode == false
+    // so we don't want to use groups
+    // we return number of threads in default primary group:
+    return CountAffinity(processAffinityMask);
+  }
+  UInt32 GetNumSystemThreads() const
+  {
+    if (Groups.GroupSizes.Size() > 1 && Groups.NumThreadsTotal)
+      return Groups.NumThreadsTotal;
+    return CountAffinity(systemAffinityMask);
+  }
  BOOL Get();
diff --git a/CPP/Windows/Thread.h b/CPP/Windows/Thread.h
index d72f64c..75c1616 100644
--- a/CPP/Windows/Thread.h
+++ b/CPP/Windows/Thread.h
@@ -26,8 +26,10 @@ public:
    { return Thread_Create_With_Affinity(&thread, startAddress, param, affinity); }
  WRes Create_With_CpuSet(THREAD_FUNC_TYPE startAddress, LPVOID param, const CCpuSet *cpuSet)
    { return Thread_Create_With_CpuSet(&thread, startAddress, param, cpuSet); }
-  
+ 
-  #ifdef _WIN32
+#ifdef _WIN32
+  WRes Create_With_Group(THREAD_FUNC_TYPE startAddress, LPVOID param, unsigned group, CAffinityMask affinity = 0)
+    { return Thread_Create_With_Group(&thread, startAddress, param, group, affinity); }
  operator HANDLE() { return thread; }
  void Attach(HANDLE handle) { thread = handle; }
  HANDLE Detach() { HANDLE h = thread; thread = NULL; return h; }
@@ -36,7 +38,7 @@ public:
  bool Terminate(DWORD exitCode) { return BOOLToBool(::TerminateThread(thread, exitCode)); }
  int GetPriority() { return ::GetThreadPriority(thread); }
  bool SetPriority(int priority) { return BOOLToBool(::SetThreadPriority(thread, priority)); }
-  #endif
+#endif
 };
 }
diff --git a/CPP/Windows/TimeUtils.cpp b/CPP/Windows/TimeUtils.cpp
index bbd79ba..4e3bc59 100644
--- a/CPP/Windows/TimeUtils.cpp
+++ b/CPP/Windows/TimeUtils.cpp
@@ -258,8 +258,9 @@ bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
      FreeBSD 11.0, NetBSD 7.1, OpenBSD 6.0,
      Minix 3.1.8, AIX 7.1, HP-UX 11.31, IRIX 6.5, Solaris 11.3,
      Cygwin 2.9, mingw, MSVC 14, Android 9.0.
+  Android NDK defines TIME_UTC but doesn't have the timespec_get().
 */
-#if defined(TIME_UTC)
+#if defined(TIME_UTC) && !defined(__ANDROID__)
 #define ZIP7_USE_timespec_get
 // #pragma message("ZIP7_USE_timespec_get")
 #elif defined(CLOCK_REALTIME)