9.22

9.21
9.20
2025-12-17 16:11:52 -06:00 · 2016-05-28 00:16:06 +01:00 · 2016-05-28 00:16:05 +01:00 · 2016-05-28 00:16:05 +01:00 · 2016-05-28 00:16:04 +01:00 · 2016-05-28 00:16:04 +01:00
383 changed files with 15183 additions and 8522 deletions
--- a/C/Util/7z/7zAlloc.c
+++ b/C/Util/7z/7zAlloc.c
@@ -1,7 +1,6 @@
 /* 7zAlloc.c -- Allocation functions
-2008-10-04 : Igor Pavlov : Public domain */
+2010-10-29 : Igor Pavlov : Public domain */

-#include <stdlib.h>
 #include "7zAlloc.h"

 /* #define _SZ_ALLOC_DEBUG */
--- a/C/Util/7z/7zAlloc.h
+++ b/C/Util/7z/7zAlloc.h
@@ -1,14 +1,10 @@
 /* 7zAlloc.h -- Allocation functions
-2009-02-07 : Igor Pavlov : Public domain */
+2010-10-29 : Igor Pavlov : Public domain */

 #ifndef __7Z_ALLOC_H
 #define __7Z_ALLOC_H

-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
+#include <stdlib.h>

 void *SzAlloc(void *p, size_t size);
 void SzFree(void *p, void *address);
@@ -16,8 +12,4 @@ void SzFree(void *p, void *address);
 void *SzAllocTemp(void *p, size_t size);
 void SzFreeTemp(void *p, void *address);

-#ifdef __cplusplus
-}
-#endif
-
 #endif
--- a/C/7zCrc.c
+++ b/C/7zCrc.c
@@ -1,15 +1,24 @@
-/* 7zCrc.c -- CRC32 calculation
-2009-11-23 : Igor Pavlov : Public domain */
+/* 7zCrc.c -- CRC32 init
+2010-12-01 : Igor Pavlov : Public domain */

 #include "7zCrc.h"
 #include "CpuArch.h"

 #define kCrcPoly 0xEDB88320

-#ifdef MY_CPU_LE
-#define CRC_NUM_TABLES 8
+#ifdef MY_CPU_X86_OR_AMD64
+  #define CRC_NUM_TABLES 8
+  UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
+#elif defined(MY_CPU_LE)
+  #define CRC_NUM_TABLES 4
 #else
-#define CRC_NUM_TABLES 1
+  #define CRC_NUM_TABLES 5
+  #define CRC_UINT32_SWAP(v) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))
+  UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
+#endif
+
+#ifndef MY_CPU_BE
+  UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
 #endif

 typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);
@@ -17,25 +26,6 @@ typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size,
 static CRC_FUNC g_CrcUpdate;
 UInt32 g_CrcTable[256 * CRC_NUM_TABLES];

-#if CRC_NUM_TABLES == 1
-
-#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
-
-static UInt32 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table)
-{
-  const Byte *p = (const Byte *)data;
-  for (; size > 0; size--, p++)
-    v = CRC_UPDATE_BYTE_2(v, *p);
-  return v;
-}
-
-#else
-
-UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
-UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
-
-#endif
-
 UInt32 MY_FAST_CALL CrcUpdate(UInt32 v, const void *data, size_t size)
 {
  return g_CrcUpdate(v, data, size, g_CrcTable);
@@ -57,18 +47,37 @@ void MY_FAST_CALL CrcGenerateTable()
      r = (r >> 1) ^ (kCrcPoly & ~((r & 1) - 1));
    g_CrcTable[i] = r;
  }
-  #if CRC_NUM_TABLES == 1
-  g_CrcUpdate = CrcUpdateT1;
-  #else
  for (; i < 256 * CRC_NUM_TABLES; i++)
  {
    UInt32 r = g_CrcTable[i - 256];
    g_CrcTable[i] = g_CrcTable[r & 0xFF] ^ (r >> 8);
  }
+  
+  #ifdef MY_CPU_LE
+
  g_CrcUpdate = CrcUpdateT4;
-  #ifdef MY_CPU_X86_OR_AMD64
+  
+  #if CRC_NUM_TABLES == 8
  if (!CPU_Is_InOrder())
    g_CrcUpdate = CrcUpdateT8;
  #endif
+
+  #else
+  {
+    #ifndef MY_CPU_BE
+    UInt32 k = 1;
+    if (*(const Byte *)&k == 1)
+      g_CrcUpdate = CrcUpdateT4;
+    else
+    #endif
+    {
+      for (i = 256 * CRC_NUM_TABLES - 1; i >= 256; i--)
+      {
+        UInt32 x = g_CrcTable[i - 256];
+        g_CrcTable[i] = CRC_UINT32_SWAP(x);
+      }
+      g_CrcUpdate = CrcUpdateT1_BeT4;
+    }
+  }
  #endif
 }
--- a/C/7zCrcOpt.c
+++ b/C/7zCrcOpt.c
@@ -1,12 +1,12 @@
-/* 7zCrcOpt.c -- CRC32 calculation : optimized version
-2009-11-23 : Igor Pavlov : Public domain */
+/* 7zCrcOpt.c -- CRC32 calculation
+2010-12-01 : Igor Pavlov : Public domain */

 #include "CpuArch.h"

-#ifdef MY_CPU_LE
-
 #define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))

+#ifndef MY_CPU_BE
+
 UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table)
 {
  const Byte *p = (const Byte *)data;
@@ -32,3 +32,33 @@ UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const U
 }

 #endif
+
+
+#ifndef MY_CPU_LE
+
+#define CRC_UINT32_SWAP(v) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))
+
+UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table)
+{
+  const Byte *p = (const Byte *)data;
+  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
+    v = CRC_UPDATE_BYTE_2(v, *p);
+  v = CRC_UINT32_SWAP(v);
+  table += 0x100;
+  for (; size >= 4; size -= 4, p += 4)
+  {
+    v ^= *(const UInt32 *)p;
+    v =
+      table[0x000 + (v & 0xFF)] ^
+      table[0x100 + ((v >> 8) & 0xFF)] ^
+      table[0x200 + ((v >> 16) & 0xFF)] ^
+      table[0x300 + ((v >> 24))];
+  }
+  table -= 0x100;
+  v = CRC_UINT32_SWAP(v);
+  for (; size > 0; size--, p++)
+    v = CRC_UPDATE_BYTE_2(v, *p);
+  return v;
+}
+
+#endif
--- a/C/7zDec.c
+++ b/C/7zDec.c
@@ -1,5 +1,5 @@
 /* 7zDec.c -- Decoding from 7z folder
-2010-03-15 : Igor Pavlov : Public domain */
+2010-11-02 : Igor Pavlov : Public domain */

 #include <string.h>

@@ -18,9 +18,13 @@

 #define k_Copy 0
 #define k_LZMA2 0x21
-#define k_LZMA 0x30101
-#define k_BCJ 0x03030103
-#define k_BCJ2 0x0303011B
+#define k_LZMA  0x30101
+#define k_BCJ   0x03030103
+#define k_PPC   0x03030205
+#define k_ARM   0x03030501
+#define k_ARMT  0x03030701
+#define k_SPARC 0x03030805
+#define k_BCJ2  0x0303011B

 #ifdef _7ZIP_PPMD_SUPPPORT

@@ -260,7 +264,6 @@ static Bool IS_SUPPORTED_CODER(const CSzCoderInfo *c)
      IS_MAIN_METHOD((UInt32)c->MethodID);
 }

-#define IS_BCJ(c) ((c)->MethodID == k_BCJ && (c)->NumInStreams == 1 && (c)->NumOutStreams == 1)
 #define IS_BCJ2(c) ((c)->MethodID == k_BCJ2 && (c)->NumInStreams == 4 && (c)->NumOutStreams == 1)

 static SRes CheckSupportedFolder(const CSzFolder *f)
@@ -277,11 +280,24 @@ static SRes CheckSupportedFolder(const CSzFolder *f)
  }
  if (f->NumCoders == 2)
  {
-    if (!IS_BCJ(&f->Coders[1]) ||
-        f->NumPackStreams != 1 || f->PackStreams[0] != 0 ||
+    CSzCoderInfo *c = &f->Coders[1];
+    if (c->MethodID > (UInt32)0xFFFFFFFF ||
+        c->NumInStreams != 1 ||
+        c->NumOutStreams != 1 ||
+        f->NumPackStreams != 1 ||
+        f->PackStreams[0] != 0 ||
        f->NumBindPairs != 1 ||
-        f->BindPairs[0].InIndex != 1 || f->BindPairs[0].OutIndex != 0)
+        f->BindPairs[0].InIndex != 1 ||
+        f->BindPairs[0].OutIndex != 0)
      return SZ_ERROR_UNSUPPORTED;
+    switch ((UInt32)c->MethodID)
+    {
+      case k_BCJ:
+      case k_ARM:
+        break;
+      default:
+        return SZ_ERROR_UNSUPPORTED;
+    }
    return SZ_OK;
  }
  if (f->NumCoders == 4)
@@ -314,6 +330,8 @@ static UInt64 GetSum(const UInt64 *values, UInt32 index)
  return sum;
 }

+#define CASE_BRA_CONV(isa) case k_ ## isa: isa ## _Convert(outBuffer, outSize, 0, 0); break;
+
 static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
    ILookInStream *inStream, UInt64 startPos,
    Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain,
@@ -391,14 +409,6 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
        #endif
      }
    }
-    else if (coder->MethodID == k_BCJ)
-    {
-      UInt32 state;
-      if (ci != 1)
-        return SZ_ERROR_UNSUPPORTED;
-      x86_Convert_Init(state);
-      x86_Convert(outBuffer, outSize, 0, &state, 0);
-    }
    else if (coder->MethodID == k_BCJ2)
    {
      UInt64 offset = GetSum(packSizes, 1);
@@ -425,7 +435,23 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
      RINOK(res)
    }
    else
-      return SZ_ERROR_UNSUPPORTED;
+    {
+      if (ci != 1)
+        return SZ_ERROR_UNSUPPORTED;
+      switch(coder->MethodID)
+      {
+        case k_BCJ:
+        {
+          UInt32 state;
+          x86_Convert_Init(state);
+          x86_Convert(outBuffer, outSize, 0, &state, 0);
+          break;
+        }
+        CASE_BRA_CONV(ARM)
+        default:
+          return SZ_ERROR_UNSUPPORTED;
+      }
+    }
  }
  return SZ_OK;
 }
--- a/C/7zIn.c
+++ b/C/7zIn.c
@@ -1,5 +1,5 @@
 /* 7zIn.c -- 7z Input functions
-2010-03-11 : Igor Pavlov : Public domain */
+2010-10-29 : Igor Pavlov : Public domain */

 #include <string.h>

@@ -1218,12 +1218,16 @@ static SRes SzArEx_Open2(
    ISzAlloc *allocTemp)
 {
  Byte header[k7zStartHeaderSize];
+  Int64 startArcPos;
  UInt64 nextHeaderOffset, nextHeaderSize;
  size_t nextHeaderSizeT;
  UInt32 nextHeaderCRC;
  CBuf buffer;
  SRes res;

+  startArcPos = 0;
+  RINOK(inStream->Seek(inStream, &startArcPos, SZ_SEEK_CUR));
+
  RINOK(LookInStream_Read2(inStream, header, k7zStartHeaderSize, SZ_ERROR_NO_ARCHIVE));

  if (!TestSignatureCandidate(header))
@@ -1235,7 +1239,7 @@ static SRes SzArEx_Open2(
  nextHeaderSize = GetUi64(header + 20);
  nextHeaderCRC = GetUi32(header + 28);

-  p->startPosAfterHeader = k7zStartHeaderSize;
+  p->startPosAfterHeader = startArcPos + k7zStartHeaderSize;
  
  if (CrcCalc(header + 12, 20) != GetUi32(header + 8))
    return SZ_ERROR_CRC;
@@ -1252,13 +1256,13 @@ static SRes SzArEx_Open2(
  {
    Int64 pos = 0;
    RINOK(inStream->Seek(inStream, &pos, SZ_SEEK_END));
-    if ((UInt64)pos < nextHeaderOffset ||
-        (UInt64)pos < k7zStartHeaderSize + nextHeaderOffset ||
-        (UInt64)pos < k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)
+    if ((UInt64)pos < startArcPos + nextHeaderOffset ||
+        (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset ||
+        (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)
      return SZ_ERROR_INPUT_EOF;
  }

-  RINOK(LookInStream_SeekTo(inStream, k7zStartHeaderSize + nextHeaderOffset));
+  RINOK(LookInStream_SeekTo(inStream, startArcPos + k7zStartHeaderSize + nextHeaderOffset));

  if (!Buf_Create(&buffer, nextHeaderSizeT, allocTemp))
    return SZ_ERROR_MEM;
--- a/C/7zVersion.h
+++ b/C/7zVersion.h
@@ -1,7 +1,8 @@
 #define MY_VER_MAJOR 9
-#define MY_VER_MINOR 17
-#define MY_VER_BUILD 0
-#define MY_VERSION "9.17 beta"
-#define MY_DATE "2010-10-04"
+#define MY_VER_MINOR 22
+#define MY_VER_BUILD 00
+#define MY_VERSION "9.22 beta"
+#define MY_7ZIP_VERSION "9.22 beta"
+#define MY_DATE "2011-04-18"
 #define MY_COPYRIGHT ": Igor Pavlov : Public domain"
 #define MY_VERSION_COPYRIGHT_DATE MY_VERSION " " MY_COPYRIGHT " : " MY_DATE
--- a/C/7zVersion.rc
+++ b/C/7zVersion.rc
@@ -0,0 +1,55 @@
+#define MY_VS_FFI_FILEFLAGSMASK  0x0000003FL
+#define MY_VOS_NT_WINDOWS32  0x00040004L
+#define MY_VOS_CE_WINDOWS32  0x00050004L
+
+#define MY_VFT_APP  0x00000001L
+#define MY_VFT_DLL  0x00000002L
+
+// #include <WinVer.h>
+
+#ifndef MY_VERSION
+#include "7zVersion.h"
+#endif
+
+#define MY_VER MY_VER_MAJOR,MY_VER_MINOR,MY_VER_BUILD,0
+
+#ifdef DEBUG
+#define DBG_FL VS_FF_DEBUG
+#else
+#define DBG_FL 0
+#endif
+
+#define MY_VERSION_INFO(fileType, descr, intName, origName)  \
+LANGUAGE 9, 1 \
+1 VERSIONINFO \
+  FILEVERSION MY_VER \
+  PRODUCTVERSION MY_VER \
+  FILEFLAGSMASK MY_VS_FFI_FILEFLAGSMASK \
+  FILEFLAGS DBG_FL \
+  FILEOS MY_VOS_NT_WINDOWS32 \
+  FILETYPE fileType \
+  FILESUBTYPE 0x0L \
+BEGIN \
+    BLOCK "StringFileInfo" \
+    BEGIN  \
+        BLOCK "040904b0" \
+        BEGIN \
+            VALUE "CompanyName", "Igor Pavlov" \
+            VALUE "FileDescription", descr \
+            VALUE "FileVersion", MY_VERSION  \
+            VALUE "InternalName", intName \
+            VALUE "LegalCopyright", MY_COPYRIGHT \
+            VALUE "OriginalFilename", origName \
+            VALUE "ProductName", "7-Zip" \
+            VALUE "ProductVersion", MY_VERSION \
+        END \
+    END \
+    BLOCK "VarFileInfo" \
+    BEGIN \
+        VALUE "Translation", 0x409, 1200 \
+    END \
+END
+
+#define MY_VERSION_INFO_APP(descr, intName) MY_VERSION_INFO(MY_VFT_APP, descr, intName, intName ".exe")
+
+#define MY_VERSION_INFO_DLL(descr, intName) MY_VERSION_INFO(MY_VFT_DLL, descr, intName, intName ".dll")
--- a/C/CpuArch.c
+++ b/C/CpuArch.c
@@ -1,5 +1,5 @@
 /* CpuArch.c -- CPU specific code
-2009-12-12: Igor Pavlov : Public domain */
+2010-10-26: Igor Pavlov : Public domain */

 #include "CpuArch.h"

@@ -72,13 +72,13 @@ static void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d)

  #else

- 	__asm__ __volatile__ (
- 		"cpuid"
- 		: "=a" (*a) ,
- 		  "=b" (*b) ,
- 		  "=c" (*c) ,
- 		  "=d" (*d)
-		: "0" (function)) ;
+  __asm__ __volatile__ (
+    "cpuid"
+    : "=a" (*a) ,
+      "=b" (*b) ,
+      "=c" (*c) ,
+      "=d" (*d)
+    : "0" (function)) ;

  #endif
  
--- a/C/CpuArch.h
+++ b/C/CpuArch.h
@@ -1,5 +1,5 @@
 /* CpuArch.h -- CPU specific code
-2010-05-20: Igor Pavlov : Public domain */
+2010-12-01: Igor Pavlov : Public domain */

 #ifndef __CPU_ARCH_H
 #define __CPU_ARCH_H
@@ -40,14 +40,26 @@ If MY_CPU_LE_UNALIGN is not defined, we don't know about these properties of pla
 #define MY_CPU_ARM_LE
 #endif

+#if defined(_WIN32) && defined(_M_IA64)
+#define MY_CPU_IA64_LE
+#endif
+
 #if defined(MY_CPU_X86_OR_AMD64)
 #define MY_CPU_LE_UNALIGN
 #endif

-#if defined(MY_CPU_X86_OR_AMD64) || defined(MY_CPU_ARM_LE)
+#if defined(MY_CPU_X86_OR_AMD64) || defined(MY_CPU_ARM_LE)  || defined(MY_CPU_IA64_LE) || defined(__ARMEL__) || defined(__MIPSEL__) || defined(__LITTLE_ENDIAN__)
 #define MY_CPU_LE
 #endif

+#if defined(__BIG_ENDIAN__) || defined(__m68k__) ||  defined(__ARMEB__) || defined(__MIPSEB__)
+#define MY_CPU_BE
+#endif
+
+#if defined(MY_CPU_LE) && defined(MY_CPU_BE)
+Stop_Compiling_Bad_Endian
+#endif
+
 #ifdef MY_CPU_LE_UNALIGN

 #define GetUi16(p) (*(const UInt16 *)(p))
--- a/C/Lzma2Dec.c
+++ b/C/Lzma2Dec.c
@@ -1,5 +1,5 @@
 /* Lzma2Dec.c -- LZMA2 Decoder
-2009-05-03 : Igor Pavlov : Public domain */
+2010-12-15 : Igor Pavlov : Public domain */

 /* #define SHOW_DEBUG_INFO */

@@ -330,27 +330,21 @@ SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *
 SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
    Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc)
 {
-  CLzma2Dec decoder;
+  CLzma2Dec p;
  SRes res;
  SizeT outSize = *destLen, inSize = *srcLen;
-  Byte props[LZMA_PROPS_SIZE];
-
-  Lzma2Dec_Construct(&decoder);
-
  *destLen = *srcLen = 0;
  *status = LZMA_STATUS_NOT_SPECIFIED;
-  decoder.decoder.dic = dest;
-  decoder.decoder.dicBufSize = outSize;
-
-  RINOK(Lzma2Dec_GetOldProps(prop, props));
-  RINOK(LzmaDec_AllocateProbs(&decoder.decoder, props, LZMA_PROPS_SIZE, alloc));
-  
+  Lzma2Dec_Construct(&p);
+  RINOK(Lzma2Dec_AllocateProbs(&p, prop, alloc));
+  p.decoder.dic = dest;
+  p.decoder.dicBufSize = outSize;
+  Lzma2Dec_Init(&p);
  *srcLen = inSize;
-  res = Lzma2Dec_DecodeToDic(&decoder, outSize, src, srcLen, finishMode, status);
-  *destLen = decoder.decoder.dicPos;
+  res = Lzma2Dec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);
+  *destLen = p.decoder.dicPos;
  if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
    res = SZ_ERROR_INPUT_EOF;
-
-  LzmaDec_FreeProbs(&decoder.decoder, alloc);
+  Lzma2Dec_FreeProbs(&p, alloc);
  return res;
 }
--- a/C/LzmaDec.c
+++ b/C/LzmaDec.c
@@ -1,5 +1,5 @@
 /* LzmaDec.c -- LZMA Decoder
-2009-09-20 : Igor Pavlov : Public domain */
+2010-12-15 : Igor Pavlov : Public domain */

 #include "LzmaDec.h"

@@ -442,8 +442,9 @@ static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)

    p->processedPos += len;
    p->remainLen -= len;
-    while (len-- != 0)
+    while (len != 0)
    {
+      len--;
      dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
      dicPos++;
    }
@@ -972,28 +973,21 @@ SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
 {
  CLzmaDec p;
  SRes res;
-  SizeT inSize = *srcLen;
-  SizeT outSize = *destLen;
-  *srcLen = *destLen = 0;
+  SizeT outSize = *destLen, inSize = *srcLen;
+  *destLen = *srcLen = 0;
+  *status = LZMA_STATUS_NOT_SPECIFIED;
  if (inSize < RC_INIT_SIZE)
    return SZ_ERROR_INPUT_EOF;
-
  LzmaDec_Construct(&p);
-  res = LzmaDec_AllocateProbs(&p, propData, propSize, alloc);
-  if (res != 0)
-    return res;
+  RINOK(LzmaDec_AllocateProbs(&p, propData, propSize, alloc));
  p.dic = dest;
  p.dicBufSize = outSize;
-
  LzmaDec_Init(&p);
-  
  *srcLen = inSize;
  res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);
-
+  *destLen = p.dicPos;
  if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
    res = SZ_ERROR_INPUT_EOF;
-
-  (*destLen) = p.dicPos;
  LzmaDec_FreeProbs(&p, alloc);
  return res;
 }
--- a/C/LzmaEnc.c
+++ b/C/LzmaEnc.c
@@ -1,5 +1,5 @@
 /* LzmaEnc.c -- LZMA Encoder
-2010-04-16 : Igor Pavlov : Public domain */
+2011-01-27 : Igor Pavlov : Public domain */

 #include <string.h>

@@ -46,6 +46,7 @@ void LzmaEncProps_Init(CLzmaEncProps *p)
 {
  p->level = 5;
  p->dictSize = p->mc = 0;
+  p->reduceSize = (UInt32)(Int32)-1;
  p->lc = p->lp = p->pb = p->algo = p->fb = p->btMode = p->numHashBytes = p->numThreads = -1;
  p->writeEndMark = 0;
 }
@@ -56,6 +57,15 @@ void LzmaEncProps_Normalize(CLzmaEncProps *p)
  if (level < 0) level = 5;
  p->level = level;
  if (p->dictSize == 0) p->dictSize = (level <= 5 ? (1 << (level * 2 + 14)) : (level == 6 ? (1 << 25) : (1 << 26)));
+  if (p->dictSize > p->reduceSize)
+  {
+    unsigned i;
+    for (i = 15; i <= 30; i++)
+    {
+      if (p->reduceSize <= ((UInt32)2 << i)) { p->dictSize = ((UInt32)2 << i); break; }
+      if (p->reduceSize <= ((UInt32)3 << i)) { p->dictSize = ((UInt32)3 << i); break; }
+    }
+  }
  if (p->lc < 0) p->lc = 3;
  if (p->lp < 0) p->lp = 0;
  if (p->pb < 0) p->pb = 2;
@@ -329,7 +339,6 @@ typedef struct

  SRes result;
  UInt32 dictSize;
-  UInt32 matchFinderCycles;

  int needInit;

@@ -398,7 +407,6 @@ SRes LzmaEnc_SetProps(CLzmaEncHandle pp, const CLzmaEncProps *props2)
      props.dictSize > ((UInt32)1 << kDicLogSizeMaxCompress) || props.dictSize > ((UInt32)1 << 30))
    return SZ_ERROR_PARAM;
  p->dictSize = props.dictSize;
-  p->matchFinderCycles = props.mc;
  {
    unsigned fb = props.fb;
    if (fb < 5)
--- a/C/LzmaEnc.h
+++ b/C/LzmaEnc.h
@@ -1,14 +1,12 @@
 /*  LzmaEnc.h -- LZMA Encoder
-2009-02-07 : Igor Pavlov : Public domain */
+2011-01-27 : Igor Pavlov : Public domain */

 #ifndef __LZMA_ENC_H
 #define __LZMA_ENC_H

 #include "Types.h"

-#ifdef __cplusplus
-extern "C" {
-#endif
+EXTERN_C_BEGIN

 #define LZMA_PROPS_SIZE 5

@@ -18,6 +16,8 @@ typedef struct _CLzmaEncProps
  UInt32 dictSize; /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version
                      (1 << 12) <= dictSize <= (1 << 30) for 64-bit version
                       default = (1 << 24) */
+  UInt32 reduceSize; /* estimated size of data that will be compressed. default = 0xFFFFFFFF.
+                        Encoder uses this value to reduce dictionary size */
  int lc;          /* 0 <= lc <= 8, default = 3 */
  int lp;          /* 0 <= lp <= 4, default = 0 */
  int pb;          /* 0 <= pb <= 4, default = 2 */
@@ -73,8 +73,6 @@ SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
    const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
    ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);

-#ifdef __cplusplus
-}
-#endif
+EXTERN_C_END

 #endif
--- a/C/Ppmd.h
+++ b/C/Ppmd.h
@@ -1,5 +1,5 @@
 /* Ppmd.h -- PPMD codec common code
-2010-03-12 : Igor Pavlov : Public domain
+2011-01-27 : Igor Pavlov : Public domain
 This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */

 #ifndef __PPMD_H
@@ -29,6 +29,9 @@ EXTERN_C_BEGIN
 #define PPMD_N4 ((128 + 3 - 1 * PPMD_N1 - 2 * PPMD_N2 - 3 * PPMD_N3) / 4)
 #define PPMD_NUM_INDEXES (PPMD_N1 + PPMD_N2 + PPMD_N3 + PPMD_N4)

+#pragma pack(push, 1)
+/* Most compilers works OK here even without #pragma pack(push, 1), but some GCC compilers need it. */
+
 /* SEE-contexts for PPM-contexts with masked symbols */
 typedef struct
 {
@@ -48,6 +51,8 @@ typedef struct
  UInt16 SuccessorHigh;
 } CPpmd_State;

+#pragma pack(pop)
+
 typedef
  #ifdef PPMD_32BIT
    CPpmd_State *
--- a/C/Ppmd8.h
+++ b/C/Ppmd8.h
@@ -1,5 +1,5 @@
 /* Ppmd8.h -- PPMdI codec
-2010-03-24 : Igor Pavlov : Public domain
+2011-01-27 : Igor Pavlov : Public domain
 This code is based on:
  PPMd var.I (2002): Dmitry Shkarin : Public domain
  Carryless rangecoder (1999): Dmitry Subbotin : Public domain */
@@ -24,6 +24,8 @@ typedef
  #endif
  CPpmd8_Context_Ref;

+#pragma pack(push, 1)
+
 typedef struct CPpmd8_Context_
 {
  Byte NumStats;
@@ -33,6 +35,8 @@ typedef struct CPpmd8_Context_
  CPpmd8_Context_Ref Suffix;
 } CPpmd8_Context;

+#pragma pack(pop)
+
 #define Ppmd8Context_OneState(p) ((CPpmd_State *)&(p)->SummFreq)

 /* The BUG in Shkarin's code for FREEZE mode was fixed, but that fixed
--- a/C/Types.h
+++ b/C/Types.h
@@ -1,5 +1,5 @@
 /* Types.h -- Basic types
-2010-04-16 : Igor Pavlov : Public domain */
+2010-10-09 : Igor Pavlov : Public domain */

 #ifndef __7Z_TYPES_H
 #define __7Z_TYPES_H
@@ -233,6 +233,22 @@ typedef struct
 #define IAlloc_Alloc(p, size) (p)->Alloc((p), size)
 #define IAlloc_Free(p, a) (p)->Free((p), a)

+#ifdef _WIN32
+
+#define CHAR_PATH_SEPARATOR '\\'
+#define WCHAR_PATH_SEPARATOR L'\\'
+#define STRING_PATH_SEPARATOR "\\"
+#define WSTRING_PATH_SEPARATOR L"\\"
+
+#else
+
+#define CHAR_PATH_SEPARATOR '/'
+#define WCHAR_PATH_SEPARATOR L'/'
+#define STRING_PATH_SEPARATOR "/"
+#define WSTRING_PATH_SEPARATOR L"/"
+
+#endif
+
 EXTERN_C_END

 #endif
--- a/C/Util/7z/7z.dsp
+++ b/C/Util/7z/7z.dsp
@@ -92,6 +92,14 @@ SOURCE=..\..\7z.h
 # End Source File
 # Begin Source File

+SOURCE=..\..\7zAlloc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zAlloc.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\7zBuf.c
 # End Source File
 # Begin Source File
@@ -141,6 +149,10 @@ SOURCE=..\..\Bcj2.h
 # End Source File
 # Begin Source File

+SOURCE=..\..\Bra.c
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\Bra.h
 # End Source File
 # Begin Source File
@@ -196,14 +208,6 @@ SOURCE=..\..\Types.h
 # End Group
 # Begin Source File

-SOURCE=.\7zAlloc.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\7zAlloc.h
-# End Source File
-# Begin Source File
-
 SOURCE=.\7zMain.c
 # End Source File
 # End Target
--- a/C/Util/7z/7zMain.c
+++ b/C/Util/7z/7zMain.c
@@ -1,16 +1,15 @@
 /* 7zMain.c - Test application for 7z Decoder
-2010-09-20 : Igor Pavlov : Public domain */
+2010-10-28 : Igor Pavlov : Public domain */

 #include <stdio.h>
 #include <string.h>

 #include "../../7z.h"
+#include "../../7zAlloc.h"
 #include "../../7zCrc.h"
 #include "../../7zFile.h"
 #include "../../7zVersion.h"

-#include "7zAlloc.h"
-
 #ifndef USE_WINDOWS_FILE
 /* for mkdir */
 #ifdef _WIN32
@@ -21,12 +20,6 @@
 #endif
 #endif

-#ifdef _WIN32
-#define CHAR_PATH_SEPARATOR '\\'
-#else
-#define CHAR_PATH_SEPARATOR '/'
-#endif
-
 static ISzAlloc g_Alloc = { SzAlloc, SzFree };

 static int Buf_EnsureSize(CBuf *dest, size_t size)
@@ -117,7 +110,14 @@ static SRes Utf16_To_Char(CBuf *buf, const UInt16 *s, int fileMode)
    {
      char defaultChar = '_';
      BOOL defUsed;
-      int numChars = WideCharToMultiByte(fileMode ? (AreFileApisANSI() ? CP_ACP : CP_OEMCP) : CP_OEMCP,
+      int numChars = WideCharToMultiByte(fileMode ?
+          (
+          #ifdef UNDER_CE
+          CP_ACP
+          #else
+          AreFileApisANSI() ? CP_ACP : CP_OEMCP
+          #endif
+          ) : CP_OEMCP,
          0, s, len, (char *)buf->data, size, &defaultChar, &defUsed);
      if (numChars == 0 || numChars >= size)
        return SZ_ERROR_FAIL;
--- a/C/Util/7z/makefile
+++ b/C/Util/7z/makefile
@@ -4,6 +4,7 @@ CFLAGS = $(CFLAGS) -D_7ZIP_PPMD_SUPPPORT
 PROG = 7zDec.exe

 C_OBJS = \
+  $O\7zAlloc.obj \
  $O\7zBuf.obj \
  $O\7zBuf2.obj \
  $O\7zCrc.obj \
@@ -13,6 +14,7 @@ C_OBJS = \
  $O\7zIn.obj \
  $O\7zStream.obj \
  $O\Bcj2.obj \
+  $O\Bra.obj \
  $O\Bra86.obj \
  $O\CpuArch.obj \
  $O\Lzma2Dec.obj \
@@ -21,7 +23,6 @@ C_OBJS = \
  $O\Ppmd7Dec.obj \

 7Z_OBJS = \
-  $O\7zAlloc.obj \
  $O\7zMain.obj \

 OBJS = \
--- a/C/Util/7z/makefile.gcc
+++ b/C/Util/7z/makefile.gcc
@@ -4,7 +4,7 @@ LIB =
 RM = rm -f
 CFLAGS = -c -O2 -Wall

-OBJS = 7zMain.o 7zAlloc.o 7zBuf.o 7zBuf2.o 7zCrc.o 7zCrcOpt.o 7zDec.o 7zIn.o CpuArch.o LzmaDec.o Lzma2Dec.o Bra86.o Bcj2.o Ppmd7.o Ppmd7Dec.o 7zFile.o 7zStream.o
+OBJS = 7zMain.o 7zAlloc.o 7zBuf.o 7zBuf2.o 7zCrc.o 7zCrcOpt.o 7zDec.o 7zIn.o CpuArch.o LzmaDec.o Lzma2Dec.o Bra.o Bra86.o Bcj2.o Ppmd7.o Ppmd7Dec.o 7zFile.o 7zStream.o

 all: $(PROG)

@@ -15,7 +15,7 @@ $(PROG): $(OBJS)
 	$(CXX) $(CFLAGS) 7zMain.c

 7zAlloc.o: 7zAlloc.c
-	$(CXX) $(CFLAGS) 7zAlloc.c
+	$(CXX) $(CFLAGS) ../../7zAlloc.c

 7zBuf.o: ../../7zBuf.c
 	$(CXX) $(CFLAGS) ../../7zBuf.c
@@ -44,6 +44,9 @@ LzmaDec.o: ../../LzmaDec.c
 Lzma2Dec.o: ../../Lzma2Dec.c
 	$(CXX) $(CFLAGS) ../../Lzma2Dec.c

+Bra.o: ../../Bra.c
+	$(CXX) $(CFLAGS) ../../Bra.c
+
 Bra86.o: ../../Bra86.c
 	$(CXX) $(CFLAGS) ../../Bra86.c

--- a/C/Util/LzmaLib/resource.rc
+++ b/C/Util/LzmaLib/resource.rc
@@ -1,4 +1,3 @@
-#include "../../../CPP/7zip/MyVersionInfo.rc"
+#include "../../7zVersion.rc"

 MY_VERSION_INFO_DLL("LZMA library", "LZMA")
-
--- a/C/Util/SfxSetup/SfxSetup.c
+++ b/C/Util/SfxSetup/SfxSetup.c
@@ -0,0 +1,588 @@
+/* SfxSetup.c - 7z SFX Setup
+2010-12-13 : Igor Pavlov : Public domain */
+
+#ifndef UNICODE
+#define UNICODE
+#endif
+
+#ifndef _UNICODE
+#define _UNICODE
+#endif
+
+#ifdef _CONSOLE
+#include <stdio.h>
+#endif
+
+#include "../../7z.h"
+#include "../../7zAlloc.h"
+#include "../../7zCrc.h"
+#include "../../7zFile.h"
+#include "../../CpuArch.h"
+
+#define k_EXE_ExtIndex 1
+
+static const char *kExts[] =
+{
+  "bat",
+  "cmd",
+  "exe",
+  "inf",
+  "msi",
+  #ifdef UNDER_CE
+  "cab",
+  #endif
+  "html",
+  "htm"
+};
+
+static const char *kNames[] =
+{
+  "setup",
+  "install",
+  "run",
+  "start"
+};
+
+static unsigned FindExt(const wchar_t *s, unsigned *extLen)
+{
+  unsigned len = (unsigned)wcslen(s);
+  unsigned i;
+  for (i = len; i > 0; i--)
+  {
+    if (s[i - 1] == '.')
+    {
+      *extLen = len - i;
+      return i - 1;
+    }
+  }
+  *extLen = 0;
+  return len;
+}
+
+#define MAKE_CHAR_UPPER(c) ((((c) >= 'a' && (c) <= 'z') ? (c) -= 0x20 : (c)))
+
+static unsigned FindItem(const char **items, unsigned num, const wchar_t *s, unsigned len)
+{
+  unsigned i;
+  for (i = 0; i < num; i++)
+  {
+    const char *item = items[i];
+    unsigned itemLen = (unsigned)strlen(item);
+    unsigned j;
+    if (len != itemLen)
+      continue;
+    for (j = 0; j < len; j++)
+    {
+      unsigned c = item[j];
+      if (c != s[j] && MAKE_CHAR_UPPER(c) != s[j])
+        break;
+    }
+    if (j == len)
+      return i;
+  }
+  return i;
+}
+
+#ifdef _CONSOLE
+static BOOL WINAPI HandlerRoutine(DWORD ctrlType)
+{
+  ctrlType = ctrlType;
+  return TRUE;
+}
+#endif
+
+static void PrintErrorMessage(const char *message)
+{
+  #ifdef _CONSOLE
+  printf("\n7-Zip Error: %s\n", message);
+  #else
+  #ifdef UNDER_CE
+  WCHAR messageW[256 + 4];
+  unsigned i;
+  for (i = 0; i < 256 && message[i] != 0; i++)
+    messageW[i] = message[i];
+  messageW[i] = 0;
+  MessageBoxW(0, messageW, L"7-Zip Error", MB_ICONERROR);
+  #else
+  MessageBoxA(0, message, "7-Zip Error", MB_ICONERROR);
+  #endif
+  #endif
+}
+
+static WRes MyCreateDir(const WCHAR *name)
+{
+  return CreateDirectoryW(name, NULL) ? 0 : GetLastError();
+}
+
+#ifdef UNDER_CE
+#define kBufferSize (1 << 13)
+#else
+#define kBufferSize (1 << 15)
+#endif
+
+#define kSignatureSearchLimit (1 << 22)
+
+static Bool FindSignature(CSzFile *stream, UInt64 *resPos)
+{
+  Byte buf[kBufferSize];
+  size_t numPrevBytes = 0;
+  *resPos = 0;
+  for (;;)
+  {
+    size_t processed, pos;
+    if (*resPos > kSignatureSearchLimit)
+      return False;
+    processed = kBufferSize - numPrevBytes;
+    if (File_Read(stream, buf + numPrevBytes, &processed) != 0)
+      return False;
+    processed += numPrevBytes;
+    if (processed < k7zStartHeaderSize ||
+        (processed == k7zStartHeaderSize && numPrevBytes != 0))
+      return False;
+    processed -= k7zStartHeaderSize;
+    for (pos = 0; pos <= processed; pos++)
+    {
+      for (; buf[pos] != '7' && pos <= processed; pos++);
+      if (pos > processed)
+        break;
+      if (memcmp(buf + pos, k7zSignature, k7zSignatureSize) == 0)
+        if (CrcCalc(buf + pos + 12, 20) == GetUi32(buf + pos + 8))
+        {
+          *resPos += pos;
+          return True;
+        }
+    }
+    *resPos += processed;
+    numPrevBytes = k7zStartHeaderSize;
+    memmove(buf, buf + processed, k7zStartHeaderSize);
+  }
+}
+
+static Bool DoesFileOrDirExist(const WCHAR *path)
+{
+  WIN32_FIND_DATAW fd;
+  HANDLE handle;
+  handle = FindFirstFileW(path, &fd);
+  if (handle == INVALID_HANDLE_VALUE)
+    return False;
+  FindClose(handle);
+  return True;
+}
+
+static WRes RemoveDirWithSubItems(WCHAR *path)
+{
+  WIN32_FIND_DATAW fd;
+  HANDLE handle;
+  WRes res = 0;
+  size_t len = wcslen(path);
+  wcscpy(path + len, L"*");
+  handle = FindFirstFileW(path, &fd);
+  path[len] = L'\0';
+  if (handle == INVALID_HANDLE_VALUE)
+    return GetLastError();
+  for (;;)
+  {
+    if (wcscmp(fd.cFileName, L".") != 0 &&
+        wcscmp(fd.cFileName, L"..") != 0)
+    {
+      wcscpy(path + len, fd.cFileName);
+      if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
+      {
+        wcscat(path, L"\\");
+        res = RemoveDirWithSubItems(path);
+      }
+      else
+      {
+        SetFileAttributesW(path, 0);
+        if (DeleteFileW(path) == 0)
+          res = GetLastError();
+      }
+      if (res != 0)
+        break;
+    }
+    if (!FindNextFileW(handle, &fd))
+    {
+      res = GetLastError();
+      if (res == ERROR_NO_MORE_FILES)
+        res = 0;
+      break;
+    }
+  }
+  path[len] = L'\0';
+  FindClose(handle);
+  if (res == 0)
+  {
+    if (!RemoveDirectoryW(path))
+      res = GetLastError();
+  }
+  return res;
+}
+
+#ifdef _CONSOLE
+int MY_CDECL main()
+#else
+int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
+  #ifdef UNDER_CE
+  LPWSTR
+  #else
+  LPSTR
+  #endif
+  lpCmdLine, int nCmdShow)
+#endif
+{
+  CFileInStream archiveStream;
+  CLookToRead lookStream;
+  CSzArEx db;
+  SRes res = SZ_OK;
+  ISzAlloc allocImp;
+  ISzAlloc allocTempImp;
+  WCHAR sfxPath[MAX_PATH + 2];
+  WCHAR path[MAX_PATH * 3 + 2];
+  size_t pathLen;
+  DWORD winRes;
+  const wchar_t *cmdLineParams;
+  const char *errorMessage = NULL;
+  Bool useShellExecute = True;
+
+  #ifdef _CONSOLE
+  SetConsoleCtrlHandler(HandlerRoutine, TRUE);
+  #else
+  hInstance = hInstance;
+  hPrevInstance = hPrevInstance;
+  lpCmdLine = lpCmdLine;
+  nCmdShow = nCmdShow;
+  #endif
+
+  CrcGenerateTable();
+
+  allocImp.Alloc = SzAlloc;
+  allocImp.Free = SzFree;
+
+  allocTempImp.Alloc = SzAllocTemp;
+  allocTempImp.Free = SzFreeTemp;
+
+  FileInStream_CreateVTable(&archiveStream);
+  LookToRead_CreateVTable(&lookStream, False);
+ 
+  winRes = GetModuleFileNameW(NULL, sfxPath, MAX_PATH);
+  if (winRes == 0 || winRes > MAX_PATH)
+    return 1;
+  {
+    cmdLineParams = GetCommandLineW();
+    #ifndef UNDER_CE
+    {
+      Bool quoteMode = False;
+      for (;; cmdLineParams++)
+      {
+        wchar_t c = *cmdLineParams;
+        if (c == L'\"')
+          quoteMode = !quoteMode;
+        else if (c == 0 || (c == L' ' && !quoteMode))
+          break;
+      }
+    }
+    #endif
+  }
+
+  {
+    unsigned i;
+    DWORD d;
+    winRes = GetTempPathW(MAX_PATH, path);
+    if (winRes == 0 || winRes > MAX_PATH)
+      return 1;
+    pathLen = wcslen(path);
+    d = (GetTickCount() << 12) ^ (GetCurrentThreadId() << 14) ^ GetCurrentProcessId();
+    for (i = 0;; i++, d += GetTickCount())
+    {
+      if (i >= 100)
+      {
+        res = SZ_ERROR_FAIL;
+        break;
+      }
+      wcscpy(path + pathLen, L"7z");
+
+      {
+        wchar_t *s = path + wcslen(path);
+        UInt32 value = d;
+        unsigned k;
+        for (k = 0; k < 8; k++)
+        {
+          unsigned t = value & 0xF;
+          value >>= 4;
+          s[7 - k] = (char)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
+        }
+        s[k] = '\0';
+      }
+
+      if (DoesFileOrDirExist(path))
+        continue;
+      if (CreateDirectoryW(path, NULL))
+      {
+        wcscat(path, L"\\");
+        pathLen = wcslen(path);
+        break;
+      }
+      if (GetLastError() != ERROR_ALREADY_EXISTS)
+      {
+        res = SZ_ERROR_FAIL;
+        break;
+      }
+    }
+    if (res != SZ_OK)
+      errorMessage = "Can't create temp folder";
+  }
+
+  if (res != SZ_OK)
+  {
+    if (!errorMessage)
+      errorMessage = "Error";
+    PrintErrorMessage(errorMessage);
+    return 1;
+  }
+
+  if (InFile_OpenW(&archiveStream.file, sfxPath) != 0)
+  {
+    errorMessage = "can not open input file";
+    res = SZ_ERROR_FAIL;
+  }
+  else
+  {
+    UInt64 pos = 0;
+    if (!FindSignature(&archiveStream.file, &pos))
+      res = SZ_ERROR_FAIL;
+    else if (File_Seek(&archiveStream.file, (Int64 *)&pos, SZ_SEEK_SET) != 0)
+      res = SZ_ERROR_FAIL;
+    if (res != 0)
+      errorMessage = "Can't find 7z archive";
+  }
+
+  if (res == SZ_OK)
+  {
+    lookStream.realStream = &archiveStream.s;
+    LookToRead_Init(&lookStream);
+  }
+
+  SzArEx_Init(&db);
+  if (res == SZ_OK)
+  {
+    res = SzArEx_Open(&db, &lookStream.s, &allocImp, &allocTempImp);
+  }
+  if (res == SZ_OK)
+  {
+    UInt32 executeFileIndex = (UInt32)(Int32)-1;
+    UInt32 minPrice = 1 << 30;
+    UInt32 i;
+    UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */
+    Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */
+    size_t outBufferSize = 0;  /* it can have any value before first call (if outBuffer = 0) */
+    
+    for (i = 0; i < db.db.NumFiles; i++)
+    {
+      size_t offset = 0;
+      size_t outSizeProcessed = 0;
+      const CSzFileItem *f = db.db.Files + i;
+      size_t len;
+      WCHAR *temp;
+      len = SzArEx_GetFileNameUtf16(&db, i, NULL);
+      
+      if (len >= MAX_PATH)
+      {
+        res = SZ_ERROR_FAIL;
+        break;
+      }
+      
+      temp = path + pathLen;
+      
+      SzArEx_GetFileNameUtf16(&db, i, temp);
+      {
+        res = SzArEx_Extract(&db, &lookStream.s, i,
+          &blockIndex, &outBuffer, &outBufferSize,
+          &offset, &outSizeProcessed,
+          &allocImp, &allocTempImp);
+        if (res != SZ_OK)
+          break;
+      }
+      {
+        CSzFile outFile;
+        size_t processedSize;
+        size_t j;
+        size_t nameStartPos = 0;
+        for (j = 0; temp[j] != 0; j++)
+        {
+          if (temp[j] == '/')
+          {
+            temp[j] = 0;
+            MyCreateDir(path);
+            temp[j] = CHAR_PATH_SEPARATOR;
+            nameStartPos = j + 1;
+          }
+        }
+
+        if (f->IsDir)
+        {
+          MyCreateDir(path);
+          continue;
+        }
+        else
+        {
+          unsigned extLen;
+          const WCHAR *name = temp + nameStartPos;
+          unsigned len = (unsigned)wcslen(name);
+          unsigned nameLen = FindExt(temp + nameStartPos, &extLen);
+          unsigned extPrice = FindItem(kExts, sizeof(kExts) / sizeof(kExts[0]), name + len - extLen, extLen);
+          unsigned namePrice = FindItem(kNames, sizeof(kNames) / sizeof(kNames[0]), name, nameLen);
+
+          unsigned price = namePrice + extPrice * 64 + (nameStartPos == 0 ? 0 : (1 << 12));
+          if (minPrice > price)
+          {
+            minPrice = price;
+            executeFileIndex = i;
+            useShellExecute = (extPrice != k_EXE_ExtIndex);
+          }
+         
+          if (DoesFileOrDirExist(path))
+          {
+            errorMessage = "Duplicate file";
+            res = SZ_ERROR_FAIL;
+            break;
+          }
+          if (OutFile_OpenW(&outFile, path))
+          {
+            errorMessage = "Can't open output file";
+            res = SZ_ERROR_FAIL;
+            break;
+          }
+        }
+        processedSize = outSizeProcessed;
+        if (File_Write(&outFile, outBuffer + offset, &processedSize) != 0 || processedSize != outSizeProcessed)
+        {
+          errorMessage = "Can't write output file";
+          res = SZ_ERROR_FAIL;
+        }
+        
+        #ifdef USE_WINDOWS_FILE
+        if (f->MTimeDefined)
+        {
+          FILETIME mTime;
+          mTime.dwLowDateTime = f->MTime.Low;
+          mTime.dwHighDateTime = f->MTime.High;
+          SetFileTime(outFile.handle, NULL, NULL, &mTime);
+        }
+        #endif
+        
+        {
+          SRes res2 = File_Close(&outFile);
+          if (res != SZ_OK)
+            break;
+          if (res2 != SZ_OK)
+          {
+            res = res2;
+            break;
+          }
+        }
+        #ifdef USE_WINDOWS_FILE
+        if (f->AttribDefined)
+          SetFileAttributesW(path, f->Attrib);
+        #endif
+      }
+    }
+
+    if (res == SZ_OK)
+    {
+      if (executeFileIndex == (UInt32)(Int32)-1)
+      {
+        errorMessage = "There is no file to execute";
+        res = SZ_ERROR_FAIL;
+      }
+      else
+      {
+        WCHAR *temp = path + pathLen;
+        UInt32 j;
+        SzArEx_GetFileNameUtf16(&db, executeFileIndex, temp);
+        for (j = 0; temp[j] != 0; j++)
+          if (temp[j] == '/')
+            temp[j] = CHAR_PATH_SEPARATOR;
+      }
+    }
+    IAlloc_Free(&allocImp, outBuffer);
+  }
+  SzArEx_Free(&db, &allocImp);
+
+  File_Close(&archiveStream.file);
+
+  if (res == SZ_OK)
+  {
+    HANDLE hProcess = 0;
+    if (useShellExecute)
+    {
+      SHELLEXECUTEINFO ei;
+      UINT32 executeRes;
+      BOOL success;
+      
+      memset(&ei, 0, sizeof(ei));
+      ei.cbSize = sizeof(ei);
+      ei.lpFile = path;
+      ei.fMask = SEE_MASK_NOCLOSEPROCESS
+          #ifndef UNDER_CE
+          | SEE_MASK_FLAG_DDEWAIT
+          #endif
+          /* | SEE_MASK_NO_CONSOLE */
+          ;
+      if (wcslen(cmdLineParams) != 0)
+        ei.lpParameters = cmdLineParams;
+      ei.nShow = SW_SHOWNORMAL; /* SW_HIDE; */
+      success = ShellExecuteEx(&ei);
+      executeRes = (UINT32)(UINT_PTR)ei.hInstApp;
+      if (!success || (executeRes <= 32 && executeRes != 0))  /* executeRes = 0 in Windows CE */
+        res = SZ_ERROR_FAIL;
+      else
+        hProcess = ei.hProcess;
+    }
+    else
+    {
+      STARTUPINFOW si;
+      PROCESS_INFORMATION pi;
+      WCHAR cmdLine[MAX_PATH * 3];
+
+      wcscpy(cmdLine, path);
+      wcscat(cmdLine, cmdLineParams);
+      memset(&si, 0, sizeof(si));
+      si.cb = sizeof(si);
+      if (CreateProcessW(NULL, cmdLine, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi) == 0)
+        res = SZ_ERROR_FAIL;
+      else
+      {
+        CloseHandle(pi.hThread);
+        hProcess = pi.hProcess;
+      }
+    }
+    if (hProcess != 0)
+    {
+      WaitForSingleObject(hProcess, INFINITE);
+      CloseHandle(hProcess);
+    }
+  }
+
+  path[pathLen] = L'\0';
+  RemoveDirWithSubItems(path);
+
+  if (res == SZ_OK)
+    return 0;
+  
+  {
+    if (res == SZ_ERROR_UNSUPPORTED)
+      errorMessage = "Decoder doesn't support this archive";
+    else if (res == SZ_ERROR_MEM)
+      errorMessage = "Can't allocate required memory";
+    else if (res == SZ_ERROR_CRC)
+      errorMessage = "CRC error";
+    else
+    {
+      if (!errorMessage)
+        errorMessage = "ERROR";
+    }
+    if (errorMessage)
+      PrintErrorMessage(errorMessage);
+  }
+  return 1;
+}
--- a/C/Util/SfxSetup/SfxSetup.dsp
+++ b/C/Util/SfxSetup/SfxSetup.dsp
@@ -0,0 +1,198 @@
+# Microsoft Developer Studio Project File - Name="SfxSetup" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=SfxSetup - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "SfxSetup.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "SfxSetup.mak" CFG="SfxSetup - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "SfxSetup - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "SfxSetup - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "SfxSetup - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+
+!ELSEIF  "$(CFG)" == "SfxSetup - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "SfxSetup - Win32 Release"
+# Name "SfxSetup - Win32 Debug"
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\7z.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zAlloc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zAlloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zBuf.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zCrc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zCrcOpt.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zDec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zFile.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zFile.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zIn.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zStream.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bcj2.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bcj2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bra.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bra.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bra86.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\CpuArch.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Lzma2Dec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Lzma2Dec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaDec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Types.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\SfxSetup.c
+# End Source File
+# End Target
+# End Project
--- a/C/Util/SfxSetup/SfxSetup.dsw
+++ b/C/Util/SfxSetup/SfxSetup.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "SfxSetup"=.\SfxSetup.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
--- a/C/Util/SfxSetup/makefile
+++ b/C/Util/SfxSetup/makefile
@@ -0,0 +1,35 @@
+PROG = 7zS2.sfx
+LIBS = $(LIBS) 
+CFLAGS = $(CFLAGS) -DUNICODE -D_UNICODE -D_CRT_SECURE_NO_WARNINGS
+
+C_OBJS = \
+  $O\7zAlloc.obj \
+  $O\7zBuf.obj \
+  $O\7zBuf2.obj \
+  $O\7zCrc.obj \
+  $O\7zCrcOpt.obj \
+  $O\7zFile.obj \
+  $O\7zDec.obj \
+  $O\7zIn.obj \
+  $O\7zStream.obj \
+  $O\Bcj2.obj \
+  $O\Bra.obj \
+  $O\Bra86.obj \
+  $O\CpuArch.obj \
+  $O\Lzma2Dec.obj \
+  $O\LzmaDec.obj \
+
+7Z_OBJS = \
+  $O\SfxSetup.obj \
+
+OBJS = \
+  $(7Z_OBJS) \
+  $(C_OBJS) \
+  $O\resource.res
+
+!include "../../../CPP/Build.mak"
+
+$(7Z_OBJS): $(*B).c
+	$(COMPL_O1)
+$(C_OBJS): ../../$(*B).c
+	$(COMPL_O1)
--- a/C/Util/SfxSetup/makefile_con
+++ b/C/Util/SfxSetup/makefile_con
@@ -0,0 +1,35 @@
+PROG = 7zS2con.sfx
+LIBS = $(LIBS) 
+CFLAGS = $(CFLAGS) -DUNICODE -D_UNICODE -D_CONSOLE
+
+C_OBJS = \
+  $O\7zAlloc.obj \
+  $O\7zBuf.obj \
+  $O\7zBuf2.obj \
+  $O\7zCrc.obj \
+  $O\7zCrcOpt.obj \
+  $O\7zFile.obj \
+  $O\7zDec.obj \
+  $O\7zIn.obj \
+  $O\7zStream.obj \
+  $O\Bcj2.obj \
+  $O\Bra.obj \
+  $O\Bra86.obj \
+  $O\CpuArch.obj \
+  $O\Lzma2Dec.obj \
+  $O\LzmaDec.obj \
+
+7Z_OBJS = \
+  $O\SfxSetup.obj \
+
+OBJS = \
+  $(7Z_OBJS) \
+  $(C_OBJS) \
+  $O\resource.res
+
+!include "../../../CPP/Build.mak"
+
+$(7Z_OBJS): $(*B).c
+	$(COMPL_O1)
+$(C_OBJS): ../../$(*B).c
+	$(COMPL_O1)
--- a/C/Util/SfxSetup/resource.rc
+++ b/C/Util/SfxSetup/resource.rc
@@ -0,0 +1,5 @@
+#include "../../7zVersion.rc"
+
+MY_VERSION_INFO_APP("7z Setup SFX small", "7zS2.sfx")
+
+1  ICON "setup.ico"
--- a/C/Util/SfxSetup/setup.ico
+++ b/C/Util/SfxSetup/setup.ico
--- a/C/Xz.h
+++ b/C/Xz.h
@@ -1,5 +1,5 @@
 /* Xz.h - Xz interface
-2010-09-17 : Igor Pavlov : Public domain */
+2011-01-09 : Igor Pavlov : Public domain */

 #ifndef __XZ_H
 #define __XZ_H
@@ -220,7 +220,8 @@ typedef struct
  Byte buf[XZ_BLOCK_HEADER_SIZE_MAX];
 } CXzUnpacker;

-SRes XzUnpacker_Create(CXzUnpacker *p, ISzAlloc *alloc);
+void XzUnpacker_Construct(CXzUnpacker *p, ISzAlloc *alloc);
+void XzUnpacker_Init(CXzUnpacker *p);
 void XzUnpacker_Free(CXzUnpacker *p);

 /*
@@ -232,8 +233,9 @@ finishMode:
 Returns:
  SZ_OK
    status:
-      LZMA_STATUS_FINISHED_WITH_MARK
-      LZMA_STATUS_NOT_FINISHED
+      CODER_STATUS_NOT_FINISHED,
+      CODER_STATUS_NEEDS_MORE_INPUT - maybe there are more xz streams,
+                                      call XzUnpacker_IsStreamWasFinished to check that current stream was finished
  SZ_ERROR_DATA - Data error
  SZ_ERROR_MEM  - Memory allocation error
  SZ_ERROR_UNSUPPORTED - Unsupported properties
--- a/C/XzDec.c
+++ b/C/XzDec.c
@@ -1,5 +1,5 @@
 /* XzDec.c -- Xz Decode
-2010-04-16 : Igor Pavlov : Public domain */
+2011-02-07 : Igor Pavlov : Public domain */

 /* #define XZ_DUMP */

@@ -18,7 +18,8 @@
 #include "Lzma2Dec.h"

 #ifdef USE_SUBBLOCK
-#include "SbDec.h"
+#include "Bcj3Dec.c"
+#include "SbDec.c"
 #endif

 #include "Xz.h"
@@ -72,7 +73,6 @@ SRes BraState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAlloc *a
 {
  CBraState *p = ((CBraState *)pp);
  alloc = alloc;
-  p->encodeMode = 0;
  p->ip = 0;
  if (p->methodId == XZ_ID_Delta)
  {
@@ -195,7 +195,7 @@ static SRes BraState_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *src,
  return SZ_OK;
 }

-SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, ISzAlloc *alloc)
+SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAlloc *alloc)
 {
  CBraState *decoder;
  if (id != XZ_ID_Delta &&
@@ -211,6 +211,7 @@ SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, ISzAlloc *alloc)
  if (decoder == 0)
    return SZ_ERROR_MEM;
  decoder->methodId = (UInt32)id;
+  decoder->encodeMode = encodeMode;
  p->p = decoder;
  p->Free = BraState_Free;
  p->SetProps = BraState_SetProps;
@@ -225,8 +226,8 @@ SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, ISzAlloc *alloc)

 static void SbState_Free(void *pp, ISzAlloc *alloc)
 {
-  CSubblockDec *p = (CSubblockDec *)pp;
-  SubblockDec_Free(p, alloc);
+  CSbDec *p = (CSbDec *)pp;
+  SbDec_Free(p);
  alloc->Free(alloc, pp);
 }

@@ -240,24 +241,32 @@ static SRes SbState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAl

 static void SbState_Init(void *pp)
 {
-  SubblockDec_Init((CSubblockDec *)pp);
+  SbDec_Init((CSbDec *)pp);
 }

 static SRes SbState_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
    int srcWasFinished, ECoderFinishMode finishMode, int *wasFinished)
 {
-  ECoderStatus status;
-  SRes res = SubblockDec_Decode((CSubblockDec *)pp, dest, destLen, src, srcLen, finishMode, &status);
+  CSbDec *p = (CSbDec *)pp;
+  SRes res;
  srcWasFinished = srcWasFinished;
-  *wasFinished = (status == LZMA_STATUS_FINISHED_WITH_MARK);
+  p->dest = dest;
+  p->destLen = *destLen;
+  p->src = src;
+  p->srcLen = *srcLen;
+  p->finish = finishMode; /* change it */
+  res = SbDec_Decode((CSbDec *)pp);
+  *destLen -= p->destLen;
+  *srcLen -= p->srcLen;
+  *wasFinished = (*destLen == 0 && *srcLen == 0); /* change it */
  return res;
 }

 SRes SbState_SetFromMethod(IStateCoder *p, ISzAlloc *alloc)
 {
-  CSubblockDec *decoder;
+  CSbDec *decoder;
  p->p = 0;
-  decoder = alloc->Alloc(alloc, sizeof(CSubblockDec));
+  decoder = alloc->Alloc(alloc, sizeof(CSbDec));
  if (decoder == 0)
    return SZ_ERROR_MEM;
  p->p = decoder;
@@ -265,7 +274,8 @@ SRes SbState_SetFromMethod(IStateCoder *p, ISzAlloc *alloc)
  p->SetProps = SbState_SetProps;
  p->Init = SbState_Init;
  p->Code = SbState_Code;
-  SubblockDec_Construct(decoder);
+  SbDec_Construct(decoder);
+  SbDec_SetAlloc(decoder, alloc);
  return SZ_OK;
 }
 #endif
@@ -369,7 +379,7 @@ SRes MixCoder_SetFromMethod(CMixCoder *p, int coderIndex, UInt64 methodId)
  }
  if (coderIndex == 0)
    return SZ_ERROR_UNSUPPORTED;
-  return BraState_SetFromMethod(sc, methodId, p->alloc);
+  return BraState_SetFromMethod(sc, methodId, 0, p->alloc);
 }

 SRes MixCoder_Code(CMixCoder *p, Byte *dest, SizeT *destLen,
@@ -587,13 +597,17 @@ SRes XzDec_Init(CMixCoder *p, const CXzBlock *block)
  return SZ_OK;
 }

-SRes XzUnpacker_Create(CXzUnpacker *p, ISzAlloc *alloc)
+void XzUnpacker_Init(CXzUnpacker *p)
 {
-  MixCoder_Construct(&p->decoder, alloc);
  p->state = XZ_STATE_STREAM_HEADER;
  p->pos = 0;
  p->numStreams = 0;
-  return SZ_OK;
+}
+
+void XzUnpacker_Construct(CXzUnpacker *p, ISzAlloc *alloc)
+{
+  MixCoder_Construct(&p->decoder, alloc);
+  XzUnpacker_Init(p);
 }

 void XzUnpacker_Free(CXzUnpacker *p)
--- a/C/XzEnc.c
+++ b/C/XzEnc.c
@@ -1,5 +1,5 @@
 /* XzEnc.c -- Xz Encode
-2009-06-04 : Igor Pavlov : Public domain */
+2011-02-07 : Igor Pavlov : Public domain */

 #include <stdlib.h>
 #include <string.h>
@@ -9,7 +9,9 @@
 #include "Bra.h"
 #include "CpuArch.h"
 #ifdef USE_SUBBLOCK
-#include "SbEnc.h"
+#include "Bcj3Enc.c"
+#include "SbFind.c"
+#include "SbEnc.c"
 #endif

 #include "XzEnc.h"
@@ -198,158 +200,147 @@ static size_t MyWrite(void *pp, const void *data, size_t size)

 /* ---------- CSeqInFilter ---------- */

-/*
-typedef struct _IFilter
-{
-  void *p;
-  void (*Free)(void *p, ISzAlloc *alloc);
-  SRes (*SetProps)(void *p, const Byte *props, size_t propSize, ISzAlloc *alloc);
-  void (*Init)(void *p);
-  size_t (*Filter)(void *p, Byte *data, SizeT destLen);
-} IFilter;
-
-#define FILT_BUF_SIZE (1 << 19)
+#define FILTER_BUF_SIZE (1 << 20)

 typedef struct
 {
  ISeqInStream p;
  ISeqInStream *realStream;
-  UInt32 x86State;
-  UInt32 ip;
-  UInt64 processed;
-  CXzCheck check;
-  Byte buf[FILT_BUF_SIZE];
-  UInt32 bufferPos;
-  UInt32 convertedPosBegin;
-  UInt32 convertedPosEnd;
-  IFilter *filter;
+  IStateCoder StateCoder;
+  Byte *buf;
+  size_t curPos;
+  size_t endPos;
+  int srcWasFinished;
 } CSeqInFilter;

 static SRes SeqInFilter_Read(void *pp, void *data, size_t *size)
 {
  CSeqInFilter *p = (CSeqInFilter *)pp;
-  size_t remSize = *size;
+  size_t sizeOriginal = *size;
+  if (sizeOriginal == 0)
+    return S_OK;
  *size = 0;
-
-  while (remSize > 0)
+  for (;;)
  {
-    int i;
-    if (p->convertedPosBegin != p->convertedPosEnd)
+    if (!p->srcWasFinished && p->curPos == p->endPos)
    {
-      UInt32 sizeTemp = p->convertedPosEnd - p->convertedPosBegin;
-      if (remSize < sizeTemp)
-        sizeTemp = (UInt32)remSize;
-      memmove(data, p->buf + p->convertedPosBegin, sizeTemp);
-      p->convertedPosBegin += sizeTemp;
-      data = (void *)((Byte *)data + sizeTemp);
-      remSize -= sizeTemp;
-      *size += sizeTemp;
-      break;
+      p->curPos = 0;
+      p->endPos = FILTER_BUF_SIZE;
+      RINOK(p->realStream->Read(p->realStream, p->buf, &p->endPos));
+      if (p->endPos == 0)
+        p->srcWasFinished = 1;
    }
-    for (i = 0; p->convertedPosEnd + i < p->bufferPos; i++)
-      p->buf[i] = p->buf[i + p->convertedPosEnd];
-    p->bufferPos = i;
-    p->convertedPosBegin = p->convertedPosEnd = 0;
    {
-      size_t processedSizeTemp = FILT_BUF_SIZE - p->bufferPos;
-      RINOK(p->realStream->Read(p->realStream, p->buf + p->bufferPos, &processedSizeTemp));
-      p->bufferPos = p->bufferPos + (UInt32)processedSizeTemp;
-    }
-    p->convertedPosEnd = (UInt32)p->filter->Filter(p->filter->p, p->buf, p->bufferPos);
-    if (p->convertedPosEnd == 0)
-    {
-      if (p->bufferPos == 0)
-        break;
-      else
-      {
-        p->convertedPosEnd = p->bufferPos;
-        continue;
-      }
-    }
-    if (p->convertedPosEnd > p->bufferPos)
-    {
-      for (; p->bufferPos < p->convertedPosEnd; p->bufferPos++)
-        p->buf[p->bufferPos] = 0;
-      p->convertedPosEnd = (UInt32)p->filter->Filter(p->filter->p, p->buf, p->bufferPos);
+      SizeT srcLen = p->endPos - p->curPos;
+      int wasFinished;
+      SRes res;
+      *size = sizeOriginal;
+      res = p->StateCoder.Code(p->StateCoder.p, data, size, p->buf + p->curPos, &srcLen,
+        p->srcWasFinished, CODER_FINISH_ANY, &wasFinished);
+      p->curPos += srcLen;
+      if (*size != 0 || srcLen == 0 || res != 0)
+        return res;
    }
  }
-  return SZ_OK;
 }
-*/

-/*
-typedef struct
+static void SeqInFilter_Construct(CSeqInFilter *p)
 {
-  ISeqInStream p;
-  ISeqInStream *realStream;
-  CMixCoder mixCoder;
-  Byte buf[FILT_BUF_SIZE];
-  UInt32 bufPos;
-  UInt32 bufSize;
-} CMixCoderSeqInStream;
+  p->buf = NULL;
+  p->p.Read = SeqInFilter_Read;
+}

-static SRes CMixCoderSeqInStream_Read(void *pp, void *data, size_t *size)
+static void SeqInFilter_Free(CSeqInFilter *p)
 {
-  CMixCoderSeqInStream *p = (CMixCoderSeqInStream *)pp;
-  SRes res = SZ_OK;
-  size_t remSize = *size;
-  *size = 0;
-  while (remSize > 0)
+  if (p->buf)
  {
-    if (p->bufPos == p->bufSize)
-    {
-      size_t curSize;
-      p->bufPos = p->bufSize = 0;
-      if (*size != 0)
-        break;
-      curSize = FILT_BUF_SIZE;
-      RINOK(p->realStream->Read(p->realStream, p->buf, &curSize));
-      p->bufSize = (UInt32)curSize;
-    }
-    {
-      SizeT destLen = remSize;
-      SizeT srcLen = p->bufSize - p->bufPos;
-      res = MixCoder_Code(&p->mixCoder, data, &destLen, p->buf + p->bufPos, &srcLen, 0);
-      data = (void *)((Byte *)data + destLen);
-      remSize -= destLen;
-      *size += destLen;
-      p->bufPos += srcLen;
-    }
+    g_Alloc.Free(&g_Alloc, p->buf);
+    p->buf = NULL;
  }
-  return res;
 }
-*/
+
+SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAlloc *alloc);
+
+static SRes SeqInFilter_Init(CSeqInFilter *p, const CXzFilter *props)
+{
+  if (!p->buf)
+  {
+    p->buf = g_Alloc.Alloc(&g_Alloc, FILTER_BUF_SIZE);
+    if (!p->buf)
+      return SZ_ERROR_MEM;
+  }
+  p->curPos = p->endPos = 0;
+  p->srcWasFinished = 0;
+  RINOK(BraState_SetFromMethod(&p->StateCoder, props->id, 1, &g_Alloc));
+  RINOK(p->StateCoder.SetProps(p->StateCoder.p, props->props, props->propsSize, &g_Alloc));
+  p->StateCoder.Init(p->StateCoder.p);
+  return S_OK;
+}
+
+/* ---------- CSbEncInStream ---------- */

 #ifdef USE_SUBBLOCK
+
 typedef struct
 {
  ISeqInStream p;
-  CSubblockEnc sb;
-  UInt64 processed;
+  ISeqInStream *inStream;
+  CSbEnc enc;
 } CSbEncInStream;

-void SbEncInStream_Init(CSbEncInStream *p)
-{
-  p->processed = 0;
-  SubblockEnc_Init(&p->sb);
-}
-
 static SRes SbEncInStream_Read(void *pp, void *data, size_t *size)
 {
  CSbEncInStream *p = (CSbEncInStream *)pp;
-  SRes res = SubblockEnc_Read(&p->sb, data, size);
-  p->processed += *size;
-  return res;
+  size_t sizeOriginal = *size;
+  if (sizeOriginal == 0)
+    return S_OK;
+  for (;;)
+  {
+    if (p->enc.needRead && !p->enc.readWasFinished)
+    {
+      size_t processed = p->enc.needReadSizeMax;
+      RINOK(p->inStream->Read(p->inStream, p->enc.buf + p->enc.readPos, &processed));
+      p->enc.readPos += processed;
+      if (processed == 0)
+      {
+        p->enc.readWasFinished = True;
+        p->enc.isFinalFinished = True;
+      }
+      p->enc.needRead = False;
+    }
+    *size = sizeOriginal;
+    RINOK(SbEnc_Read(&p->enc, data, size));
+    if (*size != 0 || !p->enc.needRead)
+      return S_OK;
+  }
 }
+
+void SbEncInStream_Construct(CSbEncInStream *p, ISzAlloc *alloc)
+{
+  SbEnc_Construct(&p->enc, alloc);
+  p->p.Read = SbEncInStream_Read;
+}
+
+SRes SbEncInStream_Init(CSbEncInStream *p)
+{
+  return SbEnc_Init(&p->enc);
+}
+
+void SbEncInStream_Free(CSbEncInStream *p)
+{
+  SbEnc_Free(&p->enc);
+}
+
 #endif

+
 typedef struct
 {
-  /* CMixCoderSeqInStream inStream; */
  CLzma2EncHandle lzma2;
  #ifdef USE_SUBBLOCK
  CSbEncInStream sb;
  #endif
+  CSeqInFilter filter;
  ISzAlloc *alloc;
  ISzAlloc *bigAlloc;
 } CLzma2WithFilters;
@@ -361,9 +352,9 @@ static void Lzma2WithFilters_Construct(CLzma2WithFilters *p, ISzAlloc *alloc, IS
  p->bigAlloc = bigAlloc;
  p->lzma2 = NULL;
  #ifdef USE_SUBBLOCK
-  p->sb.p.Read = SbEncInStream_Read;
-  SubblockEnc_Construct(&p->sb.sb, p->alloc);
+  SbEncInStream_Construct(&p->sb, alloc);
  #endif
+  SeqInFilter_Construct(&p->filter);
 }

 static SRes Lzma2WithFilters_Create(CLzma2WithFilters *p)
@@ -376,8 +367,9 @@ static SRes Lzma2WithFilters_Create(CLzma2WithFilters *p)

 static void Lzma2WithFilters_Free(CLzma2WithFilters *p)
 {
+  SeqInFilter_Free(&p->filter);
  #ifdef USE_SUBBLOCK
-  SubblockEnc_Free(&p->sb.sb);
+  SbEncInStream_Free(&p->sb);
  #endif
  if (p->lzma2)
  {
@@ -386,17 +378,28 @@ static void Lzma2WithFilters_Free(CLzma2WithFilters *p)
  }
 }

-static SRes Xz_Compress(CXzStream *xz,
-    CLzma2WithFilters *lzmaf,
-    ISeqOutStream *outStream,
-    ISeqInStream *inStream,
-    const CLzma2EncProps *lzma2Props,
-    Bool useSubblock,
-    ICompressProgress *progress)
+void XzProps_Init(CXzProps *p)
 {
-  xz->flags = XZ_CHECK_CRC32;
+  p->lzma2Props = 0;
+  p->filterProps = 0;
+  p->checkId = XZ_CHECK_CRC32;
+}

-  RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, lzma2Props));
+void XzFilterProps_Init(CXzFilterProps *p)
+{
+  p->id = 0;
+  p->delta = 0;
+  p->ip= 0;
+  p->ipDefined = False;
+}
+
+static SRes Xz_Compress(CXzStream *xz, CLzma2WithFilters *lzmaf,
+    ISeqOutStream *outStream, ISeqInStream *inStream,
+    const CXzProps *props, ICompressProgress *progress)
+{
+  xz->flags = (Byte)props->checkId;
+
+  RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, props->lzma2Props));
  RINOK(Xz_WriteHeader(xz->flags, outStream));

  {
@@ -404,15 +407,27 @@ static SRes Xz_Compress(CXzStream *xz,
    CSeqSizeOutStream seqSizeOutStream;
    CXzBlock block;
    int filterIndex = 0;
+    CXzFilter *filter = NULL;
+    const CXzFilterProps *fp = props->filterProps;
    
    XzBlock_ClearFlags(&block);
-    XzBlock_SetNumFilters(&block, 1 + (useSubblock ? 1 : 0));
+    XzBlock_SetNumFilters(&block, 1 + (fp ? 1 : 0));
    
-    if (useSubblock)
+    if (fp)
    {
-      CXzFilter *f = &block.filters[filterIndex++];
-      f->id = XZ_ID_Subblock;
-      f->propsSize = 0;
+      filter = &block.filters[filterIndex++];
+      filter->id = fp->id;
+      filter->propsSize = 0;
+      if (fp->id == XZ_ID_Delta)
+      {
+        filter->props[0] = (Byte)(fp->delta - 1);
+        filter->propsSize = 1;
+      }
+      else if (fp->ipDefined)
+      {
+        SetUi32(filter->props, fp->ip);
+        filter->propsSize = 4;
+      }
    }

    {
@@ -432,20 +447,30 @@ static SRes Xz_Compress(CXzStream *xz,
    checkInStream.realStream = inStream;
    SeqCheckInStream_Init(&checkInStream, XzFlags_GetCheckType(xz->flags));
    
-    #ifdef USE_SUBBLOCK
-    if (useSubblock)
+    if (fp)
    {
-      lzmaf->sb.sb.inStream = &checkInStream.p;
-      SubblockEnc_Init(&lzmaf->sb.sb);
+      #ifdef USE_SUBBLOCK
+      if (fp->id == XZ_ID_Subblock)
+      {
+        lzmaf->sb.inStream = &checkInStream.p;
+        RINOK(SbEncInStream_Init(&lzmaf->sb));
+      }
+      else
+      #endif
+      {
+        lzmaf->filter.realStream = &checkInStream.p;
+        RINOK(SeqInFilter_Init(&lzmaf->filter, filter));
+      }
    }
-    #endif
-    
+
    {
      UInt64 packPos = seqSizeOutStream.processed;
      SRes res = Lzma2Enc_Encode(lzmaf->lzma2, &seqSizeOutStream.p,
+        fp ?
        #ifdef USE_SUBBLOCK
-        useSubblock ? &lzmaf->sb.p:
+        (fp->id == XZ_ID_Subblock) ? &lzmaf->sb.p:
        #endif
+        &lzmaf->filter.p:
        &checkInStream.p,
        progress);
      RINOK(res);
@@ -467,8 +492,7 @@ static SRes Xz_Compress(CXzStream *xz,
 }

 SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,
-    const CLzma2EncProps *lzma2Props, Bool useSubblock,
-    ICompressProgress *progress)
+    const CXzProps *props, ICompressProgress *progress)
 {
  SRes res;
  CXzStream xz;
@@ -477,8 +501,7 @@ SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,
  Lzma2WithFilters_Construct(&lzmaf, &g_Alloc, &g_BigAlloc);
  res = Lzma2WithFilters_Create(&lzmaf);
  if (res == SZ_OK)
-    res = Xz_Compress(&xz, &lzmaf, outStream, inStream,
-        lzma2Props, useSubblock, progress);
+    res = Xz_Compress(&xz, &lzmaf, outStream, inStream, props, progress);
  Lzma2WithFilters_Free(&lzmaf);
  Xz_Free(&xz, &g_Alloc);
  return res;
--- a/C/XzEnc.h
+++ b/C/XzEnc.h
@@ -1,5 +1,5 @@
 /* XzEnc.h -- Xz Encode
-2009-04-15 : Igor Pavlov : Public domain */
+2011-02-07 : Igor Pavlov : Public domain */

 #ifndef __XZ_ENC_H
 #define __XZ_ENC_H
@@ -8,18 +8,32 @@

 #include "Xz.h"

-#ifdef __cplusplus
-extern "C" {
-#endif
+EXTERN_C_BEGIN
+
+typedef struct
+{
+  UInt32 id;
+  UInt32 delta;
+  UInt32 ip;
+  int ipDefined;
+} CXzFilterProps;
+
+void XzFilterProps_Init(CXzFilterProps *p);
+
+typedef struct
+{
+  const CLzma2EncProps *lzma2Props;
+  const CXzFilterProps *filterProps;
+  unsigned checkId;
+} CXzProps;
+
+void XzProps_Init(CXzProps *p);

 SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,
-    const CLzma2EncProps *lzma2Props, Bool useSubblock,
-    ICompressProgress *progress);
+    const CXzProps *props, ICompressProgress *progress);

 SRes Xz_EncodeEmpty(ISeqOutStream *outStream);

-#ifdef __cplusplus
-}
-#endif
+EXTERN_C_END

 #endif
--- a/C/XzIn.c
+++ b/C/XzIn.c
@@ -1,5 +1,5 @@
 /* XzIn.c - Xz input
-2009-06-19 : Igor Pavlov : Public domain */
+2011-02-01 : Igor Pavlov : Public domain */

 #include <string.h>

@@ -152,39 +152,38 @@ static SRes Xz_ReadBackward(CXzStream *p, ILookInStream *stream, Int64 *startOff
  
  if (memcmp(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) != 0)
  {
-    Int64 i = 0;
+    UInt32 total = 0;
    *startOffset += XZ_STREAM_FOOTER_SIZE;
    for (;;)
    {
-      int j;
-      size_t processedSize;
+      size_t i;
      #define TEMP_BUF_SIZE (1 << 10)
      Byte tempBuf[TEMP_BUF_SIZE];
-      if (*startOffset < XZ_STREAM_FOOTER_SIZE || i > (1 << 16))
+      if (*startOffset < XZ_STREAM_FOOTER_SIZE || total > (1 << 16))
        return SZ_ERROR_NO_ARCHIVE;
-      processedSize = (*startOffset > TEMP_BUF_SIZE) ? TEMP_BUF_SIZE : (size_t)*startOffset;
-      i += processedSize;
-      *startOffset = -(Int64)processedSize;
+      i = (*startOffset > TEMP_BUF_SIZE) ? TEMP_BUF_SIZE : (size_t)*startOffset;
+      total += (UInt32)i;
+      *startOffset = -(Int64)i;
      RINOK(SeekFromCur(stream, startOffset));
-      RINOK(LookInStream_Read2(stream, tempBuf, processedSize, SZ_ERROR_NO_ARCHIVE));
-      for (j = (int)processedSize; j >= 0; j--)
-        if (tempBuf[j -1] != 0)
+      RINOK(LookInStream_Read2(stream, tempBuf, i, SZ_ERROR_NO_ARCHIVE));
+      for (; i != 0; i--)
+        if (tempBuf[i - 1] != 0)
          break;
-      if (j != 0)
+      if (i != 0)
      {
-        if ((j & 3) != 0)
-          return SZ_ERROR_NO_ARCHIVE;
-        *startOffset += j;
-        if (*startOffset < XZ_STREAM_FOOTER_SIZE)
-          return SZ_ERROR_NO_ARCHIVE;
-        *startOffset -= XZ_STREAM_FOOTER_SIZE;
-        RINOK(stream->Seek(stream, startOffset, SZ_SEEK_SET));
-        RINOK(LookInStream_Read2(stream, buf, XZ_STREAM_FOOTER_SIZE, SZ_ERROR_NO_ARCHIVE));
-        if (memcmp(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) != 0)
+        if ((i & 3) != 0)
          return SZ_ERROR_NO_ARCHIVE;
+        *startOffset += i;
        break;
      }
    }
+    if (*startOffset < XZ_STREAM_FOOTER_SIZE)
+      return SZ_ERROR_NO_ARCHIVE;
+    *startOffset -= XZ_STREAM_FOOTER_SIZE;
+    RINOK(stream->Seek(stream, startOffset, SZ_SEEK_SET));
+    RINOK(LookInStream_Read2(stream, buf, XZ_STREAM_FOOTER_SIZE, SZ_ERROR_NO_ARCHIVE));
+    if (memcmp(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) != 0)
+      return SZ_ERROR_NO_ARCHIVE;
  }
  
  p->flags = (CXzStreamFlags)GetBe16(buf + 8);
--- a/CPP/7zip/Archive/7z/7zCompressionMode.h
+++ b/CPP/7zip/Archive/7z/7zCompressionMode.h
@@ -3,19 +3,18 @@
 #ifndef __7Z_COMPRESSION_MODE_H
 #define __7Z_COMPRESSION_MODE_H

-#include "../../../Common/MyString.h"
-
-#include "../../../Windows/PropVariant.h"
-
+#include "../../Common/MethodId.h"
 #include "../../Common/MethodProps.h"

 namespace NArchive {
 namespace N7z {

-struct CMethodFull: public CMethod
+struct CMethodFull: public CProps
 {
+  CMethodId Id;
  UInt32 NumInStreams;
  UInt32 NumOutStreams;
+
  bool IsSimpleCoder() const { return (NumInStreams == 1) && (NumOutStreams == 1); }
 };

--- a/CPP/7zip/Archive/7z/7zEncode.cpp
+++ b/CPP/7zip/Archive/7z/7zEncode.cpp
@@ -49,6 +49,15 @@ static void ConvertBindInfoToFolderItemInfo(const NCoderMixer::CBindInfo &bindIn
    folder.PackStreams.Add(bindInfo.InStreams[i]);
 }

+static HRESULT SetCoderProps2(const CProps &props, const UInt64 *dataSizeReduce, IUnknown *coder)
+{
+  CMyComPtr<ICompressSetCoderProperties> setCoderProperties;
+  coder->QueryInterface(IID_ICompressSetCoderProperties, (void **)&setCoderProperties);
+  if (setCoderProperties)
+    return props.SetCoderProps(setCoderProperties, dataSizeReduce);
+  return props.AreThereNonOptionalProps() ? E_INVALIDARG : S_OK;
+}
+
 HRESULT CEncoder::CreateMixerCoder(
    DECL_EXTERNAL_CODECS_LOC_VARS
    const UInt64 *inSizeForReduce)
@@ -86,8 +95,7 @@ HRESULT CEncoder::CreateMixerCoder(
    }
    #endif
        
-
-    RINOK(SetMethodProperties(methodFull, inSizeForReduce, encoderCommon));
+    RINOK(SetCoderProps2(methodFull, inSizeForReduce, encoderCommon));

    /*
    CMyComPtr<ICryptoResetSalt> resetSalt;
@@ -193,11 +201,9 @@ HRESULT CEncoder::Encode(
  // UInt64 outStreamStartPos;
  // RINOK(stream->Seek(0, STREAM_SEEK_CUR, &outStreamStartPos));
  
-  CSequentialInStreamSizeCount2 *inStreamSizeCountSpec =
-      new CSequentialInStreamSizeCount2;
+  CSequentialInStreamSizeCount2 *inStreamSizeCountSpec = new CSequentialInStreamSizeCount2;
  CMyComPtr<ISequentialInStream> inStreamSizeCount = inStreamSizeCountSpec;
-  CSequentialOutStreamSizeCount *outStreamSizeCountSpec =
-      new CSequentialOutStreamSizeCount;
+  CSequentialOutStreamSizeCount *outStreamSizeCountSpec = new CSequentialOutStreamSizeCount;
  CMyComPtr<ISequentialOutStream> outStreamSizeCount = outStreamSizeCountSpec;

  inStreamSizeCountSpec->Init(inStream);
@@ -226,13 +232,11 @@ HRESULT CEncoder::Encode(
    _mixerCoderSpec->_coders[i].QueryInterface(IID_ICompressWriteCoderProperties, (void **)&writeCoderProperties);
    if (writeCoderProperties != NULL)
    {
-      CSequentialOutStreamImp *outStreamSpec = new CSequentialOutStreamImp;
+      CDynBufSeqOutStream *outStreamSpec = new CDynBufSeqOutStream;
      CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
      outStreamSpec->Init();
      writeCoderProperties->WriteCoderProperties(outStream);
-      size_t size = outStreamSpec->GetSize();
-      encodingInfo.Props.SetCapacity(size);
-      memmove(encodingInfo.Props, outStreamSpec->GetBuffer(), size);
+      outStreamSpec->CopyToBuffer(encodingInfo.Props);
    }
  }

@@ -250,8 +254,7 @@ HRESULT CEncoder::Encode(
  RINOK(_mixerCoder->Code(&inStreamPointers.Front(), NULL, 1,
    &outStreamPointers.Front(), NULL, outStreamPointers.Size(), compressProgress));
  
-  ConvertBindInfoToFolderItemInfo(_decompressBindInfo, _decompressionMethods,
-      folderItem);
+  ConvertBindInfoToFolderItemInfo(_decompressBindInfo, _decompressionMethods, folderItem);
  
  packSizes.Add(outStreamSizeCountSpec->GetSize());
  
--- a/CPP/7zip/Archive/7z/7zHandler.cpp
+++ b/CPP/7zip/Archive/7z/7zHandler.cpp
@@ -24,25 +24,20 @@

 using namespace NWindows;

-extern UString ConvertMethodIdToString(UInt64 id);
-
 namespace NArchive {
 namespace N7z {

 CHandler::CHandler()
 {
-  _crcSize = 4;
-
  #ifndef _NO_CRYPTO
  _passwordIsDefined = false;
  #endif

  #ifdef EXTRACT_ONLY
+  _crcSize = 4;
  #ifdef __7Z_SET_PROPERTIES
  _numThreads = NSystem::GetNumberOfProcessors();
  #endif
-  #else
-  Init();
  #endif
 }

@@ -70,7 +65,7 @@ STDMETHODIMP CHandler::GetPropertyInfo(UInt32 /* index */,

 #else

-STATPROPSTG kArcProps[] =
+static const STATPROPSTG kArcProps[] =
 {
  { NULL, kpidMethod, VT_BSTR},
  { NULL, kpidSolid, VT_BOOL},
@@ -80,6 +75,25 @@ STATPROPSTG kArcProps[] =
  { NULL, kpidOffset, VT_UI8}
 };

+static inline wchar_t GetHex(Byte value)
+{
+  return (wchar_t)((value < 10) ? ('0' + value) : ('A' + (value - 10)));
+}
+
+static UString ConvertMethodIdToString(UInt64 id)
+{
+  wchar_t s[32];
+  int len = 32;
+  s[--len] = 0;
+  do
+  {
+    s[--len] = GetHex((Byte)id & 0xF); id >>= 4;
+    s[--len] = GetHex((Byte)id & 0xF); id >>= 4;
+  }
+  while (id != 0);
+  return s + len;
+}
+
 STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
 {
  COM_TRY_BEGIN
@@ -172,22 +186,18 @@ static UString GetStringForSizeValue(UInt32 value)
  return result;
 }

-static const UInt64 k_Copy = 0x0;
-static const UInt64 k_Delta = 3;
-static const UInt64 k_LZMA2 = 0x21;
-static const UInt64 k_LZMA  = 0x030101;
-static const UInt64 k_PPMD  = 0x030401;
-
-static wchar_t GetHex(Byte value)
-{
-  return (wchar_t)((value < 10) ? (L'0' + value) : (L'A' + (value - 10)));
-}
 static inline void AddHexToString(UString &res, Byte value)
 {
  res += GetHex((Byte)(value >> 4));
  res += GetHex((Byte)(value & 0xF));
 }

+static void AddProp32(UString &s, const wchar_t *name, UInt32 v)
+{
+  s += name;
+  s += ConvertUInt32ToString(v);
+}
+ 
 #endif

 bool CHandler::IsEncrypted(UInt32 index2) const
@@ -283,6 +293,14 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID,  PROPVARIANT *va
              {
                UInt32 dicSize = GetUi32((const Byte *)coder.Props + 1);
                propsString = GetStringForSizeValue(dicSize);
+                UInt32 d = coder.Props[0];
+                UInt32 lc = d % 9;
+                d /= 9;
+                UInt32 pb = d / 5;
+                UInt32 lp = d % 5;
+                if (lc != 3) AddProp32(propsString, L":lc", lc);
+                if (lp != 0) AddProp32(propsString, L":lp", lp);
+                if (pb != 2) AddProp32(propsString, L":pb", pb);
              }
              else if (coder.MethodID == k_LZMA2 && coder.Props.GetCapacity() == 1)
              {
--- a/CPP/7zip/Archive/7z/7zHandler.h
+++ b/CPP/7zip/Archive/7z/7zHandler.h
@@ -18,6 +18,16 @@
 namespace NArchive {
 namespace N7z {

+const UInt32 k_Copy = 0x0;
+const UInt32 k_Delta = 3;
+const UInt32 k_LZMA2 = 0x21;
+const UInt32 k_LZMA  = 0x030101;
+const UInt32 k_PPMD  = 0x030401;
+const UInt32 k_BCJ  = 0x03030103;
+const UInt32 k_BCJ2 = 0x0303011B;
+const UInt32 k_Deflate = 0x040108;
+const UInt32 k_BZip2   = 0x040202;
+
 #ifndef __7Z_SET_PROPERTIES

 #ifdef EXTRACT_ONLY
@@ -31,9 +41,52 @@ namespace N7z {
 #endif


+#ifndef EXTRACT_ONLY
+
+class COutHandler: public CMultiMethodProps
+{
+  HRESULT SetSolidFromString(const UString &s);
+  HRESULT SetSolidFromPROPVARIANT(const PROPVARIANT &value);
+public:
+  bool _removeSfxBlock;
+  
+  UInt64 _numSolidFiles;
+  UInt64 _numSolidBytes;
+  bool _numSolidBytesDefined;
+  bool _solidExtension;
+
+  bool _compressHeaders;
+  bool _encryptHeadersSpecified;
+  bool _encryptHeaders;
+
+  bool WriteCTime;
+  bool WriteATime;
+  bool WriteMTime;
+
+  bool _volumeMode;
+
+  void InitSolidFiles() { _numSolidFiles = (UInt64)(Int64)(-1); }
+  void InitSolidSize()  { _numSolidBytes = (UInt64)(Int64)(-1); }
+  void InitSolid()
+  {
+    InitSolidFiles();
+    InitSolidSize();
+    _solidExtension = false;
+    _numSolidBytesDefined = false;
+  }
+
+  void InitProps();
+
+  COutHandler() { InitProps(); }
+
+  HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
+};
+
+#endif
+
 class CHandler:
  #ifndef EXTRACT_ONLY
-  public NArchive::COutHandler,
+  public COutHandler,
  #endif
  public IInArchive,
  #ifdef __7Z_SET_PROPERTIES
@@ -90,16 +143,16 @@ private:
  
  CRecordVector<CBind> _binds;

-  HRESULT SetCompressionMethod(CCompressionMethodMode &method,
+  HRESULT PropsMethod_To_FullMethod(CMethodFull &dest, const COneMethodInfo &m);
+  HRESULT SetHeaderMethod(CCompressionMethodMode &headerMethod);
+  void AddDefaultMethod();
+  HRESULT SetMainMethod(CCompressionMethodMode &method,
      CObjectVector<COneMethodInfo> &methodsInfo
      #ifndef _7ZIP_ST
      , UInt32 numThreads
      #endif
      );

-  HRESULT SetCompressionMethod(
-      CCompressionMethodMode &method,
-      CCompressionMethodMode &headerMethod);

  #endif

--- a/CPP/7zip/Archive/7z/7zHandlerOut.cpp
+++ b/CPP/7zip/Archive/7z/7zHandlerOut.cpp
@@ -2,13 +2,9 @@

 #include "StdAfx.h"

-#include "../../../Windows/PropVariant.h"
-
 #include "../../../Common/ComTry.h"
 #include "../../../Common/StringToInt.h"

-#include "../../ICoder.h"
-
 #include "../Common/ItemNameUtils.h"
 #include "../Common/ParseProperties.h"

@@ -21,24 +17,19 @@ using namespace NWindows;
 namespace NArchive {
 namespace N7z {

-static const wchar_t *kLZMAMethodName = L"LZMA";
-static const wchar_t *kCopyMethod = L"Copy";
-static const wchar_t *kDefaultMethodName = kLZMAMethodName;
+static const wchar_t *k_LZMA_Name = L"LZMA";
+static const wchar_t *kDefaultMethodName = k_LZMA_Name;
+static const wchar_t *k_Copy_Name = L"Copy";

-static const UInt32 kLzmaAlgorithmX5 = 1;
-static const wchar_t *kLzmaMatchFinderForHeaders = L"BT2";
-static const UInt32 kDictionaryForHeaders =
+static const wchar_t *k_MatchFinder_ForHeaders = L"BT2";
+static const UInt32 k_NumFastBytes_ForHeaders = 273;
+static const UInt32 k_Level_ForHeaders = 5;
+static const UInt32 k_Dictionary_ForHeaders =
  #ifdef UNDER_CE
-  1 << 18
+  1 << 18;
  #else
-  1 << 20
+  1 << 20;
  #endif
-;
-static const UInt32 kNumFastBytesForHeaders = 273;
-static const UInt32 kAlgorithmForHeaders = kLzmaAlgorithmX5;
-
-static inline bool IsCopyMethod(const UString &methodName)
-  { return (methodName.CompareNoCase(kCopyMethod) == 0); }

 STDMETHODIMP CHandler::GetFileTimeType(UInt32 *type)
 {
@@ -46,123 +37,105 @@ STDMETHODIMP CHandler::GetFileTimeType(UInt32 *type)
  return S_OK;
 }

-HRESULT CHandler::SetCompressionMethod(
-    CCompressionMethodMode &methodMode,
-    CCompressionMethodMode &headerMethod)
+HRESULT CHandler::PropsMethod_To_FullMethod(CMethodFull &dest, const COneMethodInfo &m)
 {
-  HRESULT res = SetCompressionMethod(methodMode, _methods
-  #ifndef _7ZIP_ST
-  , _numThreads
-  #endif
-  );
-  RINOK(res);
-  methodMode.Binds = _binds;
-
-  if (_compressHeaders)
-  {
-    // headerMethod.Methods.Add(methodMode.Methods.Back());
-
-    CObjectVector<COneMethodInfo> headerMethodInfoVector;
-    COneMethodInfo oneMethodInfo;
-    oneMethodInfo.MethodName = kLZMAMethodName;
-    {
-      CProp prop;
-      prop.Id = NCoderPropID::kMatchFinder;
-      prop.Value = kLzmaMatchFinderForHeaders;
-      oneMethodInfo.Props.Add(prop);
-    }
-    {
-      CProp prop;
-      prop.Id = NCoderPropID::kAlgorithm;
-      prop.Value = kAlgorithmForHeaders;
-      oneMethodInfo.Props.Add(prop);
-    }
-    {
-      CProp prop;
-      prop.Id = NCoderPropID::kNumFastBytes;
-      prop.Value = (UInt32)kNumFastBytesForHeaders;
-      oneMethodInfo.Props.Add(prop);
-    }
-    {
-      CProp prop;
-      prop.Id = NCoderPropID::kDictionarySize;
-      prop.Value = (UInt32)kDictionaryForHeaders;
-      oneMethodInfo.Props.Add(prop);
-    }
-    headerMethodInfoVector.Add(oneMethodInfo);
-    HRESULT res = SetCompressionMethod(headerMethod, headerMethodInfoVector
-      #ifndef _7ZIP_ST
-      , 1
-      #endif
-    );
-    RINOK(res);
-  }
+  if (!FindMethod(
+      EXTERNAL_CODECS_VARS
+      m.MethodName, dest.Id, dest.NumInStreams, dest.NumOutStreams))
+    return E_INVALIDARG;
+  (CProps &)dest = (CProps &)m;
  return S_OK;
 }

-HRESULT CHandler::SetCompressionMethod(
+HRESULT CHandler::SetHeaderMethod(CCompressionMethodMode &headerMethod)
+{
+  if (!_compressHeaders)
+    return S_OK;
+  COneMethodInfo m;
+  m.MethodName = k_LZMA_Name;
+  m.AddPropString(NCoderPropID::kMatchFinder, k_MatchFinder_ForHeaders);
+  m.AddProp32(NCoderPropID::kLevel, k_Level_ForHeaders);
+  m.AddProp32(NCoderPropID::kNumFastBytes, k_NumFastBytes_ForHeaders);
+  m.AddProp32(NCoderPropID::kDictionarySize, k_Dictionary_ForHeaders);
+  m.AddNumThreadsProp(1);
+
+  CMethodFull methodFull;
+  RINOK(PropsMethod_To_FullMethod(methodFull, m));
+  headerMethod.Methods.Add(methodFull);
+  return S_OK;
+}
+
+void CHandler::AddDefaultMethod()
+{
+  for (int i = 0; i < _methods.Size(); i++)
+  {
+    UString &methodName = _methods[0].MethodName;
+    if (methodName.IsEmpty())
+      methodName = kDefaultMethodName;
+  }
+  if (_methods.IsEmpty())
+  {
+    COneMethodInfo m;
+    m.MethodName = (GetLevel() == 0 ? k_Copy_Name : kDefaultMethodName);
+    _methods.Add(m);
+  }
+}
+
+HRESULT CHandler::SetMainMethod(
    CCompressionMethodMode &methodMode,
-    CObjectVector<COneMethodInfo> &methodsInfo
+    CObjectVector<COneMethodInfo> &methods
    #ifndef _7ZIP_ST
    , UInt32 numThreads
    #endif
    )
 {
-  UInt32 level = _level;
-  
-  if (methodsInfo.IsEmpty())
-  {
-    COneMethodInfo oneMethodInfo;
-    oneMethodInfo.MethodName = ((level == 0) ? kCopyMethod : kDefaultMethodName);
-    methodsInfo.Add(oneMethodInfo);
-  }
+  AddDefaultMethod();
+
+  const UInt64 kSolidBytes_Min = (1 << 24);
+  const UInt64 kSolidBytes_Max = ((UInt64)1 << 32) - 1;

  bool needSolid = false;
-  for(int i = 0; i < methodsInfo.Size(); i++)
+  for (int i = 0; i < methods.Size(); i++)
  {
-    COneMethodInfo &oneMethodInfo = methodsInfo[i];
-    SetCompressionMethod2(oneMethodInfo
+    COneMethodInfo &oneMethodInfo = methods[i];
+    SetGlobalLevelAndThreads(oneMethodInfo
      #ifndef _7ZIP_ST
      , numThreads
      #endif
      );

-    if (!IsCopyMethod(oneMethodInfo.MethodName))
-      needSolid = true;
-
    CMethodFull methodFull;
-
-    if (!FindMethod(
-        EXTERNAL_CODECS_VARS
-        oneMethodInfo.MethodName, methodFull.Id, methodFull.NumInStreams, methodFull.NumOutStreams))
-      return E_INVALIDARG;
-    methodFull.Props = oneMethodInfo.Props;
+    RINOK(PropsMethod_To_FullMethod(methodFull, oneMethodInfo));
    methodMode.Methods.Add(methodFull);

-    if (!_numSolidBytesDefined)
+    if (methodFull.Id != k_Copy)
+      needSolid = true;
+
+    if (_numSolidBytesDefined)
+      continue;
+
+    UInt32 dicSize;
+    switch (methodFull.Id)
    {
-      for (int j = 0; j < methodFull.Props.Size(); j++)
-      {
-        const CProp &prop = methodFull.Props[j];
-        if ((prop.Id == NCoderPropID::kDictionarySize ||
-             prop.Id == NCoderPropID::kUsedMemorySize) && prop.Value.vt == VT_UI4)
-        {
-          _numSolidBytes = ((UInt64)prop.Value.ulVal) << 7;
-          const UInt64 kMinSize = (1 << 24);
-          if (_numSolidBytes < kMinSize)
-            _numSolidBytes = kMinSize;
-          _numSolidBytesDefined = true;
-          break;
-        }
-      }
+      case k_LZMA:
+      case k_LZMA2: dicSize = oneMethodInfo.Get_Lzma_DicSize(); break;
+      case k_PPMD: dicSize = oneMethodInfo.Get_Ppmd_MemSize(); break;
+      case k_Deflate: dicSize = (UInt32)1 << 15; break;
+      case k_BZip2: dicSize = oneMethodInfo.Get_BZip2_BlockSize(); break;
+      default: continue;
    }
+    _numSolidBytes = (UInt64)dicSize << 7;
+    if (_numSolidBytes < kSolidBytes_Min) _numSolidBytes = kSolidBytes_Min;
+    if (_numSolidBytes > kSolidBytes_Max) _numSolidBytes = kSolidBytes_Max;
+    _numSolidBytesDefined = true;
  }

-  if (!needSolid && !_numSolidBytesDefined)
-  {
-    _numSolidBytesDefined = true;
-    _numSolidBytes  = 0;
-  }
+  if (!_numSolidBytesDefined)
+    if (needSolid)
+      _numSolidBytes = kSolidBytes_Max;
+    else
+      _numSolidBytes = 0;
+  _numSolidBytesDefined = true;
  return S_OK;
 }

@@ -326,7 +299,16 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
  }

  CCompressionMethodMode methodMode, headerMethod;
-  RINOK(SetCompressionMethod(methodMode, headerMethod));
+
+  HRESULT res = SetMainMethod(methodMode, _methods
+    #ifndef _7ZIP_ST
+    , _numThreads
+    #endif
+    );
+  RINOK(res);
+  methodMode.Binds = _binds;
+
+  RINOK(SetHeaderMethod(headerMethod));
  #ifndef _7ZIP_ST
  methodMode.NumThreads = _numThreads;
  headerMethod.NumThreads = 1;
@@ -373,8 +355,9 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
  CUpdateOptions options;
  options.Method = &methodMode;
  options.HeaderMethod = (_compressHeaders || encryptHeaders) ? &headerMethod : 0;
-  options.UseFilters = _level != 0 && _autoFilter;
-  options.MaxFilter = _level >= 8;
+  int level = GetLevel();
+  options.UseFilters = level != 0 && _autoFilter;
+  options.MaxFilter = level >= 8;

  options.HeaderOptions.CompressMainHeader = compressMainHeader;
  options.HeaderOptions.WriteCTime = WriteCTime;
@@ -393,7 +376,7 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
  CMyComPtr<ICryptoGetTextPassword> getPassword;
  updateCallback->QueryInterface(IID_ICryptoGetTextPassword, (void **)&getPassword);
  
-  HRESULT res = Update(
+  res = Update(
      EXTERNAL_CODECS_VARS
      #ifdef _7Z_VOL
      volume ? volume->Stream: 0,
@@ -437,25 +420,138 @@ static HRESULT GetBindInfoPart(UString &srcString, UInt32 &coder, UInt32 &stream
  return S_OK;
 }

-static HRESULT GetBindInfo(UString &srcString, CBind &bind)
+void COutHandler::InitProps()
 {
-  RINOK(GetBindInfoPart(srcString, bind.OutCoder, bind.OutStream));
-  if (srcString[0] != ':')
-    return E_INVALIDARG;
-  srcString.Delete(0);
-  RINOK(GetBindInfoPart(srcString, bind.InCoder, bind.InStream));
-  if (!srcString.IsEmpty())
-    return E_INVALIDARG;
+  CMultiMethodProps::Init();
+
+  _removeSfxBlock = false;
+  _compressHeaders = true;
+  _encryptHeadersSpecified = false;
+  _encryptHeaders = false;
+  
+  WriteCTime = false;
+  WriteATime = false;
+  WriteMTime = true;
+  
+  _volumeMode = false;
+  InitSolid();
+}
+
+HRESULT COutHandler::SetSolidFromString(const UString &s)
+{
+  UString s2 = s;
+  s2.MakeUpper();
+  for (int i = 0; i < s2.Length();)
+  {
+    const wchar_t *start = ((const wchar_t *)s2) + i;
+    const wchar_t *end;
+    UInt64 v = ConvertStringToUInt64(start, &end);
+    if (start == end)
+    {
+      if (s2[i++] != 'E')
+        return E_INVALIDARG;
+      _solidExtension = true;
+      continue;
+    }
+    i += (int)(end - start);
+    if (i == s2.Length())
+      return E_INVALIDARG;
+    wchar_t c = s2[i++];
+    if (c == 'F')
+    {
+      if (v < 1)
+        v = 1;
+      _numSolidFiles = v;
+    }
+    else
+    {
+      unsigned numBits;
+      switch (c)
+      {
+        case 'B': numBits =  0; break;
+        case 'K': numBits = 10; break;
+        case 'M': numBits = 20; break;
+        case 'G': numBits = 30; break;
+        default: return E_INVALIDARG;
+      }
+      _numSolidBytes = (v << numBits);
+      _numSolidBytesDefined = true;
+    }
+  }
  return S_OK;
 }

-STDMETHODIMP CHandler::SetProperties(const wchar_t **names, const PROPVARIANT *values, Int32 numProperties)
+HRESULT COutHandler::SetSolidFromPROPVARIANT(const PROPVARIANT &value)
+{
+  bool isSolid;
+  switch (value.vt)
+  {
+    case VT_EMPTY: isSolid = true; break;
+    case VT_BOOL: isSolid = (value.boolVal != VARIANT_FALSE); break;
+    case VT_BSTR:
+      if (StringToBool(value.bstrVal, isSolid))
+        break;
+      return SetSolidFromString(value.bstrVal);
+    default: return E_INVALIDARG;
+  }
+  if (isSolid)
+    InitSolid();
+  else
+    _numSolidFiles = 1;
+  return S_OK;
+}
+
+HRESULT COutHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
+{
+  UString name = nameSpec;
+  name.MakeUpper();
+  if (name.IsEmpty())
+    return E_INVALIDARG;
+  
+  if (name[0] == L'S')
+  {
+    name.Delete(0);
+    if (name.IsEmpty())
+      return SetSolidFromPROPVARIANT(value);
+    if (value.vt != VT_EMPTY)
+      return E_INVALIDARG;
+    return SetSolidFromString(name);
+  }
+  
+  UInt32 number;
+  int index = ParseStringToUInt32(name, number);
+  UString realName = name.Mid(index);
+  if (index == 0)
+  {
+    if (name.CompareNoCase(L"RSFX") == 0) return PROPVARIANT_to_bool(value, _removeSfxBlock);
+    if (name.CompareNoCase(L"HC") == 0) return PROPVARIANT_to_bool(value, _compressHeaders);
+    if (name.CompareNoCase(L"HCF") == 0)
+    {
+      bool compressHeadersFull = true;
+      RINOK(PROPVARIANT_to_bool(value, compressHeadersFull));
+      return compressHeadersFull ? S_OK: E_INVALIDARG;
+    }
+    if (name.CompareNoCase(L"HE") == 0)
+    {
+      RINOK(PROPVARIANT_to_bool(value, _encryptHeaders));
+      _encryptHeadersSpecified = true;
+      return S_OK;
+    }
+    if (name.CompareNoCase(L"TC") == 0) return PROPVARIANT_to_bool(value, WriteCTime);
+    if (name.CompareNoCase(L"TA") == 0) return PROPVARIANT_to_bool(value, WriteATime);
+    if (name.CompareNoCase(L"TM") == 0) return PROPVARIANT_to_bool(value, WriteMTime);
+    if (name.CompareNoCase(L"V") == 0) return PROPVARIANT_to_bool(value, _volumeMode);
+  }
+  return CMultiMethodProps::SetProperty(name, value);
+}
+
+STDMETHODIMP CHandler::SetProperties(const wchar_t **names, const PROPVARIANT *values, Int32 numProps)
 {
  COM_TRY_BEGIN
  _binds.Clear();
-  BeforeSetProperty();
+  InitProps();

-  for (int i = 0; i < numProperties; i++)
+  for (int i = 0; i < numProps; i++)
  {
    UString name = names[i];
    name.MakeUpper();
@@ -466,9 +562,17 @@ STDMETHODIMP CHandler::SetProperties(const wchar_t **names, const PROPVARIANT *v

    if (name[0] == 'B')
    {
+      if (value.vt != VT_EMPTY)
+        return E_INVALIDARG;
      name.Delete(0);
      CBind bind;
-      RINOK(GetBindInfo(name, bind));
+      RINOK(GetBindInfoPart(name, bind.OutCoder, bind.OutStream));
+      if (name[0] != ':')
+        return E_INVALIDARG;
+      name.Delete(0);
+      RINOK(GetBindInfoPart(name, bind.InCoder, bind.InStream));
+      if (!name.IsEmpty())
+        return E_INVALIDARG;
      _binds.Add(bind);
      continue;
    }
@@ -476,6 +580,47 @@ STDMETHODIMP CHandler::SetProperties(const wchar_t **names, const PROPVARIANT *v
    RINOK(SetProperty(name, value));
  }

+  int numEmptyMethods = GetNumEmptyMethods();
+  if (numEmptyMethods > 0)
+  {
+    int k;
+    for (k = 0; k < _binds.Size(); k++)
+    {
+      const CBind &bind = _binds[k];
+      if (bind.InCoder < (UInt32)numEmptyMethods ||
+          bind.OutCoder < (UInt32)numEmptyMethods)
+        return E_INVALIDARG;
+    }
+    for (k = 0; k < _binds.Size(); k++)
+    {
+      CBind &bind = _binds[k];
+      bind.InCoder -= (UInt32)numEmptyMethods;
+      bind.OutCoder -= (UInt32)numEmptyMethods;
+    }
+    _methods.Delete(0, numEmptyMethods);
+  }
+  
+  AddDefaultMethod();
+
+  if (!_filterMethod.MethodName.IsEmpty())
+  {
+    for (int k = 0; k < _binds.Size(); k++)
+    {
+      CBind &bind = _binds[k];
+      bind.InCoder++;
+      bind.OutCoder++;
+    }
+    _methods.Insert(0, _filterMethod);
+  }
+
+  for (int k = 0; k < _binds.Size(); k++)
+  {
+    const CBind &bind = _binds[k];
+    if (bind.InCoder >= (UInt32)_methods.Size() ||
+        bind.OutCoder >= (UInt32)_methods.Size())
+      return E_INVALIDARG;
+  }
+
  return S_OK;
  COM_TRY_END
 }
--- a/CPP/7zip/Archive/7z/7zIn.cpp
+++ b/CPP/7zip/Archive/7z/7zIn.cpp
@@ -280,50 +280,60 @@ void CInByte2::ReadString(UString &s)
  _pos += rem + 2;
 }

-static inline bool TestSignatureCandidate(const Byte *p)
+static inline bool TestSignature(const Byte *p)
 {
  for (int i = 0; i < kSignatureSize; i++)
    if (p[i] != kSignature[i])
      return false;
-  return (p[0x1A] == 0 && p[0x1B] == 0);
+  return CrcCalc(p + 12, 20) == GetUi32(p + 8);
 }

+#ifdef FORMAT_7Z_RECOVERY
+static inline bool TestSignature2(const Byte *p)
+{
+  int i;
+  for (i = 0; i < kSignatureSize; i++)
+    if (p[i] != kSignature[i])
+      return false;
+  if (CrcCalc(p + 12, 20) == GetUi32(p + 8))
+    return true;
+  for (i = 8; i < kHeaderSize; i++)
+    if (p[i] != 0)
+      return false;
+  return (p[6] != 0 || p[7] != 0);
+}
+#else
+#define TestSignature2(p) TestSignature(p)
+#endif
+
 HRESULT CInArchive::FindAndReadSignature(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
 {
  RINOK(ReadStream_FALSE(stream, _header, kHeaderSize));

-  if (TestSignatureCandidate(_header))
+  if (TestSignature2(_header))
    return S_OK;

  CByteBuffer byteBuffer;
  const UInt32 kBufferSize = (1 << 16);
  byteBuffer.SetCapacity(kBufferSize);
  Byte *buffer = byteBuffer;
-  UInt32 numPrevBytes = kHeaderSize - 1;
-  memcpy(buffer, _header + 1, numPrevBytes);
-  UInt64 curTestPos = _arhiveBeginStreamPosition + 1;
+  memcpy(buffer, _header, kHeaderSize);
+  UInt64 curTestPos = _arhiveBeginStreamPosition;
  for (;;)
  {
    if (searchHeaderSizeLimit != NULL)
      if (curTestPos - _arhiveBeginStreamPosition > *searchHeaderSizeLimit)
        break;
-    do
+    UInt32 processedSize;
+    RINOK(stream->Read(buffer + kHeaderSize, kBufferSize - kHeaderSize, &processedSize));
+    if (processedSize == 0)
+      return S_FALSE;
+    for (UInt32 pos = 1; pos <= processedSize; pos++)
    {
-      UInt32 numReadBytes = kBufferSize - numPrevBytes;
-      UInt32 processedSize;
-      RINOK(stream->Read(buffer + numPrevBytes, numReadBytes, &processedSize));
-      numPrevBytes += processedSize;
-      if (processedSize == 0)
-        return S_FALSE;
-    }
-    while (numPrevBytes < kHeaderSize);
-    UInt32 numTests = numPrevBytes - kHeaderSize + 1;
-    for (UInt32 pos = 0; pos < numTests; pos++)
-    {
-      for (; buffer[pos] != '7' && pos < numTests; pos++);
-      if (pos == numTests)
+      for (; buffer[pos] != '7' && pos <= processedSize; pos++);
+      if (pos > processedSize)
        break;
-      if (TestSignatureCandidate(buffer + pos))
+      if (TestSignature(buffer + pos))
      {
        memcpy(_header, buffer + pos, kHeaderSize);
        curTestPos += pos;
@@ -331,9 +341,8 @@ HRESULT CInArchive::FindAndReadSignature(IInStream *stream, const UInt64 *search
        return stream->Seek(curTestPos + kHeaderSize, STREAM_SEEK_SET, NULL);
      }
    }
-    curTestPos += numTests;
-    numPrevBytes -= numTests;
-    memmove(buffer, buffer + numTests, numPrevBytes);
+    curTestPos += processedSize;
+    memmove(buffer, buffer + processedSize, kHeaderSize);
  }
  return S_FALSE;
 }
@@ -344,6 +353,8 @@ HRESULT CInArchive::Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
  HeadersSize = 0;
  Close();
  RINOK(stream->Seek(0, STREAM_SEEK_CUR, &_arhiveBeginStreamPosition))
+  RINOK(stream->Seek(0, STREAM_SEEK_END, &_fileEndPosition))
+  RINOK(stream->Seek(_arhiveBeginStreamPosition, STREAM_SEEK_SET, NULL))
  RINOK(FindAndReadSignature(stream, searchHeaderSizeLimit));
  _stream = stream;
  return S_OK;
@@ -812,7 +823,7 @@ HRESULT CInArchive::ReadAndDecodePackedStreams(
      ThrowUnsupported();
    data.SetCapacity(unpackSize);
    
-    CSequentialOutStreamImp2 *outStreamSpec = new CSequentialOutStreamImp2;
+    CBufPtrSeqOutStream *outStreamSpec = new CBufPtrSeqOutStream;
    CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
    outStreamSpec->Init(data, unpackSize);
    
@@ -1164,23 +1175,26 @@ HRESULT CInArchive::ReadDatabase2(
    nextHeaderCRC = CrcCalc(buf + i, (size_t)nextHeaderSize);
    RINOK(_stream->Seek(cur, STREAM_SEEK_SET, NULL));
  }
+  else
  #endif
-
-  #ifdef FORMAT_7Z_RECOVERY
-  crcFromArchive = crc;
-  #endif
+  {
+    if (crc != crcFromArchive)
+      ThrowIncorrect();
+  }

  db.ArchiveInfo.StartPositionAfterHeader = _arhiveBeginStreamPosition + kHeaderSize;

-  if (crc != crcFromArchive)
-    ThrowIncorrect();
-
  if (nextHeaderSize == 0)
    return S_OK;

-  if (nextHeaderSize > (UInt64)0xFFFFFFFF)
+  if (nextHeaderSize > (UInt64)(UInt32)0xFFFFFFFF)
    return S_FALSE;

+  if ((Int64)nextHeaderOffset < 0)
+    return S_FALSE;
+
+  if (db.ArchiveInfo.StartPositionAfterHeader + nextHeaderOffset > _fileEndPosition)
+    return S_FALSE;
  RINOK(_stream->Seek(nextHeaderOffset, STREAM_SEEK_CUR, NULL));

  CByteBuffer buffer2;
--- a/CPP/7zip/Archive/7z/7zIn.h
+++ b/CPP/7zip/Archive/7z/7zIn.h
@@ -133,6 +133,7 @@ class CInArchive
  CInByte2 *_inByteBack;
 
  UInt64 _arhiveBeginStreamPosition;
+  UInt64 _fileEndPosition;

  Byte _header[kHeaderSize];

--- a/CPP/7zip/Archive/7z/7zUpdate.cpp
+++ b/CPP/7zip/Archive/7z/7zUpdate.cpp
@@ -24,15 +24,6 @@
 namespace NArchive {
 namespace N7z {

-static const UInt64 k_LZMA = 0x030101;
-static const UInt64 k_BCJ  = 0x03030103;
-static const UInt64 k_BCJ2 = 0x0303011B;
-
-static const wchar_t *kMatchFinderForBCJ2_LZMA = L"BT2";
-static const UInt32 kDictionaryForBCJ2_LZMA = 1 << 20;
-static const UInt32 kAlgorithmForBCJ2_LZMA = 1;
-static const UInt32 kNumFastBytesForBCJ2_LZMA = 64;
-
 #ifdef MY_CPU_X86_OR_AMD64
 #define USE_86_FILTER
 #endif
@@ -339,90 +330,74 @@ static bool IsExeExt(const UString &ext)
  return false;
 }

-#ifdef USE_86_FILTER

-static inline void GetMethodFull(UInt64 methodID, UInt32 numInStreams, CMethodFull &methodResult)
+static inline void GetMethodFull(UInt64 methodID, UInt32 numInStreams, CMethodFull &m)
 {
-  methodResult.Id = methodID;
-  methodResult.NumInStreams = numInStreams;
-  methodResult.NumOutStreams = 1;
+  m.Id = methodID;
+  m.NumInStreams = numInStreams;
+  m.NumOutStreams = 1;
 }

-static void MakeExeMethod(const CCompressionMethodMode &method,
-    bool bcj2Filter, CCompressionMethodMode &exeMethod)
+static void AddBcj2Methods(CCompressionMethodMode &mode)
 {
-  exeMethod = method;
+  CMethodFull m;
+  GetMethodFull(k_LZMA, 1, m);
+  
+  m.AddProp32(NCoderPropID::kDictionarySize, 1 << 20);
+  m.AddProp32(NCoderPropID::kNumFastBytes, 128);
+  m.AddProp32(NCoderPropID::kNumThreads, 1);
+  m.AddProp32(NCoderPropID::kLitPosBits, 2);
+  m.AddProp32(NCoderPropID::kLitContextBits, 0);
+  // m.AddPropString(NCoderPropID::kMatchFinder, L"BT2");
+
+  mode.Methods.Add(m);
+  mode.Methods.Add(m);
+  
+  CBind bind;
+  bind.OutCoder = 0;
+  bind.InStream = 0;
+  bind.InCoder = 1;  bind.OutStream = 0;  mode.Binds.Add(bind);
+  bind.InCoder = 2;  bind.OutStream = 1;  mode.Binds.Add(bind);
+  bind.InCoder = 3;  bind.OutStream = 2;  mode.Binds.Add(bind);
+}
+
+static void MakeExeMethod(CCompressionMethodMode &mode,
+    bool useFilters, bool addFilter, bool bcj2Filter)
+{
+  if (!mode.Binds.IsEmpty() || !useFilters || mode.Methods.Size() > 2)
+    return;
+  if (mode.Methods.Size() == 2)
+  {
+    if (mode.Methods[0].Id == k_BCJ2)
+      AddBcj2Methods(mode);
+    return;
+  }
+  if (!addFilter)
+    return;
+  bcj2Filter = bcj2Filter;
+  #ifdef USE_86_FILTER
  if (bcj2Filter)
  {
-    CMethodFull methodFull;
-    GetMethodFull(k_BCJ2, 4, methodFull);
-    exeMethod.Methods.Insert(0, methodFull);
-    GetMethodFull(k_LZMA, 1, methodFull);
-    {
-      CProp prop;
-      prop.Id = NCoderPropID::kAlgorithm;
-      prop.Value = kAlgorithmForBCJ2_LZMA;
-      methodFull.Props.Add(prop);
-    }
-    {
-      CProp prop;
-      prop.Id = NCoderPropID::kMatchFinder;
-      prop.Value = kMatchFinderForBCJ2_LZMA;
-      methodFull.Props.Add(prop);
-    }
-    {
-      CProp prop;
-      prop.Id = NCoderPropID::kDictionarySize;
-      prop.Value = kDictionaryForBCJ2_LZMA;
-      methodFull.Props.Add(prop);
-    }
-    {
-      CProp prop;
-      prop.Id = NCoderPropID::kNumFastBytes;
-      prop.Value = kNumFastBytesForBCJ2_LZMA;
-      methodFull.Props.Add(prop);
-    }
-    {
-      CProp prop;
-      prop.Id = NCoderPropID::kNumThreads;
-      prop.Value = (UInt32)1;
-      methodFull.Props.Add(prop);
-    }
-
-    exeMethod.Methods.Add(methodFull);
-    exeMethod.Methods.Add(methodFull);
-    CBind bind;
-
-    bind.OutCoder = 0;
-    bind.InStream = 0;
-
-    bind.InCoder = 1;
-    bind.OutStream = 0;
-    exeMethod.Binds.Add(bind);
-
-    bind.InCoder = 2;
-    bind.OutStream = 1;
-    exeMethod.Binds.Add(bind);
-
-    bind.InCoder = 3;
-    bind.OutStream = 2;
-    exeMethod.Binds.Add(bind);
+    CMethodFull m;
+    GetMethodFull(k_BCJ2, 4, m);
+    mode.Methods.Insert(0, m);
+    AddBcj2Methods(mode);
  }
  else
  {
-    CMethodFull methodFull;
-    GetMethodFull(k_BCJ, 1, methodFull);
-    exeMethod.Methods.Insert(0, methodFull);
+    CMethodFull m;
+    GetMethodFull(k_BCJ, 1, m);
+    mode.Methods.Insert(0, m);
    CBind bind;
    bind.OutCoder = 0;
    bind.InStream = 0;
    bind.InCoder = 1;
    bind.OutStream = 0;
-    exeMethod.Binds.Add(bind);
+    mode.Binds.Add(bind);
  }
+  #endif
 }

-#endif

 static void FromUpdateItemToFileItem(const CUpdateItem &ui,
    CFileItem &file, CFileItem2 &file2)
@@ -601,6 +576,7 @@ public:
    Fos = FosSpec;
    Result = E_FAIL;
  }
+  ~CThreadDecoder() { CVirtThread::WaitThreadFinish(); }
  virtual void Execute();
 };

@@ -669,9 +645,7 @@ STDMETHODIMP CCryptoGetTextPassword::CryptoGetTextPassword(BSTR *password)

 static const int kNumGroupsMax = 4;

-#ifdef USE_86_FILTER
 static bool Is86Group(int group) { return (group & 1) != 0; }
-#endif
 static bool IsEncryptedGroup(int group) { return (group & 2) != 0; }
 static int GetGroupIndex(bool encrypted, int bcjFiltered)
  { return (encrypted ? 2 : 0) + (bcjFiltered ? 1 : 0); }
@@ -789,16 +763,15 @@ HRESULT Update(
  if (inSizeForReduce2 > inSizeForReduce)
    inSizeForReduce = inSizeForReduce2;

-  const UInt32 kMinReduceSize = (1 << 16);
-  if (inSizeForReduce < kMinReduceSize)
-    inSizeForReduce = kMinReduceSize;
-
  RINOK(updateCallback->SetTotal(complexity));

  CLocalProgress *lps = new CLocalProgress;
  CMyComPtr<ICompressProgressInfo> progress = lps;
  lps->Init(updateCallback, true);

+  CStreamBinder sb;
+  RINOK(sb.CreateEvents());
+
  CThreadDecoder threadDecoder;
  if (!folderRefs.IsEmpty())
  {
@@ -870,13 +843,8 @@ HRESULT Update(
  {
    const CSolidGroup &group = groups[groupIndex];

-    CCompressionMethodMode method;
-    #ifdef USE_86_FILTER
-    if (Is86Group(groupIndex))
-      MakeExeMethod(*options.Method, options.MaxFilter, method);
-    else
-    #endif
-      method = *options.Method;
+    CCompressionMethodMode method = *options.Method;
+    MakeExeMethod(method, options.UseFilters, Is86Group(groupIndex), options.MaxFilter);

    if (IsEncryptedGroup(groupIndex))
    {
@@ -923,11 +891,6 @@ HRESULT Update(
      }
      else
      {
-        CStreamBinder sb;
-        RINOK(sb.CreateEvents());
-        CMyComPtr<ISequentialOutStream> sbOutStream;
-        CMyComPtr<ISequentialInStream> sbInStream;
-        sb.CreateStreams(&sbInStream, &sbOutStream);
        CBoolVector extractStatuses;
        
        CNum numUnpackStreams = db->NumUnpackStreamsVector[folderIndex];
@@ -946,24 +909,31 @@ HRESULT Update(
          extractStatuses.Add(needExtract);
        }

-        RINOK(threadDecoder.FosSpec->Init(db, db->FolderStartFileIndex[folderIndex], &extractStatuses, sbOutStream));
-        sbOutStream.Release();
-        
-        threadDecoder.InStream = inStream;
-        threadDecoder.Folder = &db->Folders[folderIndex];
-        threadDecoder.StartPos = db->GetFolderStreamPos(folderIndex, 0);
-        threadDecoder.PackSizes = &db->PackSizes[db->FolderStartPackStreamIndex[folderIndex]];
-        
-        threadDecoder.Start();
-        
        int startPackIndex = newDatabase.PackSizes.Size();
        CFolder newFolder;
-        RINOK(encoder.Encode(
-          EXTERNAL_CODECS_LOC_VARS
-          sbInStream, NULL, &inSizeForReduce, newFolder,
-          archive.SeqStream, newDatabase.PackSizes, progress));
-        
-        threadDecoder.WaitFinish();
+        {
+          CMyComPtr<ISequentialInStream> sbInStream;
+          {
+            CMyComPtr<ISequentialOutStream> sbOutStream;
+            sb.CreateStreams(&sbInStream, &sbOutStream);
+            sb.ReInit();
+            RINOK(threadDecoder.FosSpec->Init(db, db->FolderStartFileIndex[folderIndex], &extractStatuses, sbOutStream));
+          }
+          
+          threadDecoder.InStream = inStream;
+          threadDecoder.Folder = &db->Folders[folderIndex];
+          threadDecoder.StartPos = db->GetFolderStreamPos(folderIndex, 0);
+          threadDecoder.PackSizes = &db->PackSizes[db->FolderStartPackStreamIndex[folderIndex]];
+          
+          threadDecoder.Start();
+          
+          RINOK(encoder.Encode(
+            EXTERNAL_CODECS_LOC_VARS
+            sbInStream, NULL, &inSizeForReduce, newFolder,
+            archive.SeqStream, newDatabase.PackSizes, progress));
+          
+          threadDecoder.WaitExecuteFinish();
+        }

        RINOK(threadDecoder.Result);

@@ -1134,6 +1104,8 @@ HRESULT Update(
  if (folderRefIndex != folderRefs.Size())
    return E_FAIL;

+  RINOK(lps->SetCur());
+
  /*
  folderRefs.ClearAndFree();
  fileIndexToUpdateIndexMap.ClearAndFree();
@@ -1169,7 +1141,7 @@ HRESULT Update(
      newDatabase.AddFile(file, file2);
    }
  }
-    
+
  newDatabase.ReserveDown();
  return S_OK;
 }
--- a/CPP/7zip/Archive/Bz2Handler.cpp
+++ b/CPP/7zip/Archive/Bz2Handler.cpp
@@ -4,13 +4,6 @@

 #include "Common/ComTry.h"

-#include "Windows/PropVariant.h"
-
-#ifndef _7ZIP_ST
-#include "../../Windows/System.h"
-#endif
-
-#include "../Common/CreateCoder.h"
 #include "../Common/ProgressUtils.h"
 #include "../Common/RegisterArc.h"
 #include "../Common/StreamUtils.h"
@@ -20,21 +13,13 @@
 #include "../Compress/CopyCoder.h"

 #include "Common/DummyOutStream.h"
-#include "Common/ParseProperties.h"
+#include "Common/HandlerOut.h"

 using namespace NWindows;

 namespace NArchive {
 namespace NBz2 {

-static const UInt32 kNumPassesX1 = 1;
-static const UInt32 kNumPassesX7 = 2;
-static const UInt32 kNumPassesX9 = 7;
-
-static const UInt32 kDicSizeX1 = 100000;
-static const UInt32 kDicSizeX3 = 500000;
-static const UInt32 kDicSizeX5 = 900000;
-
 class CHandler:
  public IInArchive,
  public IArchiveOpenSeq,
@@ -48,22 +33,7 @@ class CHandler:
  UInt64 _startPosition;
  bool _packSizeDefined;

-  UInt32 _level;
-  UInt32 _dicSize;
-  UInt32 _numPasses;
-  #ifndef _7ZIP_ST
-  UInt32 _numThreads;
-  #endif
-
-  void InitMethodProperties()
-  {
-    _level = 5;
-    _dicSize =
-    _numPasses = 0xFFFFFFFF;
-    #ifndef _7ZIP_ST
-    _numThreads = NWindows::NSystem::GetNumberOfProcessors();;
-    #endif
-  }
+  CSingleMethodProps _props;

 public:
  MY_UNKNOWN_IMP4(IInArchive, IArchiveOpenSeq, IOutArchive, ISetProperties)
@@ -73,10 +43,10 @@ public:
  STDMETHOD(OpenSeq)(ISequentialInStream *stream);
  STDMETHOD(SetProperties)(const wchar_t **names, const PROPVARIANT *values, Int32 numProps);

-  CHandler() { InitMethodProperties(); }
+  CHandler() { }
 };

-STATPROPSTG kProps[] =
+static const STATPROPSTG kProps[] =
 {
  { NULL, kpidPackSize, VT_UI8}
 };
@@ -87,7 +57,7 @@ IMP_IInArchive_ArcProps_NO_Table
 STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
 {
  NCOM::CPropVariant prop;
-  switch(propID)
+  switch (propID)
  {
    case kpidPhySize: if (_packSizeDefined) prop = _packSize; break;
  }
@@ -104,7 +74,7 @@ STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
 STDMETHODIMP CHandler::GetProperty(UInt32 /* index */, PROPID propID,  PROPVARIANT *value)
 {
  NWindows::NCOM::CPropVariant prop;
-  switch(propID)
+  switch (propID)
  {
    case kpidPackSize: if (_packSizeDefined) prop = _packSize; break;
  }
@@ -188,7 +158,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
  decoderSpec->SetInStream(_seqStream);

  #ifndef _7ZIP_ST
-  RINOK(decoderSpec->SetNumberOfThreads(_numThreads));
+  RINOK(decoderSpec->SetNumberOfThreads(_props._numThreads));
  #endif

  CDummyOutStream *outStreamSpec = new CDummyOutStream;
@@ -246,50 +216,19 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 static HRESULT UpdateArchive(
    UInt64 unpackSize,
    ISequentialOutStream *outStream,
-    int indexInClient,
-    UInt32 dictionary,
-    UInt32 numPasses,
-    #ifndef _7ZIP_ST
-    UInt32 numThreads,
-    #endif
+    const CProps &props,
    IArchiveUpdateCallback *updateCallback)
 {
  RINOK(updateCallback->SetTotal(unpackSize));
-  UInt64 complexity = 0;
-  RINOK(updateCallback->SetCompleted(&complexity));
-
  CMyComPtr<ISequentialInStream> fileInStream;
-
-  RINOK(updateCallback->GetStream(indexInClient, &fileInStream));
-
+  RINOK(updateCallback->GetStream(0, &fileInStream));
  CLocalProgress *localProgressSpec = new CLocalProgress;
  CMyComPtr<ICompressProgressInfo> localProgress = localProgressSpec;
  localProgressSpec->Init(updateCallback, true);
-  
  NCompress::NBZip2::CEncoder *encoderSpec = new NCompress::NBZip2::CEncoder;
  CMyComPtr<ICompressCoder> encoder = encoderSpec;
-  {
-    NWindows::NCOM::CPropVariant properties[] =
-    {
-      dictionary,
-      numPasses
-      #ifndef _7ZIP_ST
-      , numThreads
-      #endif
-    };
-    PROPID propIDs[] =
-    {
-      NCoderPropID::kDictionarySize,
-      NCoderPropID::kNumPasses
-      #ifndef _7ZIP_ST
-      , NCoderPropID::kNumThreads
-      #endif
-    };
-    RINOK(encoderSpec->SetCoderProperties(propIDs, properties, sizeof(propIDs) / sizeof(propIDs[0])));
-  }
-  
+  RINOK(props.SetCoderProps(encoderSpec, NULL));
  RINOK(encoder->Code(fileInStream, outStream, NULL, NULL, localProgress));
-  
  return updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK);
 }

@@ -336,25 +275,7 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
        return E_INVALIDARG;
      size = prop.uhVal.QuadPart;
    }
-  
-    UInt32 dicSize = _dicSize;
-    if (dicSize == 0xFFFFFFFF)
-      dicSize = (_level >= 5 ? kDicSizeX5 :
-                (_level >= 3 ? kDicSizeX3 :
-                               kDicSizeX1));
-
-    UInt32 numPasses = _numPasses;
-    if (numPasses == 0xFFFFFFFF)
-      numPasses = (_level >= 9 ? kNumPassesX9 :
-                  (_level >= 7 ? kNumPassesX7 :
-                                 kNumPassesX1));
-
-    return UpdateArchive(
-        size, outStream, 0, dicSize, numPasses,
-        #ifndef _7ZIP_ST
-        _numThreads,
-        #endif
-        updateCallback);
+    return UpdateArchive(size, outStream, _props, updateCallback);
  }
  if (indexInArchive != 0)
    return E_INVALIDARG;
@@ -365,47 +286,7 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt

 STDMETHODIMP CHandler::SetProperties(const wchar_t **names, const PROPVARIANT *values, Int32 numProps)
 {
-  InitMethodProperties();
-  #ifndef _7ZIP_ST
-  const UInt32 numProcessors = NSystem::GetNumberOfProcessors();
-  _numThreads = numProcessors;
-  #endif
-
-  for (int i = 0; i < numProps; i++)
-  {
-    UString name = names[i];
-    name.MakeUpper();
-    if (name.IsEmpty())
-      return E_INVALIDARG;
-    const PROPVARIANT &prop = values[i];
-    if (name[0] == L'X')
-    {
-      UInt32 level = 9;
-      RINOK(ParsePropValue(name.Mid(1), prop, level));
-      _level = level;
-    }
-    else if (name[0] == L'D')
-    {
-      UInt32 dicSize = kDicSizeX5;
-      RINOK(ParsePropDictionaryValue(name.Mid(1), prop, dicSize));
-      _dicSize = dicSize;
-    }
-    else if (name.Left(4) == L"PASS")
-    {
-      UInt32 num = kNumPassesX9;
-      RINOK(ParsePropValue(name.Mid(4), prop, num));
-      _numPasses = num;
-    }
-    else if (name.Left(2) == L"MT")
-    {
-      #ifndef _7ZIP_ST
-      RINOK(ParseMtProp(name.Mid(2), prop, numProcessors, _numThreads));
-      #endif
-    }
-    else
-      return E_INVALIDARG;
-  }
-  return S_OK;
+  return _props.SetProperties(names, values, numProps);
 }

 static IInArchive *CreateArc() { return new CHandler; }
--- a/CPP/7zip/Archive/Cab/CabHandler.cpp
+++ b/CPP/7zip/Archive/Cab/CabHandler.cpp
@@ -4,9 +4,7 @@

 #include "../../../../C/Alloc.h"

-#include "Common/Buffer.h"
 #include "Common/ComTry.h"
-#include "Common/Defs.h"
 #include "Common/IntToString.h"
 #include "Common/StringConvert.h"
 #include "Common/UTFConvert.h"
@@ -654,7 +652,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
  bool allFilesMode = (numItems == (UInt32)-1);
  if (allFilesMode)
    numItems = m_Database.Items.Size();
-  if(numItems == 0)
+  if (numItems == 0)
    return S_OK;
  bool testMode = (testModeSpec != 0);
  UInt64 totalUnPacked = 0;
@@ -780,12 +778,13 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
        curUnpack, extractCallback, testMode);

    cabBlockInStreamSpec->MsZip = false;
+    HRESULT res = S_OK;
    switch(folder.GetCompressionMethod())
    {
      case NHeader::NCompressionMethodMajor::kNone:
        break;
      case NHeader::NCompressionMethodMajor::kMSZip:
-        if(deflateDecoderSpec == NULL)
+        if (!deflateDecoder)
        {
          deflateDecoderSpec = new NCompress::NDeflate::NDecoder::CCOMCoder;
          deflateDecoder = deflateDecoderSpec;
@@ -793,33 +792,35 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
        cabBlockInStreamSpec->MsZip = true;
        break;
      case NHeader::NCompressionMethodMajor::kLZX:
-        if(lzxDecoderSpec == NULL)
+        if (!lzxDecoder)
        {
          lzxDecoderSpec = new NCompress::NLzx::CDecoder;
          lzxDecoder = lzxDecoderSpec;
        }
-        RINOK(lzxDecoderSpec->SetParams(folder.CompressionTypeMinor));
+        res = lzxDecoderSpec->SetParams(folder.CompressionTypeMinor);
        break;
      case NHeader::NCompressionMethodMajor::kQuantum:
-        if(quantumDecoderSpec == NULL)
+        if (!quantumDecoder)
        {
          quantumDecoderSpec = new NCompress::NQuantum::CDecoder;
          quantumDecoder = quantumDecoderSpec;
        }
-        quantumDecoderSpec->SetParams(folder.CompressionTypeMinor);
+        res = quantumDecoderSpec->SetParams(folder.CompressionTypeMinor);
        break;
      default:
-      {
-        RINOK(cabFolderOutStream->Unsupported());
-        totalUnPacked += curUnpack;
-        continue;
-      }
+        res = E_INVALIDARG;
+        break;
    }

+    if (res == E_INVALIDARG)
+    {
+      RINOK(cabFolderOutStream->Unsupported());
+      totalUnPacked += curUnpack;
+      continue;
+    }
+    RINOK(res);
+
    cabBlockInStreamSpec->InitForNewFolder();
-
-    HRESULT res = S_OK;
-
    {
      int volIndex = mvItem.VolumeIndex;
      int locFolderIndex = item.GetFolderIndex(db.Folders.Size());
--- a/CPP/7zip/Archive/Chm/ChmIn.h
+++ b/CPP/7zip/Archive/Chm/ChmIn.h
@@ -39,7 +39,7 @@ struct CItem
  {
    if (Name.Length() == 0)
      return false;
-    return (Name[Name.Length() - 1] == '/');
+    return (Name.Back() == '/');
  }
 };

--- a/CPP/7zip/Archive/Common/CoderMixer2MT.cpp
+++ b/CPP/7zip/Archive/Common/CoderMixer2MT.cpp
@@ -214,7 +214,7 @@ STDMETHODIMP CCoderMixer2MT::Code(ISequentialInStream **inStreams,

  for (i = 0; i < _coders.Size(); i++)
    if (i != _progressCoderIndex)
-      _coders[i].WaitFinish();
+      _coders[i].WaitExecuteFinish();

  RINOK(ReturnIfError(E_ABORT));
  RINOK(ReturnIfError(E_OUTOFMEMORY));
--- a/CPP/7zip/Archive/Common/CoderMixer2MT.h
+++ b/CPP/7zip/Archive/Common/CoderMixer2MT.h
@@ -19,6 +19,7 @@ struct CCoder2: public CCoderInfo2, public CVirtThread
  CRecordVector<ISequentialOutStream*> OutStreamPointers;

  CCoder2(UInt32 numInStreams, UInt32 numOutStreams);
+  ~CCoder2() { CVirtThread::WaitThreadFinish(); }
  void SetCoderInfo(const UInt64 **inSizes, const UInt64 **outSizes);
  virtual void Execute();
  void Code(ICompressProgressInfo *progress);
--- a/CPP/7zip/Archive/Common/CoderMixer2ST.cpp
+++ b/CPP/7zip/Archive/Common/CoderMixer2ST.cpp
@@ -4,7 +4,7 @@

 #include "CoderMixer2ST.h"

-namespace NCoderMixer2 {
+namespace NCoderMixer {

 CCoderMixer2ST::CCoderMixer2ST() {}

@@ -42,7 +42,7 @@ HRESULT CCoderMixer2ST::GetInStream(
 {
  CMyComPtr<ISequentialInStream> seqInStream;
  int i;
-  for(i = 0; i < _bindInfo.InStreams.Size(); i++)
+  for (i = 0; i < _bindInfo.InStreams.Size(); i++)
    if (_bindInfo.InStreams[i] == streamIndex)
    {
      seqInStream = inStreams[i];
@@ -57,7 +57,7 @@ HRESULT CCoderMixer2ST::GetInStream(
  _bindInfo.FindOutStream(_bindInfo.BindPairs[binderIndex].OutIndex,
      coderIndex, coderStreamIndex);

-  CCoderInfo &coder = _coders[coderIndex];
+  CCoderInfo2 &coder = _coders[coderIndex];
  if (!coder.Coder)
    return E_NOTIMPL;
  coder.Coder.QueryInterface(IID_ISequentialInStream, &seqInStream);
@@ -91,7 +91,7 @@ HRESULT CCoderMixer2ST::GetOutStream(
 {
  CMyComPtr<ISequentialOutStream> seqOutStream;
  int i;
-  for(i = 0; i < _bindInfo.OutStreams.Size(); i++)
+  for (i = 0; i < _bindInfo.OutStreams.Size(); i++)
    if (_bindInfo.OutStreams[i] == streamIndex)
    {
      seqOutStream = outStreams[i];
@@ -106,7 +106,7 @@ HRESULT CCoderMixer2ST::GetOutStream(
  _bindInfo.FindInStream(_bindInfo.BindPairs[binderIndex].InIndex,
      coderIndex, coderStreamIndex);

-  CCoderInfo &coder = _coders[coderIndex];
+  CCoderInfo2 &coder = _coders[coderIndex];
  if (!coder.Coder)
    return E_NOTIMPL;
  coder.Coder.QueryInterface(IID_ISequentialOutStream, &seqOutStream);
@@ -169,7 +169,7 @@ STDMETHODIMP CCoderMixer2ST::Code(ISequentialInStream **inStreams,
 
  // _mainCoderIndex = 0;
  // _mainCoderIndex = _coders.Size() - 1;
-  CCoderInfo &mainCoder = _coders[_mainCoderIndex];
+  CCoderInfo2 &mainCoder = _coders[_mainCoderIndex];

  CObjectVector< CMyComPtr<ISequentialInStream> > seqInStreams;
  CObjectVector< CMyComPtr<ISequentialOutStream> > seqOutStreams;
@@ -198,7 +198,7 @@ STDMETHODIMP CCoderMixer2ST::Code(ISequentialInStream **inStreams,
  {
    if (i == _mainCoderIndex)
      continue;
-    CCoderInfo &coder = _coders[i];
+    CCoderInfo2 &coder = _coders[i];
    CMyComPtr<ICompressSetOutStreamSize> setOutStreamSize;
    coder.Coder.QueryInterface(IID_ICompressSetOutStreamSize, &setOutStreamSize);
    if (setOutStreamSize)
--- a/CPP/7zip/Archive/Common/CoderMixer2ST.h
+++ b/CPP/7zip/Archive/Common/CoderMixer2ST.h
@@ -7,7 +7,7 @@
 #include "../../../Common/MyCom.h"
 #include "../../ICoder.h"

-namespace NCoderMixer2 {
+namespace NCoderMixer {

 //  SetBindInfo()
 //  for each coder
@@ -26,11 +26,11 @@ namespace NCoderMixer2 {
 //    Code
 //  }

-struct CSTCoderInfo: public CCoderInfo
+struct CSTCoderInfo: public CCoderInfo2
 {
  bool IsMain;
  CSTCoderInfo(UInt32 numInStreams, UInt32 numOutStreams, bool isMain):
-    CCoderInfo(numInStreams, numOutStreams),IsMain(isMain) {}
+    CCoderInfo2(numInStreams, numOutStreams), IsMain(isMain) {}
 };

 class CCoderMixer2ST:
@@ -84,5 +84,5 @@ public:
 };

 }
-#endif

+#endif
--- a/CPP/7zip/Archive/Common/CoderMixerMT.cpp
+++ b/CPP/7zip/Archive/Common/CoderMixerMT.cpp
@@ -73,7 +73,7 @@ STDMETHODIMP CCoderMixerMT::Code(ISequentialInStream *inStream,

  for (i = 0; i < _coders.Size(); i++)
    if (i != _progressCoderIndex)
-      _coders[i].WaitFinish();
+      _coders[i].WaitExecuteFinish();

  RINOK(ReturnIfError(E_ABORT));
  RINOK(ReturnIfError(E_OUTOFMEMORY));
--- a/CPP/7zip/Archive/Common/CoderMixerMT.h
+++ b/CPP/7zip/Archive/Common/CoderMixerMT.h
@@ -18,6 +18,7 @@ struct CCoder: public CCoderInfo, public CVirtThread

  virtual void Execute();
  void Code(ICompressProgressInfo *progress);
+  ~CCoder() { CVirtThread::WaitThreadFinish(); }
 };

 /*
--- a/CPP/7zip/Archive/Common/HandlerOut.cpp
+++ b/CPP/7zip/Archive/Common/HandlerOut.cpp
@@ -2,16 +2,10 @@

 #include "StdAfx.h"

-#include "../../../Common/StringToInt.h"
-
-#include "../../../Windows/PropVariant.h"
-
 #ifndef _7ZIP_ST
 #include "../../../Windows/System.h"
 #endif

-#include "../../ICoder.h"
-
 #include "../Common/ParseProperties.h"

 #include "HandlerOut.h"
@@ -20,487 +14,40 @@ using namespace NWindows;

 namespace NArchive {

-static const wchar_t *kCopyMethod = L"Copy";
-static const wchar_t *kLZMAMethodName = L"LZMA";
-static const wchar_t *kLZMA2MethodName = L"LZMA2";
-static const wchar_t *kBZip2MethodName = L"BZip2";
-static const wchar_t *kPpmdMethodName = L"PPMd";
-static const wchar_t *kDeflateMethodName = L"Deflate";
-static const wchar_t *kDeflate64MethodName = L"Deflate64";
-
-static const wchar_t *kLzmaMatchFinderX1 = L"HC4";
-static const wchar_t *kLzmaMatchFinderX5 = L"BT4";
-
-static const UInt32 kLzmaAlgoX1 = 0;
-static const UInt32 kLzmaAlgoX5 = 1;
-
-static const UInt32 kLzmaDicSizeX1 = 1 << 16;
-static const UInt32 kLzmaDicSizeX3 = 1 << 20;
-static const UInt32 kLzmaDicSizeX5 = 1 << 24;
-static const UInt32 kLzmaDicSizeX7 = 1 << 25;
-static const UInt32 kLzmaDicSizeX9 = 1 << 26;
-
-static const UInt32 kLzmaFastBytesX1 = 32;
-static const UInt32 kLzmaFastBytesX7 = 64;
-
-static const UInt32 kPpmdMemSizeX1 = (1 << 22);
-static const UInt32 kPpmdMemSizeX5 = (1 << 24);
-static const UInt32 kPpmdMemSizeX7 = (1 << 26);
-static const UInt32 kPpmdMemSizeX9 = (192 << 20);
-
-static const UInt32 kPpmdOrderX1 = 4;
-static const UInt32 kPpmdOrderX5 = 6;
-static const UInt32 kPpmdOrderX7 = 16;
-static const UInt32 kPpmdOrderX9 = 32;
-
-static const UInt32 kDeflateAlgoX1 = 0;
-static const UInt32 kDeflateAlgoX5 = 1;
-
-static const UInt32 kDeflateFastBytesX1 = 32;
-static const UInt32 kDeflateFastBytesX7 = 64;
-static const UInt32 kDeflateFastBytesX9 = 128;
-
-static const UInt32 kDeflatePassesX1 = 1;
-static const UInt32 kDeflatePassesX7 = 3;
-static const UInt32 kDeflatePassesX9 = 10;
-
-static const UInt32 kBZip2NumPassesX1 = 1;
-static const UInt32 kBZip2NumPassesX7 = 2;
-static const UInt32 kBZip2NumPassesX9 = 7;
-
-static const UInt32 kBZip2DicSizeX1 = 100000;
-static const UInt32 kBZip2DicSizeX3 = 500000;
-static const UInt32 kBZip2DicSizeX5 = 900000;
-
-static const wchar_t *kDefaultMethodName = kLZMAMethodName;
-
-static const wchar_t *kLzmaMatchFinderForHeaders = L"BT2";
-static const UInt32 kDictionaryForHeaders = 1 << 20;
-static const UInt32 kNumFastBytesForHeaders = 273;
-static const UInt32 kAlgorithmForHeaders = kLzmaAlgoX5;
-
-static bool AreEqual(const UString &methodName, const wchar_t *s)
-  { return (methodName.CompareNoCase(s) == 0); }
-
-bool COneMethodInfo::IsLzma() const
+static void SetMethodProp32(COneMethodInfo &m, PROPID propID, UInt32 value)
 {
-  return
-    AreEqual(MethodName, kLZMAMethodName) ||
-    AreEqual(MethodName, kLZMA2MethodName);
+  if (m.FindProp(propID) < 0)
+    m.AddProp32(propID, value);
 }

-static inline bool IsBZip2Method(const UString &methodName)
-  { return AreEqual(methodName, kBZip2MethodName); }
-
-static inline bool IsPpmdMethod(const UString &methodName)
-  { return AreEqual(methodName, kPpmdMethodName); }
-
-static inline bool IsDeflateMethod(const UString &methodName)
-{
-  return
-    AreEqual(methodName, kDeflateMethodName) ||
-    AreEqual(methodName, kDeflate64MethodName);
-}
-
-struct CNameToPropID
-{
-  PROPID PropID;
-  VARTYPE VarType;
-  const wchar_t *Name;
-};
-
-static CNameToPropID g_NameToPropID[] =
-{
-  { NCoderPropID::kBlockSize, VT_UI4, L"C" },
-  { NCoderPropID::kDictionarySize, VT_UI4, L"D" },
-  { NCoderPropID::kUsedMemorySize, VT_UI4, L"MEM" },
-
-  { NCoderPropID::kOrder, VT_UI4, L"O" },
-  { NCoderPropID::kPosStateBits, VT_UI4, L"PB" },
-  { NCoderPropID::kLitContextBits, VT_UI4, L"LC" },
-  { NCoderPropID::kLitPosBits, VT_UI4, L"LP" },
-  { NCoderPropID::kEndMarker, VT_BOOL, L"eos" },
-
-  { NCoderPropID::kNumPasses, VT_UI4, L"Pass" },
-  { NCoderPropID::kNumFastBytes, VT_UI4, L"fb" },
-  { NCoderPropID::kMatchFinderCycles, VT_UI4, L"mc" },
-  { NCoderPropID::kAlgorithm, VT_UI4, L"a" },
-  { NCoderPropID::kMatchFinder, VT_BSTR, L"mf" },
-  { NCoderPropID::kNumThreads, VT_UI4, L"mt" },
-  { NCoderPropID::kDefaultProp, VT_UI4, L"" }
-};
-
-static bool ConvertProperty(PROPVARIANT srcProp, VARTYPE varType, NCOM::CPropVariant &destProp)
-{
-  if (varType == srcProp.vt)
-  {
-    destProp = srcProp;
-    return true;
-  }
-  if (varType == VT_UI1)
-  {
-    if (srcProp.vt == VT_UI4)
-    {
-      UInt32 value = srcProp.ulVal;
-      if (value > 0xFF)
-        return false;
-      destProp = (Byte)value;
-      return true;
-    }
-  }
-  else if (varType == VT_BOOL)
-  {
-    bool res;
-    if (SetBoolProperty(res, srcProp) != S_OK)
-      return false;
-    destProp = res;
-    return true;
-  }
-  return false;
-}
-    
-static int FindPropIdExact(const UString &name)
-{
-  for (int i = 0; i < sizeof(g_NameToPropID) / sizeof(g_NameToPropID[0]); i++)
-    if (name.CompareNoCase(g_NameToPropID[i].Name) == 0)
-      return i;
-  return -1;
-}
-
-static int FindPropIdStart(const UString &name)
-{
-  for (int i = 0; i < sizeof(g_NameToPropID) / sizeof(g_NameToPropID[0]); i++)
-  {
-    UString t = g_NameToPropID[i].Name;
-    if (t.CompareNoCase(name.Left(t.Length())) == 0)
-      return i;
-  }
-  return -1;
-}
-
-static void SetMethodProp(COneMethodInfo &m, PROPID propID, const NCOM::CPropVariant &value)
-{
-  for (int j = 0; j < m.Props.Size(); j++)
-    if (m.Props[j].Id == propID)
-      return;
-  CProp prop;
-  prop.Id = propID;
-  prop.Value = value;
-  m.Props.Add(prop);
-}
-
-void COutHandler::SetCompressionMethod2(COneMethodInfo &oneMethodInfo
+void CMultiMethodProps::SetGlobalLevelAndThreads(COneMethodInfo &oneMethodInfo
    #ifndef _7ZIP_ST
    , UInt32 numThreads
    #endif
    )
 {
  UInt32 level = _level;
-  if (oneMethodInfo.MethodName.IsEmpty())
-    oneMethodInfo.MethodName = kDefaultMethodName;
-  
-  if (oneMethodInfo.IsLzma())
-  {
-    UInt32 dicSize =
-      (level >= 9 ? kLzmaDicSizeX9 :
-      (level >= 7 ? kLzmaDicSizeX7 :
-      (level >= 5 ? kLzmaDicSizeX5 :
-      (level >= 3 ? kLzmaDicSizeX3 :
-                    kLzmaDicSizeX1))));
-    
-    UInt32 algo =
-      (level >= 5 ? kLzmaAlgoX5 :
-                    kLzmaAlgoX1);
-    
-    UInt32 fastBytes =
-      (level >= 7 ? kLzmaFastBytesX7 :
-                    kLzmaFastBytesX1);
-    
-    const wchar_t *matchFinder =
-      (level >= 5 ? kLzmaMatchFinderX5 :
-                    kLzmaMatchFinderX1);
-    
-    SetMethodProp(oneMethodInfo, NCoderPropID::kDictionarySize, dicSize);
-    SetMethodProp(oneMethodInfo, NCoderPropID::kAlgorithm, algo);
-    SetMethodProp(oneMethodInfo, NCoderPropID::kNumFastBytes, fastBytes);
-    SetMethodProp(oneMethodInfo, NCoderPropID::kMatchFinder, matchFinder);
-    #ifndef _7ZIP_ST
-    SetMethodProp(oneMethodInfo, NCoderPropID::kNumThreads, numThreads);
-    #endif
-  }
-  else if (IsDeflateMethod(oneMethodInfo.MethodName))
-  {
-    UInt32 fastBytes =
-      (level >= 9 ? kDeflateFastBytesX9 :
-      (level >= 7 ? kDeflateFastBytesX7 :
-                    kDeflateFastBytesX1));
-    
-    UInt32 numPasses =
-      (level >= 9 ? kDeflatePassesX9 :
-      (level >= 7 ? kDeflatePassesX7 :
-                    kDeflatePassesX1));
-    
-    UInt32 algo =
-      (level >= 5 ? kDeflateAlgoX5 :
-                    kDeflateAlgoX1);
-    
-    SetMethodProp(oneMethodInfo, NCoderPropID::kAlgorithm, algo);
-    SetMethodProp(oneMethodInfo, NCoderPropID::kNumFastBytes, fastBytes);
-    SetMethodProp(oneMethodInfo, NCoderPropID::kNumPasses, numPasses);
-  }
-  else if (IsBZip2Method(oneMethodInfo.MethodName))
-  {
-    UInt32 numPasses =
-      (level >= 9 ? kBZip2NumPassesX9 :
-      (level >= 7 ? kBZip2NumPassesX7 :
-                    kBZip2NumPassesX1));
-    
-    UInt32 dicSize =
-      (level >= 5 ? kBZip2DicSizeX5 :
-      (level >= 3 ? kBZip2DicSizeX3 :
-                    kBZip2DicSizeX1));
-    
-    SetMethodProp(oneMethodInfo, NCoderPropID::kNumPasses, numPasses);
-    SetMethodProp(oneMethodInfo, NCoderPropID::kDictionarySize, dicSize);
-    #ifndef _7ZIP_ST
-    SetMethodProp(oneMethodInfo, NCoderPropID::kNumThreads, numThreads);
-    #endif
-  }
-  else if (IsPpmdMethod(oneMethodInfo.MethodName))
-  {
-    UInt32 useMemSize =
-      (level >= 9 ? kPpmdMemSizeX9 :
-      (level >= 7 ? kPpmdMemSizeX7 :
-      (level >= 5 ? kPpmdMemSizeX5 :
-                    kPpmdMemSizeX1)));
-    
-    UInt32 order =
-      (level >= 9 ? kPpmdOrderX9 :
-      (level >= 7 ? kPpmdOrderX7 :
-      (level >= 5 ? kPpmdOrderX5 :
-                    kPpmdOrderX1)));
-    
-    SetMethodProp(oneMethodInfo, NCoderPropID::kUsedMemorySize, useMemSize);
-    SetMethodProp(oneMethodInfo, NCoderPropID::kOrder, order);
-  }
-}
-
-static void SplitParams(const UString &srcString, UStringVector &subStrings)
-{
-  subStrings.Clear();
-  UString name;
-  int len = srcString.Length();
-  if (len == 0)
-    return;
-  for (int i = 0; i < len; i++)
-  {
-    wchar_t c = srcString[i];
-    if (c == L':')
-    {
-      subStrings.Add(name);
-      name.Empty();
-    }
-    else
-      name += c;
-  }
-  subStrings.Add(name);
-}
-
-static void SplitParam(const UString &param, UString &name, UString &value)
-{
-  int eqPos = param.Find(L'=');
-  if (eqPos >= 0)
-  {
-    name = param.Left(eqPos);
-    value = param.Mid(eqPos + 1);
-    return;
-  }
-  for(int i = 0; i < param.Length(); i++)
-  {
-    wchar_t c = param[i];
-    if (c >= L'0' && c <= L'9')
-    {
-      name = param.Left(i);
-      value = param.Mid(i);
-      return;
-    }
-  }
-  name = param;
-}
-
-HRESULT COutHandler::SetParam(COneMethodInfo &oneMethodInfo, const UString &name, const UString &value)
-{
-  CProp prop;
-  int index = FindPropIdExact(name);
-  if (index < 0)
-    return E_INVALIDARG;
-  const CNameToPropID &nameToPropID = g_NameToPropID[index];
-  prop.Id = nameToPropID.PropID;
-
-  if (prop.Id == NCoderPropID::kBlockSize ||
-      prop.Id == NCoderPropID::kDictionarySize ||
-      prop.Id == NCoderPropID::kUsedMemorySize)
-  {
-    UInt32 dicSize;
-    RINOK(ParsePropDictionaryValue(value, dicSize));
-    prop.Value = dicSize;
-  }
-  else
-  {
-    NCOM::CPropVariant propValue;
-    
-    if (nameToPropID.VarType == VT_BSTR)
-      propValue = value;
-    else if (nameToPropID.VarType == VT_BOOL)
-    {
-      bool res;
-      if (!StringToBool(value, res))
-        return E_INVALIDARG;
-      propValue = res;
-    }
-    else
-    {
-      UInt32 number;
-      if (ParseStringToUInt32(value, number) == value.Length())
-        propValue = number;
-      else
-        propValue = value;
-    }
-    
-    if (!ConvertProperty(propValue, nameToPropID.VarType, prop.Value))
-      return E_INVALIDARG;
-  }
-  oneMethodInfo.Props.Add(prop);
-  return S_OK;
-}
-
-HRESULT COutHandler::SetParams(COneMethodInfo &oneMethodInfo, const UString &srcString)
-{
-  UStringVector params;
-  SplitParams(srcString, params);
-  if (params.Size() > 0)
-    oneMethodInfo.MethodName = params[0];
-  for (int i = 1; i < params.Size(); i++)
-  {
-    const UString &param = params[i];
-    UString name, value;
-    SplitParam(param, name, value);
-    RINOK(SetParam(oneMethodInfo, name, value));
-  }
-  return S_OK;
-}
-
-HRESULT COutHandler::SetSolidSettings(const UString &s)
-{
-  UString s2 = s;
-  s2.MakeUpper();
-  for (int i = 0; i < s2.Length();)
-  {
-    const wchar_t *start = ((const wchar_t *)s2) + i;
-    const wchar_t *end;
-    UInt64 v = ConvertStringToUInt64(start, &end);
-    if (start == end)
-    {
-      if (s2[i++] != 'E')
-        return E_INVALIDARG;
-      _solidExtension = true;
-      continue;
-    }
-    i += (int)(end - start);
-    if (i == s2.Length())
-      return E_INVALIDARG;
-    wchar_t c = s2[i++];
-    switch(c)
-    {
-      case 'F':
-        if (v < 1)
-          v = 1;
-        _numSolidFiles = v;
-        break;
-      case 'B':
-        _numSolidBytes = v;
-        _numSolidBytesDefined = true;
-        break;
-      case 'K':
-        _numSolidBytes = (v << 10);
-        _numSolidBytesDefined = true;
-        break;
-      case 'M':
-        _numSolidBytes = (v << 20);
-        _numSolidBytesDefined = true;
-        break;
-      case 'G':
-        _numSolidBytes = (v << 30);
-        _numSolidBytesDefined = true;
-        break;
-      default:
-        return E_INVALIDARG;
-    }
-  }
-  return S_OK;
-}
-
-HRESULT COutHandler::SetSolidSettings(const PROPVARIANT &value)
-{
-  bool isSolid;
-  switch(value.vt)
-  {
-    case VT_EMPTY:
-      isSolid = true;
-      break;
-    case VT_BOOL:
-      isSolid = (value.boolVal != VARIANT_FALSE);
-      break;
-    case VT_BSTR:
-      if (StringToBool(value.bstrVal, isSolid))
-        break;
-      return SetSolidSettings(value.bstrVal);
-    default:
-      return E_INVALIDARG;
-  }
-  if (isSolid)
-    InitSolid();
-  else
-    _numSolidFiles = 1;
-  return S_OK;
-}
-
-void COutHandler::Init()
-{
-  _removeSfxBlock = false;
-  _compressHeaders = true;
-  _encryptHeadersSpecified = false;
-  _encryptHeaders = false;
-  
-  WriteCTime = false;
-  WriteATime = false;
-  WriteMTime = true;
-  
+  if (level != (UInt32)(UInt32)-1)
+    SetMethodProp32(oneMethodInfo, NCoderPropID::kLevel, (UInt32)level);
  #ifndef _7ZIP_ST
-  _numThreads = NSystem::GetNumberOfProcessors();
+  SetMethodProp32(oneMethodInfo, NCoderPropID::kNumThreads, numThreads);
+  #endif
+}
+
+void CMultiMethodProps::Init()
+{
+  #ifndef _7ZIP_ST
+  _numProcessors = _numThreads = NSystem::GetNumberOfProcessors();
  #endif
  
-  _level = 5;
+  _level = (UInt32)(UInt32)-1;
  _autoFilter = true;
-  _volumeMode = false;
  _crcSize = 4;
-  InitSolid();
+  _filterMethod.Clear();
+  _methods.Clear();
 }

-void COutHandler::BeforeSetProperty()
-{
-  Init();
-  #ifndef _7ZIP_ST
-  numProcessors = NSystem::GetNumberOfProcessors();
-  #endif
-
-  mainDicSize = 0xFFFFFFFF;
-  mainDicMethodIndex = 0xFFFFFFFF;
-  minNumber = 0;
-  _crcSize = 4;
-}
-
-HRESULT COutHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
+HRESULT CMultiMethodProps::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
 {
  UString name = nameSpec;
  name.MakeUpper();
@@ -511,24 +58,14 @@ HRESULT COutHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &val
  {
    name.Delete(0);
    _level = 9;
-    return ParsePropValue(name, value, _level);
-  }
-  
-  if (name[0] == L'S')
-  {
-    name.Delete(0);
-    if (name.IsEmpty())
-      return SetSolidSettings(value);
-    if (value.vt != VT_EMPTY)
-      return E_INVALIDARG;
-    return SetSolidSettings(name);
+    return ParsePropToUInt32(name, value, _level);
  }
  
  if (name == L"CRC")
  {
-    _crcSize = 4;
    name.Delete(0, 3);
-    return ParsePropValue(name, value, _crcSize);
+    _crcSize = 4;
+    return ParsePropToUInt32(name, value, _crcSize);
  }
  
  UInt32 number;
@@ -536,86 +73,67 @@ HRESULT COutHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &val
  UString realName = name.Mid(index);
  if (index == 0)
  {
-    if(name.Left(2).CompareNoCase(L"MT") == 0)
+    if (name.Left(2).CompareNoCase(L"MT") == 0)
    {
      #ifndef _7ZIP_ST
-      RINOK(ParseMtProp(name.Mid(2), value, numProcessors, _numThreads));
+      RINOK(ParseMtProp(name.Mid(2), value, _numProcessors, _numThreads));
      #endif
      return S_OK;
    }
-    if (name.CompareNoCase(L"RSFX") == 0)  return SetBoolProperty(_removeSfxBlock, value);
-    if (name.CompareNoCase(L"F") == 0) return SetBoolProperty(_autoFilter, value);
-    if (name.CompareNoCase(L"HC") == 0) return SetBoolProperty(_compressHeaders, value);
-    if (name.CompareNoCase(L"HCF") == 0)
+    if (name.CompareNoCase(L"F") == 0)
    {
-      bool compressHeadersFull = true;
-      RINOK(SetBoolProperty(compressHeadersFull, value));
-      if (!compressHeadersFull)
+      HRESULT res = PROPVARIANT_to_bool(value, _autoFilter);
+      if (res == S_OK)
+        return res;
+      if (value.vt != VT_BSTR)
        return E_INVALIDARG;
-      return S_OK;
+      return _filterMethod.ParseMethodFromPROPVARIANT(L"", value);
    }
-    if (name.CompareNoCase(L"HE") == 0)
-    {
-      RINOK(SetBoolProperty(_encryptHeaders, value));
-      _encryptHeadersSpecified = true;
-      return S_OK;
-    }
-    if (name.CompareNoCase(L"TC") == 0) return SetBoolProperty(WriteCTime, value);
-    if (name.CompareNoCase(L"TA") == 0) return SetBoolProperty(WriteATime, value);
-    if (name.CompareNoCase(L"TM") == 0) return SetBoolProperty(WriteMTime, value);
-    if (name.CompareNoCase(L"V") == 0) return SetBoolProperty(_volumeMode, value);
    number = 0;
  }
-  if (number > 10000)
+  if (number > 64)
    return E_FAIL;
-  if (number < minNumber)
-    return E_INVALIDARG;
-  number -= minNumber;
-  for(int j = _methods.Size(); j <= (int)number; j++)
-  {
-    COneMethodInfo oneMethodInfo;
-    _methods.Add(oneMethodInfo);
-  }
-  
-  COneMethodInfo &oneMethodInfo = _methods[number];
-  
-  if (realName.Length() == 0)
-  {
-    if (value.vt != VT_BSTR)
-      return E_INVALIDARG;
-    
-    RINOK(SetParams(oneMethodInfo, value.bstrVal));
-  }
-  else
-  {
-    int index = FindPropIdStart(realName);
-    if (index < 0)
-      return E_INVALIDARG;
-    const CNameToPropID &nameToPropID = g_NameToPropID[index];
-    CProp prop;
-    prop.Id = nameToPropID.PropID;
+  for (int j = _methods.Size(); j <= (int)number; j++)
+    _methods.Add(COneMethodInfo());
+  return _methods[number].ParseMethodFromPROPVARIANT(realName, value);
+}

-    if (prop.Id == NCoderPropID::kBlockSize ||
-        prop.Id == NCoderPropID::kDictionarySize ||
-        prop.Id == NCoderPropID::kUsedMemorySize)
+void CSingleMethodProps::Init()
+{
+  Clear();
+  #ifndef _7ZIP_ST
+  _numProcessors = _numThreads = NWindows::NSystem::GetNumberOfProcessors();
+  AddNumThreadsProp(_numThreads);
+  #endif
+  _level = (UInt32)(UInt32)-1;
+}
+
+HRESULT CSingleMethodProps::SetProperties(const wchar_t **names, const PROPVARIANT *values, Int32 numProps)
+{
+  Init();
+  for (int i = 0; i < numProps; i++)
+  {
+    UString name = names[i];
+    name.MakeUpper();
+    if (name.IsEmpty())
+      return E_INVALIDARG;
+    const PROPVARIANT &value = values[i];
+    if (name[0] == L'X')
    {
-      UInt32 dicSize;
-      RINOK(ParsePropDictionaryValue(realName.Mid(MyStringLen(nameToPropID.Name)), value, dicSize));
-      prop.Value = dicSize;
-      if (number <= mainDicMethodIndex)
-        mainDicSize = dicSize;
+      UInt32 a = 9;
+      RINOK(ParsePropToUInt32(name.Mid(1), value, a));
+      _level = a;
+      AddLevelProp(a);
+    }
+    else if (name.Left(2).CompareNoCase(L"MT") == 0)
+    {
+      #ifndef _7ZIP_ST
+      RINOK(ParseMtProp(name.Mid(2), value, _numProcessors, _numThreads));
+      AddNumThreadsProp(_numThreads);
+      #endif
    }
    else
-    {
-      int index = FindPropIdExact(realName);
-      if (index < 0)
-        return E_INVALIDARG;
-      const CNameToPropID &nameToPropID = g_NameToPropID[index];
-      prop.Id = nameToPropID.PropID;
-      if (!ConvertProperty(value, nameToPropID.VarType, prop.Value))
-        return E_INVALIDARG;
-    }
-    oneMethodInfo.Props.Add(prop);
+      return ParseParamsFromPROPVARIANT(name, value);
  }
  return S_OK;
 }
--- a/CPP/7zip/Archive/Common/HandlerOut.h
+++ b/CPP/7zip/Archive/Common/HandlerOut.h
@@ -3,83 +3,61 @@
 #ifndef __HANDLER_OUT_H
 #define __HANDLER_OUT_H

-#include "../../../Common/MyString.h"
 #include "../../Common/MethodProps.h"

 namespace NArchive {

-struct COneMethodInfo
-{
-  CObjectVector<CProp> Props;
-  UString MethodName;
-
-  bool IsLzma() const;
-};
-
-class COutHandler
+class CMultiMethodProps
 {
+  UInt32 _level;
 public:
-  HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
-  
-  HRESULT SetSolidSettings(const UString &s);
-  HRESULT SetSolidSettings(const PROPVARIANT &value);
-
  #ifndef _7ZIP_ST
  UInt32 _numThreads;
+  UInt32 _numProcessors;
  #endif

  UInt32 _crcSize;
-
  CObjectVector<COneMethodInfo> _methods;
-  bool _removeSfxBlock;
-  
-  UInt64 _numSolidFiles;
-  UInt64 _numSolidBytes;
-  bool _numSolidBytesDefined;
-  bool _solidExtension;
-
-  bool _compressHeaders;
-  bool _encryptHeadersSpecified;
-  bool _encryptHeaders;
-
-  bool WriteCTime;
-  bool WriteATime;
-  bool WriteMTime;
-
+  COneMethodInfo _filterMethod;
  bool _autoFilter;
-  UInt32 _level;

-  bool _volumeMode;
-
-  HRESULT SetParam(COneMethodInfo &oneMethodInfo, const UString &name, const UString &value);
-  HRESULT SetParams(COneMethodInfo &oneMethodInfo, const UString &srcString);
-
-  void SetCompressionMethod2(COneMethodInfo &oneMethodInfo
+  void SetGlobalLevelAndThreads(COneMethodInfo &oneMethodInfo
      #ifndef _7ZIP_ST
      , UInt32 numThreads
      #endif
      );

-  void InitSolidFiles() { _numSolidFiles = (UInt64)(Int64)(-1); }
-  void InitSolidSize()  { _numSolidBytes = (UInt64)(Int64)(-1); }
-  void InitSolid()
+  int GetNumEmptyMethods() const
  {
-    InitSolidFiles();
-    InitSolidSize();
-    _solidExtension = false;
-    _numSolidBytesDefined = false;
+    int i;
+    for (i = 0; i < _methods.Size(); i++)
+      if (!_methods[i].IsEmpty())
+        break;
+    return i;
  }

+  int GetLevel() const { return _level == (UInt32)(UInt32)-1 ? 5 : (int)_level; }
+
  void Init();

-  COutHandler() { Init(); }
+  CMultiMethodProps() { Init(); }
+  HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
+};

-  void BeforeSetProperty();
+class CSingleMethodProps: public CMethodProps
+{
+  UInt32 _level;
+  
+  void Init();
+public:
+  #ifndef _7ZIP_ST
+  UInt32 _numThreads;
+  UInt32 _numProcessors;
+  #endif

-  UInt32 minNumber;
-  UInt32 numProcessors;
-  UInt32 mainDicSize;
-  UInt32 mainDicMethodIndex;
+  CSingleMethodProps() { Init(); }
+  int GetLevel() const { return _level == (UInt32)(UInt32)-1 ? 5 : (int)_level; }
+  HRESULT SetProperties(const wchar_t **names, const PROPVARIANT *values, Int32 numProps);
 };

 }
--- a/CPP/7zip/Archive/Common/ItemNameUtils.cpp
+++ b/CPP/7zip/Archive/Common/ItemNameUtils.cpp
@@ -2,6 +2,8 @@

 #include "StdAfx.h"

+#include "../../../../C/Types.h"
+
 #include "ItemNameUtils.h"

 namespace NArchive {
@@ -29,8 +31,8 @@ UString GetOSName2(const UString &name)
  if (name.IsEmpty())
    return UString();
  UString newName = GetOSName(name);
-  if (newName[newName.Length() - 1] == kOSDirDelimiter)
-    newName.Delete(newName.Length() - 1);
+  if (newName.Back() == kOSDirDelimiter)
+    newName.DeleteBack();
  return newName;
 }

--- a/CPP/7zip/Archive/Common/MultiStream.cpp
+++ b/CPP/7zip/Archive/Common/MultiStream.cpp
@@ -6,72 +6,61 @@

 STDMETHODIMP CMultiStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
-  if(processedSize != NULL)
+  if (processedSize)
    *processedSize = 0;
-  while(_streamIndex < Streams.Size() && size > 0)
+  if (size == 0)
+    return S_OK;
+  if (_pos >= _totalLength)
+    return (_pos == _totalLength) ? S_OK : E_FAIL;
+
  {
-    CSubStreamInfo &s = Streams[_streamIndex];
-    if (_pos == s.Size)
+    int left = 0, mid = _streamIndex, right = Streams.Size();
+    for (;;)
    {
-      _streamIndex++;
-      _pos = 0;
-      continue;
+      CSubStreamInfo &m = Streams[mid];
+      if (_pos < m.GlobalOffset)
+        right = mid;
+      else if (_pos >= m.GlobalOffset + m.Size)
+        left = mid + 1;
+      else
+      {
+        _streamIndex = mid;
+        break;
+      }
+      mid = (left + right) / 2;
    }
-    RINOK(s.Stream->Seek(s.Pos + _pos, STREAM_SEEK_SET, 0));
-    UInt32 sizeToRead = UInt32(MyMin((UInt64)size, s.Size - _pos));
-    UInt32 realProcessed;
-    HRESULT result = s.Stream->Read(data, sizeToRead, &realProcessed);
-    data = (void *)((Byte *)data + realProcessed);
-    size -= realProcessed;
-    if(processedSize != NULL)
-      *processedSize += realProcessed;
-    _pos += realProcessed;
-    _seekPos += realProcessed;
-    RINOK(result);
-    break;
+    _streamIndex = mid;
  }
-  return S_OK;
+  
+  CSubStreamInfo &s = Streams[_streamIndex];
+  UInt64 localPos = _pos - s.GlobalOffset;
+  if (localPos != s.LocalPos)
+  {
+    RINOK(s.Stream->Seek(localPos, STREAM_SEEK_SET, &s.LocalPos));
+  }
+  UInt64 rem = s.Size - localPos;
+  if (size > rem)
+    size = (UInt32)rem;
+  HRESULT result = s.Stream->Read(data, size, &size);
+  _pos += size;
+  s.LocalPos += size;
+  if (processedSize)
+    *processedSize = size;
+  return result;
 }
  
-STDMETHODIMP CMultiStream::Seek(Int64 offset, UInt32 seekOrigin,
-    UInt64 *newPosition)
+STDMETHODIMP CMultiStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
-  UInt64 newPos;
  switch(seekOrigin)
  {
-    case STREAM_SEEK_SET:
-      newPos = offset;
-      break;
-    case STREAM_SEEK_CUR:
-      newPos = _seekPos + offset;
-      break;
-    case STREAM_SEEK_END:
-      newPos = _totalLength + offset;
-      break;
-    default:
-      return STG_E_INVALIDFUNCTION;
+    case STREAM_SEEK_SET: _pos = offset; break;
+    case STREAM_SEEK_CUR: _pos = _pos + offset; break;
+    case STREAM_SEEK_END: _pos = _totalLength + offset; break;
+    default: return STG_E_INVALIDFUNCTION;
  }
-  _seekPos = 0;
-  for (_streamIndex = 0; _streamIndex < Streams.Size(); _streamIndex++)
-  {
-    UInt64 size = Streams[_streamIndex].Size;
-    if (newPos < _seekPos + size)
-    {
-      _pos = newPos - _seekPos;
-      _seekPos += _pos;
-      if (newPosition != 0)
-        *newPosition = newPos;
-      return S_OK;
-    }
-    _seekPos += size;
-  }
-  if (newPos == _seekPos)
-  {
-    if (newPosition != 0)
-      *newPosition = newPos;
-    return S_OK;
-  }
-  return E_FAIL;
+  if (newPosition != 0)
+    *newPosition = _pos;
+  return S_OK;
 }


--- a/CPP/7zip/Archive/Common/MultiStream.h
+++ b/CPP/7zip/Archive/Common/MultiStream.h
@@ -1,36 +1,44 @@
 // MultiStream.h

-#ifndef __MULTISTREAM_H
-#define __MULTISTREAM_H
+#ifndef __MULTI_STREAM_H
+#define __MULTI_STREAM_H

 #include "../../../Common/MyCom.h"
 #include "../../../Common/MyVector.h"
-#include "../../Archive/IArchive.h"
+
+#include "../../IStream.h"

 class CMultiStream:
  public IInStream,
  public CMyUnknownImp
 {
-  int _streamIndex;
  UInt64 _pos;
-  UInt64 _seekPos;
  UInt64 _totalLength;
+  int _streamIndex;
 public:
  struct CSubStreamInfo
  {
    CMyComPtr<IInStream> Stream;
-    UInt64 Pos;
    UInt64 Size;
+    UInt64 GlobalOffset;
+    UInt64 LocalPos;
  };
  CObjectVector<CSubStreamInfo> Streams;
-  void Init()
+  
+  HRESULT Init()
  {
-    _streamIndex = 0;
-    _pos = 0;
-    _seekPos = 0;
-    _totalLength = 0;
+    UInt64 total = 0;
    for (int i = 0; i < Streams.Size(); i++)
-      _totalLength += Streams[i].Size;
+    {
+      CSubStreamInfo &s = Streams[i];
+      s.GlobalOffset = total;
+      total += Streams[i].Size;
+      RINOK(s.Stream->Seek(0, STREAM_SEEK_CUR, &s.LocalPos));
+    }
+    _totalLength = total;
+    _pos = 0;
+    _streamIndex = 0;
+    return S_OK;
  }

  MY_UNKNOWN_IMP1(IInStream)
--- a/CPP/7zip/Archive/Common/ParseProperties.cpp
+++ b/CPP/7zip/Archive/Common/ParseProperties.cpp
@@ -1,177 +1,3 @@
 // ParseProperties.cpp

 #include "StdAfx.h"
-
-#include "ParseProperties.h"
-
-#include "Common/StringToInt.h"
-#include "Common/MyCom.h"
-
-HRESULT ParsePropValue(const UString &name, const PROPVARIANT &prop, UInt32 &resValue)
-{
-  if (prop.vt == VT_UI4)
-  {
-    if (!name.IsEmpty())
-      return E_INVALIDARG;
-    resValue = prop.ulVal;
-  }
-  else if (prop.vt == VT_EMPTY)
-  {
-    if(!name.IsEmpty())
-    {
-      const wchar_t *start = name;
-      const wchar_t *end;
-      UInt64 v = ConvertStringToUInt64(start, &end);
-      if (end - start != name.Length())
-        return E_INVALIDARG;
-      resValue = (UInt32)v;
-    }
-  }
-  else
-    return E_INVALIDARG;
-  return S_OK;
-}
-
-static const int kLogarithmicSizeLimit = 32;
-static const wchar_t kByteSymbol = L'B';
-static const wchar_t kKiloByteSymbol = L'K';
-static const wchar_t kMegaByteSymbol = L'M';
-
-HRESULT ParsePropDictionaryValue(const UString &srcStringSpec, UInt32 &dicSize)
-{
-  UString srcString = srcStringSpec;
-  srcString.MakeUpper();
-
-  const wchar_t *start = srcString;
-  const wchar_t *end;
-  UInt64 number = ConvertStringToUInt64(start, &end);
-  int numDigits = (int)(end - start);
-  if (numDigits == 0 || srcString.Length() > numDigits + 1)
-    return E_INVALIDARG;
-  if (srcString.Length() == numDigits)
-  {
-    if (number >= kLogarithmicSizeLimit)
-      return E_INVALIDARG;
-    dicSize = (UInt32)1 << (int)number;
-    return S_OK;
-  }
-  switch (srcString[numDigits])
-  {
-    case kByteSymbol:
-      if (number >= ((UInt64)1 << kLogarithmicSizeLimit))
-        return E_INVALIDARG;
-      dicSize = (UInt32)number;
-      break;
-    case kKiloByteSymbol:
-      if (number >= ((UInt64)1 << (kLogarithmicSizeLimit - 10)))
-        return E_INVALIDARG;
-      dicSize = (UInt32)(number << 10);
-      break;
-    case kMegaByteSymbol:
-      if (number >= ((UInt64)1 << (kLogarithmicSizeLimit - 20)))
-        return E_INVALIDARG;
-      dicSize = (UInt32)(number << 20);
-      break;
-    default:
-      return E_INVALIDARG;
-  }
-  return S_OK;
-}
-
-HRESULT ParsePropDictionaryValue(const UString &name, const PROPVARIANT &prop, UInt32 &resValue)
-{
-  if (name.IsEmpty())
-  {
-    if (prop.vt == VT_UI4)
-    {
-      UInt32 logDicSize = prop.ulVal;
-      if (logDicSize >= 32)
-        return E_INVALIDARG;
-      resValue = (UInt32)1 << logDicSize;
-      return S_OK;
-    }
-    if (prop.vt == VT_BSTR)
-      return ParsePropDictionaryValue(prop.bstrVal, resValue);
-    return E_INVALIDARG;
-  }
-  return ParsePropDictionaryValue(name, resValue);
-}
-
-bool StringToBool(const UString &s, bool &res)
-{
-  if (s.IsEmpty() || s.CompareNoCase(L"ON") == 0 || s.Compare(L"+") == 0)
-  {
-    res = true;
-    return true;
-  }
-  if (s.CompareNoCase(L"OFF") == 0 || s.Compare(L"-") == 0)
-  {
-    res = false;
-    return true;
-  }
-  return false;
-}
-
-HRESULT SetBoolProperty(bool &dest, const PROPVARIANT &value)
-{
-  switch(value.vt)
-  {
-    case VT_EMPTY:
-      dest = true;
-      return S_OK;
-    case VT_BOOL:
-      dest = (value.boolVal != VARIANT_FALSE);
-      return S_OK;
-    /*
-    case VT_UI4:
-      dest = (value.ulVal != 0);
-      break;
-    */
-    case VT_BSTR:
-      return StringToBool(value.bstrVal, dest) ?  S_OK : E_INVALIDARG;
-  }
-  return E_INVALIDARG;
-}
-
-int ParseStringToUInt32(const UString &srcString, UInt32 &number)
-{
-  const wchar_t *start = srcString;
-  const wchar_t *end;
-  UInt64 number64 = ConvertStringToUInt64(start, &end);
-  if (number64 > 0xFFFFFFFF)
-  {
-    number = 0;
-    return 0;
-  }
-  number = (UInt32)number64;
-  return (int)(end - start);
-}
-
-HRESULT ParseMtProp(const UString &name, const PROPVARIANT &prop, UInt32 defaultNumThreads, UInt32 &numThreads)
-{
-  if (name.IsEmpty())
-  {
-    switch(prop.vt)
-    {
-      case VT_UI4:
-        numThreads = prop.ulVal;
-        break;
-      default:
-      {
-        bool val;
-        RINOK(SetBoolProperty(val, prop));
-        numThreads = (val ? defaultNumThreads : 1);
-        break;
-      }
-    }
-  }
-  else
-  {
-    UInt32 number;
-    int index = ParseStringToUInt32(name, number);
-    if (index != name.Length())
-      return E_INVALIDARG;
-    numThreads = number;
-  }
-  return S_OK;
-}
--- a/CPP/7zip/Archive/Common/ParseProperties.h
+++ b/CPP/7zip/Archive/Common/ParseProperties.h
@@ -1,18 +1,6 @@
 // ParseProperties.h

-#ifndef __PARSEPROPERTIES_H
-#define __PARSEPROPERTIES_H
-
-#include "Common/MyString.h"
-#include "Common/Types.h"
-
-HRESULT ParsePropValue(const UString &name, const PROPVARIANT &prop, UInt32 &resValue);
-HRESULT ParsePropDictionaryValue(const UString &srcStringSpec, UInt32 &dicSize);
-HRESULT ParsePropDictionaryValue(const UString &name, const PROPVARIANT &prop, UInt32 &resValue);
-
-bool StringToBool(const UString &s, bool &res);
-HRESULT SetBoolProperty(bool &dest, const PROPVARIANT &value);
-int ParseStringToUInt32(const UString &srcString, UInt32 &number);
-HRESULT ParseMtProp(const UString &name, const PROPVARIANT &prop, UInt32 defaultNumThreads, UInt32 &numThreads);
+#ifndef __PARSE_PROPERTIES_H
+#define __PARSE_PROPERTIES_H

 #endif
--- a/CPP/7zip/Archive/CramfsHandler.cpp
+++ b/CPP/7zip/Archive/CramfsHandler.cpp
@@ -0,0 +1,644 @@
+// CramfsHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/7zCrc.h"
+#include "../../../C/CpuArch.h"
+#include "../../../C/Alloc.h"
+
+#include "Common/ComTry.h"
+#include "Common/StringConvert.h"
+
+#include "Windows/PropVariantUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+#include "../Compress/ZlibDecoder.h"
+
+namespace NArchive {
+namespace NCramfs {
+
+#define SIGNATURE { 'C','o','m','p','r','e','s','s','e','d',' ','R','O','M','F','S' }
+
+static const UInt32 kSignatureSize = 16;
+static const char kSignature[kSignatureSize] = SIGNATURE;
+
+static const UInt32 kArcSizeMax = (256 + 16) << 20;
+static const UInt32 kNumFilesMax = (1 << 19);
+static const unsigned kNumDirLevelsMax = (1 << 8);
+
+static const UInt32 kHeaderSize = 0x40;
+static const unsigned kHeaderNameSize = 16;
+static const UInt32 kNodeSize = 12;
+
+static const UInt32 kFlag_FsVer2 = (1 << 0);
+
+static const CUInt32PCharPair k_Flags[] =
+{
+  { 0, "Ver2" },
+  { 1, "SortedDirs" },
+  { 8, "Holes" },
+  { 9, "WrongSignature" },
+  { 10, "ShiftedRootOffset" }
+};
+
+static const unsigned kBlockSizeLog = 12;
+static const UInt32 kBlockSize = 1 << kBlockSizeLog;
+
+/*
+struct CNode
+{
+  UInt16 Mode;
+  UInt16 Uid;
+  UInt32 Size;
+  Byte Gid;
+  UInt32 NameLen;
+  UInt32 Offset;
+
+  void Parse(const Byte *p)
+  {
+    Mode = GetUi16(p);
+    Uid = GetUi16(p + 2);
+    Size = Get32(p + 4) & 0xFFFFFF;
+    Gid = p[7];
+    NameLen = p[8] & 0x3F;
+    Offset = Get32(p + 8) >> 6;
+  }
+};
+*/
+
+#define Get32(p) (be ? GetBe32(p) : GetUi32(p))
+
+static UInt32 GetMode(const Byte *p, bool be) { return be ? GetBe16(p) : GetUi16(p); }
+static bool IsDir(const Byte *p, bool be) { return (GetMode(p, be) & 0xF000) == 0x4000; }
+
+static UInt32 GetSize(const Byte *p, bool be)
+{
+  if (be)
+    return GetBe32(p + 4) >> 8;
+  else
+    return GetUi32(p + 4) & 0xFFFFFF;
+}
+
+static UInt32 GetNameLen(const Byte *p, bool be)
+{
+  if (be)
+    return (p[8] & 0xFC);
+  else
+    return (p[8] & 0x3F) << 2;
+}
+
+static UInt32 GetOffset(const Byte *p, bool be)
+{
+  if (be)
+    return (GetBe32(p + 8) & 0x03FFFFFF) << 2;
+  else
+    return GetUi32(p + 8) >> 6 << 2;
+}
+
+struct CItem
+{
+  UInt32 Offset;
+  int Parent;
+};
+
+struct CHeader
+{
+  bool be;
+  UInt32 Size;
+  UInt32 Flags;
+  // UInt32 Future;
+  UInt32 Crc;
+  // UInt32 Edition;
+  UInt32 NumBlocks;
+  UInt32 NumFiles;
+  char Name[kHeaderNameSize];
+
+  bool Parse(const Byte *p)
+  {
+    if (memcmp(p + 16, kSignature, kSignatureSize) != 0)
+      return false;
+    switch(GetUi32(p))
+    {
+      case 0x28CD3D45: be = false; break;
+      case 0x453DCD28: be = true; break;
+      default: return false;
+    }
+    Size = Get32(p + 4);
+    Flags = Get32(p + 8);
+    // Future = Get32(p + 0xC);
+    Crc = Get32(p + 0x20);
+    // Edition = Get32(p + 0x24);
+    NumBlocks = Get32(p + 0x28);
+    NumFiles = Get32(p + 0x2C);
+    memcpy(Name, p + 0x30, kHeaderNameSize);
+    return true;
+  }
+
+  bool IsVer2() const { return (Flags & kFlag_FsVer2) != 0; }
+};
+
+class CHandler:
+  public IInArchive,
+  public IInArchiveGetStream,
+  public CMyUnknownImp
+{
+  CRecordVector<CItem> _items;
+  CMyComPtr<IInStream> _stream;
+  Byte *_data;
+  UInt32 _size;
+  UInt32 _headersSize;
+  AString _errorMessage;
+  CHeader _h;
+
+  // Current file
+
+  NCompress::NZlib::CDecoder *_zlibDecoderSpec;
+  CMyComPtr<ICompressCoder> _zlibDecoder;
+  
+  CBufInStream *_inStreamSpec;
+  CMyComPtr<ISequentialInStream> _inStream;
+
+  CBufPtrSeqOutStream *_outStreamSpec;
+  CMyComPtr<ISequentialOutStream> _outStream;
+
+  UInt32 _curBlocksOffset;
+  UInt32 _curNumBlocks;
+
+  HRESULT OpenDir(int parent, UInt32 baseOffsetBase, unsigned level);
+  HRESULT Open2(IInStream *inStream);
+  AString GetPath(int index) const;
+  bool GetPackSize(int index, UInt32 &res) const;
+  void Free();
+public:
+  CHandler(): _data(0) {}
+  ~CHandler() { Free(); }
+  MY_UNKNOWN_IMP2(IInArchive, IInArchiveGetStream)
+  INTERFACE_IInArchive(;)
+  STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
+  HRESULT ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize);
+};
+
+static const STATPROPSTG kProps[] =
+{
+  { NULL, kpidPath, VT_BSTR},
+  { NULL, kpidIsDir, VT_BOOL},
+  { NULL, kpidSize, VT_UI4},
+  { NULL, kpidPackSize, VT_UI4},
+  { NULL, kpidPosixAttrib, VT_UI4}
+  // { NULL, kpidOffset, VT_UI4}
+};
+
+static const STATPROPSTG kArcProps[] =
+{
+  { NULL, kpidName, VT_BSTR},
+  { NULL, kpidBigEndian, VT_BOOL},
+  { NULL, kpidCharacts, VT_BSTR},
+  { NULL, kpidPhySize, VT_UI4},
+  { NULL, kpidHeadersSize, VT_UI4},
+  { NULL, kpidNumSubFiles, VT_UI4},
+  { NULL, kpidNumBlocks, VT_UI4}
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+HRESULT CHandler::OpenDir(int parent, UInt32 baseOffset, unsigned level)
+{
+  const Byte *p = _data + baseOffset;
+  bool be = _h.be;
+  if (!IsDir(p, be))
+    return S_OK;
+  UInt32 offset = GetOffset(p, be);
+  UInt32 size = GetSize(p, be);
+  if (offset == 0 && size == 0)
+    return S_OK;
+  UInt32 end = offset + size;
+  if (offset < kHeaderSize || end > _size || level > kNumDirLevelsMax)
+    return S_FALSE;
+  if (end > _headersSize)
+    _headersSize = end;
+
+  int startIndex = _items.Size();
+  
+  while (size != 0)
+  {
+    if (size < kNodeSize || (UInt32)_items.Size() >= kNumFilesMax)
+      return S_FALSE;
+    CItem item;
+    item.Parent = parent;
+    item.Offset = offset;
+    _items.Add(item);
+    UInt32 nodeLen = kNodeSize + GetNameLen(_data + offset, be);
+    if (size < nodeLen)
+      return S_FALSE;
+    offset += nodeLen;
+    size -= nodeLen;
+  }
+
+  int endIndex = _items.Size();
+  for (int i = startIndex; i < endIndex; i++)
+  {
+    RINOK(OpenDir(i, _items[i].Offset, level + 1));
+  }
+  return S_OK;
+}
+
+HRESULT CHandler::Open2(IInStream *inStream)
+{
+  Byte buf[kHeaderSize];
+  RINOK(ReadStream_FALSE(inStream, buf, kHeaderSize));
+  if (!_h.Parse(buf))
+    return S_FALSE;
+  if (_h.IsVer2())
+  {
+    if (_h.Size < kHeaderSize || _h.Size > kArcSizeMax || _h.NumFiles > kNumFilesMax)
+      return S_FALSE;
+  }
+  else
+  {
+    UInt64 size;
+    RINOK(inStream->Seek(0, STREAM_SEEK_END, &size));
+    if (size > kArcSizeMax)
+      return S_FALSE;
+    _h.Size = (UInt32)size;
+    RINOK(inStream->Seek(kHeaderSize, STREAM_SEEK_SET, NULL));
+  }
+  _data = (Byte *)MidAlloc(_h.Size);
+  if (_data == 0)
+    return E_OUTOFMEMORY;
+  memcpy(_data, buf, kHeaderSize);
+  size_t processed = _h.Size - kHeaderSize;
+  RINOK(ReadStream(inStream, _data + kHeaderSize, &processed));
+  if (processed < kNodeSize)
+    return S_FALSE;
+  _size = kHeaderSize + (UInt32)processed;
+  if (_size != _h.Size)
+    _errorMessage = "Unexpected end of archive";
+  else
+  {
+    SetUi32(_data + 0x20, 0);
+    if (_h.IsVer2())
+      if (CrcCalc(_data, _h.Size) != _h.Crc)
+        _errorMessage = "CRC error";
+  }
+  if (_h.IsVer2())
+    _items.Reserve(_h.NumFiles - 1);
+  return OpenDir(-1, kHeaderSize, 0);
+}
+
+AString CHandler::GetPath(int index) const
+{
+  unsigned len = 0;
+  int indexMem = index;
+  do
+  {
+    const CItem &item = _items[index];
+    index = item.Parent;
+    const Byte *p = _data + item.Offset;
+    unsigned size = GetNameLen(p, _h.be);
+    p += kNodeSize;
+    unsigned i;
+    for (i = 0; i < size && p[i]; i++);
+    len += i + 1;
+  }
+  while (index >= 0);
+  len--;
+
+  AString path;
+  char *dest = path.GetBuffer(len) + len;
+  index = indexMem;
+  for (;;)
+  {
+    const CItem &item = _items[index];
+    index = item.Parent;
+    const Byte *p = _data + item.Offset;
+    unsigned size = GetNameLen(p, _h.be);
+    p += kNodeSize;
+    unsigned i;
+    for (i = 0; i < size && p[i]; i++);
+    dest -= i;
+    memcpy(dest, p, i);
+    if (index < 0)
+      break;
+    *(--dest) = CHAR_PATH_SEPARATOR;
+  }
+  path.ReleaseBuffer(len);
+  return path;
+}
+
+bool CHandler::GetPackSize(int index, UInt32 &res) const
+{
+  const CItem &item = _items[index];
+  const Byte *p = _data + item.Offset;
+  bool be = _h.be;
+  UInt32 offset = GetOffset(p, be);
+  if (offset < kHeaderSize)
+    return false;
+  UInt32 numBlocks = (GetSize(p, be) + kBlockSize - 1) >> kBlockSizeLog;
+  UInt32 start = offset + numBlocks * 4;
+  if (start > _size)
+    return false;
+  UInt32 end = Get32(_data + start - 4);
+  if (end < start)
+    return false;
+  res = end - start;
+  return true;
+}
+
+STDMETHODIMP CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback * /* callback */)
+{
+  COM_TRY_BEGIN
+  {
+    Close();
+    RINOK(Open2(stream));
+    _stream = stream;
+  }
+  return S_OK;
+  COM_TRY_END
+}
+
+void CHandler::Free()
+{
+  MidFree(_data);
+  _data = 0;
+}
+
+STDMETHODIMP CHandler::Close()
+{
+  _headersSize = 0;
+  _items.Clear();
+  _stream.Release();
+  _errorMessage.Empty();
+  Free();
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
+{
+  *numItems = _items.Size();
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NWindows::NCOM::CPropVariant prop;
+  switch(propID)
+  {
+    case kpidName:
+    {
+      char dest[kHeaderNameSize + 4];
+      memcpy(dest, _h.Name, kHeaderNameSize);
+      dest[kHeaderNameSize] = 0;
+      prop = dest;
+      break;
+    }
+    case kpidBigEndian: prop = _h.be; break;
+    case kpidCharacts: FLAGS_TO_PROP(k_Flags, _h.Flags, prop); break;
+    case kpidNumBlocks: if (_h.IsVer2()) prop = _h.NumBlocks; break;
+    case kpidNumSubFiles: if (_h.IsVer2()) prop = _h.NumFiles; break;
+    case kpidPhySize: if (_h.IsVer2()) prop = _h.Size; break;
+    case kpidHeadersSize: prop = _headersSize; break;
+    case kpidError: if (!_errorMessage.IsEmpty()) prop = _errorMessage; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NWindows::NCOM::CPropVariant prop;
+  const CItem &item = _items[index];
+  const Byte *p = _data + item.Offset;
+  bool be = _h.be;
+  bool isDir = IsDir(p, be);
+  switch(propID)
+  {
+    case kpidPath: prop = MultiByteToUnicodeString(GetPath(index), CP_OEMCP); break;
+    case kpidIsDir: prop = isDir; break;
+    // case kpidOffset: prop = (UInt32)GetOffset(p, be); break;
+    case kpidSize: if (!isDir) prop = GetSize(p, be); break;
+    case kpidPackSize:
+      if (!isDir)
+      {
+        UInt32 size;
+        if (GetPackSize(index, size))
+          prop = size;
+      }
+      break;
+    case kpidPosixAttrib: prop = (UInt32)GetMode(p, be); break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+class CCramfsInStream: public CCachedInStream
+{
+  HRESULT ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize);
+public:
+  CHandler *Handler;
+};
+
+HRESULT CCramfsInStream::ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize)
+{
+  return Handler->ReadBlock(blockIndex, dest, blockSize);
+}
+
+HRESULT CHandler::ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize)
+{
+  if (!_zlibDecoder)
+  {
+    _zlibDecoderSpec = new NCompress::NZlib::CDecoder();
+    _zlibDecoder = _zlibDecoderSpec;
+  }
+  if (!_inStream)
+  {
+    _inStreamSpec = new CBufInStream();
+    _inStream = _inStreamSpec;
+  }
+  if (!_outStream)
+  {
+    _outStreamSpec = new CBufPtrSeqOutStream();
+    _outStream = _outStreamSpec;
+  }
+  bool be = _h.be;
+  const Byte *p = _data + (_curBlocksOffset + (UInt32)blockIndex * 4);
+  UInt32 start = (blockIndex == 0 ? _curBlocksOffset + _curNumBlocks * 4: Get32(p - 4));
+  UInt32 end = Get32(p);
+  if (end < start || end > _size)
+    return S_FALSE;
+  UInt32 inSize = end - start;
+  _inStreamSpec->Init(_data + start, inSize);
+  _outStreamSpec->Init(dest, blockSize);
+  RINOK(_zlibDecoder->Code(_inStream, _outStream, NULL, NULL, NULL));
+  return (_zlibDecoderSpec->GetInputProcessedSize() == inSize &&
+      _outStreamSpec->GetPos() == blockSize) ? S_OK : S_FALSE;
+}
+
+STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+    Int32 testMode, IArchiveExtractCallback *extractCallback)
+{
+  COM_TRY_BEGIN
+  bool allFilesMode = (numItems == (UInt32)-1);
+  if (allFilesMode)
+    numItems = _items.Size();
+  if (numItems == 0)
+    return S_OK;
+  bool be = _h.be;
+  UInt64 totalSize = 0;
+  UInt32 i;
+  for (i = 0; i < numItems; i++)
+  {
+    const Byte *p = _data + _items[allFilesMode ? i : indices[i]].Offset;
+    if (!IsDir(p, be))
+      totalSize += GetSize(p, be);
+  }
+  extractCallback->SetTotal(totalSize);
+
+  UInt64 totalPackSize;
+  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);
+
+  CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+  CMyComPtr<ISequentialInStream> inStream(streamSpec);
+  streamSpec->SetStream(_stream);
+
+  for (i = 0; i < numItems; i++)
+  {
+    lps->InSize = totalPackSize;
+    lps->OutSize = totalSize;
+    RINOK(lps->SetCur());
+    CMyComPtr<ISequentialOutStream> outStream;
+    Int32 askMode = testMode ?
+        NExtract::NAskMode::kTest :
+        NExtract::NAskMode::kExtract;
+    UInt32 index = allFilesMode ? i : indices[i];
+    const CItem &item = _items[index];
+    RINOK(extractCallback->GetStream(index, &outStream, askMode));
+    const Byte *p = _data + item.Offset;
+
+    if (IsDir(p, be))
+    {
+      RINOK(extractCallback->PrepareOperation(askMode));
+      RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK));
+      continue;
+    }
+    UInt32 curSize = GetSize(p, be);
+    totalSize += curSize;
+    UInt32 packSize;
+    if (GetPackSize(index, packSize))
+      totalPackSize += packSize;
+
+    if (!testMode && !outStream)
+      continue;
+    RINOK(extractCallback->PrepareOperation(askMode));
+
+    UInt32 offset = GetOffset(p, be);
+    if (offset < kHeaderSize)
+      curSize = 0;
+
+    int res = NExtract::NOperationResult::kDataError;
+    {
+      CMyComPtr<ISequentialInStream> inSeqStream;
+      CMyComPtr<IInStream> inStream;
+      HRESULT hres = GetStream(index, &inSeqStream);
+      if (inSeqStream)
+        inSeqStream.QueryInterface(IID_IInStream, &inStream);
+      if (hres == E_OUTOFMEMORY)
+        return E_OUTOFMEMORY;
+      if (hres == S_FALSE || !inStream)
+        res = NExtract::NOperationResult::kUnSupportedMethod;
+      else
+      {
+        RINOK(hres);
+        if (inStream)
+        {
+          HRESULT hres = copyCoder->Code(inStream, outStream, NULL, NULL, progress);
+          if (hres != S_OK && hres != S_FALSE)
+          {
+            RINOK(hres);
+          }
+          if (copyCoderSpec->TotalSize == curSize && hres == S_OK)
+            res = NExtract::NOperationResult::kOK;
+        }
+      }
+    }
+    RINOK(extractCallback->SetOperationResult(res));
+  }
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
+{
+  COM_TRY_BEGIN
+
+  const CItem &item = _items[index];
+  const Byte *p = _data + item.Offset;
+
+  bool be = _h.be;
+  if (IsDir(p, be))
+    return E_FAIL;
+
+  UInt32 size = GetSize(p, be);
+  UInt32 numBlocks = (size + kBlockSize - 1) >> kBlockSizeLog;
+  UInt32 offset = GetOffset(p, be);
+  if (offset < kHeaderSize)
+  {
+    if (offset != 0)
+      return S_FALSE;
+    CBufInStream *streamSpec = new CBufInStream;
+    CMyComPtr<IInStream> streamTemp = streamSpec;
+    streamSpec->Init(NULL, 0);
+    *stream = streamTemp.Detach();
+    return S_OK;
+  }
+
+  if (offset + numBlocks * 4 > _size)
+    return S_FALSE;
+  UInt32 prev = offset;
+  for (UInt32 i = 0; i < numBlocks; i++)
+  {
+    UInt32 next = Get32(_data + offset + i * 4);
+    if (next < prev || next > _size)
+      return S_FALSE;
+    prev = next;
+  }
+
+  CCramfsInStream *streamSpec = new CCramfsInStream;
+  CMyComPtr<IInStream> streamTemp = streamSpec;
+  _curNumBlocks = numBlocks;
+  _curBlocksOffset = offset;
+  streamSpec->Handler = this;
+  if (!streamSpec->Alloc(kBlockSizeLog, 21 - kBlockSizeLog))
+    return E_OUTOFMEMORY;
+  streamSpec->Init(size);
+  *stream = streamTemp.Detach();
+
+  return S_OK;
+  COM_TRY_END
+}
+
+static IInArchive *CreateArc() { return new NArchive::NCramfs::CHandler; }
+
+static CArcInfo g_ArcInfo =
+  { L"CramFS", L"cramfs", 0, 0xD3, SIGNATURE, kSignatureSize, false, CreateArc, 0 };
+
+REGISTER_ARC(Cramfs)
+
+}}
--- a/CPP/7zip/Archive/DeflateProps.cpp
+++ b/CPP/7zip/Archive/DeflateProps.cpp
@@ -1,118 +1,3 @@
 // DeflateProps.cpp

 #include "StdAfx.h"
-
-#include "Windows/PropVariant.h"
-
-#include "Common/ParseProperties.h"
-
-#include "DeflateProps.h"
-
-namespace NArchive {
-
-static const UInt32 kAlgo1 = 0;
-static const UInt32 kAlgo5 = 1;
-
-static const UInt32 kPasses1 = 1;
-static const UInt32 kPasses7 = 3;
-static const UInt32 kPasses9 = 10;
-
-static const UInt32 kFb1 = 32;
-static const UInt32 kFb7 = 64;
-static const UInt32 kFb9 = 128;
-
-void CDeflateProps::Normalize()
-{
-  UInt32 level = Level;
-  if (level == 0xFFFFFFFF)
-    level = 5;
-  
-  if (Algo == 0xFFFFFFFF)
-    Algo = (level >= 5 ?
-      kAlgo5 :
-      kAlgo1);
-
-  if (NumPasses == 0xFFFFFFFF)
-    NumPasses =
-      (level >= 9 ? kPasses9 :
-      (level >= 7 ? kPasses7 :
-                    kPasses1));
-  if (Fb == 0xFFFFFFFF)
-    Fb =
-      (level >= 9 ? kFb9 :
-      (level >= 7 ? kFb7 :
-                    kFb1));
-}
-
-HRESULT CDeflateProps::SetCoderProperties(ICompressSetCoderProperties *setCoderProperties)
-{
-  Normalize();
-
-  NWindows::NCOM::CPropVariant props[] =
-  {
-    Algo,
-    NumPasses,
-    Fb,
-    Mc
-  };
-  PROPID propIDs[] =
-  {
-    NCoderPropID::kAlgorithm,
-    NCoderPropID::kNumPasses,
-    NCoderPropID::kNumFastBytes,
-    NCoderPropID::kMatchFinderCycles
-  };
-  int numProps = sizeof(propIDs) / sizeof(propIDs[0]);
-  if (!McDefined)
-    numProps--;
-  return setCoderProperties->SetCoderProperties(propIDs, props, numProps);
-}
-
-HRESULT CDeflateProps::SetProperties(const wchar_t **names, const PROPVARIANT *values, Int32 numProps)
-{
-  Init();
-  for (int i = 0; i < numProps; i++)
-  {
-    UString name = names[i];
-    name.MakeUpper();
-    if (name.IsEmpty())
-      return E_INVALIDARG;
-    const PROPVARIANT &prop = values[i];
-    if (name[0] == L'X')
-    {
-      UInt32 a = 9;
-      RINOK(ParsePropValue(name.Mid(1), prop, a));
-      Level = a;
-    }
-    else if (name.Left(1) == L"A")
-    {
-      UInt32 a = kAlgo5;
-      RINOK(ParsePropValue(name.Mid(1), prop, a));
-      Algo = a;
-    }
-    else if (name.Left(4) == L"PASS")
-    {
-      UInt32 a = kPasses9;
-      RINOK(ParsePropValue(name.Mid(4), prop, a));
-      NumPasses = a;
-    }
-    else if (name.Left(2) == L"FB")
-    {
-      UInt32 a = kFb9;
-      RINOK(ParsePropValue(name.Mid(2), prop, a));
-      Fb = a;
-    }
-    else if (name.Left(2) == L"MC")
-    {
-      UInt32 a = 0xFFFFFFFF;
-      RINOK(ParsePropValue(name.Mid(2), prop, a));
-      Mc = a;
-      McDefined = true;
-    }
-    else
-      return E_INVALIDARG;
-  }
-  return S_OK;
-}
-
-}
--- a/CPP/7zip/Archive/DeflateProps.h
+++ b/CPP/7zip/Archive/DeflateProps.h
@@ -3,33 +3,4 @@
 #ifndef __DEFLATE_PROPS_H
 #define __DEFLATE_PROPS_H

-#include "../ICoder.h"
-
-namespace NArchive {
-
-class CDeflateProps
-{
-  UInt32 Level;
-  UInt32 NumPasses;
-  UInt32 Fb;
-  UInt32 Algo;
-  UInt32 Mc;
-  bool McDefined;
-
-  void Init()
-  {
-    Level = NumPasses = Fb = Algo = Mc = 0xFFFFFFFF;
-    McDefined = false;
-  }
-  void Normalize();
-public:
-  CDeflateProps() { Init(); }
-  bool IsMaximum() const { return Algo > 0; }
-
-  HRESULT SetCoderProperties(ICompressSetCoderProperties *setCoderProperties);
-  HRESULT SetProperties(const wchar_t **names, const PROPVARIANT *values, Int32 numProps);
-};
-
-}
-
 #endif
--- a/CPP/7zip/Archive/ElfHandler.cpp
+++ b/CPP/7zip/Archive/ElfHandler.cpp
@@ -277,9 +277,9 @@ static const CUInt32PCharPair g_AbiOS[] =

 static const CUInt32PCharPair g_SegmentFlags[] =
 {
-  { 1 << 0, "Execute" },
-  { 1 << 1, "Write" },
-  { 1 << 2, "Read" }
+  { 0, "Execute" },
+  { 1, "Write" },
+  { 2, "Read" }
 };

 static const char *g_Types[] =
--- a/CPP/7zip/Archive/GzHandler.cpp
+++ b/CPP/7zip/Archive/GzHandler.cpp
@@ -18,11 +18,10 @@
 #include "../Compress/DeflateDecoder.h"
 #include "../Compress/DeflateEncoder.h"

+#include "Common/HandlerOut.h"
 #include "Common/InStreamWithCRC.h"
 #include "Common/OutStreamWithCRC.h"

-#include "DeflateProps.h"
-
 #define Get32(p) GetUi32(p)

 using namespace NWindows;
@@ -305,7 +304,7 @@ class CHandler:
  CMyComPtr<ICompressCoder> _decoder;
  NCompress::NDeflate::NDecoder::CCOMCoder *_decoderSpec;

-  CDeflateProps _method;
+  CSingleMethodProps _props;

 public:
  MY_UNKNOWN_IMP4(IInArchive, IArchiveOpenSeq, IOutArchive, ISetProperties)
@@ -321,7 +320,7 @@ public:
  }
 };

-STATPROPSTG kProps[] =
+static STATPROPSTG const kProps[] =
 {
  { NULL, kpidPath, VT_BSTR},
  { NULL, kpidSize, VT_UI8},
@@ -545,7 +544,7 @@ static HRESULT UpdateArchive(
    ISequentialOutStream *outStream,
    UInt64 unpackSize,
    const CItem &newItem,
-    CDeflateProps &deflateProps,
+    const CSingleMethodProps &props,
    IArchiveUpdateCallback *updateCallback)
 {
  UInt64 complexity = 0;
@@ -567,7 +566,7 @@ static HRESULT UpdateArchive(
  
  CItem item = newItem;
  item.Method = NHeader::NCompressionMethod::kDeflate;
-  item.ExtraFlags = deflateProps.IsMaximum() ?
+  item.ExtraFlags = props.GetLevel() >= 7 ?
      NHeader::NExtraFlags::kMaximum :
      NHeader::NExtraFlags::kFastest;

@@ -577,7 +576,7 @@ static HRESULT UpdateArchive(

  NCompress::NDeflate::NEncoder::CCOMCoder *deflateEncoderSpec = new NCompress::NDeflate::NEncoder::CCOMCoder;
  CMyComPtr<ICompressCoder> deflateEncoder = deflateEncoderSpec;
-  RINOK(deflateProps.SetCoderProperties(deflateEncoderSpec));
+  RINOK(props.SetCoderProps(deflateEncoderSpec, NULL));
  RINOK(deflateEncoder->Code(crcStream, outStream, NULL, NULL, progress));

  item.Crc = inStreamSpec->GetCRC();
@@ -616,8 +615,7 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
      if (prop.vt != VT_FILETIME)
        return E_INVALIDARG;
      utcTime = prop.filetime;
-      if (!NTime::FileTimeToUnixTime(utcTime, newItem.Time))
-        return E_INVALIDARG;
+      NTime::FileTimeToUnixTime(utcTime, newItem.Time);
    }
    {
      NCOM::CPropVariant prop;
@@ -658,8 +656,7 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
        return E_INVALIDARG;
      size = prop.uhVal.QuadPart;
    }
-
-    return UpdateArchive(outStream, size, newItem, _method, updateCallback);
+    return UpdateArchive(outStream, size, newItem, _props, updateCallback);
  }
    
  if (indexInArchive != 0)
@@ -680,7 +677,7 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt

 STDMETHODIMP CHandler::SetProperties(const wchar_t **names, const PROPVARIANT *values, Int32 numProps)
 {
-  return _method.SetProperties(names, values, numProps);
+  return _props.SetProperties(names, values, numProps);
 }

 static IInArchive *CreateArc() { return new CHandler; }
--- a/CPP/7zip/Archive/Icons/bz2.ico
+++ b/CPP/7zip/Archive/Icons/bz2.ico
--- a/CPP/7zip/Archive/Icons/cab.ico
+++ b/CPP/7zip/Archive/Icons/cab.ico
--- a/CPP/7zip/Archive/Icons/fat.ico
+++ b/CPP/7zip/Archive/Icons/fat.ico
--- a/CPP/7zip/Archive/Icons/gz.ico
+++ b/CPP/7zip/Archive/Icons/gz.ico
--- a/CPP/7zip/Archive/Icons/hfs.ico
+++ b/CPP/7zip/Archive/Icons/hfs.ico
--- a/CPP/7zip/Archive/Icons/iso.ico
+++ b/CPP/7zip/Archive/Icons/iso.ico
--- a/CPP/7zip/Archive/Icons/split.ico
+++ b/CPP/7zip/Archive/Icons/split.ico
--- a/CPP/7zip/Archive/Icons/squashfs.ico
+++ b/CPP/7zip/Archive/Icons/squashfs.ico
--- a/CPP/7zip/Archive/Icons/xz.ico
+++ b/CPP/7zip/Archive/Icons/xz.ico
--- a/CPP/7zip/Archive/Iso/IsoHandler.cpp
+++ b/CPP/7zip/Archive/Iso/IsoHandler.cpp
@@ -24,7 +24,7 @@ using namespace NTime;
 namespace NArchive {
 namespace NIso {

-static STATPROPSTG kProps[] =
+static const STATPROPSTG kProps[] =
 {
  { NULL, kpidPath, VT_BSTR},
  { NULL, kpidIsDir, VT_BOOL},
@@ -33,8 +33,17 @@ static STATPROPSTG kProps[] =
  { NULL, kpidMTime, VT_FILETIME}
 };

+static const STATPROPSTG kArcProps[] =
+{
+  { NULL, kpidComment, VT_BSTR},
+  { NULL, kpidCTime, VT_FILETIME},
+  { NULL, kpidMTime, VT_FILETIME}
+  // { NULL, kpidPhySize, VT_UI8},
+  // { NULL, kpidHeadersSize, VT_UI8}
+};
+
 IMP_IInArchive_Props
-IMP_IInArchive_ArcProps_NO
+IMP_IInArchive_ArcProps

 STDMETHODIMP CHandler::Open(IInStream *stream,
    const UInt64 * /* maxCheckStartPosition */,
@@ -66,6 +75,58 @@ STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
  return S_OK;
 }

+static void AddString(AString &s, const char *name, const Byte *p, int size)
+{
+  int i;
+  for (i = 0; i < size && p[i]; i++);
+  for (; i > 0 && p[i - 1] == ' '; i--);
+  if (i != 0)
+  {
+    AString d;
+    memcpy(d.GetBuffer(i), p, i);
+    d.ReleaseBuffer(i);
+    s += '\n';
+    s += name;
+    s += ": ";
+    s += d;
+  }
+}
+
+#define ADD_STRING(n, v) AddString(s, n, vol. ## v, sizeof(vol. ## v))
+
+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NWindows::NCOM::CPropVariant prop;
+  const CVolumeDescriptor &vol = _archive.VolDescs[_archive.MainVolDescIndex];
+  switch(propID)
+  {
+    case kpidComment:
+    {
+      AString s;
+      ADD_STRING("System", SystemId);
+      ADD_STRING("Volume", VolumeId);
+      ADD_STRING("VolumeSet", VolumeSetId);
+      ADD_STRING("Publisher", PublisherId);
+      ADD_STRING("Preparer", DataPreparerId);
+      ADD_STRING("Application", ApplicationId);
+      ADD_STRING("Copyright", CopyrightFileId);
+      ADD_STRING("Abstract", AbstractFileId);
+      ADD_STRING("Bib", BibFileId);
+      prop = s;
+      break;
+    }
+    case kpidCTime: { FILETIME utc; if (vol.CTime.GetFileTime(utc)) prop = utc; break; }
+    case kpidMTime: { FILETIME utc; if (vol.MTime.GetFileTime(utc)) prop = utc; break; }
+    // case kpidPhySize: break;
+    // case kpidHeadersSize: break;
+    case kpidError: if (_archive.IncorrectBigEndian) prop = "Incorrect big-endian headers"; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
 STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
 {
  COM_TRY_BEGIN
@@ -87,9 +148,7 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
        prop = (const wchar_t *)s;
        break;
      }
-      case kpidIsDir:
-        prop = false;
-        break;
+      case kpidIsDir: prop = false; break;
      case kpidSize:
      case kpidPackSize:
        prop = (UInt64)_archive.GetBootItemSize(index);
@@ -113,17 +172,15 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val

          int pos = s.ReverseFind(L';');
          if (pos >= 0 && pos == s.Length() - 2)
-              if (s[s.Length() - 1] == L'1')
+              if (s.Back() == L'1')
                s = s.Left(pos);
          if (!s.IsEmpty())
-            if (s[s.Length() - 1] == L'.')
-              s = s.Left(s.Length() - 1);
+            if (s.Back() == L'.')
+              s.DeleteBack();
          prop = (const wchar_t *)NItemName::GetOSName2(s);
        }
        break;
-      case kpidIsDir:
-        prop = item.IsDir();
-        break;
+      case kpidIsDir: prop = item.IsDir(); break;
      case kpidSize:
      case kpidPackSize:
        if (!item.IsDir())
@@ -131,16 +188,9 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
        break;
      case kpidMTime:
      {
-        FILETIME utcFileTime;
-        if (item.DateTime.GetFileTime(utcFileTime))
-          prop = utcFileTime;
-        /*
-        else
-        {
-          utcFileTime.dwLowDateTime = 0;
-          utcFileTime.dwHighDateTime = 0;
-        }
-        */
+        FILETIME utc;
+        if (item.DateTime.GetFileTime(utc))
+          prop = utc;
        break;
      }
    }
@@ -161,19 +211,18 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
    return S_OK;
  UInt64 totalSize = 0;
  UInt32 i;
-  for(i = 0; i < numItems; i++)
+  for (i = 0; i < numItems; i++)
  {
    UInt32 index = (allFilesMode ? i : indices[i]);
    if (index < (UInt32)_archive.Refs.Size())
    {
      const CRef &ref = _archive.Refs[index];
      const CDir &item = ref.Dir->_subItems[ref.Index];
-      totalSize += item.DataLength;
+      if (!item.IsDir())
+        totalSize += item.DataLength;
    }
    else
-    {
      totalSize += _archive.GetBootItemSize(index - _archive.Refs.Size());
-    }
  }
  extractCallback->SetTotal(totalSize);

--- a/CPP/7zip/Archive/Iso/IsoIn.cpp
+++ b/CPP/7zip/Archive/Iso/IsoIn.cpp
@@ -65,7 +65,7 @@ UInt16 CInArchive::ReadUInt16()
  for (int i = 0; i < 2; i++)
  {
    if (b[i] != b[3 - i])
-      throw 1;
+      IncorrectBigEndian = true;
    value |= ((UInt16)(b[i]) << (8 * i));
  }
  return (UInt16)value;
@@ -440,6 +440,7 @@ HRESULT CInArchive::Open(IInStream *inStream)

 void CInArchive::Clear()
 {
+  IncorrectBigEndian = false;
  Refs.Clear();
  _rootDir.Clear();
  VolDescs.Clear();
--- a/CPP/7zip/Archive/Iso/IsoIn.h
+++ b/CPP/7zip/Archive/Iso/IsoIn.h
@@ -111,6 +111,20 @@ struct CDateTime
  signed char GmtOffset; // min intervals from -48 (West) to +52 (East) recorded.
  bool NotSpecified() const { return Year == 0 && Month == 0 && Day == 0 &&
      Hour == 0 && Minute == 0 && Second == 0 && GmtOffset == 0; }
+
+  bool GetFileTime(FILETIME &ft) const
+  {
+    UInt64 value;
+    bool res = NWindows::NTime::GetSecondsSince1601(Year, Month, Day, Hour, Minute, Second, value);
+    if (res)
+    {
+      value -= (UInt64)((Int64)GmtOffset * 15 * 60);
+      value *= 10000000;
+    }
+    ft.dwLowDateTime = (DWORD)value;
+    ft.dwHighDateTime = (DWORD)(value >> 32);
+    return res;
+  }
 };

 struct CBootRecordDescriptor
@@ -268,6 +282,7 @@ public:
  int MainVolDescIndex;
  UInt32 BlockSize;
  CObjectVector<CBootInitialEntry> BootEntries;
+  bool IncorrectBigEndian;


  bool IsJoliet() const { return VolDescs[MainVolDescIndex].IsJoliet(); }
--- a/CPP/7zip/Archive/LzhHandler.cpp
+++ b/CPP/7zip/Archive/LzhHandler.cpp
@@ -177,47 +177,6 @@ struct CItem
  }
 };

-struct CItemEx: public CItem
-{
-  UInt64 DataPosition;
-};
-
-class CInArchive
-{
-  CMyComPtr<IInStream> m_Stream;
-  UInt64 m_Position;
-  
-  HRESULT ReadBytes(void *data, UInt32 size, UInt32 &processedSize);
-  HRESULT CheckReadBytes(void *data, UInt32 size);
-public:
-  HRESULT Open(IInStream *inStream);
-  HRESULT GetNextItem(bool &filled, CItemEx &itemInfo);
-  HRESULT Skip(UInt64 numBytes);
-};
-
-HRESULT CInArchive::ReadBytes(void *data, UInt32 size, UInt32 &processedSize)
-{
-  size_t realProcessedSize = size;
-  RINOK(ReadStream(m_Stream, data, &realProcessedSize));
-  processedSize = (UInt32)realProcessedSize;
-  m_Position += processedSize;
-  return S_OK;
-}
-
-HRESULT CInArchive::CheckReadBytes(void *data, UInt32 size)
-{
-  UInt32 processedSize;
-  RINOK(ReadBytes(data, size, processedSize));
-  return (processedSize == size) ? S_OK: S_FALSE;
-}
-
-HRESULT CInArchive::Open(IInStream *inStream)
-{
-  RINOK(inStream->Seek(0, STREAM_SEEK_CUR, &m_Position));
-  m_Stream = inStream;
-  return S_OK;
-}
-
 static const Byte *ReadUInt16(const Byte *p, UInt16 &v)
 {
  v = Get16(p);
@@ -245,13 +204,13 @@ static Byte CalcSum(const Byte *data, size_t size)
  return sum;
 }

-HRESULT CInArchive::GetNextItem(bool &filled, CItemEx &item)
+static HRESULT GetNextItem(ISequentialInStream *stream, bool &filled, CItem &item)
 {
  filled = false;

-  UInt32 processedSize;
+  size_t processedSize = 2;
  Byte startHeader[2];
-  RINOK(ReadBytes(startHeader, 2, processedSize))
+  RINOK(ReadStream(stream, startHeader, &processedSize))
  if (processedSize == 0)
    return S_OK;
  if (processedSize == 1)
@@ -261,12 +220,13 @@ HRESULT CInArchive::GetNextItem(bool &filled, CItemEx &item)

  Byte header[256];
  const UInt32 kBasicPartSize = 22;
-  RINOK(ReadBytes(header, kBasicPartSize, processedSize));
+  processedSize = kBasicPartSize;
+  RINOK(ReadStream(stream, header, &processedSize));
  if (processedSize != kBasicPartSize)
    return (startHeader[0] == 0) ? S_OK: S_FALSE;

  const Byte *p = header;
-  memmove(item.Method, p, kMethodIdSize);
+  memcpy(item.Method, p, kMethodIdSize);
  if (!item.IsValidMethod())
    return S_OK;
  p += kMethodIdSize;
@@ -284,8 +244,7 @@ HRESULT CInArchive::GetNextItem(bool &filled, CItemEx &item)
    headerSize = startHeader[0];
    if (headerSize < kBasicPartSize)
      return S_FALSE;
-    UInt32 remain = headerSize - kBasicPartSize;
-    RINOK(CheckReadBytes(header + kBasicPartSize, remain));
+    RINOK(ReadStream_FALSE(stream, header + kBasicPartSize, headerSize - kBasicPartSize));
    if (startHeader[1] != CalcSum(header, headerSize))
      return S_FALSE;
    size_t nameLength = *p++;
@@ -294,13 +253,13 @@ HRESULT CInArchive::GetNextItem(bool &filled, CItemEx &item)
    p = ReadString(p, nameLength, item.Name);
  }
  else
-   headerSize = startHeader[0] | ((UInt32)startHeader[1] << 8);
+    headerSize = startHeader[0] | ((UInt32)startHeader[1] << 8);
  p = ReadUInt16(p, item.CRC);
  if (item.Level != 0)
  {
    if (item.Level == 2)
    {
-      RINOK(CheckReadBytes(header + kBasicPartSize, 2));
+      RINOK(ReadStream_FALSE(stream, header + kBasicPartSize, 2));
    }
    if ((size_t)(p - header) + 3 > headerSize)
      return S_FALSE;
@@ -317,39 +276,30 @@ HRESULT CInArchive::GetNextItem(bool &filled, CItemEx &item)
          return S_FALSE;
        item.PackSize -= nextSize;
      }
+      if (item.Extensions.Size() >= (1 << 8))
+        return S_FALSE;
      CExtension ext;
-      RINOK(CheckReadBytes(&ext.Type, 1))
+      RINOK(ReadStream_FALSE(stream, &ext.Type, 1))
      nextSize -= 3;
      ext.Data.SetCapacity(nextSize);
-      RINOK(CheckReadBytes((Byte *)ext.Data, nextSize))
+      RINOK(ReadStream_FALSE(stream, (Byte *)ext.Data, nextSize))
      item.Extensions.Add(ext);
      Byte hdr2[2];
-      RINOK(CheckReadBytes(hdr2, 2));
+      RINOK(ReadStream_FALSE(stream, hdr2, 2));
      ReadUInt16(hdr2, nextSize);
    }
  }
-  item.DataPosition = m_Position;
  filled = true;
  return S_OK;
 }

-HRESULT CInArchive::Skip(UInt64 numBytes)
-{
-  UInt64 newPostion;
-  RINOK(m_Stream->Seek(numBytes, STREAM_SEEK_CUR, &newPostion));
-  m_Position += numBytes;
-  if (m_Position != newPostion)
-    return E_FAIL;
-  return S_OK;
-}
-
 struct COsPair
 {
  Byte Id;
  const char *Name;
 };

-static COsPair g_OsPairs[] =
+static const COsPair g_OsPairs[] =
 {
  {   0, "MS-DOS" },
  { 'M', "MS-DOS" },
@@ -380,7 +330,7 @@ static const char *GetOS(Byte osId)
  return kUnknownOS;
 }

-static STATPROPSTG kProps[] =
+static const STATPROPSTG kProps[] =
 {
  { NULL, kpidPath, VT_BSTR},
  { NULL, kpidIsDir, VT_BOOL},
@@ -393,6 +343,11 @@ static STATPROPSTG kProps[] =
  { NULL, kpidHostOS, VT_BSTR}
 };

+static const STATPROPSTG kArcProps[] =
+{
+  { NULL, kpidPhySize, VT_UI8}
+};
+
 class CCRC
 {
  UInt16 _value;
@@ -479,12 +434,19 @@ STDMETHODIMP COutStreamWithCRC::Write(const void *data, UInt32 size, UInt32 *pro
  return result;
 }

+struct CItemEx: public CItem
+{
+  UInt64 DataPosition;
+};
+
 class CHandler:
  public IInArchive,
  public CMyUnknownImp
 {
  CObjectVector<CItemEx> _items;
  CMyComPtr<IInStream> _stream;
+  UInt64 _phySize;
+  AString _errorMessage;
 public:
  MY_UNKNOWN_IMP1(IInArchive)
  INTERFACE_IInArchive(;)
@@ -492,7 +454,7 @@ public:
 };

 IMP_IInArchive_Props
-IMP_IInArchive_ArcProps_NO
+IMP_IInArchive_ArcProps

 CHandler::CHandler() {}

@@ -502,6 +464,18 @@ STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
  return S_OK;
 }

+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
+{
+  NCOM::CPropVariant prop;
+  switch(propID)
+  {
+    case kpidPhySize: prop = _phySize; break;
+    case kpidError: if (!_errorMessage.IsEmpty()) prop = _errorMessage; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+}
+
 STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID,  PROPVARIANT *value)
 {
  COM_TRY_BEGIN
@@ -514,8 +488,8 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID,  PROPVARIANT *va
      UString s = NItemName::WinNameToOSName(MultiByteToUnicodeString(item.GetName(), CP_OEMCP));
      if (!s.IsEmpty())
      {
-        if (s[s.Length() - 1] == WCHAR_PATH_SEPARATOR)
-           s.Delete(s.Length() - 1);
+        if (s.Back() == WCHAR_PATH_SEPARATOR)
+          s.DeleteBack();
        prop = s;
      }
      break;
@@ -567,32 +541,43 @@ STDMETHODIMP CHandler::Open(IInStream *stream,
  try
  {
    _items.Clear();
-    CInArchive archive;

    UInt64 endPos = 0;
    bool needSetTotal = true;

-    if (callback != NULL)
-    {
-      RINOK(stream->Seek(0, STREAM_SEEK_END, &endPos));
-      RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));
-    }
+    RINOK(stream->Seek(0, STREAM_SEEK_END, &endPos));
+    RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));

-    RINOK(archive.Open(stream));
+    _phySize = 0;
    for (;;)
    {
      CItemEx item;
      bool filled;
-      HRESULT result = archive.GetNextItem(filled, item);
+      HRESULT result = GetNextItem(stream, filled, item);
+      RINOK(stream->Seek(0, STREAM_SEEK_CUR, &item.DataPosition));
      if (result == S_FALSE)
-        return S_FALSE;
+      {
+        _errorMessage = "Incorrect header";
+        break;
+      }
+
      if (result != S_OK)
        return S_FALSE;
+      _phySize = item.DataPosition;
      if (!filled)
        break;
      _items.Add(item);
-      archive.Skip(item.PackSize);
-      if (callback != NULL)
+
+      UInt64 newPostion;
+      RINOK(stream->Seek(item.PackSize, STREAM_SEEK_CUR, &newPostion));
+      if (newPostion > endPos)
+      {
+        _phySize = endPos;
+        _errorMessage = "Unexpected end of archive";
+        break;
+      }
+      _phySize = newPostion;
+      if (callback)
      {
        if (needSetTotal)
        {
@@ -622,6 +607,7 @@ STDMETHODIMP CHandler::Open(IInStream *stream,

 STDMETHODIMP CHandler::Close()
 {
+  _errorMessage.Empty();
  _items.Clear();
  _stream.Release();
  return S_OK;
--- a/CPP/7zip/Archive/LzmaHandler.cpp
+++ b/CPP/7zip/Archive/LzmaHandler.cpp
@@ -296,7 +296,8 @@ STDMETHODIMP CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCal
  RINOK(inStream->Seek(0, STREAM_SEEK_END, &endPos));
  _packSize = endPos - _startPosition;
  _packSizeDefined = true;
-  
+  if (_packSize >= 24 && _header.Size == 0 && _header.FilterID == 0 && _header.LzmaProps[0] == 0)
+    return S_FALSE;
  _stream = inStream;
  _seqStream = inStream;
  return S_OK;
--- a/CPP/7zip/Archive/MachoHandler.cpp
+++ b/CPP/7zip/Archive/MachoHandler.cpp
@@ -77,16 +77,16 @@ static const char *g_FileTypes[] =

 static const CUInt32PCharPair g_Flags[] =
 {
-  { (UInt32)1 << 31, "PURE_INSTRUCTIONS" },
-  { 1 << 30, "NO_TOC" },
-  { 1 << 29, "STRIP_STATIC_SYMS" },
-  { 1 << 28, "NO_DEAD_STRIP" },
-  { 1 << 27, "LIVE_SUPPORT" },
-  { 1 << 26, "SELF_MODIFYING_CODE" },
-  { 1 << 25, "DEBUG" },
-  { 1 << 10, "SOME_INSTRUCTIONS" },
-  { 1 <<  9, "EXT_RELOC" },
-  { 1 <<  8, "LOC_RELOC" }
+  { 31, "PURE_INSTRUCTIONS" },
+  { 30, "NO_TOC" },
+  { 29, "STRIP_STATIC_SYMS" },
+  { 28, "NO_DEAD_STRIP" },
+  { 27, "LIVE_SUPPORT" },
+  { 26, "SELF_MODIFYING_CODE" },
+  { 25, "DEBUG" },
+  { 10, "SOME_INSTRUCTIONS" },
+  {  9, "EXT_RELOC" },
+  {  8, "LOC_RELOC" }
 };

 static const CUInt32PCharPair g_MachinePairs[] =
--- a/CPP/7zip/Archive/MubHandler.cpp
+++ b/CPP/7zip/Archive/MubHandler.cpp
@@ -15,7 +15,7 @@

 #include "../Compress/CopyCoder.h"

-#define Get32(p) GetBe32(p)
+static UInt32 Get32(const Byte *p, int be) { if (be) return GetBe32(p); return GetUi32(p); }

 namespace NArchive {
 namespace NMub {
@@ -116,8 +116,16 @@ HRESULT CHandler::Open2(IInStream *stream)
  RINOK(ReadStream(stream, buf, &processed));
  if (processed < kHeaderSize)
    return S_FALSE;
-  UInt32 num = Get32(buf + 4);
-  if (Get32(buf) != 0xCAFEBABE || num > kNumFilesMax || processed < kHeaderSize + num * kRecordSize)
+  
+  bool be;
+  switch (GetBe32(buf))
+  {
+    case 0xCAFEBABE: be = true; break;
+    case 0xB9FAF10E: be = false; break;
+    default: return S_FALSE;
+  }
+  UInt32 num = Get32(buf + 4, be);
+  if (num > kNumFilesMax || processed < kHeaderSize + num * kRecordSize)
    return S_FALSE;
  UInt64 endPosMax = kHeaderSize;
  for (UInt32 i = 0; i < num; i++)
@@ -125,11 +133,11 @@ HRESULT CHandler::Open2(IInStream *stream)
    const Byte *p = buf + kHeaderSize + i * kRecordSize;
    CItem &sb = _items[i];
    sb.IsTail = false;
-    sb.Type = Get32(p);
-    sb.SubType = Get32(p + 4);
-    sb.Offset = Get32(p + 8);
-    sb.Size = Get32(p + 12);
-    sb.Align = Get32(p + 16);
+    sb.Type = Get32(p, be);
+    sb.SubType = Get32(p + 4, be);
+    sb.Offset = Get32(p + 8, be);
+    sb.Size = Get32(p + 12, be);
+    sb.Align = Get32(p + 16, be);

    if ((sb.Type & ~MACH_TYPE_ABI64) >= 0x100 ||
        (sb.SubType & ~MACH_SUBTYPE_ABI64) >= 0x100 ||
--- a/CPP/7zip/Archive/Nsis/NsisIn.h
+++ b/CPP/7zip/Archive/Nsis/NsisIn.h
@@ -87,7 +87,7 @@ struct CItem
    else
      s = MultiByteToUnicodeString(PrefixA);
    if (s.Length() > 0)
-      if (s[s.Length() - 1] != L'\\')
+      if (s.Back() != L'\\')
        s += L'\\';
    if (unicode)
      s += NameU;
--- a/CPP/7zip/Archive/PeHandler.cpp
+++ b/CPP/7zip/Archive/PeHandler.cpp
@@ -300,53 +300,53 @@ void CSection::Parse(const Byte *p)

 static const CUInt32PCharPair g_HeaderCharacts[] =
 {
-  { 1 << 1, "Executable" },
-  { 1 << 13, "DLL" },
-  { 1 << 8, "32-bit" },
-  { 1 << 5, "LargeAddress" },
-  { 1 << 0, "NoRelocs" },
-  { 1 << 2, "NoLineNums" },
-  { 1 << 3, "NoLocalSyms" },
-  { 1 << 4, "AggressiveWsTrim" },
-  { 1 << 9, "NoDebugInfo" },
-  { 1 << 10, "RemovableRun" },
-  { 1 << 11, "NetRun" },
-  { 1 << 12, "System" },
-  { 1 << 14, "UniCPU" },
-  { 1 << 7, "Little-Endian" },
-  { 1 << 15, "Big-Endian" }
+  {  1, "Executable" },
+  { 13, "DLL" },
+  {  8, "32-bit" },
+  {  5, "LargeAddress" },
+  {  0, "NoRelocs" },
+  {  2, "NoLineNums" },
+  {  3, "NoLocalSyms" },
+  {  4, "AggressiveWsTrim" },
+  {  9, "NoDebugInfo" },
+  { 10, "RemovableRun" },
+  { 11, "NetRun" },
+  { 12, "System" },
+  { 14, "UniCPU" },
+  {  7, "Little-Endian" },
+  { 15, "Big-Endian" }
 };

 static const CUInt32PCharPair g_DllCharacts[] =
 {
-  { 1 << 6, "Relocated" },
-  { 1 << 7, "Integrity" },
-  { 1 << 8, "NX-Compatible" },
-  { 1 << 9, "NoIsolation" },
-  { 1 << 10, "NoSEH" },
-  { 1 << 11, "NoBind" },
-  { 1 << 13, "WDM" },
-  { 1 << 15, "TerminalServerAware" }
+  {  6, "Relocated" },
+  {  7, "Integrity" },
+  {  8, "NX-Compatible" },
+  {  9, "NoIsolation" },
+  { 10, "NoSEH" },
+  { 11, "NoBind" },
+  { 13, "WDM" },
+  { 15, "TerminalServerAware" }
 };

 static const CUInt32PCharPair g_SectFlags[] =
 {
-  { 1 << 3, "NoPad" },
-  { 1 << 5, "Code" },
-  { 1 << 6, "InitializedData" },
-  { 1 << 7, "UninitializedData" },
-  { 1 << 9, "Comments" },
-  { 1 << 11, "Remove" },
-  { 1 << 12, "COMDAT" },
-  { 1 << 15, "GP" },
-  { 1 << 24, "ExtendedRelocations" },
-  { 1 << 25, "Discardable" },
-  { 1 << 26, "NotCached" },
-  { 1 << 27, "NotPaged" },
-  { 1 << 28, "Shared" },
-  { 1 << 29, "Execute" },
-  { 1 << 30, "Read" },
-  { (UInt32)1 << 31, "Write" }
+  {  3, "NoPad" },
+  {  5, "Code" },
+  {  6, "InitializedData" },
+  {  7, "UninitializedData" },
+  {  9, "Comments" },
+  { 11, "Remove" },
+  { 12, "COMDAT" },
+  { 15, "GP" },
+  { 24, "ExtendedRelocations" },
+  { 25, "Discardable" },
+  { 26, "NotCached" },
+  { 27, "NotPaged" },
+  { 28, "Shared" },
+  { 29, "Execute" },
+  { 30, "Read" },
+  { 31, "Write" }
 };

 static const CUInt32PCharPair g_MachinePairs[] =
@@ -631,7 +631,7 @@ enum
  // kpidBaseOfData32,
 };

-STATPROPSTG kArcProps[] =
+static const STATPROPSTG kArcProps[] =
 {
  { NULL, kpidCpu, VT_BSTR},
  { NULL, kpidBit64, VT_BOOL},
@@ -662,7 +662,7 @@ STATPROPSTG kArcProps[] =
  // { L"Base Of Data", kpidBaseOfData32, VT_UI8},
 };

-STATPROPSTG kProps[] =
+static const STATPROPSTG kProps[] =
 {
  { NULL, kpidPath, VT_BSTR},
  { NULL, kpidSize, VT_UI8},
@@ -1723,6 +1723,14 @@ STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
    size_t offset = item.Offset - sect.Va;
    if (!CheckItem(sect, item, offset))
      return S_FALSE;
+    if (item.HeaderSize == 0)
+    {
+      CBufInStream *streamSpec = new CBufInStream;
+      CMyComPtr<IInStream> streamTemp2 = streamSpec;
+      streamSpec->Init(_buf + offset, item.Size, (IInArchive *)this);
+      *stream = streamTemp2.Detach();
+      return S_OK;
+    }
    referenceBuf->Buf.SetCapacity(item.HeaderSize + item.Size);
    memcpy(referenceBuf->Buf, item.Header, item.HeaderSize);
    memcpy(referenceBuf->Buf + item.HeaderSize, _buf + offset, item.Size);
@@ -1741,4 +1749,335 @@ static CArcInfo g_ArcInfo =

 REGISTER_ARC(Pe)

-}}
+}
+
+
+
+
+namespace NTe {
+
+// Terse Executable (TE) image
+
+/*
+struct CDataDir
+{
+  UInt32 Va;
+  UInt32 Size;
+};
+*/
+
+static const UInt32 kHeaderSize = 40;
+
+static bool FindValue(const CUInt32PCharPair *pairs, unsigned num, UInt32 value)
+{
+  for (unsigned i = 0; i < num; i++)
+    if (pairs[i].Value == value)
+      return true;
+  return false;
+}
+
+#define MY_FIND_VALUE(pairs, value) FindValue(pairs, sizeof(pairs) / sizeof(pairs[0]), value)
+ 
+struct CHeader
+{
+  UInt16 Machine;
+  Byte NumSections;
+  Byte SubSystem;
+  UInt16 StrippedSize;
+  /*
+  UInt32 AddressOfEntryPoint;
+  UInt32 BaseOfCode;
+  UInt64 ImageBase;
+  CDataDir DataDir[2]; // base relocation and debug directory
+  */
+
+  UInt32 ConvertPa(UInt32 pa) const { return pa - StrippedSize + kHeaderSize; }
+
+  bool Parse(const Byte *p)
+  {
+    if (p[0] != 'V' || p[1] != 'Z')
+      return false;
+    Machine = Get16(p + 2);
+    NumSections = p[4];
+    SubSystem = p[5];
+    StrippedSize = Get16(p + 6);
+    /*
+    AddressOfEntryPoint = Get32(p + 8);
+    BaseOfCode = Get32(p + 12);
+    ImageBase = Get64(p + 16);
+    for (int i = 0; i < 2; i++)
+    {
+      const Byte *p2 = p + 24 + i * 8;
+      DataDir[i].Va = Get32(p2);
+      DataDir[i].Size = Get32(p2 + 4);
+    }
+    */
+    return NumSections <= 64 &&
+      MY_FIND_VALUE(NPe::g_MachinePairs, Machine) &&
+      MY_FIND_VALUE(NPe::g_SubSystems, SubSystem);
+  }
+};
+
+struct CSection
+{
+  Byte Name[8];
+
+  // UInt32 VSize;
+  UInt32 Va;
+  UInt32 PSize;
+  UInt32 Pa;
+  UInt32 Flags;
+  // UInt16 NumRelocs;
+
+  void Parse(const Byte *p)
+  {
+    memcpy(Name, p, 8);
+    // VSize = Get32(p + 8);
+    Va = Get32(p + 12);
+    PSize = Get32(p + 16);
+    Pa = Get32(p + 20);
+    // NumRelocs = Get16(p + 32);
+    Flags = Get32(p + 36);
+  }
+
+  bool Check() const { return (PSize + Pa > Pa); }
+
+  void UpdateTotalSize(UInt32 &totalSize)
+  {
+    UInt32 t = Pa + PSize;
+    if (t > totalSize)
+      totalSize = t;
+  }
+};
+
+class CHandler:
+  public IInArchive,
+  public IInArchiveGetStream,
+  public CMyUnknownImp
+{
+  UInt32 _totalSize;
+  CMyComPtr<IInStream> _stream;
+  CObjectVector<CSection> _items;
+  CHeader _h;
+  UInt64 _fileSize;
+  
+  HRESULT Open2(IInStream *stream);
+public:
+  MY_UNKNOWN_IMP2(IInArchive, IInArchiveGetStream)
+  INTERFACE_IInArchive(;)
+  STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
+};
+
+static const STATPROPSTG kProps[] =
+{
+  { NULL, kpidPath, VT_BSTR},
+  { NULL, kpidSize, VT_UI4},
+  { NULL, kpidPackSize, VT_UI4},
+  { NULL, kpidCharacts, VT_BSTR},
+  { NULL, kpidOffset, VT_UI4},
+  { NULL, kpidVa, VT_UI8}
+};
+
+enum
+{
+  kpidSubSystem
+  // , kpidImageBase
+};
+
+static const STATPROPSTG kArcProps[] =
+{
+  { NULL, kpidPhySize, VT_UI4},
+  // { NULL, kpidHeadersSize, VT_UI4},
+  { NULL, kpidCpu, VT_BSTR},
+  { L"Subsystem", kpidSubSystem, VT_BSTR},
+  // { L"Image Base", kpidImageBase, VT_UI8}
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_WITH_NAME
+
+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NCOM::CPropVariant prop;
+  switch(propID)
+  {
+    case kpidPhySize: prop = _totalSize; break;
+    case kpidCpu: PAIR_TO_PROP(NPe::g_MachinePairs, _h.Machine, prop); break;
+    case kpidSubSystem: PAIR_TO_PROP(NPe::g_SubSystems, _h.SubSystem, prop); break;
+    /*
+    case kpidImageBase: prop = _h.ImageBase; break;
+    case kpidAddressOfEntryPoint: prop = _h.AddressOfEntryPoint; break;
+    case kpidBaseOfCode: prop = _h.BaseOfCode; break;
+    */
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NCOM::CPropVariant prop;
+  {
+    const CSection &item = _items[index];
+    switch(propID)
+    {
+      case kpidPath: StringToProp(NPe::GetName(item.Name), prop); break;
+      case kpidSize:
+      case kpidPackSize: prop = (UInt64)item.PSize; break;
+      case kpidOffset: prop = item.Pa; break;
+      case kpidVa: prop = item.Va; break;
+      case kpidCharacts: FLAGS_TO_PROP(NPe::g_SectFlags, item.Flags, prop); break;
+    }
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+HRESULT CHandler::Open2(IInStream *stream)
+{
+  Byte h[kHeaderSize];
+  RINOK(ReadStream_FALSE(stream, h, kHeaderSize));
+  if (!_h.Parse(h))
+    return S_FALSE;
+
+  CByteBuffer buf;
+  UInt32 headerSize = NPe::kSectionSize * _h.NumSections;
+  buf.SetCapacity(headerSize);
+  RINOK(ReadStream_FALSE(stream, buf, headerSize));
+
+  _totalSize = kHeaderSize + headerSize;
+  
+  for (UInt32 i = 0; i < headerSize; i += NPe::kSectionSize)
+  {
+    CSection sect;
+    sect.Parse(buf + i);
+    sect.Pa = _h.ConvertPa(sect.Pa);
+    _items.Add(sect);
+    sect.UpdateTotalSize(_totalSize);
+    if (!sect.Check())
+      return S_FALSE;
+  }
+
+  return stream->Seek(0, STREAM_SEEK_END, &_fileSize);
+}
+
+STDMETHODIMP CHandler::Open(IInStream *inStream,
+    const UInt64 * /* maxCheckStartPosition */,
+    IArchiveOpenCallback * /* openArchiveCallback */)
+{
+  COM_TRY_BEGIN
+  Close();
+  try
+  {
+    if (Open2(inStream) != S_OK)
+      return S_FALSE;
+    _stream = inStream;
+  }
+  catch(...) { return S_FALSE; }
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::Close()
+{
+  _stream.Release();
+  _items.Clear();
+  _totalSize = 0;
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
+{
+  *numItems = _items.Size();
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+    Int32 testMode, IArchiveExtractCallback *extractCallback)
+{
+  COM_TRY_BEGIN
+  bool allFilesMode = (numItems == (UInt32)-1);
+  if (allFilesMode)
+    numItems = _items.Size();
+  if (numItems == 0)
+    return S_OK;
+  UInt64 totalSize = 0;
+  UInt32 i;
+  for (i = 0; i < numItems; i++)
+    totalSize += _items[allFilesMode ? i : indices[i]].PSize;
+  extractCallback->SetTotal(totalSize);
+
+  UInt64 currentTotalSize = 0;
+  
+  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+  CLocalProgress *lps = new CLocalProgress;
+  CMyComPtr<ICompressProgressInfo> progress = lps;
+  lps->Init(extractCallback, false);
+
+  CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+  CMyComPtr<ISequentialInStream> inStream(streamSpec);
+  streamSpec->SetStream(_stream);
+
+  for (i = 0; i < numItems; i++)
+  {
+    lps->InSize = lps->OutSize = currentTotalSize;
+    RINOK(lps->SetCur());
+    CMyComPtr<ISequentialOutStream> realOutStream;
+    Int32 askMode = testMode ?
+        NExtract::NAskMode::kTest :
+        NExtract::NAskMode::kExtract;
+    UInt32 index = allFilesMode ? i : indices[i];
+    const CSection &item = _items[index];
+    RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
+    currentTotalSize += item.PSize;
+    
+    if (!testMode && !realOutStream)
+      continue;
+    RINOK(extractCallback->PrepareOperation(askMode));
+    int res = NExtract::NOperationResult::kDataError;
+    if (item.Pa <= _fileSize)
+    {
+      if (testMode)
+      {
+        if (item.Pa + item.PSize <= _fileSize)
+          res = NExtract::NOperationResult::kOK;
+      }
+      else
+      {
+        RINOK(_stream->Seek(item.Pa, STREAM_SEEK_SET, NULL));
+        streamSpec->Init(item.PSize);
+        RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress));
+        if (copyCoderSpec->TotalSize == item.PSize)
+          res = NExtract::NOperationResult::kOK;
+      }
+    }
+    realOutStream.Release();
+    RINOK(extractCallback->SetOperationResult(res));
+  }
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
+{
+  COM_TRY_BEGIN
+  const CSection &item = _items[index];
+  return CreateLimitedInStream(_stream, item.Pa, item.PSize, stream);
+  COM_TRY_END
+}
+
+static IInArchive *CreateArc() { return new CHandler; }
+
+static CArcInfo g_ArcInfo =
+  { L"TE", L"te", 0, 0xCF, { 'V', 'Z' }, 2, false, CreateArc, 0 };
+
+REGISTER_ARC(TE)
+
+}
+}
--- a/CPP/7zip/Archive/Rar/RarHandler.cpp
+++ b/CPP/7zip/Archive/Rar/RarHandler.cpp
@@ -7,6 +7,7 @@
 #include "Common/StringConvert.h"

 #include "Windows/PropVariant.h"
+#include "Windows/PropVariantUtils.h"
 #include "Windows/Time.h"

 #include "../../IPassword.h"
@@ -46,7 +47,21 @@ static const int kNumHostOSes = sizeof(kHostOS) / sizeof(kHostOS[0]);

 static const wchar_t *kUnknownOS = L"Unknown";

-STATPROPSTG kProps[] =
+static const CUInt32PCharPair k_Flags[] =
+{
+  { 0, "Volume" },
+  { 1, "Comment" },
+  { 2, "Lock" },
+  { 3, "Solid" },
+  { 4, "NewVolName" }, // pack_comment in old versuons
+  { 5, "Authenticity" },
+  { 6, "Recovery" },
+  { 7, "BlockEncryption" },
+  { 8, "FirstVolume" },
+  { 9, "EncryptVer" }
+};
+
+static const STATPROPSTG kProps[] =
 {
  { NULL, kpidPath, VT_BSTR},
  { NULL, kpidIsDir, VT_BOOL},
@@ -68,8 +83,9 @@ STATPROPSTG kProps[] =
  { NULL, kpidUnpackVer, VT_UI1}
 };

-STATPROPSTG kArcProps[] =
+static const STATPROPSTG kArcProps[] =
 {
+  { NULL, kpidCharacts, VT_BSTR},
  { NULL, kpidSolid, VT_BOOL},
  { NULL, kpidNumBlocks, VT_UI4},
  // { NULL, kpidEncrypted, VT_BOOL},
@@ -93,11 +109,12 @@ UInt64 CHandler::GetPackSize(int refIndex) const

 STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
 {
-  // COM_TRY_BEGIN
+  COM_TRY_BEGIN
  NWindows::NCOM::CPropVariant prop;
  switch(propID)
  {
    case kpidSolid: prop = _archiveInfo.IsSolid(); break;
+    case kpidCharacts: FLAGS_TO_PROP(k_Flags, _archiveInfo.Flags, prop); break;
    // case kpidEncrypted: prop = _archiveInfo.IsEncrypted(); break; // it's for encrypted names.
    case kpidIsVolume: prop = _archiveInfo.IsVolume(); break;
    case kpidNumVolumes: prop = (UInt32)_archives.Size(); break;
@@ -112,10 +129,11 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
      prop = (UInt32)numBlocks;
      break;
    }
+    case kpidError: if (!_errorMessage.IsEmpty()) prop = _errorMessage; break;
  }
  prop.Detach(value);
  return S_OK;
-  // COM_TRY_END
+  COM_TRY_END
 }

 STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
@@ -324,19 +342,19 @@ public:

 HRESULT CHandler::Open2(IInStream *stream,
    const UInt64 *maxCheckStartPosition,
-    IArchiveOpenCallback *openArchiveCallback)
+    IArchiveOpenCallback *openCallback)
 {
  {
    CMyComPtr<IArchiveOpenVolumeCallback> openVolumeCallback;
    CMyComPtr<ICryptoGetTextPassword> getTextPassword;
-    CMyComPtr<IArchiveOpenCallback> openArchiveCallbackWrap = openArchiveCallback;
+    CMyComPtr<IArchiveOpenCallback> openArchiveCallbackWrap = openCallback;
    
    CVolumeName seqName;

    UInt64 totalBytes = 0;
    UInt64 curBytes = 0;

-    if (openArchiveCallback != NULL)
+    if (openCallback)
    {
      openArchiveCallbackWrap.QueryInterface(IID_IArchiveOpenVolumeCallback, &openVolumeCallback);
      openArchiveCallbackWrap.QueryInterface(IID_ICryptoGetTextPassword, &getTextPassword);
@@ -378,12 +396,12 @@ HRESULT CHandler::Open2(IInStream *stream,
        inStream = stream;

      UInt64 endPos = 0;
-      if (openArchiveCallback != NULL)
+      RINOK(stream->Seek(0, STREAM_SEEK_END, &endPos));
+      RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));
+      if (openCallback)
      {
-        RINOK(stream->Seek(0, STREAM_SEEK_END, &endPos));
-        RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));
        totalBytes += endPos;
-        RINOK(openArchiveCallback->SetTotal(NULL, &totalBytes));
+        RINOK(openCallback->SetTotal(NULL, &totalBytes));
      }
      
      NArchive::NRar::CInArchive archive;
@@ -395,8 +413,16 @@ HRESULT CHandler::Open2(IInStream *stream,
      CItemEx item;
      for (;;)
      {
+        if (archive.m_Position > endPos)
+        {
+          AddErrorMessage("Unexpected end of archive");
+          break;
+        }
        bool decryptionError;
-        HRESULT result = archive.GetNextItem(item, getTextPassword, decryptionError);
+        AString errorMessageLoc;
+        HRESULT result = archive.GetNextItem(item, getTextPassword, decryptionError, errorMessageLoc);
+        if (errorMessageLoc)
+          AddErrorMessage(errorMessageLoc);
        if (result == S_FALSE)
        {
          if (decryptionError && _items.IsEmpty())
@@ -426,11 +452,11 @@ HRESULT CHandler::Open2(IInStream *stream,
          _refItems.Add(refItem);
        }
        _items.Add(item);
-        if (openArchiveCallback != NULL && _items.Size() % 100 == 0)
+        if (openCallback && _items.Size() % 100 == 0)
        {
          UInt64 numFiles = _items.Size();
          UInt64 numBytes = curBytes + item.Position;
-          RINOK(openArchiveCallback->SetCompleted(&numFiles, &numBytes));
+          RINOK(openCallback->SetCompleted(&numFiles, &numBytes));
        }
      }
      curBytes += endPos;
@@ -442,13 +468,13 @@ HRESULT CHandler::Open2(IInStream *stream,

 STDMETHODIMP CHandler::Open(IInStream *stream,
    const UInt64 *maxCheckStartPosition,
-    IArchiveOpenCallback *openArchiveCallback)
+    IArchiveOpenCallback *openCallback)
 {
  COM_TRY_BEGIN
  Close();
  try
  {
-    HRESULT res = Open2(stream, maxCheckStartPosition, openArchiveCallback);
+    HRESULT res = Open2(stream, maxCheckStartPosition, openCallback);
    if (res != S_OK)
      Close();
    return res;
@@ -461,6 +487,7 @@ STDMETHODIMP CHandler::Open(IInStream *stream,
 STDMETHODIMP CHandler::Close()
 {
  COM_TRY_BEGIN
+  _errorMessage.Empty();
  _refItems.Clear();
  _items.Clear();
  _archives.Clear();
--- a/CPP/7zip/Archive/Rar/RarHandler.h
+++ b/CPP/7zip/Archive/Rar/RarHandler.h
@@ -4,11 +4,12 @@
 #define __RAR_HANDLER_H

 #include "../IArchive.h"
-#include "RarIn.h"
-#include "RarVolumeInStream.h"

 #include "../../Common/CreateCoder.h"

+#include "RarIn.h"
+#include "RarVolumeInStream.h"
+
 namespace NArchive {
 namespace NRar {

@@ -17,26 +18,15 @@ class CHandler:
  PUBLIC_ISetCompressCodecsInfo
  public CMyUnknownImp
 {
-public:
-  MY_QUERYINTERFACE_BEGIN2(IInArchive)
-  QUERY_ENTRY_ISetCompressCodecsInfo
-  MY_QUERYINTERFACE_END
-  MY_ADDREF_RELEASE
-  
-  INTERFACE_IInArchive(;)
-
-  DECL_ISetCompressCodecsInfo
-
-private:
  CRecordVector<CRefItem> _refItems;
  CObjectVector<CItemEx> _items;
  CObjectVector<CInArchive> _archives;
  NArchive::NRar::CInArchiveInfo _archiveInfo;
+  AString _errorMessage;

  DECL_EXTERNAL_CODECS_VARS

  UInt64 GetPackSize(int refIndex) const;
-  // NArchive::NRar::CInArchive _archive;

  bool IsSolid(int refIndex)
  {
@@ -49,10 +39,26 @@ private:
    }
    return item.IsSolid();
  }
+  void AddErrorMessage(const AString &s)
+  {
+    if (!_errorMessage.IsEmpty())
+      _errorMessage += '\n';
+    _errorMessage += s;
+  }

  HRESULT Open2(IInStream *stream,
      const UInt64 *maxCheckStartPosition,
-      IArchiveOpenCallback *openArchiveCallback);
+      IArchiveOpenCallback *openCallback);
+
+public:
+  MY_QUERYINTERFACE_BEGIN2(IInArchive)
+  QUERY_ENTRY_ISetCompressCodecsInfo
+  MY_QUERYINTERFACE_END
+  MY_ADDREF_RELEASE
+  
+  INTERFACE_IInArchive(;)
+
+  DECL_ISetCompressCodecsInfo
 };

 }}
--- a/CPP/7zip/Archive/Rar/RarHeader.h
+++ b/CPP/7zip/Archive/Rar/RarHeader.h
@@ -5,9 +5,9 @@

 #include "Common/Types.h"

-namespace NArchive{
-namespace NRar{
-namespace NHeader{
+namespace NArchive {
+namespace NRar {
+namespace NHeader {

 const int kMarkerSize = 7;
 extern Byte kMarker[kMarkerSize];
@@ -18,16 +18,16 @@ namespace NBlockType
 {
  enum EBlockType
  {
-    kMarker        = 0x72,
-    kArchiveHeader = 0x73,
-    kFileHeader    = 0x74,
-    kCommentHeader = 0x75,
-    kOldAuthenticity = 0x76,
-    kSubBlock       = 0x77,
-    kRecoveryRecord = 0x78,
-    kAuthenticity   = 0x79,
-
-    kEndOfArchive   = 0x7B // Is not safe
+    kMarker = 0x72,
+    kArchiveHeader,
+    kFileHeader,
+    kCommentHeader,
+    kOldAuthenticity,
+    kOldSubBlock,
+    kRecoveryRecord,
+    kAuthenticity,
+    kSubBlock,
+    kEndOfArchive
  };
 }

@@ -43,32 +43,13 @@ namespace NArchive
  const UInt16 kBlockEncryption  = 0x80;
  const UInt16 kFirstVolume = 0x100; // (set only by RAR 3.0 and later)
  const UInt16 kEncryptVer = 0x200; // RAR 3.6 there is EncryptVer Byte in End of MainHeader
-  
-  const int kHeaderSizeMin = 7;

-  struct CBlock
-  {
-    UInt16 CRC;
-    Byte Type;
-    UInt16 Flags;
-    UInt16 Size;
-    UInt16 Reserved1;
-    UInt32 Reserved2;
-    // UInt16 GetRealCRC() const;
-  };
+  const int kHeaderSizeMin = 7;
  
  const int kArchiveHeaderSize = 13;

  const int kBlockHeadersAreEncrypted = 0x80;

-  struct CHeader360: public CBlock
-  {
-    Byte EncryptVersion;
-    bool IsEncrypted() const { return (Flags & NHeader::NArchive::kBlockEncryption) != 0; }
-    bool IsThereEncryptVer() const { return (Flags & NHeader::NArchive::kEncryptVer) != 0; }
-    bool IsEncryptOld() const { return (!IsThereEncryptVer() || EncryptVersion < 36); }
-    UInt32 GetBaseSize() const { return kArchiveHeaderSize + (IsEncryptOld() ? 0 : 1); }
-  };
 }

 namespace NFile
--- a/CPP/7zip/Archive/Rar/RarIn.cpp
+++ b/CPP/7zip/Archive/Rar/RarIn.cpp
@@ -3,6 +3,7 @@
 #include "StdAfx.h"

 #include "../../../../C/7zCrc.h"
+#include "../../../../C/CpuArch.h"

 #include "Common/StringConvert.h"
 #include "Common/UTFConvert.h"
@@ -14,9 +15,16 @@

 #include "RarIn.h"

+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
 namespace NArchive {
 namespace NRar {
- 
+
+static const char *k_UnexpectedEnd = "Unexpected end of archive";
+static const char *k_DecryptionError = "Decryption Error";
+
 void CInArchive::ThrowExceptionWithCode(
    CInArchiveException::CCauseType cause)
 {
@@ -42,140 +50,80 @@ void CInArchive::Close()
  m_Stream.Release();
 }

-
-static inline bool TestMarkerCandidate(const void *aTestBytes)
+HRESULT CInArchive::ReadBytesSpec(void *data, size_t *resSize)
 {
-  for (UInt32 i = 0; i < NHeader::kMarkerSize; i++)
-    if (((const Byte *)aTestBytes)[i] != NHeader::kMarker[i])
-      return false;
-  return true;
-}
-
-HRESULT CInArchive::FindAndReadMarker(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
-{
-  RINOK(FindSignatureInStream(stream,
-      NHeader::kMarker, NHeader::kMarkerSize,
-      searchHeaderSizeLimit, m_ArchiveStartPosition));
-  m_Stream = stream;
-  m_Position = m_ArchiveStartPosition + NHeader::kMarkerSize;
-  return m_Stream->Seek(m_Position, STREAM_SEEK_SET, NULL);
-}
-
-void CInArchive::ThrowUnexpectedEndOfArchiveException()
-{
-  ThrowExceptionWithCode(CInArchiveException::kUnexpectedEndOfArchive);
+  if (m_CryptoMode)
+  {
+    size_t size = *resSize;
+    *resSize = 0;
+    const Byte *bufData = m_DecryptedDataAligned;
+    UInt32 bufSize = m_DecryptedDataSize;
+    size_t i;
+    for (i = 0; i < size && m_CryptoPos < bufSize; i++)
+      ((Byte *)data)[i] = bufData[m_CryptoPos++];
+    *resSize = i;
+    return S_OK;
+  }
+  return ReadStream(m_Stream, data, resSize);
 }

 bool CInArchive::ReadBytesAndTestSize(void *data, UInt32 size)
 {
-  if (m_CryptoMode)
-  {
-    const Byte *bufData = m_DecryptedDataAligned;
-    UInt32 bufSize = m_DecryptedDataSize;
-    UInt32 i;
-    for (i = 0; i < size && m_CryptoPos < bufSize; i++)
-      ((Byte *)data)[i] = bufData[m_CryptoPos++];
-    return (i == size);
-  }
-  return (ReadStream_FALSE(m_Stream, data, size) == S_OK);
+  size_t processed = size;
+  if (ReadBytesSpec(data, &processed) != S_OK)
+    return false;
+  return processed == size;
 }

-void CInArchive::ReadBytesAndTestResult(void *data, UInt32 size)
-{
-  if(!ReadBytesAndTestSize(data,size))
-    ThrowUnexpectedEndOfArchiveException();
-}
-
-HRESULT CInArchive::ReadBytes(void *data, UInt32 size, UInt32 *processedSize)
-{
-  size_t realProcessedSize = size;
-  HRESULT result = ReadStream(m_Stream, data, &realProcessedSize);
-  if (processedSize != NULL)
-    *processedSize = (UInt32)realProcessedSize;
-  AddToSeekValue(realProcessedSize);
-  return result;
-}
-
-static UInt32 CrcUpdateUInt16(UInt32 crc, UInt16 v)
-{
-  crc = CRC_UPDATE_BYTE(crc, (Byte)(v & 0xFF));
-  crc = CRC_UPDATE_BYTE(crc, (Byte)((v >> 8) & 0xFF));
-  return crc;
-}
-
-static UInt32 CrcUpdateUInt32(UInt32 crc, UInt32 v)
-{
-  crc = CRC_UPDATE_BYTE(crc, (Byte)(v & 0xFF));
-  crc = CRC_UPDATE_BYTE(crc, (Byte)((v >> 8) & 0xFF));
-  crc = CRC_UPDATE_BYTE(crc, (Byte)((v >> 16) & 0xFF));
-  crc = CRC_UPDATE_BYTE(crc, (Byte)((v >> 24) & 0xFF));
-  return crc;
-}
-
-
 HRESULT CInArchive::Open2(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
 {
  m_CryptoMode = false;
  RINOK(stream->Seek(0, STREAM_SEEK_SET, &m_StreamStartPosition));
  m_Position = m_StreamStartPosition;

-  RINOK(FindAndReadMarker(stream, searchHeaderSizeLimit));
+  UInt64 arcStartPos;
+  RINOK(FindSignatureInStream(stream, NHeader::kMarker, NHeader::kMarkerSize,
+      searchHeaderSizeLimit, arcStartPos));
+  m_Position = arcStartPos + NHeader::kMarkerSize;
+  RINOK(stream->Seek(m_Position, STREAM_SEEK_SET, NULL));
+  Byte buf[NHeader::NArchive::kArchiveHeaderSize + 1];

-  Byte buf[NHeader::NArchive::kArchiveHeaderSize];
-  UInt32 processedSize;
-  ReadBytes(buf, sizeof(buf), &processedSize);
-  if (processedSize != sizeof(buf))
-    return S_FALSE;
-  m_CurData = buf;
-  m_CurPos = 0;
-  m_PosLimit = sizeof(buf);
+  RINOK(ReadStream_FALSE(stream, buf, NHeader::NArchive::kArchiveHeaderSize));
+  AddToSeekValue(NHeader::NArchive::kArchiveHeaderSize);

-  m_ArchiveHeader.CRC = ReadUInt16();
-  m_ArchiveHeader.Type = ReadByte();
-  m_ArchiveHeader.Flags = ReadUInt16();
-  m_ArchiveHeader.Size = ReadUInt16();
-  m_ArchiveHeader.Reserved1 = ReadUInt16();
-  m_ArchiveHeader.Reserved2 = ReadUInt32();
-  m_ArchiveHeader.EncryptVersion = 0;

-  UInt32 crc = CRC_INIT_VAL;
-  crc = CRC_UPDATE_BYTE(crc, m_ArchiveHeader.Type);
-  crc = CrcUpdateUInt16(crc, m_ArchiveHeader.Flags);
-  crc = CrcUpdateUInt16(crc, m_ArchiveHeader.Size);
-  crc = CrcUpdateUInt16(crc, m_ArchiveHeader.Reserved1);
-  crc = CrcUpdateUInt32(crc, m_ArchiveHeader.Reserved2);
+  UInt32 blockSize = Get16(buf + 5);

-  if (m_ArchiveHeader.IsThereEncryptVer() && m_ArchiveHeader.Size > NHeader::NArchive::kArchiveHeaderSize)
+  _header.EncryptVersion = 0;
+  _header.Flags = Get16(buf + 3);
+
+  UInt32 headerSize = NHeader::NArchive::kArchiveHeaderSize;
+  if (_header.IsThereEncryptVer())
  {
-    ReadBytes(&m_ArchiveHeader.EncryptVersion, 1, &processedSize);
-    if (processedSize != 1)
+    if (blockSize <= headerSize)
      return S_FALSE;
-    crc = CRC_UPDATE_BYTE(crc, m_ArchiveHeader.EncryptVersion);
+    RINOK(ReadStream_FALSE(stream, buf + NHeader::NArchive::kArchiveHeaderSize, 1));
+    AddToSeekValue(1);
+    _header.EncryptVersion = buf[NHeader::NArchive::kArchiveHeaderSize];
+    headerSize += 1;
  }
-
-  if(m_ArchiveHeader.CRC != (CRC_GET_DIGEST(crc) & 0xFFFF))
-    ThrowExceptionWithCode(CInArchiveException::kArchiveHeaderCRCError);
-  if (m_ArchiveHeader.Type != NHeader::NBlockType::kArchiveHeader)
+  if (blockSize < headerSize ||
+      buf[2] != NHeader::NBlockType::kArchiveHeader ||
+      (UInt32)Get16(buf) != (CrcCalc(buf + 2, headerSize - 2) & 0xFFFF))
    return S_FALSE;
-  m_ArchiveCommentPosition = m_Position;
-  m_SeekOnArchiveComment = true;
-  return S_OK;
-}

-void CInArchive::SkipArchiveComment()
-{
-  if (!m_SeekOnArchiveComment)
-    return;
-  AddToSeekValue(m_ArchiveHeader.Size - m_ArchiveHeader.GetBaseSize());
-  m_SeekOnArchiveComment = false;
+  size_t commentSize = blockSize - headerSize;
+  _comment.SetCapacity(commentSize);
+  RINOK(ReadStream_FALSE(stream, _comment, commentSize));
+  AddToSeekValue(commentSize);
+  m_Stream = stream;
+  _header.StartPosition = arcStartPos;
+  return S_OK;
 }

 void CInArchive::GetArchiveInfo(CInArchiveInfo &archiveInfo) const
 {
-  archiveInfo.StartPosition = m_ArchiveStartPosition;
-  archiveInfo.Flags = m_ArchiveHeader.Flags;
-  archiveInfo.CommentPosition = m_ArchiveCommentPosition;
-  archiveInfo.CommentSize = (UInt16)(m_ArchiveHeader.Size - NHeader::NArchive::kArchiveHeaderSize);
+  archiveInfo = _header;
 }

 static void DecodeUnicodeFileName(const char *name, const Byte *encName,
@@ -372,29 +320,24 @@ void CInArchive::AddToSeekValue(UInt64 addValue)
  m_Position += addValue;
 }

-HRESULT CInArchive::GetNextItem(CItemEx &item, ICryptoGetTextPassword *getTextPassword, bool &decryptionError)
+HRESULT CInArchive::GetNextItem(CItemEx &item, ICryptoGetTextPassword *getTextPassword, bool &decryptionError, AString &errorMessage)
 {
  decryptionError = false;
-  if (m_SeekOnArchiveComment)
-    SkipArchiveComment();
  for (;;)
  {
-    if(!SeekInArchive(m_Position))
-      return S_FALSE;
-    if (!m_CryptoMode && (m_ArchiveHeader.Flags &
+    SeekInArchive(m_Position);
+    if (!m_CryptoMode && (_header.Flags &
        NHeader::NArchive::kBlockHeadersAreEncrypted) != 0)
    {
      m_CryptoMode = false;
      if (getTextPassword == 0)
        return S_FALSE;
-      if(!SeekInArchive(m_Position))
-        return S_FALSE;
      if (!m_RarAES)
      {
        m_RarAESSpec = new NCrypto::NRar29::CDecoder;
        m_RarAES = m_RarAESSpec;
      }
-      m_RarAESSpec->SetRar350Mode(m_ArchiveHeader.IsEncryptOld());
+      m_RarAESSpec->SetRar350Mode(_header.IsEncryptOld());

      // Salt
      const UInt32 kSaltSize = 8;
@@ -438,8 +381,14 @@ HRESULT CInArchive::GetNextItem(CItemEx &item, ICryptoGetTextPassword *getTextPa
    }

    m_FileHeaderData.EnsureCapacity(7);
-    if(!ReadBytesAndTestSize((Byte *)m_FileHeaderData, 7))
+    size_t processed = 7;
+    RINOK(ReadBytesSpec((Byte *)m_FileHeaderData, &processed));
+    if (processed != 7)
+    {
+      if (processed != 0)
+        errorMessage = k_UnexpectedEnd;
      return S_FALSE;
+    }

    m_CurData = (Byte *)m_FileHeaderData;
    m_CurPos = 0;
@@ -460,7 +409,12 @@ HRESULT CInArchive::GetNextItem(CItemEx &item, ICryptoGetTextPassword *getTextPa
      m_FileHeaderData.EnsureCapacity(m_BlockHeader.HeadSize);
      m_CurData = (Byte *)m_FileHeaderData;
      m_PosLimit = m_BlockHeader.HeadSize;
-      ReadBytesAndTestResult(m_CurData + m_CurPos, m_BlockHeader.HeadSize - 7);
+      if (!ReadBytesAndTestSize(m_CurData + m_CurPos, m_BlockHeader.HeadSize - 7))
+      {
+        errorMessage = k_UnexpectedEnd;
+        return S_FALSE;
+      }
+
      ReadHeaderReal(item);
      if ((CrcCalc(m_CurData + 2,
          m_BlockHeader.HeadSize - item.CommentSize - 2) & 0xFFFF) != m_BlockHeader.CRC)
@@ -475,19 +429,25 @@ HRESULT CInArchive::GetNextItem(CItemEx &item, ICryptoGetTextPassword *getTextPa
    if (m_CryptoMode && m_BlockHeader.HeadSize > (1 << 10))
    {
      decryptionError = true;
+      errorMessage = k_DecryptionError;
      return S_FALSE;
    }
    if ((m_BlockHeader.Flags & NHeader::NBlock::kLongBlock) != 0)
    {
      m_FileHeaderData.EnsureCapacity(7 + 4);
      m_CurData = (Byte *)m_FileHeaderData;
-      ReadBytesAndTestResult(m_CurData + m_CurPos, 4); // test it
+      if (!ReadBytesAndTestSize(m_CurData + m_CurPos, 4))
+      {
+        errorMessage = k_UnexpectedEnd;
+        return S_FALSE;
+      }
      m_PosLimit = 7 + 4;
      UInt32 dataSize = ReadUInt32();
      AddToSeekValue(dataSize);
      if (m_CryptoMode && dataSize > (1 << 27))
      {
        decryptionError = true;
+        errorMessage = k_DecryptionError;
        return S_FALSE;
      }
      m_CryptoPos = m_BlockHeader.HeadSize;
@@ -500,11 +460,9 @@ HRESULT CInArchive::GetNextItem(CItemEx &item, ICryptoGetTextPassword *getTextPa
  }
 }

-bool CInArchive::SeekInArchive(UInt64 position)
+void CInArchive::SeekInArchive(UInt64 position)
 {
-  UInt64 newPosition;
-  m_Stream->Seek(position, STREAM_SEEK_SET, &newPosition);
-  return newPosition == position;
+  m_Stream->Seek(position, STREAM_SEEK_SET, NULL);
 }

 ISequentialInStream* CInArchive::CreateLimitedStream(UInt64 position, UInt64 size)
--- a/CPP/7zip/Archive/Rar/RarIn.h
+++ b/CPP/7zip/Archive/Rar/RarIn.h
@@ -33,18 +33,20 @@ public:
  CInArchiveException(CCauseType cause) :   Cause(cause) {}
 };

-class CInArchiveInfo
+
+struct CInArchiveInfo
 {
-public:
+  UInt32 Flags;
+  Byte EncryptVersion;
  UInt64 StartPosition;
-  UInt16 Flags;
-  UInt64 CommentPosition;
-  UInt16 CommentSize;
+  
  bool IsSolid() const { return (Flags & NHeader::NArchive::kSolid) != 0; }
  bool IsCommented() const {  return (Flags & NHeader::NArchive::kComment) != 0; }
  bool IsVolume() const {  return (Flags & NHeader::NArchive::kVolume) != 0; }
  bool HaveNewVolumeName() const {  return (Flags & NHeader::NArchive::kNewVolName) != 0; }
  bool IsEncrypted() const { return (Flags & NHeader::NArchive::kBlockEncryption) != 0; }
+  bool IsThereEncryptVer() const { return (Flags & NHeader::NArchive::kEncryptVer) != 0; }
+  bool IsEncryptOld() const { return (!IsThereEncryptVer() || EncryptVersion < 36); }
 };

 class CInArchive
@@ -52,23 +54,19 @@ class CInArchive
  CMyComPtr<IInStream> m_Stream;
  
  UInt64 m_StreamStartPosition;
-  UInt64 m_Position;
-  UInt64 m_ArchiveStartPosition;
  
-  NHeader::NArchive::CHeader360 m_ArchiveHeader;
+  CInArchiveInfo _header;
  CDynamicBuffer<char> m_NameBuffer;
  CDynamicBuffer<wchar_t> _unicodeNameBuffer;
-  bool m_SeekOnArchiveComment;
-  UInt64 m_ArchiveCommentPosition;
+
+  CByteBuffer _comment;
  
  void ReadName(CItemEx &item, int nameSize);
  void ReadHeaderReal(CItemEx &item);
  
-  HRESULT ReadBytes(void *data, UInt32 size, UInt32 *aProcessedSize);
+  HRESULT ReadBytesSpec(void *data, size_t *size);
  bool ReadBytesAndTestSize(void *data, UInt32 size);
-  void ReadBytesAndTestResult(void *data, UInt32 size);
  
-  HRESULT FindAndReadMarker(IInStream *stream, const UInt64 *searchHeaderSizeLimit);
  HRESULT Open2(IInStream *stream, const UInt64 *searchHeaderSizeLimit);

  void ThrowExceptionWithCode(CInArchiveException::CCauseType cause);
@@ -108,15 +106,15 @@ class CInArchive
  }

 public:
+  UInt64 m_Position;
+
  HRESULT Open(IInStream *inStream, const UInt64 *searchHeaderSizeLimit);
  void Close();
-  HRESULT GetNextItem(CItemEx &item, ICryptoGetTextPassword *getTextPassword, bool &decryptionError);
-  
-  void SkipArchiveComment();
+  HRESULT GetNextItem(CItemEx &item, ICryptoGetTextPassword *getTextPassword, bool &decryptionError, AString &errorMessage);
  
  void GetArchiveInfo(CInArchiveInfo &archiveInfo) const;
  
-  bool SeekInArchive(UInt64 position);
+  void SeekInArchive(UInt64 position);
  ISequentialInStream *CreateLimitedStream(UInt64 position, UInt64 size);
 };
  
--- a/CPP/7zip/Archive/RpmHandler.cpp
+++ b/CPP/7zip/Archive/RpmHandler.cpp
@@ -79,7 +79,7 @@ static HRESULT RedSigHeaderSig(IInStream *inStream, CSigHeaderSig &h)
  char dat[kCSigHeaderSigSize];
  char *cur = dat;
  RINOK(ReadStream_FALSE(inStream, dat, kCSigHeaderSigSize));
-  memmove(h.Magic, cur, 4);
+  memcpy(h.Magic, cur, 4);
  cur += 4;
  cur += 4;
  h.IndexLen = Get32(cur);
@@ -95,7 +95,7 @@ HRESULT OpenArchive(IInStream *inStream)
  char *cur = leadData;
  CLead lead;
  RINOK(ReadStream_FALSE(inStream, leadData, kLeadSize));
-  memmove(lead.Magic, cur, 4);
+  memcpy(lead.Magic, cur, 4);
  cur += 4;
  lead.Major = *cur++;
  lead.Minor = *cur++;
@@ -103,7 +103,7 @@ HRESULT OpenArchive(IInStream *inStream)
  cur += 2;
  lead.ArchNum = Get16(cur);
  cur += 2;
-  memmove(lead.Name, cur, sizeof(lead.Name));
+  memcpy(lead.Name, cur, sizeof(lead.Name));
  cur += sizeof(lead.Name);
  lead.OSNum = Get16(cur);
  cur += 2;
--- a/CPP/7zip/Archive/SplitHandler.cpp
+++ b/CPP/7zip/Archive/SplitHandler.cpp
@@ -347,7 +347,6 @@ STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
  {
    CMultiStream::CSubStreamInfo subStreamInfo;
    subStreamInfo.Stream = _streams[i];
-    subStreamInfo.Pos = 0;
    subStreamInfo.Size = _sizes[i];
    streamSpec->Streams.Add(subStreamInfo);
  }
--- a/CPP/7zip/Archive/SquashfsHandler.cpp
+++ b/CPP/7zip/Archive/SquashfsHandler.cpp
--- a/CPP/7zip/Archive/SwfHandler.cpp
+++ b/CPP/7zip/Archive/SwfHandler.cpp
@@ -21,8 +21,7 @@
 #include "../Compress/ZlibEncoder.h"

 #include "Common/DummyOutStream.h"
-
-#include "DeflateProps.h"
+#include "Common/HandlerOut.h"

 using namespace NWindows;

@@ -69,7 +68,7 @@ class CHandler:
  CMyComPtr<ISequentialInStream> _seqStream;
  CMyComPtr<IInStream> _stream;

-  CDeflateProps _method;
+  CSingleMethodProps _props;

 public:
  MY_UNKNOWN_IMP4(IInArchive, IArchiveOpenSeq, IOutArchive, ISetProperties)
@@ -206,7 +205,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 }

 static HRESULT UpdateArchive(ISequentialOutStream *outStream,
-    UInt64 size, CDeflateProps &deflateProps,
+    UInt64 size, const CSingleMethodProps &props,
    IArchiveUpdateCallback *updateCallback)
 {
  UInt64 complexity = 0;
@@ -234,7 +233,7 @@ static HRESULT UpdateArchive(ISequentialOutStream *outStream,
  NCompress::NZlib::CEncoder *encoderSpec = new NCompress::NZlib::CEncoder;
  CMyComPtr<ICompressCoder> encoder = encoderSpec;
  encoderSpec->Create();
-  RINOK(deflateProps.SetCoderProperties(encoderSpec->DeflateEncoderSpec));
+  RINOK(props.SetCoderProps(encoderSpec->DeflateEncoderSpec, NULL));
  RINOK(encoder->Code(fileInStream, outStream, NULL, NULL, progress));
  if (encoderSpec->GetInputProcessedSize() + kHeaderSize != size)
    return E_INVALIDARG;
@@ -284,7 +283,7 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
        return E_INVALIDARG;
      size = prop.uhVal.QuadPart;
    }
-    return UpdateArchive(outStream, size, _method, updateCallback);
+    return UpdateArchive(outStream, size, _props, updateCallback);
  }
    
  if (indexInArchive != 0)
@@ -304,7 +303,7 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt

 STDMETHODIMP CHandler::SetProperties(const wchar_t **names, const PROPVARIANT *values, Int32 numProps)
 {
-  return _method.SetProperties(names, values, numProps);
+  return _props.SetProperties(names, values, numProps);
 }

 static IInArchive *CreateArc() { return new CHandler; }
--- a/CPP/7zip/Archive/Tar/TarHandler.cpp
+++ b/CPP/7zip/Archive/Tar/TarHandler.cpp
@@ -10,6 +10,8 @@

 #include "../../Common/LimitedStreams.h"
 #include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamObjects.h"
+#include "../../Common/StreamUtils.h"

 #include "../Common/ItemNameUtils.h"

@@ -21,7 +23,9 @@ using namespace NWindows;
 namespace NArchive {
 namespace NTar {

-static STATPROPSTG kProps[] =
+static const char *kUnexpectedEnd = "Unexpected end of archive";
+
+static const STATPROPSTG kProps[] =
 {
  { NULL, kpidPath, VT_BSTR},
  { NULL, kpidIsDir, VT_BOOL},
@@ -34,8 +38,14 @@ static STATPROPSTG kProps[] =
  { NULL, kpidLink, VT_BSTR}
 };

+static const STATPROPSTG kArcProps[] =
+{
+  { NULL, kpidPhySize, VT_UI8},
+  { NULL, kpidHeadersSize, VT_UI8}
+};
+
 IMP_IInArchive_Props
-IMP_IInArchive_ArcProps_NO_Table
+IMP_IInArchive_ArcProps

 STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
 {
@@ -43,11 +53,24 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
  switch(propID)
  {
    case kpidPhySize: if (_phySizeDefined) prop = _phySize; break;
+    case kpidHeadersSize: if (_phySizeDefined) prop = _headersSize; break;
+    case kpidError: if (!_errorMessage.IsEmpty()) prop = _errorMessage; break;
  }
  prop.Detach(value);
  return S_OK;
 }

+HRESULT CHandler::ReadItem2(ISequentialInStream *stream, bool &filled, CItemEx &item)
+{
+  item.HeaderPos = _phySize;
+  RINOK(ReadItem(stream, filled, item, _errorMessage));
+  if (filled && item.IsSparse())
+    _isSparse = true;
+  _phySize += item.HeaderSize;
+  _headersSize += item.HeaderSize;
+  return S_OK;
+}
+
 HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *callback)
 {
  UInt64 endPos = 0;
@@ -56,26 +79,29 @@ HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *callback)
    RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));
  }
  
-  _isGood = true;
-  UInt64 pos = 0;
+  _phySizeDefined = true;
  for (;;)
  {
    CItemEx item;
    bool filled;
-    item.HeaderPosition = pos;
-    RINOK(ReadItem(stream, filled, item));
+    RINOK(ReadItem2(stream, filled, item));
    if (!filled)
      break;
    _items.Add(item);
    
-    RINOK(stream->Seek(item.GetPackSize(), STREAM_SEEK_CUR, &pos));
-    if (pos > endPos)
-      return S_FALSE;
-    if (pos == endPos)
+    RINOK(stream->Seek(item.GetPackSizeAligned(), STREAM_SEEK_CUR, &_phySize));
+    if (_phySize > endPos)
    {
-      _isGood = false;
+      _errorMessage = kUnexpectedEnd;
      break;
    }
+    /*
+    if (_phySize == endPos)
+    {
+      _errorMessage = "There are no trailing zero-filled records";
+      break;
+    }
+    */
    if (callback != NULL)
    {
      if (_items.Size() == 1)
@@ -85,7 +111,7 @@ HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *callback)
      if (_items.Size() % 100 == 0)
      {
        UInt64 numFiles = _items.Size();
-        RINOK(callback->SetCompleted(&numFiles, &pos));
+        RINOK(callback->SetCompleted(&numFiles, &_phySize));
      }
    }
  }
@@ -132,9 +158,13 @@ STDMETHODIMP CHandler::OpenSeq(ISequentialInStream *stream)

 STDMETHODIMP CHandler::Close()
 {
+  _errorMessage.Empty();
  _phySizeDefined = false;
+  _phySize = 0;
+  _headersSize = 0;
  _curIndex = 0;
  _latestIsRead = false;
+  _isSparse = false;
  _items.Clear();
  _seqStream.Release();
  _stream.Release();
@@ -159,18 +189,26 @@ HRESULT CHandler::SkipTo(UInt32 index)
  {
    if (_latestIsRead)
    {
-      UInt64 packSize = _latestItem.GetPackSize();
+      UInt64 packSize = _latestItem.GetPackSizeAligned();
      RINOK(copyCoderSpec->Code(_seqStream, NULL, &packSize, &packSize, NULL));
+      _phySize += copyCoderSpec->TotalSize;
+      if (copyCoderSpec->TotalSize != packSize)
+      {
+        _errorMessage = kUnexpectedEnd;
+        return S_FALSE;
+      }
      _latestIsRead = false;
      _curIndex++;
    }
    else
    {
      bool filled;
-      // item.HeaderPosition = pos;
-      RINOK(ReadItem(_seqStream, filled, _latestItem));
+      RINOK(ReadItem2(_seqStream, filled, _latestItem));
      if (!filled)
+      {
+        _phySizeDefined = true;
        return E_INVALIDARG;
+      }
      _latestIsRead = true;
    }
  }
@@ -203,22 +241,22 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val

  switch(propID)
  {
-    case kpidPath:  prop = NItemName::GetOSName2(TarStringToUnicode(item->Name)); break;
-    case kpidIsDir:  prop = item->IsDir(); break;
-    case kpidSize:  prop = item->Size; break;
-    case kpidPackSize:  prop = item->GetPackSize(); break;
+    case kpidPath: prop = NItemName::GetOSName2(TarStringToUnicode(item->Name)); break;
+    case kpidIsDir: prop = item->IsDir(); break;
+    case kpidSize: prop = item->GetUnpackSize(); break;
+    case kpidPackSize: prop = item->GetPackSizeAligned(); break;
    case kpidMTime:
      if (item->MTime != 0)
      {
        FILETIME ft;
-        NTime::UnixTimeToFileTime(item->MTime, ft);
-        prop = ft;
+        if (NTime::UnixTime64ToFileTime(item->MTime, ft))
+          prop = ft;
      }
      break;
    case kpidPosixAttrib: prop = item->Mode; break;
-    case kpidUser:  prop = TarStringToUnicode(item->User); break;
-    case kpidGroup:  prop = TarStringToUnicode(item->Group); break;
-    case kpidLink:  prop = TarStringToUnicode(item->LinkName); break;
+    case kpidUser: prop = TarStringToUnicode(item->User); break;
+    case kpidGroup: prop = TarStringToUnicode(item->Group); break;
+    case kpidLink: prop = TarStringToUnicode(item->LinkName); break;
  }
  prop.Detach(value);
  return S_OK;
@@ -242,7 +280,7 @@ HRESULT CHandler::Extract(const UInt32 *indices, UInt32 numItems,
  UInt64 totalSize = 0;
  UInt32 i;
  for (i = 0; i < numItems; i++)
-    totalSize += _items[allFilesMode ? i : indices[i]].Size;
+    totalSize += _items[allFilesMode ? i : indices[i]].GetUnpackSize();
  extractCallback->SetTotal(totalSize);

  UInt64 totalPackSize;
@@ -282,8 +320,9 @@ HRESULT CHandler::Extract(const UInt32 *indices, UInt32 numItems,
      item = &_items[index];

    RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
-    totalSize += item->Size;
-    totalPackSize += item->GetPackSize();
+    UInt64 unpackSize = item->GetUnpackSize();
+    totalSize += unpackSize;
+    totalPackSize += item->GetPackSizeAligned();
    if (item->IsDir())
    {
      RINOK(extractCallback->PrepareOperation(askMode));
@@ -302,23 +341,36 @@ HRESULT CHandler::Extract(const UInt32 *indices, UInt32 numItems,

    outStreamSpec->SetStream(realOutStream);
    realOutStream.Release();
-    outStreamSpec->Init(skipMode ? 0 : item->Size, true);
+    outStreamSpec->Init(skipMode ? 0 : unpackSize, true);

-    if (!seqMode)
+    Int32 opRes = NExtract::NOperationResult::kOK;
+    if (item->IsSparse())
+      opRes = NExtract::NOperationResult::kUnSupportedMethod;
+    else
    {
-      RINOK(_stream->Seek(item->GetDataPosition(), STREAM_SEEK_SET, NULL));
+      if (item->IsLink())
+      {
+        RINOK(WriteStream(outStreamSpec, (const char *)item->LinkName, item->LinkName.Length()));
+      }
+      else
+      {
+        if (!seqMode)
+        {
+          RINOK(_stream->Seek(item->GetDataPosition(), STREAM_SEEK_SET, NULL));
+        }
+        streamSpec->Init(item->GetPackSizeAligned());
+        RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress));
+      }
+      if (outStreamSpec->GetRem() != 0)
+        opRes = NExtract::NOperationResult::kDataError;
    }
-    streamSpec->Init(item->GetPackSize());
-    RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress));
    if (seqMode)
    {
      _latestIsRead = false;
      _curIndex++;
    }
    outStreamSpec->ReleaseStream();
-    RINOK(extractCallback->SetOperationResult(outStreamSpec->GetRem() == 0 ?
-        NExtract::NOperationResult::kOK:
-        NExtract::NOperationResult::kDataError));
+    RINOK(extractCallback->SetOperationResult(opRes));
  }
  return S_OK;
  COM_TRY_END
@@ -328,7 +380,17 @@ STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
 {
  COM_TRY_BEGIN
  const CItemEx &item = _items[index];
-  return CreateLimitedInStream(_stream, item.GetDataPosition(), item.Size, stream);
+  if (item.IsSparse())
+    return E_NOTIMPL;
+  if (item.IsLink())
+  {
+    CBufInStream *streamSpec = new CBufInStream;
+    CMyComPtr<IInStream> streamTemp = streamSpec;
+    streamSpec->Init((const Byte *)(const char *)item.LinkName, item.LinkName.Length(), (IInArchive *)this);
+    *stream = streamTemp.Detach();
+    return S_OK;
+  }
+  return CreateLimitedInStream(_stream, item.GetDataPosition(), item.PackSize, stream);
  COM_TRY_END
 }

--- a/CPP/7zip/Archive/Tar/TarHandler.h
+++ b/CPP/7zip/Archive/Tar/TarHandler.h
@@ -23,18 +23,21 @@ class CHandler:
  CObjectVector<CItemEx> _items;
  CMyComPtr<IInStream> _stream;
  CMyComPtr<ISequentialInStream> _seqStream;
-  bool _isGood;
  
  UInt32 _curIndex;
  bool _latestIsRead;
  CItemEx _latestItem;

  UInt64 _phySize;
+  UInt64 _headersSize;
  bool _phySizeDefined;
+  AString _errorMessage;
+  bool _isSparse;

  NCompress::CCopyCoder *copyCoderSpec;
  CMyComPtr<ICompressCoder> copyCoder;

+  HRESULT ReadItem2(ISequentialInStream *stream, bool &filled, CItemEx &itemInfo);
  HRESULT Open2(IInStream *stream, IArchiveOpenCallback *callback);
  HRESULT SkipTo(UInt32 index);

--- a/CPP/7zip/Archive/Tar/TarHandlerOut.cpp
+++ b/CPP/7zip/Archive/Tar/TarHandlerOut.cpp
@@ -37,7 +37,7 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
    IArchiveUpdateCallback *callback)
 {
  COM_TRY_BEGIN
-  if ((_stream && !_isGood) || _seqStream)
+  if ((_stream && (!_errorMessage.IsEmpty() || _isSparse)) || _seqStream)
    return E_NOTIMPL;
  CObjectVector<CUpdateItem> updateItems;
  for (UInt32 i = 0; i < numItems; i++)
@@ -81,11 +81,11 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
        NCOM::CPropVariant prop;
        RINOK(callback->GetProperty(i, kpidMTime, &prop));
        if (prop.vt == VT_EMPTY)
-          ui.Time = 0;
+          ui.MTime = 0;
        else if (prop.vt != VT_FILETIME)
          return E_INVALIDARG;
-        else if (!NTime::FileTimeToUnixTime(prop.filetime, ui.Time))
-          ui.Time = 0;
+        else
+          ui.MTime = NTime::FileTimeToUnixTime64(prop.filetime);
      }
      {
        NCOM::CPropVariant prop;
--- a/CPP/7zip/Archive/Tar/TarHeader.h
+++ b/CPP/7zip/Archive/Tar/TarHeader.h
@@ -84,6 +84,7 @@ namespace NFileHeader
        Each file name is terminated by a null + an additional null after
        the last file name. */

+    const char kSparse = 'S';
  }
  // Further link types may be defined later.

--- a/CPP/7zip/Archive/Tar/TarIn.cpp
+++ b/CPP/7zip/Archive/Tar/TarIn.cpp
@@ -63,29 +63,65 @@ static void ReadString(const char *s, int size, AString &result)
  result = temp;
 }

-static HRESULT GetNextItemReal(ISequentialInStream *stream, bool &filled, CItemEx &item, size_t &processedSize)
+static bool ParseInt64(const char *p, Int64 &val)
+{
+  UInt32 h = GetBe32(p);
+  val = GetBe64(p + 4);
+  if (h == (UInt32)1 << 31)
+    return ((val >> 63) & 1) == 0;
+  if (h == (UInt32)(Int32)-1)
+    return ((val >> 63) & 1) != 0;
+  UInt64 uv;
+  bool res = OctalToNumber(p, 12, uv);
+  val = uv;
+  return res;
+}
+
+static bool ParseSize(const char *p, UInt64 &val)
+{
+  if (GetBe32(p) == (UInt32)1 << 31)
+  {
+    // GNU extension
+    val = GetBe64(p + 4);
+    return ((val >> 63) & 1) == 0;
+  }
+  return OctalToNumber(p, 12, val);
+}
+
+static HRESULT GetNextItemReal(ISequentialInStream *stream, bool &filled, CItemEx &item, AString &error)
 {
-  item.LongLinkSize = 0;
  char buf[NFileHeader::kRecordSize];
  char *p = buf;

+  error.Empty();
  filled = false;

  bool thereAreEmptyRecords = false;
  for (;;)
  {
-    processedSize = NFileHeader::kRecordSize;
+    size_t processedSize = NFileHeader::kRecordSize;
    RINOK(ReadStream(stream, buf, &processedSize));
    if (processedSize == 0)
+    {
+      if (!thereAreEmptyRecords )
+        error = "There are no trailing zero-filled records";
      return S_OK;
+    }
    if (processedSize != NFileHeader::kRecordSize)
-      return S_FALSE;
+    {
+      error = "There is no correct record at the end of archive";
+      return S_OK;
+    }
+    item.HeaderSize += NFileHeader::kRecordSize;
    if (!IsRecordLast(buf))
      break;
    thereAreEmptyRecords = true;
  }
  if (thereAreEmptyRecords)
-    return S_FALSE;
+  {
+    error = "There are data after end of archive";
+    return S_OK;
+  }
  
  ReadString(p, NFileHeader::kNameSize, item.Name); p += NFileHeader::kNameSize;

@@ -94,17 +130,10 @@ static HRESULT GetNextItemReal(ISequentialInStream *stream, bool &filled, CItemE
  if (!OctalToNumber32(p, 8, item.UID)) item.UID = 0; p += 8;
  if (!OctalToNumber32(p, 8, item.GID)) item.GID = 0; p += 8;

-  if (GetBe32(p) == (UInt32)1 << 31)
-  {
-    // GNU extension
-    item.Size = GetBe64(p + 4);
-  }
-  else
-  {
-    RIF(OctalToNumber(p, 12, item.Size));
-  }
+  RIF(ParseSize(p, item.PackSize));
+  item.Size = item.PackSize;
  p += 12;
-  RIF(OctalToNumber32(p, 12, item.MTime)); p += 12;
+  RIF(ParseInt64(p, item.MTime)); p += 12;
  
  UInt32 checkSum;
  RIF(OctalToNumber32(p, 8, checkSum));
@@ -130,7 +159,36 @@ static HRESULT GetNextItemReal(ISequentialInStream *stream, bool &filled, CItemE
    item.Name = prefix + AString('/') + item.Name;

  if (item.LinkFlag == NFileHeader::NLinkFlag::kLink)
+  {
+    item.PackSize = 0;
    item.Size = 0;
+  }
+  else if (item.LinkFlag == NFileHeader::NLinkFlag::kSparse)
+  {
+    if (buf[482] != 0)
+      return S_FALSE;
+    RIF(ParseSize(buf + 483, item.Size));
+    p = buf + 386;
+    UInt64 min = 0;
+    for (int i = 0; i < 4; i++, p += 24)
+    {
+      if (GetBe32(p) == 0)
+        break;
+      CSparseBlock sb;
+      RIF(ParseSize(p, sb.Offset));
+      RIF(ParseSize(p + 12, sb.Size));
+      item.SparseBlocks.Add(sb);
+      if (sb.Offset < min || sb.Offset > item.Size)
+        return S_FALSE;
+      if ((sb.Offset & 0x1FF) != 0 || (sb.Size & 0x1FF) != 0)
+        return S_FALSE;
+      min = sb.Offset + sb.Size;
+      if (min < sb.Offset)
+        return S_FALSE;
+    }
+    if (min > item.Size)
+      return S_FALSE;
+  }
 
  UInt32 checkSumReal = 0;
  for (int i = 0; i < NFileHeader::kRecordSize; i++)
@@ -143,59 +201,67 @@ static HRESULT GetNextItemReal(ISequentialInStream *stream, bool &filled, CItemE
  return S_OK;
 }

-HRESULT ReadItem(ISequentialInStream *stream, bool &filled, CItemEx &item)
+HRESULT ReadItem(ISequentialInStream *stream, bool &filled, CItemEx &item, AString &error)
 {
-  size_t processedSize;
-  RINOK(GetNextItemReal(stream, filled, item, processedSize));
-  if (!filled)
-    return S_OK;
-  // GNUtar extension
-  if (item.LinkFlag == 'L' || // NEXT file has a long name
-      item.LinkFlag == 'K') // NEXT file has a long linkname
+  item.HeaderSize = 0;
+  bool flagL = false;
+  bool flagK = false;
+  AString nameL;
+  AString nameK;
+  for (;;)
  {
-    if (item.Name.Compare(NFileHeader::kLongLink) != 0)
-      if (item.Name.Compare(NFileHeader::kLongLink2) != 0)
+    RINOK(GetNextItemReal(stream, filled, item, error));
+    if (!filled)
+      return S_OK;
+    if (item.LinkFlag == 'L' || // NEXT file has a long name
+        item.LinkFlag == 'K') // NEXT file has a long linkname
+    {
+      AString *name;
+      if (item.LinkFlag == 'L')
+        { if (flagL) return S_FALSE; flagL = true; name = &nameL; }
+      else
+        { if (flagK) return S_FALSE; flagK = true; name = &nameK; }
+
+      if (item.Name.Compare(NFileHeader::kLongLink) != 0 &&
+          item.Name.Compare(NFileHeader::kLongLink2) != 0)
        return S_FALSE;
-
-    AString fullName;
-    if (item.Size > (1 << 15))
-      return S_FALSE;
-    int packSize = (int)item.GetPackSize();
-    char *buffer = fullName.GetBuffer(packSize + 1);
-
-    RINOK(ReadStream_FALSE(stream, buffer, packSize));
-    processedSize += packSize;
-    buffer[item.Size] = '\0';
-    fullName.ReleaseBuffer();
-
-    UInt64 headerPosition = item.HeaderPosition;
-    if (item.LinkFlag == 'L')
-    {
-      size_t processedSize2;
-      RINOK(GetNextItemReal(stream, filled, item, processedSize2));
-      item.LongLinkSize = (unsigned)processedSize;
+      if (item.PackSize > (1 << 14))
+        return S_FALSE;
+      int packSize = (int)item.GetPackSizeAligned();
+      char *buf = name->GetBuffer(packSize);
+      RINOK(ReadStream_FALSE(stream, buf, packSize));
+      item.HeaderSize += packSize;
+      buf[(size_t)item.PackSize] = '\0';
+      name->ReleaseBuffer();
+      continue;
    }
-    else
+    switch (item.LinkFlag)
    {
-      item.LongLinkSize = (unsigned)processedSize - NFileHeader::kRecordSize;
-      item.Size = 0;
+      case 'g':
+      case 'x':
+      case 'X':
+      {
+        // pax Extended Header
+        break;
+      }
+      case NFileHeader::NLinkFlag::kDumpDir:
+      {
+        break;
+        // GNU Extensions to the Archive Format
+      }
+      case NFileHeader::NLinkFlag::kSparse:
+      {
+        break;
+        // GNU Extensions to the Archive Format
+      }
+      default:
+        if (item.LinkFlag > '7' || (item.LinkFlag < '0' && item.LinkFlag != 0))
+          return S_FALSE;
    }
-    item.Name = fullName;
-    item.HeaderPosition = headerPosition;
-  }
-  else if (item.LinkFlag == 'g' || item.LinkFlag == 'x' || item.LinkFlag == 'X')
-  {
-    // pax Extended Header
+    if (flagL) item.Name = nameL;
+    if (flagK) item.LinkName = nameK;
    return S_OK;
  }
-  else if (item.LinkFlag == NFileHeader::NLinkFlag::kDumpDir)
-  {
-    // GNU Extensions to the Archive Format
-    return S_OK;
-  }
-  else if (item.LinkFlag > '7' || (item.LinkFlag < '0' && item.LinkFlag != 0))
-    return S_FALSE;
-  return S_OK;
 }

 }}
--- a/CPP/7zip/Archive/Tar/TarIn.h
+++ b/CPP/7zip/Archive/Tar/TarIn.h
@@ -1,9 +1,8 @@
-// Archive/TarIn.h
+// TarIn.h

 #ifndef __ARCHIVE_TAR_IN_H
 #define __ARCHIVE_TAR_IN_H

-#include "Common/MyCom.h"
 #include "../../IStream.h"

 #include "TarItem.h"
@@ -11,7 +10,7 @@
 namespace NArchive {
 namespace NTar {
  
-HRESULT ReadItem(ISequentialInStream *stream, bool &filled, CItemEx &itemInfo);
+HRESULT ReadItem(ISequentialInStream *stream, bool &filled, CItemEx &itemInfo, AString &error);

 }}
  
--- a/CPP/7zip/Archive/Tar/TarItem.h
+++ b/CPP/7zip/Archive/Tar/TarItem.h
@@ -10,15 +10,22 @@
 namespace NArchive {
 namespace NTar {

+struct CSparseBlock
+{
+  UInt64 Offset;
+  UInt64 Size;
+};
+
 struct CItem
 {
  AString Name;
+  UInt64 PackSize;
  UInt64 Size;
+  Int64 MTime;

  UInt32 Mode;
  UInt32 UID;
  UInt32 GID;
-  UInt32 MTime;
  UInt32 DeviceMajor;
  UInt32 DeviceMinor;

@@ -31,6 +38,12 @@ struct CItem
  bool DeviceMajorDefined;
  bool DeviceMinorDefined;

+  CRecordVector<CSparseBlock> SparseBlocks;
+
+  bool IsLink() const { return LinkFlag == NFileHeader::NLinkFlag::kSymbolicLink && (Size == 0); }
+  bool IsSparse() const { return LinkFlag == NFileHeader::NLinkFlag::kSparse; }
+  UInt64 GetUnpackSize() const { return IsLink() ? LinkName.Length() : Size; }
+
  bool IsDir() const
  {
    switch(LinkFlag)
@@ -53,15 +66,16 @@ struct CItem
    return true;
  }

-  UInt64 GetPackSize() const { return (Size + 0x1FF) & (~((UInt64)0x1FF)); }
+  UInt64 GetPackSizeAligned() const { return (PackSize + 0x1FF) & (~((UInt64)0x1FF)); }
 };

 struct CItemEx: public CItem
 {
-  UInt64 HeaderPosition;
-  unsigned LongLinkSize;
-  UInt64 GetDataPosition() const { return HeaderPosition + LongLinkSize + NFileHeader::kRecordSize; }
-  UInt64 GetFullSize() const { return LongLinkSize + NFileHeader::kRecordSize + Size; }
+  UInt64 HeaderPos;
+  unsigned HeaderSize;
+
+  UInt64 GetDataPosition() const { return HeaderPos + HeaderSize; }
+  UInt64 GetFullSize() const { return HeaderSize + PackSize; }
 };

 }}
--- a/CPP/7zip/Archive/Tar/TarOut.cpp
+++ b/CPP/7zip/Archive/Tar/TarOut.cpp
@@ -47,7 +47,7 @@ static bool MakeOctalString8(char *s, UInt32 value)
  if (tempString.Length() >= kMaxSize)
    return false;
  int numSpaces = kMaxSize - (tempString.Length() + 1);
-  for(int i = 0; i < numSpaces; i++)
+  for (int i = 0; i < numSpaces; i++)
    s[i] = ' ';
  MyStringCopy(s + numSpaces, (const char *)tempString);
  return true;
@@ -55,7 +55,7 @@ static bool MakeOctalString8(char *s, UInt32 value)

 static void MakeOctalString12(char *s, UInt64 value)
 {
-  AString tempString  = MakeOctalString(value);
+  AString tempString = MakeOctalString(value);
  const int kMaxSize = 12;
  if (tempString.Length() > kMaxSize)
  {
@@ -67,11 +67,23 @@ static void MakeOctalString12(char *s, UInt64 value)
    return;
  }
  int numSpaces = kMaxSize - tempString.Length();
-  for(int i = 0; i < numSpaces; i++)
+  for (int i = 0; i < numSpaces; i++)
    s[i] = ' ';
  memmove(s + numSpaces, (const char *)tempString, tempString.Length());
 }

+static void MakeOctalString12_From_Int64(char *s, Int64 value)
+{
+  if (value >= 0)
+  {
+    MakeOctalString12(s, value);
+    return;
+  }
+  s[0] = s[1] = s[2] = s[3] = (char)(Byte)0xFF;
+  for (int i = 0; i < 8; i++, value <<= 8)
+    s[4 + i] = (char)(value >> 56);
+}
+
 static bool CopyString(char *dest, const AString &src, int maxSize)
 {
  if (src.Length() >= maxSize)
@@ -100,8 +112,8 @@ HRESULT COutArchive::WriteHeaderReal(const CItem &item)
  RETURN_IF_NOT_TRUE(MakeOctalString8(cur, item.UID)); cur += 8;
  RETURN_IF_NOT_TRUE(MakeOctalString8(cur, item.GID)); cur += 8;

-  MakeOctalString12(cur, item.Size); cur += 12;
-  MakeOctalString12(cur, item.MTime); cur += 12;
+  MakeOctalString12(cur, item.PackSize); cur += 12;
+  MakeOctalString12_From_Int64(cur, item.MTime); cur += 12;
  
  memmove(cur, NFileHeader::kCheckSumBlanks, 8);
  cur += 8;
@@ -130,7 +142,7 @@ HRESULT COutArchive::WriteHeaderReal(const CItem &item)


  UInt32 checkSumReal = 0;
-  for(i = 0; i < NFileHeader::kRecordSize; i++)
+  for (i = 0; i < NFileHeader::kRecordSize; i++)
    checkSumReal += Byte(record[i]);

  RETURN_IF_NOT_TRUE(MakeOctalString8(record + 148, checkSumReal));
@@ -146,7 +158,7 @@ HRESULT COutArchive::WriteHeader(const CItem &item)

  CItem modifiedItem = item;
  int nameStreamSize = nameSize + 1;
-  modifiedItem.Size = nameStreamSize;
+  modifiedItem.PackSize = nameStreamSize;
  modifiedItem.LinkFlag = 'L';
  modifiedItem.Name = NFileHeader::kLongLink;
  modifiedItem.LinkName.Empty();
--- a/CPP/7zip/Archive/Tar/TarUpdate.cpp
+++ b/CPP/7zip/Archive/Tar/TarUpdate.cpp
@@ -48,7 +48,7 @@ HRESULT UpdateArchive(IInStream *inStream, ISequentialOutStream *outStream,

  complexity = 0;

-  for(i = 0; i < updateItems.Size(); i++)
+  for (i = 0; i < updateItems.Size(); i++)
  {
    lps->InSize = lps->OutSize = complexity;
    RINOK(lps->SetCur());
@@ -64,14 +64,14 @@ HRESULT UpdateArchive(IInStream *inStream, ISequentialOutStream *outStream,
      if (ui.IsDir)
      {
        item.LinkFlag = NFileHeader::NLinkFlag::kDirectory;
-        item.Size = 0;
+        item.PackSize = 0;
      }
      else
      {
        item.LinkFlag = NFileHeader::NLinkFlag::kNormal;
-        item.Size = ui.Size;
+        item.PackSize = ui.Size;
      }
-      item.MTime = ui.Time;
+      item.MTime = ui.MTime;
      item.DeviceMajorDefined = false;
      item.DeviceMinorDefined = false;
      item.UID = 0;
@@ -83,12 +83,12 @@ HRESULT UpdateArchive(IInStream *inStream, ISequentialOutStream *outStream,

    if (ui.NewData)
    {
-      item.Size = ui.Size;
-      if (item.Size == (UInt64)(Int64)-1)
+      item.PackSize = ui.Size;
+      if (ui.Size == (UInt64)(Int64)-1)
        return E_INVALIDARG;
    }
    else
-      item.Size = inputItems[ui.IndexInArchive].Size;
+      item.PackSize = inputItems[ui.IndexInArchive].PackSize;
  
    if (ui.NewData)
    {
@@ -101,9 +101,9 @@ HRESULT UpdateArchive(IInStream *inStream, ISequentialOutStream *outStream,
        if (!ui.IsDir)
        {
          RINOK(copyCoder->Code(fileInStream, outStream, NULL, NULL, progress));
-          if (copyCoderSpec->TotalSize != item.Size)
+          if (copyCoderSpec->TotalSize != item.PackSize)
            return E_FAIL;
-          RINOK(outArchive.FillDataResidual(item.Size));
+          RINOK(outArchive.FillDataResidual(item.PackSize));
        }
      }
      complexity += ui.Size;
@@ -111,28 +111,30 @@ HRESULT UpdateArchive(IInStream *inStream, ISequentialOutStream *outStream,
    }
    else
    {
-      const CItemEx &existItemInfo = inputItems[ui.IndexInArchive];
+      const CItemEx &existItem = inputItems[ui.IndexInArchive];
      UInt64 size;
      if (ui.NewProps)
      {
        RINOK(outArchive.WriteHeader(item));
-        RINOK(inStream->Seek(existItemInfo.GetDataPosition(), STREAM_SEEK_SET, NULL));
-        size = existItemInfo.Size;
+        RINOK(inStream->Seek(existItem.GetDataPosition(), STREAM_SEEK_SET, NULL));
+        size = existItem.PackSize;
      }
      else
      {
-        RINOK(inStream->Seek(existItemInfo.HeaderPosition, STREAM_SEEK_SET, NULL));
-        size = existItemInfo.GetFullSize();
+        RINOK(inStream->Seek(existItem.HeaderPos, STREAM_SEEK_SET, NULL));
+        size = existItem.GetFullSize();
      }
      streamSpec->Init(size);

      RINOK(copyCoder->Code(inStreamLimited, outStream, NULL, NULL, progress));
      if (copyCoderSpec->TotalSize != size)
        return E_FAIL;
-      RINOK(outArchive.FillDataResidual(existItemInfo.Size));
+      RINOK(outArchive.FillDataResidual(existItem.PackSize));
      complexity += size;
    }
  }
+  lps->InSize = lps->OutSize = complexity;
+  RINOK(lps->SetCur());
  return outArchive.WriteFinishHeader();
 }

--- a/CPP/7zip/Archive/Tar/TarUpdate.h
+++ b/CPP/7zip/Archive/Tar/TarUpdate.h
@@ -13,15 +13,15 @@ struct CUpdateItem
 {
  int IndexInArchive;
  int IndexInClient;
-  UInt32 Time;
-  UInt32 Mode;
+  Int64 MTime;
  UInt64 Size;
-  AString Name;
-  AString User;
-  AString Group;
+  UInt32 Mode;
  bool NewData;
  bool NewProps;
  bool IsDir;
+  AString Name;
+  AString User;
+  AString Group;
 };

 HRESULT UpdateArchive(IInStream *inStream, ISequentialOutStream *outStream,
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Igor Pavlov	83f8ddcc5b	9.22	2016-05-28 00:16:06 +01:00
Igor Pavlov	35596517f2	9.21	2016-05-28 00:16:05 +01:00
Igor Pavlov	de4f8c22fe	9.20	2016-05-28 00:16:05 +01:00
Igor Pavlov	b75af1bba6	9.19	2016-05-28 00:16:04 +01:00
Igor Pavlov	c65230d858	9.18	2016-05-28 00:16:04 +01:00