9.04 beta

55 files changed, 4163 insertions, 284 deletions

diff --git a/C/7zBuf.h b/C/7zBuf.h
index c5bd7187..e9f2f316 100755
--- a/C/7zBuf.h
+++ b/C/7zBuf.h
@@ -1,11 +1,15 @@
 /* 7zBuf.h -- Byte Buffer
-2008-10-04 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_BUF_H
 #define __7Z_BUF_H
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct
 {
   Byte *data;
@@ -28,4 +32,8 @@ void DynBuf_SeekToBeg(CDynBuf *p);
 int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAlloc *alloc);
 void DynBuf_Free(CDynBuf *p, ISzAlloc *alloc);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/7zCrc.h b/C/7zCrc.h
index 00dc29ce..e0d59d40 100755
--- a/C/7zCrc.h
+++ b/C/7zCrc.h
@@ -1,7 +1,5 @@
 /* 7zCrc.h -- CRC32 calculation
-2008-03-13
-Igor Pavlov
-Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_CRC_H
 #define __7Z_CRC_H
@@ -10,6 +8,10 @@ Public domain */
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 extern UInt32 g_CrcTable[];
 
 void MY_FAST_CALL CrcGenerateTable(void);
@@ -21,4 +23,8 @@ void MY_FAST_CALL CrcGenerateTable(void);
 UInt32 MY_FAST_CALL CrcUpdate(UInt32 crc, const void *data, size_t size);
 UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/7zFile.h b/C/7zFile.h
index fbef6837..bf9806bb 100755
--- a/C/7zFile.h
+++ b/C/7zFile.h
@@ -1,5 +1,5 @@
 /* 7zFile.h -- File IO
-2008-11-22 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_FILE_H
 #define __7Z_FILE_H
@@ -16,6 +16,10 @@
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 
 /* ---------- File ---------- */
 
@@ -71,4 +75,8 @@ typedef struct
 
 void FileOutStream_CreateVTable(CFileOutStream *p);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/7zVersion.h b/C/7zVersion.h
index b7eb2355..2804bc47 100755
--- a/C/7zVersion.h
+++ b/C/7zVersion.h
@@ -1,7 +1,7 @@
-#define MY_VER_MAJOR 4
-#define MY_VER_MINOR 65
+#define MY_VER_MAJOR 9
+#define MY_VER_MINOR 04
 #define MY_VER_BUILD 0
-#define MY_VERSION "4.65"
-#define MY_DATE "2009-02-03"
+#define MY_VERSION "9.04 beta"
+#define MY_DATE "2009-05-30"
 #define MY_COPYRIGHT ": Igor Pavlov : Public domain"
 #define MY_VERSION_COPYRIGHT_DATE MY_VERSION " " MY_COPYRIGHT " : " MY_DATE
diff --git a/C/Aes.h b/C/Aes.h
index ede4064a..5aa60955 100755
--- a/C/Aes.h
+++ b/C/Aes.h
@@ -1,13 +1,15 @@
 /* Aes.h -- AES encryption / decryption
-2008-08-05
-Igor Pavlov
-Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __AES_H
 #define __AES_H
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define AES_BLOCK_SIZE 16
 
 typedef struct
@@ -45,4 +47,8 @@ void AesCbc_Init(CAesCbc *p, const Byte *iv); /* iv size is AES_BLOCK_SIZE */
 SizeT AesCbc_Encode(CAesCbc *p, Byte *data, SizeT size);
 SizeT AesCbc_Decode(CAesCbc *p, Byte *data, SizeT size);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Alloc.h b/C/Alloc.h
index ff0669ca..b8e41436 100755
--- a/C/Alloc.h
+++ b/C/Alloc.h
@@ -1,13 +1,15 @@
 /* Alloc.h -- Memory allocation functions
-2008-03-13
-Igor Pavlov
-Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __COMMON_ALLOC_H
 #define __COMMON_ALLOC_H
 
 #include <stddef.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 void *MyAlloc(size_t size);
 void MyFree(void *address);
 
@@ -29,4 +31,8 @@ void BigFree(void *address);
 
 #endif
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Archive/7z/7z.dsp b/C/Archive/7z/7z.dsp
index 9626b03e..6d6b8d93 100755
--- a/C/Archive/7z/7z.dsp
+++ b/C/Archive/7z/7z.dsp
@@ -132,6 +132,14 @@ SOURCE=..\..\Bra86.c
 # 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
diff --git a/C/Archive/7z/7zAlloc.h b/C/Archive/7z/7zAlloc.h
index e752ef18..a5e88e47 100755
--- a/C/Archive/7z/7zAlloc.h
+++ b/C/Archive/7z/7zAlloc.h
@@ -1,15 +1,23 @@
 /* 7zAlloc.h -- Allocation functions
-2008-10-04 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_ALLOC_H
 #define __7Z_ALLOC_H
 
 #include <stddef.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 void *SzAlloc(void *p, size_t size);
 void SzFree(void *p, void *address);
 
 void *SzAllocTemp(void *p, size_t size);
 void SzFreeTemp(void *p, void *address);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Archive/7z/7zDecode.c b/C/Archive/7z/7zDecode.c
index 02526f0e..0d310a48 100755
--- a/C/Archive/7z/7zDecode.c
+++ b/C/Archive/7z/7zDecode.c
@@ -1,14 +1,17 @@
 /* 7zDecode.c -- Decoding from 7z folder
-2008-11-23 : Igor Pavlov : Public domain */
+2009-05-03 : Igor Pavlov : Public domain */
 
 #include <string.h>
 
 #include "../../Bcj2.h"
 #include "../../Bra.h"
 #include "../../LzmaDec.h"
+#include "../../Lzma2Dec.h"
+
 #include "7zDecode.h"
 
 #define k_Copy 0
+#define k_LZMA2 0x21
 #define k_LZMA 0x30101
 #define k_BCJ 0x03030103
 #define k_BCJ2 0x0303011B
@@ -61,6 +64,55 @@ static SRes SzDecodeLzma(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inSt
   return res;
 }
 
+static SRes SzDecodeLzma2(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inStream,
+    Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)
+{
+  CLzma2Dec state;
+  SRes res = SZ_OK;
+
+  Lzma2Dec_Construct(&state);
+  if (coder->Props.size != 1)
+    return SZ_ERROR_DATA;
+  RINOK(Lzma2Dec_AllocateProbs(&state, coder->Props.data[0], allocMain));
+  state.decoder.dic = outBuffer;
+  state.decoder.dicBufSize = outSize;
+  Lzma2Dec_Init(&state);
+
+  for (;;)
+  {
+    Byte *inBuf = NULL;
+    size_t lookahead = (1 << 18);
+    if (lookahead > inSize)
+      lookahead = (size_t)inSize;
+    res = inStream->Look((void *)inStream, (void **)&inBuf, &lookahead);
+    if (res != SZ_OK)
+      break;
+
+    {
+      SizeT inProcessed = (SizeT)lookahead, dicPos = state.decoder.dicPos;
+      ELzmaStatus status;
+      res = Lzma2Dec_DecodeToDic(&state, outSize, inBuf, &inProcessed, LZMA_FINISH_END, &status);
+      lookahead -= inProcessed;
+      inSize -= inProcessed;
+      if (res != SZ_OK)
+        break;
+      if (state.decoder.dicPos == state.decoder.dicBufSize || (inProcessed == 0 && dicPos == state.decoder.dicPos))
+      {
+        if (state.decoder.dicBufSize != outSize || lookahead != 0 ||
+            (status != LZMA_STATUS_FINISHED_WITH_MARK))
+          res = SZ_ERROR_DATA;
+        break;
+      }
+      res = inStream->Skip((void *)inStream, inProcessed);
+      if (res != SZ_OK)
+        break;
+    }
+  }
+
+  Lzma2Dec_FreeProbs(&state, allocMain);
+  return res;
+}
+
 static SRes SzDecodeCopy(UInt64 inSize, ILookInStream *inStream, Byte *outBuffer)
 {
   while (inSize > 0)
@@ -80,7 +132,7 @@ static SRes SzDecodeCopy(UInt64 inSize, ILookInStream *inStream, Byte *outBuffer
   return SZ_OK;
 }
 
-#define IS_UNSUPPORTED_METHOD(m) ((m) != k_Copy && (m) != k_LZMA)
+#define IS_UNSUPPORTED_METHOD(m) ((m) != k_Copy && (m) != k_LZMA && (m) != k_LZMA2)
 #define IS_UNSUPPORTED_CODER(c) (IS_UNSUPPORTED_METHOD(c.MethodID) || c.NumInStreams != 1 || c.NumOutStreams != 1)
 #define IS_NO_BCJ(c) (c.MethodID != k_BCJ || c.NumInStreams != 1 || c.NumOutStreams != 1)
 #define IS_NO_BCJ2(c) (c.MethodID != k_BCJ2 || c.NumInStreams != 4 || c.NumOutStreams != 1)
@@ -152,7 +204,7 @@ SRes SzDecode2(const UInt64 *packSizes, const CSzFolder *folder,
   {
     CSzCoderInfo *coder = &folder->Coders[ci];
 
-    if (coder->MethodID == k_Copy || coder->MethodID == k_LZMA)
+    if (coder->MethodID == k_Copy || coder->MethodID == k_LZMA || coder->MethodID == k_LZMA2)
     {
       UInt32 si = 0;
       UInt64 offset;
@@ -196,10 +248,14 @@ SRes SzDecode2(const UInt64 *packSizes, const CSzFolder *folder,
           return SZ_ERROR_DATA;
         RINOK(SzDecodeCopy(inSize, inStream, outBufCur));
       }
-      else
+      else if (coder->MethodID == k_LZMA)
       {
         RINOK(SzDecodeLzma(coder, inSize, inStream, outBufCur, outSizeCur, allocMain));
       }
+      else
+      {
+        RINOK(SzDecodeLzma2(coder, inSize, inStream, outBufCur, outSizeCur, allocMain));
+      }
     }
     else if (coder->MethodID == k_BCJ)
     {
diff --git a/C/Archive/7z/7zDecode.h b/C/Archive/7z/7zDecode.h
index e19fe387..0d77970d 100755
--- a/C/Archive/7z/7zDecode.h
+++ b/C/Archive/7z/7zDecode.h
@@ -1,13 +1,21 @@
 /* 7zDecode.h -- Decoding from 7z folder
-2008-11-23 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_DECODE_H
 #define __7Z_DECODE_H
 
 #include "7zItem.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 SRes SzDecode(const UInt64 *packSizes, const CSzFolder *folder,
     ILookInStream *stream, UInt64 startPos,
     Byte *outBuffer, size_t outSize, ISzAlloc *allocMain);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Archive/7z/7zExtract.h b/C/Archive/7z/7zExtract.h
index 5f78415f..6f46bfa6 100755
--- a/C/Archive/7z/7zExtract.h
+++ b/C/Archive/7z/7zExtract.h
@@ -1,11 +1,15 @@
 /* 7zExtract.h -- Extracting from 7z archive
-2008-11-23 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_EXTRACT_H
 #define __7Z_EXTRACT_H
 
 #include "7zIn.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
   SzExtract extracts file from archive
 
@@ -38,4 +42,8 @@ SRes SzAr_Extract(
     ISzAlloc *allocMain,
     ISzAlloc *allocTemp);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Archive/7z/7zHeader.h b/C/Archive/7z/7zHeader.h
index 9941b6f7..bc117d2e 100755
--- a/C/Archive/7z/7zHeader.h
+++ b/C/Archive/7z/7zHeader.h
@@ -1,11 +1,15 @@
 /* 7zHeader.h -- 7z Headers
-2008-10-04 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_HEADER_H
 #define __7Z_HEADER_H
 
 #include "../../Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define k7zSignatureSize 6
 extern Byte k7zSignature[k7zSignatureSize];
 
@@ -54,4 +58,8 @@ enum EIdEnum
   k7zIdDummy
 };
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Archive/7z/7zIn.h b/C/Archive/7z/7zIn.h
index c8430a7b..50db4d38 100755
--- a/C/Archive/7z/7zIn.h
+++ b/C/Archive/7z/7zIn.h
@@ -1,5 +1,5 @@
-/* 7zIn.h -- 7z Input functions
-2008-11-23 : Igor Pavlov : Public domain */
+/* 7zIn.h -- 7z Input
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_IN_H
 #define __7Z_IN_H
@@ -7,6 +7,10 @@
 #include "7zHeader.h"
 #include "7zItem.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct
 {
   CSzAr db;
@@ -38,4 +42,8 @@ SZ_ERROR_FAIL
 
 SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream, ISzAlloc *allocMain, ISzAlloc *allocTemp);
  
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Archive/7z/7zItem.h b/C/Archive/7z/7zItem.h
index 9f1366cd..ce7288c2 100755
--- a/C/Archive/7z/7zItem.h
+++ b/C/Archive/7z/7zItem.h
@@ -1,11 +1,15 @@
 /* 7zItem.h -- 7z Items
-2008-10-04 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_ITEM_H
 #define __7Z_ITEM_H
 
 #include "../../7zBuf.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct
 {
   UInt32 NumInStreams;
@@ -81,4 +85,8 @@ typedef struct
 void SzAr_Init(CSzAr *p);
 void SzAr_Free(CSzAr *p, ISzAlloc *alloc);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Archive/7z/7zMain.c b/C/Archive/7z/7zMain.c
index 0c20e8c3..ae65125f 100755
--- a/C/Archive/7z/7zMain.c
+++ b/C/Archive/7z/7zMain.c
@@ -1,5 +1,5 @@
 /* 7zMain.c - Test application for 7z Decoder
-2008-11-23 : Igor Pavlov : Public domain */
+2009-04-04 : Igor Pavlov : Public domain */
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -13,6 +13,37 @@
 #include "7zExtract.h"
 #include "7zIn.h"
 
+#ifndef USE_WINDOWS_FILE
+/* for mkdir */
+#ifdef _WIN32
+#include <direct.h>
+#else
+#include <sys/stat.h>
+#include <errno.h>
+#endif
+#endif
+
+#ifdef _WIN32
+#define CHAR_PATH_SEPARATOR '\\'
+#else
+#define CHAR_PATH_SEPARATOR '/'
+#endif
+
+static WRes MyCreateDir(const char *name)
+{
+  #ifdef USE_WINDOWS_FILE
+  return CreateDirectoryA(name, NULL) ? 0 : GetLastError();
+  #else
+  #ifdef _WIN32
+  return _mkdir(name)
+  #else
+  return mkdir(name, 0777)
+  #endif
+  == 0 ? 0 : errno;
+  #endif
+}
+
+
 static void ConvertNumberToString(UInt64 value, char *s)
 {
   char temp[32];
@@ -33,7 +64,7 @@ static void ConvertNumberToString(UInt64 value, char *s)
 #define PERIOD_100 (PERIOD_4 * 25 - 1)
 #define PERIOD_400 (PERIOD_100 * 4 + 1)
 
-static void ConvertFileTimeToString(CNtfsFileTime *ft, char *s)
+static void ConvertFileTimeToString(const CNtfsFileTime *ft, char *s)
 {
   unsigned year, mon, day, hour, min, sec;
   UInt64 v64 = ft->Low | ((UInt64)ft->High << 32);
@@ -97,16 +128,19 @@ int MY_CDECL main(int numargs, char *args[])
   SRes res;
   ISzAlloc allocImp;
   ISzAlloc allocTempImp;
+  char *temp = NULL;
+  size_t tempSize = 0;
 
-  printf("\n7z ANSI-C Decoder " MY_VERSION_COPYRIGHT_DATE "\n");
+  printf("\n7z ANSI-C Decoder " MY_VERSION_COPYRIGHT_DATE "\n\n");
   if (numargs == 1)
   {
     printf(
-      "\nUsage: 7zDec <command> <archive_name>\n\n"
+      "Usage: 7zDec <command> <archive_name>\n\n"
       "<Commands>\n"
-      "  e: Extract files from archive\n"
+      "  e: Extract files from archive (without using directory names)\n"
       "  l: List contents of archive\n"
-      "  t: Test integrity of archive\n");
+      "  t: Test integrity of archive\n"
+      "  x: eXtract files with full paths\n");
     return 0;
   }
   if (numargs < 3)
@@ -141,17 +175,18 @@ int MY_CDECL main(int numargs, char *args[])
   if (res == SZ_OK)
   {
     char *command = args[1];
-    int listCommand = 0, testCommand = 0, extractCommand = 0;
+    int listCommand = 0, testCommand = 0, extractCommand = 0, fullPaths = 0;
     if (strcmp(command, "l") == 0) listCommand = 1;
     else if (strcmp(command, "t") == 0) testCommand = 1;
     else if (strcmp(command, "e") == 0) extractCommand = 1;
+    else if (strcmp(command, "x") == 0) { extractCommand = 1; fullPaths = 1; }
 
     if (listCommand)
     {
       UInt32 i;
       for (i = 0; i < db.db.NumFiles; i++)
       {
-        CSzFileItem *f = db.db.Files + i;
+        const CSzFileItem *f = db.db.Files + i;
         char s[32], t[32];
         ConvertNumberToString(f->Size, s);
         if (f->MTimeDefined)
@@ -159,7 +194,10 @@ int MY_CDECL main(int numargs, char *args[])
         else
           strcpy(t, "                   ");
 
-        printf("%s %10s  %s\n", t, s, f->Name);
+        printf("%s %10s  %s", t, s, f->Name);
+        if (f->IsDir)
+          printf("/");
+        printf("\n");
       }
     }
     else if (testCommand || extractCommand)
@@ -174,44 +212,67 @@ int MY_CDECL main(int numargs, char *args[])
       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) */
 
-      printf("\n");
       for (i = 0; i < db.db.NumFiles; i++)
       {
         size_t offset;
         size_t outSizeProcessed;
-        CSzFileItem *f = db.db.Files + i;
-        if (f->IsDir)
-          printf("Directory ");
-        else
-          printf(testCommand ?
+        const CSzFileItem *f = db.db.Files + i;
+        if (f->IsDir && !fullPaths)
+          continue;
+        printf(testCommand ?
             "Testing   ":
             "Extracting");
         printf(" %s", f->Name);
         if (f->IsDir)
+          printf("/");
+        else
         {
-          printf("\n");
-          continue;
+          res = SzAr_Extract(&db, &lookStream.s, i,
+              &blockIndex, &outBuffer, &outBufferSize,
+              &offset, &outSizeProcessed,
+              &allocImp, &allocTempImp);
+          if (res != SZ_OK)
+            break;
         }
-        res = SzAr_Extract(&db, &lookStream.s, i,
-            &blockIndex, &outBuffer, &outBufferSize,
-            &offset, &outSizeProcessed,
-            &allocImp, &allocTempImp);
-        if (res != SZ_OK)
-          break;
         if (!testCommand)
         {
           CSzFile outFile;
           size_t processedSize;
-          char *fileName = f->Name;
-          size_t nameLen = strlen(f->Name);
-          for (; nameLen > 0; nameLen--)
-            if (f->Name[nameLen - 1] == '/')
+          size_t j, nameLen = strlen(f->Name);
+          const char *destPath;
+          if (nameLen + 1 > tempSize)
+          {
+            SzFree(NULL, temp);
+            tempSize = nameLen + 1;
+            temp = (char *)SzAlloc(NULL, tempSize);
+            if (temp == 0)
             {
-              fileName = f->Name + nameLen;
+              res = SZ_ERROR_MEM;
               break;
             }
-            
-          if (OutFile_Open(&outFile, fileName))
+          }
+          destPath = temp;
+          strcpy(temp, f->Name);
+          for (j = 0; j < nameLen; j++)
+            if (temp[j] == '/')
+            {
+              if (fullPaths)
+              {
+                temp[j] = 0;
+                MyCreateDir(temp);
+                temp[j] = CHAR_PATH_SEPARATOR;
+              }
+              else
+                destPath = temp + j + 1;
+            }
+    
+          if (f->IsDir)
+          {
+            MyCreateDir(destPath);
+            printf("\n");
+            continue;
+          }
+          else if (OutFile_Open(&outFile, destPath))
           {
             PrintError("can not open output file");
             res = SZ_ERROR_FAIL;
@@ -243,6 +304,7 @@ int MY_CDECL main(int numargs, char *args[])
     }
   }
   SzArEx_Free(&db, &allocImp);
+  SzFree(NULL, temp);
 
   File_Close(&archiveStream.file);
   if (res == SZ_OK)
diff --git a/C/Archive/7z/makefile b/C/Archive/7z/makefile
index c7bb05bd..cf06c860 100755
--- a/C/Archive/7z/makefile
+++ b/C/Archive/7z/makefile
@@ -7,6 +7,7 @@ C_OBJS = \
   $O\7zBuf2.obj \
   $O\7zCrc.obj \
   $O\LzmaDec.obj \
+  $O\Lzma2Dec.obj \
   $O\Bra86.obj \
   $O\Bcj2.obj \
   $O\7zFile.obj \
diff --git a/C/Archive/7z/makefile.gcc b/C/Archive/7z/makefile.gcc
index 2203dfc1..29d2aa02 100755
--- a/C/Archive/7z/makefile.gcc
+++ b/C/Archive/7z/makefile.gcc
@@ -4,7 +4,7 @@ LIB =
 RM = rm -f
 CFLAGS = -c -O2 -Wall
 
-OBJS = 7zAlloc.o 7zBuf.o 7zBuf2.o 7zCrc.o 7zDecode.o 7zExtract.o 7zHeader.o 7zIn.o 7zItem.o 7zMain.o LzmaDec.o Bra86.o Bcj2.o 7zFile.o 7zStream.o
+OBJS = 7zAlloc.o 7zBuf.o 7zBuf2.o 7zCrc.o 7zDecode.o 7zExtract.o 7zHeader.o 7zIn.o 7zItem.o 7zMain.o LzmaDec.o Lzma2Dec.o Bra86.o Bcj2.o 7zFile.o 7zStream.o
 
 all: $(PROG)
 
@@ -44,6 +44,9 @@ $(PROG): $(OBJS)
 LzmaDec.o: ../../LzmaDec.c
 	$(CXX) $(CFLAGS) ../../LzmaDec.c
 
+Lzma2Dec.o: ../../Lzma2Dec.c
+	$(CXX) $(CFLAGS) ../../Lzma2Dec.c
+
 Bra86.o: ../../Bra86.c
 	$(CXX) $(CFLAGS) ../../Bra86.c
 
diff --git a/C/Bcj2.h b/C/Bcj2.h
index 32d450b3..dbc05414 100755
--- a/C/Bcj2.h
+++ b/C/Bcj2.h
@@ -1,11 +1,15 @@
 /* Bcj2.h -- Converter for x86 code (BCJ2)
-2008-10-04 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __BCJ2_H
 #define __BCJ2_H
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 Conditions:
   outSize <= FullOutputSize,
@@ -27,4 +31,8 @@ int Bcj2_Decode(
     const Byte *buf3, SizeT size3,
     Byte *outBuf, SizeT outSize);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Bra.h b/C/Bra.h
index 45e231e8..5748c1c0 100755
--- a/C/Bra.h
+++ b/C/Bra.h
@@ -1,11 +1,15 @@
 /* Bra.h -- Branch converters for executables
-2008-10-04 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __BRA_H
 #define __BRA_H
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 These functions convert relative addresses to absolute addresses
 in CALL instructions to increase the compression ratio.
@@ -57,4 +61,8 @@ SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
 SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
 SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/BwtSort.h b/C/BwtSort.h
index f373213e..ce5598f0 100755
--- a/C/BwtSort.h
+++ b/C/BwtSort.h
@@ -1,13 +1,15 @@
 /* BwtSort.h -- BWT block sorting
-2008-03-26
-Igor Pavlov
-Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
-#ifndef __BWTSORT_H
-#define __BWTSORT_H
+#ifndef __BWT_SORT_H
+#define __BWT_SORT_H
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* use BLOCK_SORT_EXTERNAL_FLAGS if blockSize can be > 1M */
 /* #define BLOCK_SORT_EXTERNAL_FLAGS */
 
@@ -21,4 +23,8 @@ Public domain */
 
 UInt32 BlockSort(UInt32 *indices, const Byte *data, UInt32 blockSize);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/CpuArch.h b/C/CpuArch.h
index 7384b0c3..10ec02b3 100755
--- a/C/CpuArch.h
+++ b/C/CpuArch.h
@@ -1,10 +1,12 @@
 /* CpuArch.h
-2008-08-05
-Igor Pavlov
-Public domain */
+2009-03-22 : Igor Pavlov : Public domain */
 
-#ifndef __CPUARCH_H
-#define __CPUARCH_H
+#ifndef __CPU_ARCH_H
+#define __CPU_ARCH_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 /*
 LITTLE_ENDIAN_UNALIGN means:
@@ -23,6 +25,7 @@ about these properties of platform.
 #define GetUi16(p) (*(const UInt16 *)(p))
 #define GetUi32(p) (*(const UInt32 *)(p))
 #define GetUi64(p) (*(const UInt64 *)(p))
+#define SetUi16(p, d) *(UInt16 *)(p) = (d);
 #define SetUi32(p, d) *(UInt32 *)(p) = (d);
 
 #else
@@ -37,6 +40,10 @@ about these properties of platform.
 
 #define GetUi64(p) (GetUi32(p) | ((UInt64)GetUi32(((const Byte *)(p)) + 4) << 32))
 
+#define SetUi16(p, d) { UInt32 _x_ = (d); \
+    ((Byte *)(p))[0] = (Byte)_x_; \
+    ((Byte *)(p))[1] = (Byte)(_x_ >> 8); }
+
 #define SetUi32(p, d) { UInt32 _x_ = (d); \
     ((Byte *)(p))[0] = (Byte)_x_; \
     ((Byte *)(p))[1] = (Byte)(_x_ >> 8); \
@@ -66,4 +73,8 @@ about these properties of platform.
 
 #define GetBe16(p) (((UInt16)((const Byte *)(p))[0] << 8) | ((const Byte *)(p))[1])
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Delta.c b/C/Delta.c
new file mode 100755
index 00000000..2b327f15
--- /dev/null
+++ b/C/Delta.c
@@ -0,0 +1,62 @@
+/* Delta.c -- Delta converter
+2009-05-26 : Igor Pavlov : Public domain */
+
+#include "Delta.h"
+
+void Delta_Init(Byte *state)
+{
+  unsigned i;
+  for (i = 0; i < DELTA_STATE_SIZE; i++)
+    state[i] = 0;
+}
+
+static void MyMemCpy(Byte *dest, const Byte *src, unsigned size)
+{
+  unsigned i;
+  for (i = 0; i < size; i++)
+    dest[i] = src[i];
+}
+
+void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size)
+{
+  Byte buf[DELTA_STATE_SIZE];
+  unsigned j = 0;
+  MyMemCpy(buf, state, delta);
+  {
+    SizeT i;
+    for (i = 0; i < size;)
+    {
+      for (j = 0; j < delta && i < size; i++, j++)
+      {
+        Byte b = data[i];
+        data[i] = (Byte)(b - buf[j]);
+        buf[j] = b;
+      }
+    }
+  }
+  if (j == delta)
+    j = 0;
+  MyMemCpy(state, buf + j, delta - j);
+  MyMemCpy(state + delta - j, buf, j);
+}
+
+void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size)
+{
+  Byte buf[DELTA_STATE_SIZE];
+  unsigned j = 0;
+  MyMemCpy(buf, state, delta);
+  {
+    SizeT i;
+    for (i = 0; i < size;)
+    {
+      for (j = 0; j < delta && i < size; i++, j++)
+      {
+        buf[j] = data[i] = (Byte)(buf[j] + data[i]);
+      }
+    }
+  }
+  if (j == delta)
+    j = 0;
+  MyMemCpy(state, buf + j, delta - j);
+  MyMemCpy(state + delta - j, buf, j);
+}
diff --git a/C/Delta.h b/C/Delta.h
new file mode 100755
index 00000000..0d4cd627
--- /dev/null
+++ b/C/Delta.h
@@ -0,0 +1,23 @@
+/* Delta.h -- Delta converter
+2009-04-15 : Igor Pavlov : Public domain */
+
+#ifndef __DELTA_H
+#define __DELTA_H
+
+#include "Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define DELTA_STATE_SIZE 256
+
+void Delta_Init(Byte *state);
+void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size);
+void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/C/HuffEnc.h b/C/HuffEnc.h
index 00dd9aca..9cf4bfde 100755
--- a/C/HuffEnc.h
+++ b/C/HuffEnc.h
@@ -1,13 +1,15 @@
-/* HuffEnc.h -- functions for Huffman encoding
-2008-03-26
-Igor Pavlov
-Public domain */
+/* HuffEnc.h -- Huffman encoding
+2009-02-07 : Igor Pavlov : Public domain */
 
-#ifndef __HUFFENC_H
-#define __HUFFENC_H
+#ifndef __HUFF_ENC_H
+#define __HUFF_ENC_H
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 Conditions:
   num <= 1024 = 2 ^ NUM_BITS
@@ -18,4 +20,8 @@ Conditions:
  
 void Huffman_Generate(const UInt32 *freqs, UInt32 *p, Byte *lens, UInt32 num, UInt32 maxLen);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/LzFind.c b/C/LzFind.c
index 34f4f09e..e3ecb054 100755
--- a/C/LzFind.c
+++ b/C/LzFind.c
@@ -1,5 +1,5 @@
 /* LzFind.c -- Match finder for LZ algorithms
-2008-10-04 : Igor Pavlov : Public domain */
+2009-04-22 : Igor Pavlov : Public domain */
 
 #include <string.h>
 
@@ -58,6 +58,17 @@ static void MatchFinder_ReadBlock(CMatchFinder *p)
 {
   if (p->streamEndWasReached || p->result != SZ_OK)
     return;
+  if (p->directInput)
+  {
+    UInt32 curSize = 0xFFFFFFFF - p->streamPos;
+    if (curSize > p->directInputRem)
+      curSize = (UInt32)p->directInputRem;
+    p->directInputRem -= curSize;
+    p->streamPos += curSize;
+    if (p->directInputRem == 0)
+      p->streamEndWasReached = 1;
+    return;
+  }
   for (;;)
   {
     Byte *dest = p->buffer + (p->streamPos - p->pos);
@@ -88,6 +99,8 @@ void MatchFinder_MoveBlock(CMatchFinder *p)
 
 int MatchFinder_NeedMove(CMatchFinder *p)
 {
+  if (p->directInput)
+    return 0;
   /* if (p->streamEndWasReached) return 0; */
   return ((size_t)(p->bufferBase + p->blockSize - p->buffer) <= p->keepSizeAfter);
 }
@@ -112,8 +125,6 @@ static void MatchFinder_SetDefaultSettings(CMatchFinder *p)
   p->cutValue = 32;
   p->btMode = 1;
   p->numHashBytes = 4;
-  /* p->skipModeBits = 0; */
-  p->directInput = 0;
   p->bigHash = 0;
 }
 
@@ -177,7 +188,7 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
   /* we need one additional byte, since we use MoveBlock after pos++ and before dictionary using */
   if (LzInWindow_Create(p, sizeReserv, alloc))
   {
-    UInt32 newCyclicBufferSize = (historySize /* >> p->skipModeBits */) + 1;
+    UInt32 newCyclicBufferSize = historySize + 1;
     UInt32 hs;
     p->matchMaxLen = matchMaxLen;
     {
@@ -192,7 +203,6 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
         hs |= (hs >> 4);
         hs |= (hs >> 8);
         hs >>= 1;
-        /* hs >>= p->skipModeBits; */
         hs |= 0xFFFF; /* don't change it! It's required for Deflate */
         if (hs > (1 << 24))
         {
diff --git a/C/LzFind.h b/C/LzFind.h
index 5b9cebfd..010c4b92 100755
--- a/C/LzFind.h
+++ b/C/LzFind.h
@@ -1,11 +1,15 @@
 /* LzFind.h -- Match finder for LZ algorithms
-2008-10-04 : Igor Pavlov : Public domain */
+2009-04-22 : Igor Pavlov : Public domain */
 
-#ifndef __LZFIND_H
-#define __LZFIND_H
+#ifndef __LZ_FIND_H
+#define __LZ_FIND_H
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef UInt32 CLzRef;
 
 typedef struct _CMatchFinder
@@ -35,8 +39,8 @@ typedef struct _CMatchFinder
 
   UInt32 numHashBytes;
   int directInput;
+  size_t directInputRem;
   int btMode;
-  /* int skipModeBits; */
   int bigHash;
   UInt32 historySize;
   UInt32 fixedHashSize;
@@ -104,4 +108,8 @@ UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
 void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
 void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/LzFindMt.c b/C/LzFindMt.c
index b49cd76b..5c23f8ea 100755
--- a/C/LzFindMt.c
+++ b/C/LzFindMt.c
@@ -1,5 +1,5 @@
 /* LzFindMt.c -- multithreaded Match finder for LZ algorithms
-2008-10-04 : Igor Pavlov : Public domain */
+2009-05-26 : Igor Pavlov : Public domain */
 
 #include "LzHash.h"
 
@@ -143,7 +143,7 @@ DEF_GetHeads2(2,  (p[0] | ((UInt32)p[1] << 8)), hashMask = hashMask; crc = crc;
 DEF_GetHeads(3,  (crc[p[0]] ^ p[1] ^ ((UInt32)p[2] << 8)) & hashMask)
 DEF_GetHeads(4,  (crc[p[0]] ^ p[1] ^ ((UInt32)p[2] << 8) ^ (crc[p[3]] << 5)) & hashMask)
 DEF_GetHeads(4b, (crc[p[0]] ^ p[1] ^ ((UInt32)p[2] << 8) ^ ((UInt32)p[3] << 16)) & hashMask)
-DEF_GetHeads(5,  (crc[p[0]] ^ p[1] ^ ((UInt32)p[2] << 8) ^ (crc[p[3]] << 5) ^ (crc[p[4]] << 3)) & hashMask)
+/* DEF_GetHeads(5,  (crc[p[0]] ^ p[1] ^ ((UInt32)p[2] << 8) ^ (crc[p[3]] << 5) ^ (crc[p[4]] << 3)) & hashMask) */
 
 void HashThreadFunc(CMatchFinderMt *mt)
 {
diff --git a/C/LzFindMt.h b/C/LzFindMt.h
index 2c7e462d..b985af5f 100755
--- a/C/LzFindMt.h
+++ b/C/LzFindMt.h
@@ -1,11 +1,15 @@
 /* LzFindMt.h -- multithreaded Match finder for LZ algorithms
-2008-10-04 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
-#ifndef __LZFINDMT_H
-#define __LZFINDMT_H
+#ifndef __LZ_FIND_MT_H
+#define __LZ_FIND_MT_H
 
-#include "Threads.h"
 #include "LzFind.h"
+#include "Threads.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 #define kMtHashBlockSize (1 << 13)
 #define kMtHashNumBlocks (1 << 3)
@@ -94,4 +98,8 @@ SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddB
 void MatchFinderMt_CreateVTable(CMatchFinderMt *p, IMatchFinder *vTable);
 void MatchFinderMt_ReleaseStream(CMatchFinderMt *p);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/LzHash.h b/C/LzHash.h
index 9f4173e7..f3e89966 100755
--- a/C/LzHash.h
+++ b/C/LzHash.h
@@ -1,8 +1,8 @@
 /* LzHash.h -- HASH functions for LZ algorithms
-2008-10-04 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
-#ifndef __LZHASH_H
-#define __LZHASH_H
+#ifndef __LZ_HASH_H
+#define __LZ_HASH_H
 
 #define kHash2Size (1 << 10)
 #define kHash3Size (1 << 16)
diff --git a/C/Lzma2Dec.c b/C/Lzma2Dec.c
new file mode 100755
index 00000000..7ea1cc95
--- /dev/null
+++ b/C/Lzma2Dec.c
@@ -0,0 +1,356 @@
+/* Lzma2Dec.c -- LZMA2 Decoder
+2009-05-03 : Igor Pavlov : Public domain */
+
+/* #define SHOW_DEBUG_INFO */
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#endif
+
+#include <string.h>
+
+#include "Lzma2Dec.h"
+
+/*
+00000000  -  EOS
+00000001 U U  -  Uncompressed Reset Dic
+00000010 U U  -  Uncompressed No Reset
+100uuuuu U U P P  -  LZMA no reset
+101uuuuu U U P P  -  LZMA reset state
+110uuuuu U U P P S  -  LZMA reset state + new prop
+111uuuuu U U P P S  -  LZMA reset state + new prop + reset dic
+
+  u, U - Unpack Size
+  P - Pack Size
+  S - Props
+*/
+
+#define LZMA2_CONTROL_LZMA (1 << 7)
+#define LZMA2_CONTROL_COPY_NO_RESET 2
+#define LZMA2_CONTROL_COPY_RESET_DIC 1
+#define LZMA2_CONTROL_EOF 0
+
+#define LZMA2_IS_UNCOMPRESSED_STATE(p) (((p)->control & LZMA2_CONTROL_LZMA) == 0)
+
+#define LZMA2_GET_LZMA_MODE(p) (((p)->control >> 5) & 3)
+#define LZMA2_IS_THERE_PROP(mode) ((mode) >= 2)
+
+#define LZMA2_LCLP_MAX 4
+#define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11))
+
+#ifdef SHOW_DEBUG_INFO
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+typedef enum
+{
+  LZMA2_STATE_CONTROL,
+  LZMA2_STATE_UNPACK0,
+  LZMA2_STATE_UNPACK1,
+  LZMA2_STATE_PACK0,
+  LZMA2_STATE_PACK1,
+  LZMA2_STATE_PROP,
+  LZMA2_STATE_DATA,
+  LZMA2_STATE_DATA_CONT,
+  LZMA2_STATE_FINISHED,
+  LZMA2_STATE_ERROR
+} ELzma2State;
+
+static SRes Lzma2Dec_GetOldProps(Byte prop, Byte *props)
+{
+  UInt32 dicSize;
+  if (prop > 40)
+    return SZ_ERROR_UNSUPPORTED;
+  dicSize = (prop == 40) ? 0xFFFFFFFF : LZMA2_DIC_SIZE_FROM_PROP(prop);
+  props[0] = (Byte)LZMA2_LCLP_MAX;
+  props[1] = (Byte)(dicSize);
+  props[2] = (Byte)(dicSize >> 8);
+  props[3] = (Byte)(dicSize >> 16);
+  props[4] = (Byte)(dicSize >> 24);
+  return SZ_OK;
+}
+
+SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAlloc *alloc)
+{
+  Byte props[LZMA_PROPS_SIZE];
+  RINOK(Lzma2Dec_GetOldProps(prop, props));
+  return LzmaDec_AllocateProbs(&p->decoder, props, LZMA_PROPS_SIZE, alloc);
+}
+
+SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAlloc *alloc)
+{
+  Byte props[LZMA_PROPS_SIZE];
+  RINOK(Lzma2Dec_GetOldProps(prop, props));
+  return LzmaDec_Allocate(&p->decoder, props, LZMA_PROPS_SIZE, alloc);
+}
+
+void Lzma2Dec_Init(CLzma2Dec *p)
+{
+  p->state = LZMA2_STATE_CONTROL;
+  p->needInitDic = True;
+  p->needInitState = True;
+  p->needInitProp = True;
+  LzmaDec_Init(&p->decoder);
+}
+
+static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b)
+{
+  switch(p->state)
+  {
+    case LZMA2_STATE_CONTROL:
+      p->control = b;
+      PRF(printf("\n %4X ", p->decoder.dicPos));
+      PRF(printf(" %2X", b));
+      if (p->control == 0)
+        return LZMA2_STATE_FINISHED;
+      if (LZMA2_IS_UNCOMPRESSED_STATE(p))
+      {
+        if ((p->control & 0x7F) > 2)
+          return LZMA2_STATE_ERROR;
+        p->unpackSize = 0;
+      }
+      else
+        p->unpackSize = (UInt32)(p->control & 0x1F) << 16;
+      return LZMA2_STATE_UNPACK0;
+    
+    case LZMA2_STATE_UNPACK0:
+      p->unpackSize |= (UInt32)b << 8;
+      return LZMA2_STATE_UNPACK1;
+    
+    case LZMA2_STATE_UNPACK1:
+      p->unpackSize |= (UInt32)b;
+      p->unpackSize++;
+      PRF(printf(" %8d", p->unpackSize));
+      return (LZMA2_IS_UNCOMPRESSED_STATE(p)) ? LZMA2_STATE_DATA : LZMA2_STATE_PACK0;
+    
+    case LZMA2_STATE_PACK0:
+      p->packSize = (UInt32)b << 8;
+      return LZMA2_STATE_PACK1;
+
+    case LZMA2_STATE_PACK1:
+      p->packSize |= (UInt32)b;
+      p->packSize++;
+      PRF(printf(" %8d", p->packSize));
+      return LZMA2_IS_THERE_PROP(LZMA2_GET_LZMA_MODE(p)) ? LZMA2_STATE_PROP:
+        (p->needInitProp ? LZMA2_STATE_ERROR : LZMA2_STATE_DATA);
+
+    case LZMA2_STATE_PROP:
+    {
+      int lc, lp;
+      if (b >= (9 * 5 * 5))
+        return LZMA2_STATE_ERROR;
+      lc = b % 9;
+      b /= 9;
+      p->decoder.prop.pb = b / 5;
+      lp = b % 5;
+      if (lc + lp > LZMA2_LCLP_MAX)
+        return LZMA2_STATE_ERROR;
+      p->decoder.prop.lc = lc;
+      p->decoder.prop.lp = lp;
+      p->needInitProp = False;
+      return LZMA2_STATE_DATA;
+    }
+  }
+  return LZMA2_STATE_ERROR;
+}
+
+static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const Byte *src, SizeT size)
+{
+  memcpy(p->dic + p->dicPos, src, size);
+  p->dicPos += size;
+  if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= size)
+    p->checkDicSize = p->prop.dicSize;
+  p->processedPos += (UInt32)size;
+}
+
+void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState);
+
+SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
+    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
+{
+  SizeT inSize = *srcLen;
+  *srcLen = 0;
+  *status = LZMA_STATUS_NOT_SPECIFIED;
+
+  while (p->state != LZMA2_STATE_FINISHED)
+  {
+    SizeT dicPos = p->decoder.dicPos;
+    if (p->state == LZMA2_STATE_ERROR)
+      return SZ_ERROR_DATA;
+    if (dicPos == dicLimit && finishMode == LZMA_FINISH_ANY)
+    {
+      *status = LZMA_STATUS_NOT_FINISHED;
+      return SZ_OK;
+    }
+    if (p->state != LZMA2_STATE_DATA && p->state != LZMA2_STATE_DATA_CONT)
+    {
+      if (*srcLen == inSize)
+      {
+        *status = LZMA_STATUS_NEEDS_MORE_INPUT;
+        return SZ_OK;
+      }
+      (*srcLen)++;
+      p->state = Lzma2Dec_UpdateState(p, *src++);
+      continue;
+    }
+    {
+      SizeT destSizeCur = dicLimit - dicPos;
+      SizeT srcSizeCur = inSize - *srcLen;
+      ELzmaFinishMode curFinishMode = LZMA_FINISH_ANY;
+      
+      if (p->unpackSize <= destSizeCur)
+      {
+        destSizeCur = (SizeT)p->unpackSize;
+        curFinishMode = LZMA_FINISH_END;
+      }
+
+      if (LZMA2_IS_UNCOMPRESSED_STATE(p))
+      {
+        if (*srcLen == inSize)
+        {
+          *status = LZMA_STATUS_NEEDS_MORE_INPUT;
+          return SZ_OK;
+        }
+
+        if (p->state == LZMA2_STATE_DATA)
+        {
+          Bool initDic = (p->control == LZMA2_CONTROL_COPY_RESET_DIC);
+          if (initDic)
+            p->needInitProp = p->needInitState = True;
+          else if (p->needInitDic)
+            return SZ_ERROR_DATA;
+          p->needInitDic = False;
+          LzmaDec_InitDicAndState(&p->decoder, initDic, False);
+        }
+
+        if (srcSizeCur > destSizeCur)
+          srcSizeCur = destSizeCur;
+
+        if (srcSizeCur == 0)
+          return SZ_ERROR_DATA;
+
+        LzmaDec_UpdateWithUncompressed(&p->decoder, src, srcSizeCur);
+
+        src += srcSizeCur;
+        *srcLen += srcSizeCur;
+        p->unpackSize -= (UInt32)srcSizeCur;
+        p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT;
+      }
+      else
+      {
+        SizeT outSizeProcessed;
+        SRes res;
+
+        if (p->state == LZMA2_STATE_DATA)
+        {
+          int mode = LZMA2_GET_LZMA_MODE(p);
+          Bool initDic = (mode == 3);
+          Bool initState = (mode > 0);
+          if ((!initDic && p->needInitDic) || (!initState && p->needInitState))
+            return SZ_ERROR_DATA;
+          
+          LzmaDec_InitDicAndState(&p->decoder, initDic, initState);
+          p->needInitDic = False;
+          p->needInitState = False;
+          p->state = LZMA2_STATE_DATA_CONT;
+        }
+        if (srcSizeCur > p->packSize)
+          srcSizeCur = (SizeT)p->packSize;
+          
+        res = LzmaDec_DecodeToDic(&p->decoder, dicPos + destSizeCur, src, &srcSizeCur, curFinishMode, status);
+        
+        src += srcSizeCur;
+        *srcLen += srcSizeCur;
+        p->packSize -= (UInt32)srcSizeCur;
+
+        outSizeProcessed = p->decoder.dicPos - dicPos;
+        p->unpackSize -= (UInt32)outSizeProcessed;
+
+        RINOK(res);
+        if (*status == LZMA_STATUS_NEEDS_MORE_INPUT)
+          return res;
+
+        if (srcSizeCur == 0 && outSizeProcessed == 0)
+        {
+          if (*status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK ||
+              p->unpackSize != 0 || p->packSize != 0)
+            return SZ_ERROR_DATA;
+          p->state = LZMA2_STATE_CONTROL;
+        }
+        if (*status == LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
+          *status = LZMA_STATUS_NOT_FINISHED;
+      }
+    }
+  }
+  *status = LZMA_STATUS_FINISHED_WITH_MARK;
+  return SZ_OK;
+}
+
+SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
+{
+  SizeT outSize = *destLen, inSize = *srcLen;
+  *srcLen = *destLen = 0;
+  for (;;)
+  {
+    SizeT srcSizeCur = inSize, outSizeCur, dicPos;
+    ELzmaFinishMode curFinishMode;
+    SRes res;
+    if (p->decoder.dicPos == p->decoder.dicBufSize)
+      p->decoder.dicPos = 0;
+    dicPos = p->decoder.dicPos;
+    if (outSize > p->decoder.dicBufSize - dicPos)
+    {
+      outSizeCur = p->decoder.dicBufSize;
+      curFinishMode = LZMA_FINISH_ANY;
+    }
+    else
+    {
+      outSizeCur = dicPos + outSize;
+      curFinishMode = finishMode;
+    }
+
+    res = Lzma2Dec_DecodeToDic(p, outSizeCur, src, &srcSizeCur, curFinishMode, status);
+    src += srcSizeCur;
+    inSize -= srcSizeCur;
+    *srcLen += srcSizeCur;
+    outSizeCur = p->decoder.dicPos - dicPos;
+    memcpy(dest, p->decoder.dic + dicPos, outSizeCur);
+    dest += outSizeCur;
+    outSize -= outSizeCur;
+    *destLen += outSizeCur;
+    if (res != 0)
+      return res;
+    if (outSizeCur == 0 || outSize == 0)
+      return SZ_OK;
+  }
+}
+
+SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
+    Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc)
+{
+  CLzma2Dec decoder;
+  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));
+  
+  *srcLen = inSize;
+  res = Lzma2Dec_DecodeToDic(&decoder, outSize, src, srcLen, finishMode, status);
+  *destLen = decoder.decoder.dicPos;
+  if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
+    res = SZ_ERROR_INPUT_EOF;
+
+  LzmaDec_FreeProbs(&decoder.decoder, alloc);
+  return res;
+}
diff --git a/C/Lzma2Dec.h b/C/Lzma2Dec.h
new file mode 100755
index 00000000..6bc07bbc
--- /dev/null
+++ b/C/Lzma2Dec.h
@@ -0,0 +1,84 @@
+/* Lzma2Dec.h -- LZMA2 Decoder
+2009-05-03 : Igor Pavlov : Public domain */
+
+#ifndef __LZMA2_DEC_H
+#define __LZMA2_DEC_H
+
+#include "LzmaDec.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ---------- State Interface ---------- */
+
+typedef struct
+{
+  CLzmaDec decoder;
+  UInt32 packSize;
+  UInt32 unpackSize;
+  int state;
+  Byte control;
+  Bool needInitDic;
+  Bool needInitState;
+  Bool needInitProp;
+} CLzma2Dec;
+
+#define Lzma2Dec_Construct(p) LzmaDec_Construct(&(p)->decoder)
+#define Lzma2Dec_FreeProbs(p, alloc) LzmaDec_FreeProbs(&(p)->decoder, alloc);
+#define Lzma2Dec_Free(p, alloc) LzmaDec_Free(&(p)->decoder, alloc);
+
+SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAlloc *alloc);
+SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAlloc *alloc);
+void Lzma2Dec_Init(CLzma2Dec *p);
+
+
+/*
+finishMode:
+  It has meaning only if the decoding reaches output limit (*destLen or dicLimit).
+  LZMA_FINISH_ANY - use smallest number of input bytes
+  LZMA_FINISH_END - read EndOfStream marker after decoding
+
+Returns:
+  SZ_OK
+    status:
+      LZMA_STATUS_FINISHED_WITH_MARK
+      LZMA_STATUS_NOT_FINISHED
+      LZMA_STATUS_NEEDS_MORE_INPUT
+  SZ_ERROR_DATA - Data error
+*/
+
+SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
+    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
+
+SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen,
+    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
+
+
+/* ---------- One Call Interface ---------- */
+
+/*
+finishMode:
+  It has meaning only if the decoding reaches output limit (*destLen).
+  LZMA_FINISH_ANY - use smallest number of input bytes
+  LZMA_FINISH_END - read EndOfStream marker after decoding
+
+Returns:
+  SZ_OK
+    status:
+      LZMA_STATUS_FINISHED_WITH_MARK
+      LZMA_STATUS_NOT_FINISHED
+  SZ_ERROR_DATA - Data error
+  SZ_ERROR_MEM  - Memory allocation error
+  SZ_ERROR_UNSUPPORTED - Unsupported properties
+  SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
+*/
+
+SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
+    Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/C/Lzma2Enc.c b/C/Lzma2Enc.c
new file mode 100755
index 00000000..afccd4da
--- /dev/null
+++ b/C/Lzma2Enc.c
@@ -0,0 +1,484 @@
+/* Lzma2Enc.c -- LZMA2 Encoder
+2009-05-26 : Igor Pavlov : Public domain */
+
+/* #include <stdio.h> */
+#include <string.h>
+
+#include "Lzma2Enc.h"
+
+/* #define COMPRESS_MT */
+
+#ifdef COMPRESS_MT
+#include "MtCoder.h"
+#else
+#define NUM_MT_CODER_THREADS_MAX 1
+#endif
+
+#define LZMA2_CONTROL_LZMA (1 << 7)
+#define LZMA2_CONTROL_COPY_NO_RESET 2
+#define LZMA2_CONTROL_COPY_RESET_DIC 1
+#define LZMA2_CONTROL_EOF 0
+
+#define LZMA2_LCLP_MAX 4
+
+#define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11))
+
+#define LZMA2_PACK_SIZE_MAX (1 << 16)
+#define LZMA2_COPY_CHUNK_SIZE LZMA2_PACK_SIZE_MAX
+#define LZMA2_UNPACK_SIZE_MAX (1 << 21)
+#define LZMA2_KEEP_WINDOW_SIZE LZMA2_UNPACK_SIZE_MAX
+
+#define LZMA2_CHUNK_SIZE_COMPRESSED_MAX ((1 << 16) + 16)
+
+
+#define PRF(x) /* x */
+
+/* ---------- CLzma2EncInt ---------- */
+
+typedef struct
+{
+  CLzmaEncHandle enc;
+  UInt64 srcPos;
+  Byte props;
+  Bool needInitState;
+  Bool needInitProp;
+} CLzma2EncInt;
+
+static SRes Lzma2EncInt_Init(CLzma2EncInt *p, const CLzma2EncProps *props)
+{
+  Byte propsEncoded[LZMA_PROPS_SIZE];
+  SizeT propsSize = LZMA_PROPS_SIZE;
+  RINOK(LzmaEnc_SetProps(p->enc, &props->lzmaProps));
+  RINOK(LzmaEnc_WriteProperties(p->enc, propsEncoded, &propsSize));
+  p->srcPos = 0;
+  p->props = propsEncoded[0];
+  p->needInitState = True;
+  p->needInitProp = True;
+  return SZ_OK;
+}
+
+SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp, ISeqInStream *inStream, UInt32 keepWindowSize,
+    ISzAlloc *alloc, ISzAlloc *allocBig);
+SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,
+    UInt32 keepWindowSize, ISzAlloc *alloc, ISzAlloc *allocBig);
+SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, Bool reInit,
+    Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize);
+const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle pp);
+void LzmaEnc_Finish(CLzmaEncHandle pp);
+void LzmaEnc_SaveState(CLzmaEncHandle pp);
+void LzmaEnc_RestoreState(CLzmaEncHandle pp);
+
+
+static SRes Lzma2EncInt_EncodeSubblock(CLzma2EncInt *p, Byte *outBuf,
+    size_t *packSizeRes, ISeqOutStream *outStream)
+{
+  size_t packSizeLimit = *packSizeRes;
+  size_t packSize = packSizeLimit;
+  UInt32 unpackSize = LZMA2_UNPACK_SIZE_MAX;
+  unsigned lzHeaderSize = 5 + (p->needInitProp ? 1 : 0);
+  Bool useCopyBlock;
+  SRes res;
+
+  *packSizeRes = 0;
+  if (packSize < lzHeaderSize)
+    return SZ_ERROR_OUTPUT_EOF;
+  packSize -= lzHeaderSize;
+  
+  LzmaEnc_SaveState(p->enc);
+  res = LzmaEnc_CodeOneMemBlock(p->enc, p->needInitState,
+      outBuf + lzHeaderSize, &packSize, LZMA2_PACK_SIZE_MAX, &unpackSize);
+  
+  PRF(printf("\npackSize = %7d unpackSize = %7d  ", packSize, unpackSize));
+
+  if (unpackSize == 0)
+    return res;
+
+  if (res == SZ_OK)
+    useCopyBlock = (packSize + 2 >= unpackSize || packSize > (1 << 16));
+  else
+  {
+    if (res != SZ_ERROR_OUTPUT_EOF)
+      return res;
+    res = SZ_OK;
+    useCopyBlock = True;
+  }
+
+  if (useCopyBlock)
+  {
+    size_t destPos = 0;
+    PRF(printf("################# COPY           "));
+    while (unpackSize > 0)
+    {
+      UInt32 u = (unpackSize < LZMA2_COPY_CHUNK_SIZE) ? unpackSize : LZMA2_COPY_CHUNK_SIZE;
+      if (packSizeLimit - destPos < u + 3)
+        return SZ_ERROR_OUTPUT_EOF;
+      outBuf[destPos++] = (Byte)(p->srcPos == 0 ? LZMA2_CONTROL_COPY_RESET_DIC : LZMA2_CONTROL_COPY_NO_RESET);
+      outBuf[destPos++] = (Byte)((u - 1) >> 8);
+      outBuf[destPos++] = (Byte)(u - 1);
+      memcpy(outBuf + destPos, LzmaEnc_GetCurBuf(p->enc) - unpackSize, u);
+      unpackSize -= u;
+      destPos += u;
+      p->srcPos += u;
+      if (outStream)
+      {
+        *packSizeRes += destPos;
+        if (outStream->Write(outStream, outBuf, destPos) != destPos)
+          return SZ_ERROR_WRITE;
+        destPos = 0;
+      }
+      else
+        *packSizeRes = destPos;
+      /* needInitState = True; */
+    }
+    LzmaEnc_RestoreState(p->enc);
+    return SZ_OK;
+  }
+  {
+    size_t destPos = 0;
+    UInt32 u = unpackSize - 1;
+    UInt32 pm = (UInt32)(packSize - 1);
+    unsigned mode = (p->srcPos == 0) ? 3 : (p->needInitState ? (p->needInitProp ? 2 : 1) : 0);
+
+    PRF(printf("               "));
+
+    outBuf[destPos++] = (Byte)(LZMA2_CONTROL_LZMA | (mode << 5) | (u >> 16) & 0x1F);
+    outBuf[destPos++] = (Byte)(u >> 8);
+    outBuf[destPos++] = (Byte)u;
+    outBuf[destPos++] = (Byte)(pm >> 8);
+    outBuf[destPos++] = (Byte)pm;
+    
+    if (p->needInitProp)
+      outBuf[destPos++] = p->props;
+    
+    p->needInitProp = False;
+    p->needInitState = False;
+    destPos += packSize;
+    p->srcPos += unpackSize;
+
+    if (outStream)
+      if (outStream->Write(outStream, outBuf, destPos) != destPos)
+        return SZ_ERROR_WRITE;
+    *packSizeRes = destPos;
+    return SZ_OK;
+  }
+}
+
+/* ---------- Lzma2 Props ---------- */
+
+void Lzma2EncProps_Init(CLzma2EncProps *p)
+{
+  LzmaEncProps_Init(&p->lzmaProps);
+  p->numTotalThreads = -1;
+  p->numBlockThreads = -1;
+  p->blockSize = 0;
+}
+
+
+static SRes Progress(ICompressProgress *p, UInt64 inSize, UInt64 outSize)
+{
+  return (p && p->Progress(p, inSize, outSize) != SZ_OK) ? SZ_ERROR_PROGRESS : SZ_OK;
+}
+
+/* ---------- Lzma2 ---------- */
+
+extern struct _CLzma2Enc;
+
+typedef struct _CLzma2Enc
+{
+  Byte propEncoded;
+  CLzma2EncProps props;
+  
+  Byte *outBuf;
+
+  ISzAlloc *alloc;
+  ISzAlloc *allocBig;
+
+  CLzma2EncInt coders[NUM_MT_CODER_THREADS_MAX];
+
+  #ifdef COMPRESS_MT
+  CMtCoder mtCoder;
+  #endif
+
+} CLzma2Enc;
+
+
+/* ---------- Lzma2EncThread ---------- */
+
+static SRes Lzma2Enc_EncodeMt1(CLzma2EncInt *p, CLzma2Enc *mainEncoder,
+  ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress)
+{
+  UInt64 packTotal = 0;
+  SRes res = SZ_OK;
+
+  if (mainEncoder->outBuf == 0)
+  {
+    mainEncoder->outBuf = IAlloc_Alloc(mainEncoder->alloc, LZMA2_CHUNK_SIZE_COMPRESSED_MAX);
+    if (mainEncoder->outBuf == 0)
+      return SZ_ERROR_MEM;
+  }
+  RINOK(Lzma2EncInt_Init(p, &mainEncoder->props));
+  RINOK(LzmaEnc_PrepareForLzma2(p->enc, inStream, LZMA2_KEEP_WINDOW_SIZE,
+      mainEncoder->alloc, mainEncoder->allocBig));
+  for (;;)
+  {
+    size_t packSize = LZMA2_CHUNK_SIZE_COMPRESSED_MAX;
+    res = Lzma2EncInt_EncodeSubblock(p, mainEncoder->outBuf, &packSize, outStream);
+    if (res != SZ_OK)
+      break;
+    packTotal += packSize;
+    res = Progress(progress, p->srcPos, packTotal);
+    if (res != SZ_OK)
+      break;
+    if (packSize == 0)
+      break;
+  }
+  LzmaEnc_Finish(p->enc);
+  if (res == SZ_OK)
+  {
+    Byte b = 0;
+    if (outStream->Write(outStream, &b, 1) != 1)
+      return SZ_ERROR_WRITE;
+  }
+  return res;
+}
+
+#ifdef COMPRESS_MT
+
+typedef struct
+{
+  IMtCoderCallback funcTable;
+  CLzma2Enc *lzma2Enc;
+} CMtCallbackImp;
+
+static SRes MtCallbackImp_Code(void *pp, unsigned index, Byte *dest, size_t *destSize,
+      const Byte *src, size_t srcSize, int finished)
+{
+  CMtCallbackImp *imp = (CMtCallbackImp *)pp;
+  CLzma2Enc *mainEncoder = imp->lzma2Enc;
+  CLzma2EncInt *p = &mainEncoder->coders[index];
+
+  SRes res = SZ_OK;
+  {
+    size_t destLim = *destSize;
+    *destSize = 0;
+
+    if (srcSize != 0)
+    {
+      RINOK(Lzma2EncInt_Init(p, &mainEncoder->props));
+     
+      RINOK(LzmaEnc_MemPrepare(p->enc, src, srcSize, LZMA2_KEEP_WINDOW_SIZE,
+          mainEncoder->alloc, mainEncoder->allocBig));
+     
+      while (p->srcPos < srcSize)
+      {
+        size_t packSize = destLim - *destSize;
+        res = Lzma2EncInt_EncodeSubblock(p, dest + *destSize, &packSize, NULL);
+        if (res != SZ_OK)
+          break;
+        *destSize += packSize;
+
+        if (packSize == 0)
+        {
+          res = SZ_ERROR_FAIL;
+          break;
+        }
+
+        if (MtProgress_Set(&mainEncoder->mtCoder.mtProgress, index, p->srcPos, *destSize) != SZ_OK)
+        {
+          res = SZ_ERROR_PROGRESS;
+          break;
+        }
+      }
+      LzmaEnc_Finish(p->enc);
+      if (res != SZ_OK)
+        return res;
+    }
+    if (finished)
+    {
+      if (*destSize == destLim)
+        return SZ_ERROR_OUTPUT_EOF;
+      dest[(*destSize)++] = 0;
+    }
+  }
+  return res;
+}
+
+#endif
+
+/* ---------- Lzma2Enc ---------- */
+
+CLzma2EncHandle Lzma2Enc_Create(ISzAlloc *alloc, ISzAlloc *allocBig)
+{
+  CLzma2Enc *p = (CLzma2Enc *)alloc->Alloc(alloc, sizeof(CLzma2Enc));
+  if (p == 0)
+    return NULL;
+  Lzma2EncProps_Init(&p->props);
+  Lzma2EncProps_Normalize(&p->props);
+  p->outBuf = 0;
+  p->alloc = alloc;
+  p->allocBig = allocBig;
+  {
+    unsigned i;
+    for (i = 0; i < NUM_MT_CODER_THREADS_MAX; i++)
+      p->coders[i].enc = 0;
+  }
+  #ifdef COMPRESS_MT
+  MtCoder_Construct(&p->mtCoder);
+  #endif
+
+  return p;
+}
+
+void Lzma2Enc_Destroy(CLzma2EncHandle pp)
+{
+  CLzma2Enc *p = (CLzma2Enc *)pp;
+  unsigned i;
+  for (i = 0; i < NUM_MT_CODER_THREADS_MAX; i++)
+  {
+    CLzma2EncInt *t = &p->coders[i];
+    if (t->enc)
+    {
+      LzmaEnc_Destroy(t->enc, p->alloc, p->allocBig);
+      t->enc = 0;
+    }
+  }
+
+  #ifdef COMPRESS_MT
+  MtCoder_Destruct(&p->mtCoder);
+  #endif
+
+  IAlloc_Free(p->alloc, p->outBuf);
+  IAlloc_Free(p->alloc, pp);
+}
+
+void Lzma2EncProps_Normalize(CLzma2EncProps *p)
+{
+  int t1, t1n, t2, t3;
+  CLzmaEncProps lzmaProps = p->lzmaProps;
+  
+  LzmaEncProps_Normalize(&lzmaProps);
+
+  t1 = p->lzmaProps.numThreads;
+  t1n = lzmaProps.numThreads;
+  t2 = p->numBlockThreads;
+  t3 = p->numTotalThreads;
+
+  #ifdef COMPRESS_MT
+  if (t2 > NUM_MT_CODER_THREADS_MAX)
+    t2 = NUM_MT_CODER_THREADS_MAX;
+  #else
+  t2 = 1;
+  #endif
+
+  if (t3 <= 0)
+  {
+    if (t2 <= 0)
+      t2 = 1;
+    t3 = t1n * t2;
+  }
+  else
+  {
+    if (t2 <= 0)
+    {
+      t2 = t3 / t1n;
+      if (t2 == 0)
+      {
+        t1 = 1;
+        t2 = t3;
+      }
+    }
+    else if (t1 <= 0)
+    {
+      t1 = t3 / t2;
+      if (t1 == 0)
+        t1 = 1;
+    }
+    else
+      t3 = t1n * t2;
+  }
+
+  p->lzmaProps.numThreads = t1;
+  p->numBlockThreads = t2;
+  p->numTotalThreads = t3;
+  LzmaEncProps_Normalize(&p->lzmaProps);
+
+  if (p->blockSize == 0)
+  {
+    UInt64 blockSize = (UInt64)lzmaProps.dictSize << 2;
+    const UInt32 kMinSize = (UInt32)1 << 20;
+    const UInt32 kMaxSize = (UInt32)1 << 28;
+    if (blockSize < kMinSize) blockSize = kMinSize;
+    if (blockSize > kMaxSize) blockSize = kMaxSize;
+    if (blockSize < lzmaProps.dictSize)
+      blockSize = lzmaProps.dictSize;
+    p->blockSize = (size_t)blockSize;
+  }
+}
+
+SRes Lzma2Enc_SetProps(CLzma2EncHandle pp, const CLzma2EncProps *props)
+{
+  CLzma2Enc *p = (CLzma2Enc *)pp;
+  CLzmaEncProps lzmaProps = props->lzmaProps;
+  LzmaEncProps_Normalize(&lzmaProps);
+  if (lzmaProps.lc + lzmaProps.lp > LZMA2_LCLP_MAX)
+    return SZ_ERROR_PARAM;
+  p->props = *props;
+  Lzma2EncProps_Normalize(&p->props);
+  return SZ_OK;
+}
+
+Byte Lzma2Enc_WriteProperties(CLzma2EncHandle pp)
+{
+  CLzma2Enc *p = (CLzma2Enc *)pp;
+  unsigned i;
+  UInt32 dicSize = LzmaEncProps_GetDictSize(&p->props.lzmaProps);
+  for (i = 0; i < 40; i++)
+    if (dicSize <= LZMA2_DIC_SIZE_FROM_PROP(i))
+      break;
+  return (Byte)i;
+}
+
+SRes Lzma2Enc_Encode(CLzma2EncHandle pp,
+    ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress)
+{
+  CLzma2Enc *p = (CLzma2Enc *)pp;
+  int i;
+
+  for (i = 0; i < p->props.numBlockThreads; i++)
+  {
+    CLzma2EncInt *t = &p->coders[i];
+    if (t->enc == NULL)
+    {
+      t->enc = LzmaEnc_Create(p->alloc);
+      if (t->enc == NULL)
+        return SZ_ERROR_MEM;
+    }
+  }
+
+  #ifdef COMPRESS_MT
+  if (p->props.numBlockThreads <= 1)
+  #endif
+    return Lzma2Enc_EncodeMt1(&p->coders[0], p, outStream, inStream, progress);
+
+  #ifdef COMPRESS_MT
+
+  {
+    CMtCallbackImp mtCallback;
+
+    mtCallback.funcTable.Code = MtCallbackImp_Code;
+    mtCallback.lzma2Enc = p;
+    
+    p->mtCoder.progress = progress;
+    p->mtCoder.inStream = inStream;
+    p->mtCoder.outStream = outStream;
+    p->mtCoder.alloc = p->alloc;
+    p->mtCoder.mtCallback = &mtCallback.funcTable;
+
+    p->mtCoder.blockSize = p->props.blockSize;
+    p->mtCoder.destBlockSize = p->props.blockSize + (p->props.blockSize >> 10) + 16;
+    p->mtCoder.numThreads = p->props.numBlockThreads;
+    
+    return MtCoder_Code(&p->mtCoder);
+  }
+  #endif
+}
diff --git a/C/Lzma2Enc.h b/C/Lzma2Enc.h
new file mode 100755
index 00000000..28352558
--- /dev/null
+++ b/C/Lzma2Enc.h
@@ -0,0 +1,66 @@
+/* Lzma2Enc.h -- LZMA2 Encoder
+2009-02-07 : Igor Pavlov : Public domain */
+
+#ifndef __LZMA2_ENC_H
+#define __LZMA2_ENC_H
+
+#include "LzmaEnc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct
+{
+  CLzmaEncProps lzmaProps;
+  size_t blockSize;
+  int numBlockThreads;
+  int numTotalThreads;
+} CLzma2EncProps;
+
+void Lzma2EncProps_Init(CLzma2EncProps *p);
+void Lzma2EncProps_Normalize(CLzma2EncProps *p);
+
+/* ---------- CLzmaEnc2Handle Interface ---------- */
+
+/* Lzma2Enc_* functions can return the following exit codes:
+Returns:
+  SZ_OK           - OK
+  SZ_ERROR_MEM    - Memory allocation error
+  SZ_ERROR_PARAM  - Incorrect paramater in props
+  SZ_ERROR_WRITE  - Write callback error
+  SZ_ERROR_PROGRESS - some break from progress callback
+  SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version)
+*/
+
+typedef void * CLzma2EncHandle;
+
+CLzma2EncHandle Lzma2Enc_Create(ISzAlloc *alloc, ISzAlloc *allocBig);
+void Lzma2Enc_Destroy(CLzma2EncHandle p);
+SRes Lzma2Enc_SetProps(CLzma2EncHandle p, const CLzma2EncProps *props);
+Byte Lzma2Enc_WriteProperties(CLzma2EncHandle p);
+SRes Lzma2Enc_Encode(CLzma2EncHandle p,
+    ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress);
+
+/* ---------- One Call Interface ---------- */
+
+/* Lzma2Encode
+Return code:
+  SZ_OK               - OK
+  SZ_ERROR_MEM        - Memory allocation error
+  SZ_ERROR_PARAM      - Incorrect paramater
+  SZ_ERROR_OUTPUT_EOF - output buffer overflow
+  SZ_ERROR_THREAD     - errors in multithreading functions (only for Mt version)
+*/
+
+/*
+SRes Lzma2Encode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
+    const CLzmaEncProps *props, Byte *propsEncoded, int writeEndMark,
+    ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/C/LzmaDec.h b/C/LzmaDec.h
index 98cdbe94..bf7f084b 100755
--- a/C/LzmaDec.h
+++ b/C/LzmaDec.h
@@ -1,11 +1,15 @@
 /* LzmaDec.h -- LZMA Decoder
-2008-10-04 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
-#ifndef __LZMADEC_H
-#define __LZMADEC_H
+#ifndef __LZMA_DEC_H
+#define __LZMA_DEC_H
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* #define _LZMA_PROB32 */
 /* _LZMA_PROB32 can increase the speed on some CPUs,
    but memory usage for CLzmaDec::probs will be doubled in that case */
@@ -220,4 +224,8 @@ SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
     const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
     ELzmaStatus *status, ISzAlloc *alloc);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/LzmaEnc.c b/C/LzmaEnc.c
index 9196c43f..20ad727f 100755
--- a/C/LzmaEnc.c
+++ b/C/LzmaEnc.c
@@ -1,5 +1,5 @@
 /* LzmaEnc.c -- LZMA Encoder
-2009-02-02 : Igor Pavlov : Public domain */
+2009-04-22 : Igor Pavlov : Public domain */
 
 #include <string.h>
 
@@ -139,7 +139,7 @@ void LzmaEnc_FastPosInit(Byte *g_FastPos)
 
 typedef unsigned CState;
 
-typedef struct _COptimal
+typedef struct
 {
   UInt32 price;
 
@@ -218,7 +218,7 @@ typedef struct
   UInt32 counters[LZMA_NUM_PB_STATES_MAX];
 } CLenPriceEnc;
 
-typedef struct _CRangeEnc
+typedef struct
 {
   UInt32 range;
   Byte cache;
@@ -232,26 +232,6 @@ typedef struct _CRangeEnc
   SRes res;
 } CRangeEnc;
 
-typedef struct _CSeqInStreamBuf
-{
-  ISeqInStream funcTable;
-  const Byte *data;
-  SizeT rem;
-} CSeqInStreamBuf;
-
-static SRes MyRead(void *pp, void *data, size_t *size)
-{
-  size_t curSize = *size;
-  CSeqInStreamBuf *p = (CSeqInStreamBuf *)pp;
-  if (p->rem < curSize)
-    curSize = p->rem;
-  memcpy(data, p->data, curSize);
-  p->rem -= curSize;
-  p->data += curSize;
-  *size = curSize;
-  return SZ_OK;
-}
-
 typedef struct
 {
   CLzmaProb *litProbs;
@@ -274,7 +254,7 @@ typedef struct
   UInt32 state;
 } CSaveState;
 
-typedef struct _CLzmaEnc
+typedef struct
 {
   IMatchFinder matchFinder;
   void *matchFinderObj;
@@ -351,8 +331,7 @@ typedef struct _CLzmaEnc
   UInt32 dictSize;
   UInt32 matchFinderCycles;
 
-  ISeqInStream *inStream;
-  CSeqInStreamBuf seqBufInStream;
+  int needInit;
 
   CSaveState saveState;
 } CLzmaEnc;
@@ -1754,11 +1733,10 @@ void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAlloc *alloc, ISzAlloc *allocBig)
 static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, Bool useLimits, UInt32 maxPackSize, UInt32 maxUnpackSize)
 {
   UInt32 nowPos32, startPos32;
-  if (p->inStream != 0)
+  if (p->needInit)
   {
-    p->matchFinderBase.stream = p->inStream;
     p->matchFinder.Init(p->matchFinderObj);
-    p->inStream = 0;
+    p->needInit = 0;
   }
 
   if (p->finished)
@@ -2056,11 +2034,12 @@ static SRes LzmaEnc_AllocAndInit(CLzmaEnc *p, UInt32 keepWindowSize, ISzAlloc *a
   return SZ_OK;
 }
 
-static SRes LzmaEnc_Prepare(CLzmaEncHandle pp, ISeqInStream *inStream, ISeqOutStream *outStream,
+static SRes LzmaEnc_Prepare(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream,
     ISzAlloc *alloc, ISzAlloc *allocBig)
 {
   CLzmaEnc *p = (CLzmaEnc *)pp;
-  p->inStream = inStream;
+  p->matchFinderBase.stream = inStream;
+  p->needInit = 1;
   p->rc.outStream = outStream;
   return LzmaEnc_AllocAndInit(p, 0, alloc, allocBig);
 }
@@ -2070,15 +2049,16 @@ SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp,
     ISzAlloc *alloc, ISzAlloc *allocBig)
 {
   CLzmaEnc *p = (CLzmaEnc *)pp;
-  p->inStream = inStream;
+  p->matchFinderBase.stream = inStream;
+  p->needInit = 1;
   return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
 }
 
 static void LzmaEnc_SetInputBuf(CLzmaEnc *p, const Byte *src, SizeT srcLen)
 {
-  p->seqBufInStream.funcTable.Read = MyRead;
-  p->seqBufInStream.data = src;
-  p->seqBufInStream.rem = srcLen;
+  p->matchFinderBase.directInput = 1;
+  p->matchFinderBase.bufferBase = (Byte *)src;
+  p->matchFinderBase.directInputRem = srcLen;
 }
 
 SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,
@@ -2086,7 +2066,8 @@ SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,
 {
   CLzmaEnc *p = (CLzmaEnc *)pp;
   LzmaEnc_SetInputBuf(p, src, srcLen);
-  p->inStream = &p->seqBufInStream.funcTable;
+  p->needInit = 1;
+
   return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
 }
 
@@ -2101,7 +2082,7 @@ void LzmaEnc_Finish(CLzmaEncHandle pp)
   #endif
 }
 
-typedef struct _CSeqOutStreamBuf
+typedef struct
 {
   ISeqOutStream funcTable;
   Byte *data;
@@ -2170,10 +2151,8 @@ SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, Bool reInit,
   return res;
 }
 
-SRes LzmaEnc_Encode(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress,
-    ISzAlloc *alloc, ISzAlloc *allocBig)
+static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)
 {
-  CLzmaEnc *p = (CLzmaEnc *)pp;
   SRes res = SZ_OK;
 
   #ifdef COMPRESS_MF_MT
@@ -2183,8 +2162,6 @@ SRes LzmaEnc_Encode(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *i
     allocaDummy[i] = (Byte)i;
   #endif
 
-  RINOK(LzmaEnc_Prepare(pp, inStream, outStream, alloc, allocBig));
-
   for (;;)
   {
     res = LzmaEnc_CodeOneBlock(p, False, 0, 0);
@@ -2200,10 +2177,17 @@ SRes LzmaEnc_Encode(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *i
       }
     }
   }
-  LzmaEnc_Finish(pp);
+  LzmaEnc_Finish(p);
   return res;
 }
 
+SRes LzmaEnc_Encode(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress,
+    ISzAlloc *alloc, ISzAlloc *allocBig)
+{
+  RINOK(LzmaEnc_Prepare(pp, outStream, inStream, alloc, allocBig));
+  return LzmaEnc_Encode2((CLzmaEnc *)pp, progress);
+}
+
 SRes LzmaEnc_WriteProperties(CLzmaEncHandle pp, Byte *props, SizeT *size)
 {
   CLzmaEnc *p = (CLzmaEnc *)pp;
@@ -2249,8 +2233,11 @@ SRes LzmaEnc_MemEncode(CLzmaEncHandle pp, Byte *dest, SizeT *destLen, const Byte
   outStream.overflow = False;
 
   p->writeEndMark = writeEndMark;
-  res = LzmaEnc_Encode(pp, &outStream.funcTable, &p->seqBufInStream.funcTable,
-      progress, alloc, allocBig);
+
+  p->rc.outStream = &outStream.funcTable;
+  res = LzmaEnc_MemPrepare(pp, src, srcLen, 0, alloc, allocBig);
+  if (res == SZ_OK)
+    res = LzmaEnc_Encode2(p, progress);
 
   *destLen -= outStream.rem;
   if (outStream.overflow)
diff --git a/C/LzmaEnc.h b/C/LzmaEnc.h
index bfbc7d2b..200d60eb 100755
--- a/C/LzmaEnc.h
+++ b/C/LzmaEnc.h
@@ -1,11 +1,15 @@
 /*  LzmaEnc.h -- LZMA Encoder
-2008-10-04 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
-#ifndef __LZMAENC_H
-#define __LZMAENC_H
+#ifndef __LZMA_ENC_H
+#define __LZMA_ENC_H
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define LZMA_PROPS_SIZE 5
 
 typedef struct _CLzmaEncProps
@@ -69,4 +73,8 @@ 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
+
 #endif
diff --git a/C/LzmaLib.h b/C/LzmaLib.h
index 5c9eeec7..76c99ce7 100755
--- a/C/LzmaLib.h
+++ b/C/LzmaLib.h
@@ -1,20 +1,16 @@
 /* LzmaLib.h -- LZMA library interface
-2008-08-05
-Igor Pavlov
-Public domain */
+2009-04-07 : Igor Pavlov : Public domain */
 
-#ifndef __LZMALIB_H
-#define __LZMALIB_H
+#ifndef __LZMA_LIB_H
+#define __LZMA_LIB_H
 
 #include "Types.h"
 
 #ifdef __cplusplus
-  #define MY_EXTERN_C extern "C"
-#else
-  #define MY_EXTERN_C extern
+extern "C" {
 #endif
 
-#define MY_STDAPI MY_EXTERN_C int MY_STD_CALL
+#define MY_STDAPI int MY_STD_CALL
 
 #define LZMA_PROPS_SIZE 5
 
@@ -132,4 +128,8 @@ Returns:
 MY_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, SizeT *srcLen,
   const unsigned char *props, size_t propsSize);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/LzmaUtil/Lzma86Dec.h b/C/LzmaUtil/Lzma86Dec.h
index f7118219..138ce1ff 100755
--- a/C/LzmaUtil/Lzma86Dec.h
+++ b/C/LzmaUtil/Lzma86Dec.h
@@ -1,13 +1,15 @@
 /* Lzma86Dec.h -- LZMA + x86 (BCJ) Filter Decoder
-2008-08-05
-Igor Pavlov
-Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
-#ifndef __LZMA86DEC_H
-#define __LZMA86DEC_H
+#ifndef __LZMA86_DEC_H
+#define __LZMA86_DEC_H
 
 #include "../Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 Lzma86_GetUnpackSize:
   In:
@@ -42,4 +44,8 @@ Lzma86_Decode:
 
 SRes Lzma86_Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/LzmaUtil/Lzma86Enc.h b/C/LzmaUtil/Lzma86Enc.h
index 10be1cd7..355bf343 100755
--- a/C/LzmaUtil/Lzma86Enc.h
+++ b/C/LzmaUtil/Lzma86Enc.h
@@ -1,13 +1,15 @@
 /* Lzma86Enc.h -- LZMA + x86 (BCJ) Filter Encoder
-2008-08-05
-Igor Pavlov
-Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
-#ifndef __LZMA86ENC_H
-#define __LZMA86ENC_H
+#ifndef __LZMA86_ENC_H
+#define __LZMA86_ENC_H
 
 #include "../Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
 It's an example for LZMA + x86 Filter use.
 You can use .lzma86 extension, if you write that stream to file.
@@ -69,4 +71,8 @@ enum ESzFilterMode
 SRes Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
     int level, UInt32 dictSize, int filterMode);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/MtCoder.c b/C/MtCoder.c
new file mode 100755
index 00000000..57cfe353
--- /dev/null
+++ b/C/MtCoder.c
@@ -0,0 +1,327 @@
+/* MtCoder.c -- Multi-thread Coder
+2009-03-26 : Igor Pavlov : Public domain */
+
+#include <stdio.h>
+
+#include "MtCoder.h"
+
+void LoopThread_Construct(CLoopThread *p)
+{
+  Thread_Construct(&p->thread);
+  Event_Construct(&p->startEvent);
+  Event_Construct(&p->finishedEvent);
+}
+
+void LoopThread_Close(CLoopThread *p)
+{
+  Thread_Close(&p->thread);
+  Event_Close(&p->startEvent);
+  Event_Close(&p->finishedEvent);
+}
+
+static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE LoopThreadFunc(void *pp)
+{
+  CLoopThread *p = (CLoopThread *)pp;
+  for (;;)
+  {
+    if (Event_Wait(&p->startEvent) != 0)
+      return SZ_ERROR_THREAD;
+    if (p->stop)
+      return 0;
+    p->res = p->func(p->param);
+    if (Event_Set(&p->finishedEvent) != 0)
+      return SZ_ERROR_THREAD;
+  }
+}
+
+WRes LoopThread_Create(CLoopThread *p)
+{
+  p->stop = 0;
+  RINOK(AutoResetEvent_CreateNotSignaled(&p->startEvent));
+  RINOK(AutoResetEvent_CreateNotSignaled(&p->finishedEvent));
+  return Thread_Create(&p->thread, LoopThreadFunc, p);
+}
+
+WRes LoopThread_StopAndWait(CLoopThread *p)
+{
+  p->stop = 1;
+  if (Event_Set(&p->startEvent) != 0)
+    return SZ_ERROR_THREAD;
+  return Thread_Wait(&p->thread);
+}
+
+WRes LoopThread_StartSubThread(CLoopThread *p) { return Event_Set(&p->startEvent); }
+WRes LoopThread_WaitSubThread(CLoopThread *p) { return Event_Wait(&p->finishedEvent); }
+
+static SRes Progress(ICompressProgress *p, UInt64 inSize, UInt64 outSize)
+{
+  return (p && p->Progress(p, inSize, outSize) != SZ_OK) ? SZ_ERROR_PROGRESS : SZ_OK;
+}
+
+static void MtProgress_Init(CMtProgress *p, ICompressProgress *progress)
+{
+  unsigned i;
+  for (i = 0; i < NUM_MT_CODER_THREADS_MAX; i++)
+    p->inSizes[i] = p->outSizes[i] = 0;
+  p->totalInSize = p->totalOutSize = 0;
+  p->progress = progress;
+  p->res = SZ_OK;
+}
+
+static void MtProgress_Reinit(CMtProgress *p, unsigned index)
+{
+  p->inSizes[index] = 0;
+  p->outSizes[index] = 0;
+}
+
+#define UPDATE_PROGRESS(size, prev, total) \
+  if (size != (UInt64)(Int64)-1) { total += size - prev; prev = size; }
+
+SRes MtProgress_Set(CMtProgress *p, unsigned index, UInt64 inSize, UInt64 outSize)
+{
+  SRes res;
+  CriticalSection_Enter(&p->cs);
+  UPDATE_PROGRESS(inSize, p->inSizes[index], p->totalInSize)
+  UPDATE_PROGRESS(outSize, p->outSizes[index], p->totalOutSize)
+  if (p->res == SZ_OK)
+    p->res = Progress(p->progress, p->totalInSize, p->totalOutSize);
+  res = p->res;
+  CriticalSection_Leave(&p->cs);
+  return res;
+}
+
+static void MtProgress_SetError(CMtProgress *p, SRes res)
+{
+  CriticalSection_Enter(&p->cs);
+  if (p->res == SZ_OK)
+    p->res = res;
+  CriticalSection_Leave(&p->cs);
+}
+
+static void MtCoder_SetError(CMtCoder* p, SRes res)
+{
+  CriticalSection_Enter(&p->cs);
+  if (p->res == SZ_OK)
+    p->res = res;
+  CriticalSection_Leave(&p->cs);
+}
+
+/* ---------- MtThread ---------- */
+
+void CMtThread_Construct(CMtThread *p, CMtCoder *mtCoder)
+{
+  p->mtCoder = mtCoder;
+  p->outBuf = 0;
+  p->inBuf = 0;
+  Event_Construct(&p->canRead);
+  Event_Construct(&p->canWrite);
+  LoopThread_Construct(&p->thread);
+}
+
+#define RINOK_THREAD(x) { if((x) != 0) return SZ_ERROR_THREAD; }
+
+static void CMtThread_CloseEvents(CMtThread *p)
+{
+  Event_Close(&p->canRead);
+  Event_Close(&p->canWrite);
+}
+
+static void CMtThread_Destruct(CMtThread *p)
+{
+  CMtThread_CloseEvents(p);
+
+  if (Thread_WasCreated(&p->thread.thread))
+  {
+    LoopThread_StopAndWait(&p->thread);
+    LoopThread_Close(&p->thread);
+  }
+
+  if (p->mtCoder->alloc)
+    IAlloc_Free(p->mtCoder->alloc, p->outBuf);
+  p->outBuf = 0;
+
+  if (p->mtCoder->alloc)
+    IAlloc_Free(p->mtCoder->alloc, p->inBuf);
+  p->inBuf = 0;
+}
+
+#define MY_BUF_ALLOC(buf, size, newSize) \
+  if (buf == 0 || size != newSize) \
+  { IAlloc_Free(p->mtCoder->alloc, buf); \
+    size = newSize; buf = IAlloc_Alloc(p->mtCoder->alloc, size); \
+    if (buf == 0) return SZ_ERROR_MEM; }
+
+static SRes CMtThread_Prepare(CMtThread *p)
+{
+  MY_BUF_ALLOC(p->inBuf, p->inBufSize, p->mtCoder->blockSize)
+  MY_BUF_ALLOC(p->outBuf, p->outBufSize, p->mtCoder->destBlockSize)
+
+  p->stopReading = False;
+  p->stopWriting = False;
+  RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->canRead));
+  RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->canWrite));
+
+  return SZ_OK;
+}
+
+static SRes FullRead(ISeqInStream *stream, Byte *data, size_t *processedSize)
+{
+  size_t size = *processedSize;
+  *processedSize = 0;
+  while (size != 0)
+  {
+    size_t curSize = size;
+    SRes res = stream->Read(stream, data, &curSize);
+    *processedSize += curSize;
+    data += curSize;
+    size -= curSize;
+    RINOK(res);
+    if (curSize == 0)
+      return SZ_OK;
+  }
+  return SZ_OK;
+}
+
+#define GET_NEXT_THREAD(p) &p->mtCoder->threads[p->index == p->mtCoder->numThreads  - 1 ? 0 : p->index + 1]
+
+static SRes MtThread_Process(CMtThread *p, Bool *stop)
+{
+  CMtThread *next;
+  *stop = True;
+  if (Event_Wait(&p->canRead) != 0)
+    return SZ_ERROR_THREAD;
+  
+  next = GET_NEXT_THREAD(p);
+  
+  if (p->stopReading)
+  {
+    next->stopReading = True;
+    return Event_Set(&next->canRead) == 0 ? SZ_OK : SZ_ERROR_THREAD;
+  }
+
+  {
+    size_t size = p->mtCoder->blockSize;
+    size_t destSize = p->outBufSize;
+
+    RINOK(FullRead(p->mtCoder->inStream, p->inBuf, &size));
+    next->stopReading = *stop = (size != p->mtCoder->blockSize);
+    if (Event_Set(&next->canRead) != 0)
+      return SZ_ERROR_THREAD;
+
+    RINOK(p->mtCoder->mtCallback->Code(p->mtCoder->mtCallback, p->index,
+        p->outBuf, &destSize, p->inBuf, size, *stop));
+
+    MtProgress_Reinit(&p->mtCoder->mtProgress, p->index);
+
+    if (Event_Wait(&p->canWrite) != 0)
+      return SZ_ERROR_THREAD;
+    if (p->stopWriting)
+      return SZ_ERROR_FAIL;
+    if (p->mtCoder->outStream->Write(p->mtCoder->outStream, p->outBuf, destSize) != destSize)
+      return SZ_ERROR_WRITE;
+    return Event_Set(&next->canWrite) == 0 ? SZ_OK : SZ_ERROR_THREAD;
+  }
+}
+
+static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ThreadFunc(void *pp)
+{
+  CMtThread *p = (CMtThread *)pp;
+  for (;;)
+  {
+    Bool stop;
+    CMtThread *next = GET_NEXT_THREAD(p);
+    SRes res = MtThread_Process(p, &stop);
+    if (res != SZ_OK)
+    {
+      MtCoder_SetError(p->mtCoder, res);
+      MtProgress_SetError(&p->mtCoder->mtProgress, res);
+      next->stopReading = True;
+      next->stopWriting = True;
+      Event_Set(&next->canRead);
+      Event_Set(&next->canWrite);
+      return res;
+    }
+    if (stop)
+      return 0;
+  }
+}
+
+void MtCoder_Construct(CMtCoder* p)
+{
+  unsigned i;
+  p->alloc = 0;
+  for (i = 0; i < NUM_MT_CODER_THREADS_MAX; i++)
+  {
+    CMtThread *t = &p->threads[i];
+    t->index = i;
+    CMtThread_Construct(t, p);
+  }
+  CriticalSection_Init(&p->cs);
+  CriticalSection_Init(&p->mtProgress.cs);
+}
+
+void MtCoder_Destruct(CMtCoder* p)
+{
+  unsigned i;
+  for (i = 0; i < NUM_MT_CODER_THREADS_MAX; i++)
+    CMtThread_Destruct(&p->threads[i]);
+  CriticalSection_Delete(&p->cs);
+  CriticalSection_Delete(&p->mtProgress.cs);
+}
+
+SRes MtCoder_Code(CMtCoder *p)
+{
+  unsigned i, numThreads = p->numThreads;
+  SRes res = SZ_OK;
+  p->res = SZ_OK;
+
+  MtProgress_Init(&p->mtProgress, p->progress);
+
+  for (i = 0; i < numThreads; i++)
+  {
+    RINOK(CMtThread_Prepare(&p->threads[i]));
+  }
+
+  for (i = 0; i < numThreads; i++)
+  {
+    CMtThread *t = &p->threads[i];
+    CLoopThread *lt = &t->thread;
+
+    if (!Thread_WasCreated(&lt->thread))
+    {
+      lt->func = ThreadFunc;
+      lt->param = t;
+
+      if (LoopThread_Create(lt) != SZ_OK)
+      {
+        res = SZ_ERROR_THREAD;
+        break;
+      }
+    }
+  }
+
+  if (res == SZ_OK)
+  {
+    unsigned j;
+    for (i = 0; i < numThreads; i++)
+    {
+      CMtThread *t = &p->threads[i];
+      if (LoopThread_StartSubThread(&t->thread) != SZ_OK || i == 10)
+      {
+        res = SZ_ERROR_THREAD;
+        p->threads[0].stopReading = True;
+        break;
+      }
+    }
+
+    Event_Set(&p->threads[0].canWrite);
+    Event_Set(&p->threads[0].canRead);
+
+    for (j = 0; j < i; j++)
+      LoopThread_WaitSubThread(&p->threads[j].thread);
+  }
+
+  for (i = 0; i < numThreads; i++)
+    CMtThread_CloseEvents(&p->threads[i]);
+  return (res == SZ_OK) ? p->res : res;
+}
diff --git a/C/MtCoder.h b/C/MtCoder.h
new file mode 100755
index 00000000..fb813d4d
--- /dev/null
+++ b/C/MtCoder.h
@@ -0,0 +1,102 @@
+/* MtCoder.h -- Multi-thread Coder
+2009-03-26 : Igor Pavlov : Public domain */
+
+#ifndef __MT_CODER_H
+#define __MT_CODER_H
+
+#include "Threads.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct
+{
+  CThread thread;
+  CAutoResetEvent startEvent;
+  CAutoResetEvent finishedEvent;
+  int stop;
+  
+  THREAD_FUNC_TYPE func;
+  LPVOID param;
+  THREAD_FUNC_RET_TYPE res;
+} CLoopThread;
+
+void LoopThread_Construct(CLoopThread *p);
+void LoopThread_Close(CLoopThread *p);
+WRes LoopThread_Create(CLoopThread *p);
+WRes LoopThread_StopAndWait(CLoopThread *p);
+WRes LoopThread_StartSubThread(CLoopThread *p);
+WRes LoopThread_WaitSubThread(CLoopThread *p);
+
+#ifdef COMPRESS_MT
+#define NUM_MT_CODER_THREADS_MAX 32
+#else
+#define NUM_MT_CODER_THREADS_MAX 1
+#endif
+
+typedef struct
+{
+  UInt64 totalInSize;
+  UInt64 totalOutSize;
+  ICompressProgress *progress;
+  SRes res;
+  CCriticalSection cs;
+  UInt64 inSizes[NUM_MT_CODER_THREADS_MAX];
+  UInt64 outSizes[NUM_MT_CODER_THREADS_MAX];
+} CMtProgress;
+
+SRes MtProgress_Set(CMtProgress *p, unsigned index, UInt64 inSize, UInt64 outSize);
+
+struct _CMtCoder;
+
+typedef struct
+{
+  struct _CMtCoder *mtCoder;
+  Byte *outBuf;
+  size_t outBufSize;
+  Byte *inBuf;
+  size_t inBufSize;
+  unsigned index;
+  CLoopThread thread;
+
+  Bool stopReading;
+  Bool stopWriting;
+  CAutoResetEvent canRead;
+  CAutoResetEvent canWrite;
+} CMtThread;
+
+typedef struct
+{
+  SRes (*Code)(void *p, unsigned index, Byte *dest, size_t *destSize,
+      const Byte *src, size_t srcSize, int finished);
+} IMtCoderCallback;
+
+typedef struct _CMtCoder
+{
+  size_t blockSize;
+  size_t destBlockSize;
+  unsigned numThreads;
+  
+  ISeqInStream *inStream;
+  ISeqOutStream *outStream;
+  ICompressProgress *progress;
+  ISzAlloc *alloc;
+
+  IMtCoderCallback *mtCallback;
+  CCriticalSection cs;
+  SRes res;
+
+  CMtProgress mtProgress;
+  CMtThread threads[NUM_MT_CODER_THREADS_MAX];
+} CMtCoder;
+
+void MtCoder_Construct(CMtCoder* p);
+void MtCoder_Destruct(CMtCoder* p);
+SRes MtCoder_Code(CMtCoder *p);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/C/RotateDefs.h b/C/RotateDefs.h
index 95d9646b..c3a1385c 100755
--- a/C/RotateDefs.h
+++ b/C/RotateDefs.h
@@ -1,10 +1,8 @@
 /* RotateDefs.h -- Rotate functions
-2008-08-05
-Igor Pavlov
-Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
-#ifndef __ROTATEDEFS_H
-#define __ROTATEDEFS_H
+#ifndef __ROTATE_DEFS_H
+#define __ROTATE_DEFS_H
 
 #ifdef _MSC_VER
 
diff --git a/C/Sha256.h b/C/Sha256.h
index ff8c167c..0224105d 100755
--- a/C/Sha256.h
+++ b/C/Sha256.h
@@ -1,11 +1,15 @@
-/* Crypto/Sha256.h -- SHA-256 Hash function
-2008-10-04 : Igor Pavlov : Public domain */
+/* Sha256.h -- SHA-256 Hash
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __CRYPTO_SHA256_H
 #define __CRYPTO_SHA256_H
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define SHA256_DIGEST_SIZE 32
 
 typedef struct
@@ -19,4 +23,8 @@ void Sha256_Init(CSha256 *p);
 void Sha256_Update(CSha256 *p, const Byte *data, size_t size);
 void Sha256_Final(CSha256 *p, Byte *digest);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Sort.h b/C/Sort.h
index 37242749..65dfc6f6 100755
--- a/C/Sort.h
+++ b/C/Sort.h
@@ -1,14 +1,20 @@
 /* Sort.h -- Sort functions
-2008-03-19
-Igor Pavlov
-Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_SORT_H
 #define __7Z_SORT_H
 
 #include "Types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 void HeapSort(UInt32 *p, UInt32 size);
 /* void HeapSortRef(UInt32 *p, UInt32 *vals, UInt32 size); */
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Threads.c b/C/Threads.c
index 4fdd69b0..562b3484 100755
--- a/C/Threads.c
+++ b/C/Threads.c
@@ -1,11 +1,10 @@
 /* Threads.c -- multithreading library
-2008-08-05
-Igor Pavlov
-Public domain */
+2009-03-27 : Igor Pavlov : Public domain */
 
-#include "Threads.h"
 #include <process.h>
 
+#include "Threads.h"
+
 static WRes GetError()
 {
   DWORD res = GetLastError();
@@ -15,85 +14,53 @@ static WRes GetError()
 WRes HandleToWRes(HANDLE h) { return (h != 0) ? 0 : GetError(); }
 WRes BOOLToWRes(BOOL v) { return v ? 0 : GetError(); }
 
-static WRes MyCloseHandle(HANDLE *h)
+WRes HandlePtr_Close(HANDLE *p)
 {
-  if (*h != NULL)
-    if (!CloseHandle(*h))
+  if (*p != NULL)
+    if (!CloseHandle(*p))
       return GetError();
-  *h = NULL;
+  *p = NULL;
   return 0;
 }
 
-WRes Thread_Create(CThread *thread, THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE *startAddress)(void *), LPVOID parameter)
+WRes Handle_WaitObject(HANDLE h) { return (WRes)WaitForSingleObject(h, INFINITE); }
+
+WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param)
 {
   unsigned threadId; /* Windows Me/98/95: threadId parameter may not be NULL in _beginthreadex/CreateThread functions */
-  thread->handle =
-    /* CreateThread(0, 0, startAddress, parameter, 0, &threadId); */
-    (HANDLE)_beginthreadex(NULL, 0, startAddress, parameter, 0, &threadId);
+  *p =
+    /* CreateThread(0, 0, startAddress, param, 0, &threadId); */
+    (HANDLE)_beginthreadex(NULL, 0, func, param, 0, &threadId);
     /* maybe we must use errno here, but probably GetLastError() is also OK. */
-  return HandleToWRes(thread->handle);
-}
-
-WRes WaitObject(HANDLE h)
-{
-  return (WRes)WaitForSingleObject(h, INFINITE);
-}
-
-WRes Thread_Wait(CThread *thread)
-{
-  if (thread->handle == NULL)
-    return 1;
-  return WaitObject(thread->handle);
-}
-
-WRes Thread_Close(CThread *thread)
-{
-  return MyCloseHandle(&thread->handle);
+  return HandleToWRes(*p);
 }
 
-WRes Event_Create(CEvent *p, BOOL manualReset, int initialSignaled)
+WRes Event_Create(CEvent *p, BOOL manualReset, int signaled)
 {
-  p->handle = CreateEvent(NULL, manualReset, (initialSignaled ? TRUE : FALSE), NULL);
-  return HandleToWRes(p->handle);
+  *p = CreateEvent(NULL, manualReset, (signaled ? TRUE : FALSE), NULL);
+  return HandleToWRes(*p);
 }
 
-WRes ManualResetEvent_Create(CManualResetEvent *p, int initialSignaled)
-  { return Event_Create(p, TRUE, initialSignaled); }
-WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p)
-  { return ManualResetEvent_Create(p, 0); }
-
-WRes AutoResetEvent_Create(CAutoResetEvent *p, int initialSignaled)
-  { return Event_Create(p, FALSE, initialSignaled); }
-WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p)
-  { return AutoResetEvent_Create(p, 0); }
+WRes Event_Set(CEvent *p) { return BOOLToWRes(SetEvent(*p)); }
+WRes Event_Reset(CEvent *p) { return BOOLToWRes(ResetEvent(*p)); }
 
-WRes Event_Set(CEvent *p) { return BOOLToWRes(SetEvent(p->handle)); }
-WRes Event_Reset(CEvent *p) { return BOOLToWRes(ResetEvent(p->handle)); }
-WRes Event_Wait(CEvent *p) { return WaitObject(p->handle); }
-WRes Event_Close(CEvent *p) { return MyCloseHandle(&p->handle); }
+WRes ManualResetEvent_Create(CManualResetEvent *p, int signaled) { return Event_Create(p, TRUE, signaled); }
+WRes AutoResetEvent_Create(CAutoResetEvent *p, int signaled) { return Event_Create(p, FALSE, signaled); }
+WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p) { return ManualResetEvent_Create(p, 0); }
+WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p) { return AutoResetEvent_Create(p, 0); }
 
 
-WRes Semaphore_Create(CSemaphore *p, UInt32 initiallyCount, UInt32 maxCount)
+WRes Semaphore_Create(CSemaphore *p, UInt32 initCount, UInt32 maxCount)
 {
-  p->handle = CreateSemaphore(NULL, (LONG)initiallyCount, (LONG)maxCount, NULL);
-  return HandleToWRes(p->handle);
+  *p = CreateSemaphore(NULL, (LONG)initCount, (LONG)maxCount, NULL);
+  return HandleToWRes(*p);
 }
 
-WRes Semaphore_Release(CSemaphore *p, LONG releaseCount, LONG *previousCount)
-{
-  return BOOLToWRes(ReleaseSemaphore(p->handle, releaseCount, previousCount));
-}
-WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 releaseCount)
-{
-  return Semaphore_Release(p, (LONG)releaseCount, NULL);
-}
-WRes Semaphore_Release1(CSemaphore *p)
-{
-  return Semaphore_ReleaseN(p, 1);
-}
-
-WRes Semaphore_Wait(CSemaphore *p) { return WaitObject(p->handle); }
-WRes Semaphore_Close(CSemaphore *p) { return MyCloseHandle(&p->handle); }
+static WRes Semaphore_Release(CSemaphore *p, LONG releaseCount, LONG *previousCount)
+  { return BOOLToWRes(ReleaseSemaphore(*p, releaseCount, previousCount)); }
+WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 num)
+  { return Semaphore_Release(p, (LONG)num, NULL); }
+WRes Semaphore_Release1(CSemaphore *p) { return Semaphore_ReleaseN(p, 1); }
 
 WRes CriticalSection_Init(CCriticalSection *p)
 {
@@ -106,4 +73,3 @@ WRes CriticalSection_Init(CCriticalSection *p)
   __except (EXCEPTION_EXECUTE_HANDLER) { return 1; }
   return 0;
 }
-
diff --git a/C/Threads.h b/C/Threads.h
index a823e578..d0ddd80e 100755
--- a/C/Threads.h
+++ b/C/Threads.h
@@ -1,68 +1,59 @@
 /* Threads.h -- multithreading library
-2008-11-22 : Igor Pavlov : Public domain */
+2009-03-27 : Igor Pavlov : Public domain */
 
-#ifndef __7Z_THRESDS_H
-#define __7Z_THRESDS_H
+#ifndef __7Z_THREADS_H
+#define __7Z_THREADS_H
 
 #include "Types.h"
 
-typedef struct _CThread
-{
-  HANDLE handle;
-} CThread;
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+WRes HandlePtr_Close(HANDLE *h);
+WRes Handle_WaitObject(HANDLE h);
 
-#define Thread_Construct(thread) (thread)->handle = NULL
-#define Thread_WasCreated(thread) ((thread)->handle != NULL)
- 
+typedef HANDLE CThread;
+#define Thread_Construct(p) *(p) = NULL
+#define Thread_WasCreated(p) (*(p) != NULL)
+#define Thread_Close(p) HandlePtr_Close(p)
+#define Thread_Wait(p) Handle_WaitObject(*(p))
 typedef unsigned THREAD_FUNC_RET_TYPE;
 #define THREAD_FUNC_CALL_TYPE MY_STD_CALL
 #define THREAD_FUNC_DECL THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE
+typedef THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE * THREAD_FUNC_TYPE)(void *);
+WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param);
 
-WRes Thread_Create(CThread *thread, THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE *startAddress)(void *), LPVOID parameter);
-WRes Thread_Wait(CThread *thread);
-WRes Thread_Close(CThread *thread);
-
-typedef struct _CEvent
-{
-  HANDLE handle;
-} CEvent;
-
+typedef HANDLE CEvent;
 typedef CEvent CAutoResetEvent;
 typedef CEvent CManualResetEvent;
-
-#define Event_Construct(event) (event)->handle = NULL
-#define Event_IsCreated(event) ((event)->handle != NULL)
-
-WRes ManualResetEvent_Create(CManualResetEvent *event, int initialSignaled);
-WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *event);
-WRes AutoResetEvent_Create(CAutoResetEvent *event, int initialSignaled);
-WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *event);
-WRes Event_Set(CEvent *event);
-WRes Event_Reset(CEvent *event);
-WRes Event_Wait(CEvent *event);
-WRes Event_Close(CEvent *event);
-
-
-typedef struct _CSemaphore
-{
-  HANDLE handle;
-} CSemaphore;
-
-#define Semaphore_Construct(p) (p)->handle = NULL
-
-WRes Semaphore_Create(CSemaphore *p, UInt32 initiallyCount, UInt32 maxCount);
+#define Event_Construct(p) *(p) = NULL
+#define Event_IsCreated(p) (*(p) != NULL)
+#define Event_Close(p) HandlePtr_Close(p)
+#define Event_Wait(p) Handle_WaitObject(*(p))
+WRes Event_Set(CEvent *p);
+WRes Event_Reset(CEvent *p);
+WRes ManualResetEvent_Create(CManualResetEvent *p, int signaled);
+WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p);
+WRes AutoResetEvent_Create(CAutoResetEvent *p, int signaled);
+WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p);
+
+typedef HANDLE CSemaphore;
+#define Semaphore_Construct(p) (*p) = NULL
+#define Semaphore_Close(p) HandlePtr_Close(p)
+#define Semaphore_Wait(p) Handle_WaitObject(*(p))
+WRes Semaphore_Create(CSemaphore *p, UInt32 initCount, UInt32 maxCount);
 WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 num);
 WRes Semaphore_Release1(CSemaphore *p);
-WRes Semaphore_Wait(CSemaphore *p);
-WRes Semaphore_Close(CSemaphore *p);
-
 
 typedef CRITICAL_SECTION CCriticalSection;
-
 WRes CriticalSection_Init(CCriticalSection *p);
 #define CriticalSection_Delete(p) DeleteCriticalSection(p)
 #define CriticalSection_Enter(p) EnterCriticalSection(p)
 #define CriticalSection_Leave(p) LeaveCriticalSection(p)
 
+#ifdef __cplusplus
+}
 #endif
 
+#endif
diff --git a/C/Types.h b/C/Types.h
index 1af5cfc4..9af877ff 100755
--- a/C/Types.h
+++ b/C/Types.h
@@ -1,5 +1,5 @@
 /* Types.h -- Basic types
-2008-11-23 : Igor Pavlov : Public domain */
+2009-02-07 : Igor Pavlov : Public domain */
 
 #ifndef __7Z_TYPES_H
 #define __7Z_TYPES_H
@@ -10,6 +10,10 @@
 #include <windows.h>
 #endif
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define SZ_OK 0
 
 #define SZ_ERROR_DATA 1
@@ -205,4 +209,8 @@ typedef struct
 #define IAlloc_Alloc(p, size) (p)->Alloc((p), size)
 #define IAlloc_Free(p, a) (p)->Free((p), a)
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif
diff --git a/C/Xz.c b/C/Xz.c
new file mode 100755
index 00000000..18caba2c
--- /dev/null
+++ b/C/Xz.c
@@ -0,0 +1,88 @@
+/* Xz.c - Xz
+2009-04-15 : Igor Pavlov : Public domain */
+
+#include "7zCrc.h"
+#include "CpuArch.h"
+#include "Xz.h"
+#include "XzCrc64.h"
+
+Byte XZ_SIG[XZ_SIG_SIZE] = { 0xFD, '7', 'z', 'X', 'Z', 0 };
+Byte XZ_FOOTER_SIG[XZ_FOOTER_SIG_SIZE] = { 'Y', 'Z' };
+
+unsigned Xz_WriteVarInt(Byte *buf, UInt64 v)
+{
+  unsigned i = 0;
+  do
+  {
+    buf[i++] = (Byte)((v & 0x7F) | 0x80);
+    v >>= 7;
+  }
+  while (v != 0);
+  buf[i - 1] &= 0x7F;
+  return i;
+}
+
+void Xz_Construct(CXzStream *p)
+{
+  p->numBlocks = p->numBlocksAllocated = 0;
+  p->blocks = 0;
+  p->flags = 0;
+}
+
+void Xz_Free(CXzStream *p, ISzAlloc *alloc)
+{
+  alloc->Free(alloc, p->blocks);
+  p->numBlocks = p->numBlocksAllocated = 0;
+  p->blocks = 0;
+}
+
+unsigned XzFlags_GetCheckSize(CXzStreamFlags f)
+{
+  int t = XzFlags_GetCheckType(f);
+  return (t == 0) ? 0 : (4 << ((t - 1) / 3));
+}
+
+void XzCheck_Init(CXzCheck *p, int mode)
+{
+  p->mode = mode;
+  switch (mode)
+  {
+    case XZ_CHECK_CRC32: p->crc = CRC_INIT_VAL; break;
+    case XZ_CHECK_CRC64: p->crc64 = CRC64_INIT_VAL; break;
+    case XZ_CHECK_SHA256: Sha256_Init(&p->sha); break;
+  }
+}
+
+void XzCheck_Update(CXzCheck *p, const void *data, size_t size)
+{
+  switch (p->mode)
+  {
+    case XZ_CHECK_CRC32: p->crc = CrcUpdate(p->crc, data, size); break;
+    case XZ_CHECK_CRC64: p->crc64 = Crc64Update(p->crc64, data, size); break;
+    case XZ_CHECK_SHA256: Sha256_Update(&p->sha, (const Byte *)data, size); break;
+  }
+}
+
+int XzCheck_Final(CXzCheck *p, Byte *digest)
+{
+  switch (p->mode)
+  {
+    case XZ_CHECK_CRC32:
+      SetUi32(digest, CRC_GET_DIGEST(p->crc));
+      break;
+    case XZ_CHECK_CRC64:
+    {
+      int i;
+      UInt64 v = CRC64_GET_DIGEST(p->crc64);
+      for (i = 0; i < 8; i++, v >>= 8)
+        digest[i] = (Byte)(v & 0xFF);
+      break;
+    }
+    case XZ_CHECK_SHA256:
+      Sha256_Final(&p->sha, digest);
+      break;
+    default:
+      return 0;
+  }
+  return 1;
+}
diff --git a/C/Xz.h b/C/Xz.h
new file mode 100755
index 00000000..65c44d26
--- /dev/null
+++ b/C/Xz.h
@@ -0,0 +1,256 @@
+/* Xz.h - Xz interface
+2009-04-15 : Igor Pavlov : Public domain */
+
+#ifndef __XZ_H
+#define __XZ_H
+
+#include "Sha256.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XZ_ID_Subblock 1
+#define XZ_ID_Delta 3
+#define XZ_ID_X86 4
+#define XZ_ID_PPC 5
+#define XZ_ID_IA64 6
+#define XZ_ID_ARM 7
+#define XZ_ID_ARMT 8
+#define XZ_ID_SPARC 9
+#define XZ_ID_LZMA2 0x21
+
+unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value);
+unsigned Xz_WriteVarInt(Byte *buf, UInt64 v);
+
+/* ---------- xz block ---------- */
+
+#define XZ_BLOCK_HEADER_SIZE_MAX 1024
+
+#define XZ_NUM_FILTERS_MAX 4
+#define XZ_BF_NUM_FILTERS_MASK 3
+#define XZ_BF_PACK_SIZE (1 << 6)
+#define XZ_BF_UNPACK_SIZE (1 << 7)
+
+#define XZ_FILTER_PROPS_SIZE_MAX 20
+
+typedef struct
+{
+  UInt64 id;
+  UInt32 propsSize;
+  Byte props[XZ_FILTER_PROPS_SIZE_MAX];
+} CXzFilter;
+
+typedef struct
+{
+  UInt64 packSize;
+  UInt64 unpackSize;
+  Byte flags;
+  CXzFilter filters[XZ_NUM_FILTERS_MAX];
+} CXzBlock;
+
+#define XzBlock_GetNumFilters(p) (((p)->flags & XZ_BF_NUM_FILTERS_MASK) + 1)
+#define XzBlock_HasPackSize(p)   (((p)->flags & XZ_BF_PACK_SIZE) != 0)
+#define XzBlock_HasUnpackSize(p) (((p)->flags & XZ_BF_UNPACK_SIZE) != 0)
+
+SRes XzBlock_Parse(CXzBlock *p, const Byte *header);
+SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStream *inStream, Bool *isIndex, UInt32 *headerSizeRes);
+
+/* ---------- xz stream ---------- */
+
+#define XZ_SIG_SIZE 6
+#define XZ_FOOTER_SIG_SIZE 2
+
+extern Byte XZ_SIG[XZ_SIG_SIZE];
+extern Byte XZ_FOOTER_SIG[XZ_FOOTER_SIG_SIZE];
+
+#define XZ_STREAM_FLAGS_SIZE 2
+#define XZ_STREAM_CRC_SIZE 4
+
+#define XZ_STREAM_HEADER_SIZE (XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE + XZ_STREAM_CRC_SIZE)
+#define XZ_STREAM_FOOTER_SIZE (XZ_FOOTER_SIG_SIZE + XZ_STREAM_FLAGS_SIZE + XZ_STREAM_CRC_SIZE + 4)
+
+#define XZ_CHECK_MASK 0xF
+#define XZ_CHECK_NO 0
+#define XZ_CHECK_CRC32 1
+#define XZ_CHECK_CRC64 4
+#define XZ_CHECK_SHA256 10
+
+typedef struct
+{
+  int mode;
+  UInt32 crc;
+  UInt64 crc64;
+  CSha256 sha;
+} CXzCheck;
+
+void XzCheck_Init(CXzCheck *p, int mode);
+void XzCheck_Update(CXzCheck *p, const void *data, size_t size);
+int XzCheck_Final(CXzCheck *p, Byte *digest);
+
+typedef UInt16 CXzStreamFlags;
+
+#define XzFlags_IsSupported(f) ((f) <= XZ_CHECK_MASK)
+#define XzFlags_GetCheckType(f) ((f) & XZ_CHECK_MASK)
+#define XzFlags_HasDataCrc32(f) (Xz_GetCheckType(f) == XZ_CHECK_CRC32)
+unsigned XzFlags_GetCheckSize(CXzStreamFlags f);
+
+SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf);
+SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStream *inStream);
+
+typedef struct
+{
+  UInt64 unpackSize;
+  UInt64 totalSize;
+} CXzBlockSizes;
+
+typedef struct
+{
+  CXzStreamFlags flags;
+  size_t numBlocks;
+  size_t numBlocksAllocated;
+  CXzBlockSizes *blocks;
+  UInt64 startOffset;
+} CXzStream;
+
+void Xz_Construct(CXzStream *p);
+void Xz_Free(CXzStream *p, ISzAlloc *alloc);
+
+#define XZ_SIZE_OVERFLOW ((UInt64)(Int64)-1)
+
+UInt64 Xz_GetUnpackSize(const CXzStream *p);
+UInt64 Xz_GetPackSize(const CXzStream *p);
+
+typedef struct
+{
+  size_t num;
+  size_t numAllocated;
+  CXzStream *streams;
+} CXzs;
+
+void Xzs_Construct(CXzs *p);
+void Xzs_Free(CXzs *p, ISzAlloc *alloc);
+SRes Xzs_ReadBackward(CXzs *p, ILookInStream *inStream, Int64 *startOffset, ICompressProgress *progress, ISzAlloc *alloc);
+
+UInt64 Xzs_GetNumBlocks(const CXzs *p);
+UInt64 Xzs_GetUnpackSize(const CXzs *p);
+
+typedef enum
+{
+  CODER_STATUS_NOT_SPECIFIED,               /* use main error code instead */
+  CODER_STATUS_FINISHED_WITH_MARK,          /* stream was finished with end mark. */
+  CODER_STATUS_NOT_FINISHED,                /* stream was not finished */
+  CODER_STATUS_NEEDS_MORE_INPUT,            /* you must provide more input bytes */
+} ECoderStatus;
+
+typedef enum
+{
+  CODER_FINISH_ANY,   /* finish at any point */
+  CODER_FINISH_END    /* block must be finished at the end */
+} ECoderFinishMode;
+
+typedef struct _IStateCoder
+{
+  void *p;
+  void (*Free)(void *p, ISzAlloc *alloc);
+  SRes (*SetProps)(void *p, const Byte *props, size_t propSize, ISzAlloc *alloc);
+  void (*Init)(void *p);
+  SRes (*Code)(void *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
+      int srcWasFinished, ECoderFinishMode finishMode, int *wasFinished);
+} IStateCoder;
+
+#define MIXCODER_NUM_FILTERS_MAX 4
+
+typedef struct
+{
+  ISzAlloc *alloc;
+  Byte *buf;
+  int numCoders;
+  int finished[MIXCODER_NUM_FILTERS_MAX - 1];
+  size_t pos[MIXCODER_NUM_FILTERS_MAX - 1];
+  size_t size[MIXCODER_NUM_FILTERS_MAX - 1];
+  UInt64 ids[MIXCODER_NUM_FILTERS_MAX];
+  IStateCoder coders[MIXCODER_NUM_FILTERS_MAX];
+} CMixCoder;
+
+void MixCoder_Construct(CMixCoder *p, ISzAlloc *alloc);
+void MixCoder_Free(CMixCoder *p);
+void MixCoder_Init(CMixCoder *p);
+SRes MixCoder_SetFromMethod(CMixCoder *p, int coderIndex, UInt64 methodId);
+SRes MixCoder_Code(CMixCoder *p, Byte *dest, SizeT *destLen,
+    const Byte *src, SizeT *srcLen, int srcWasFinished,
+    ECoderFinishMode finishMode, ECoderStatus *status);
+
+typedef enum
+{
+  XZ_STATE_STREAM_HEADER,
+  XZ_STATE_STREAM_INDEX,
+  XZ_STATE_STREAM_INDEX_CRC,
+  XZ_STATE_STREAM_FOOTER,
+  XZ_STATE_STREAM_PADDING,
+  XZ_STATE_BLOCK_HEADER,
+  XZ_STATE_BLOCK,
+  XZ_STATE_BLOCK_FOOTER
+} EXzState;
+
+typedef struct
+{
+  EXzState state;
+  UInt32 pos;
+  unsigned alignPos;
+  unsigned indexPreSize;
+
+  CXzStreamFlags streamFlags;
+  
+  UInt32 blockHeaderSize;
+  UInt64 packSize;
+  UInt64 unpackSize;
+
+  UInt64 numBlocks;
+  UInt64 indexSize;
+  UInt64 indexPos;
+  UInt64 padSize;
+
+  UInt64 numStreams;
+
+  UInt32 crc;
+  CMixCoder decoder;
+  CXzBlock block;
+  CXzCheck check;
+  CSha256 sha;
+  Byte shaDigest[SHA256_DIGEST_SIZE];
+  Byte buf[XZ_BLOCK_HEADER_SIZE_MAX];
+} CXzUnpacker;
+
+SRes XzUnpacker_Create(CXzUnpacker *p, ISzAlloc *alloc);
+void XzUnpacker_Free(CXzUnpacker *p);
+
+/*
+finishMode:
+  It has meaning only if the decoding reaches output limit (*destLen).
+  LZMA_FINISH_ANY - use smallest number of input bytes
+  LZMA_FINISH_END - read EndOfStream marker after decoding
+
+Returns:
+  SZ_OK
+    status:
+      LZMA_STATUS_FINISHED_WITH_MARK
+      LZMA_STATUS_NOT_FINISHED
+  SZ_ERROR_DATA - Data error
+  SZ_ERROR_MEM  - Memory allocation error
+  SZ_ERROR_UNSUPPORTED - Unsupported properties
+  SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
+*/
+
+
+SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
+    const Byte *src, SizeT *srcLen, /* int srcWasFinished, */ int finishMode,
+    ECoderStatus *status);
+
+Bool XzUnpacker_IsStreamWasFinished(CXzUnpacker *p);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/C/XzCrc64.c b/C/XzCrc64.c
new file mode 100755
index 00000000..52952ebe
--- /dev/null
+++ b/C/XzCrc64.c
@@ -0,0 +1,33 @@
+/* XzCrc64.c -- CRC64 calculation
+2009-04-15 : Igor Pavlov : Public domain */
+
+#include "XzCrc64.h"
+
+#define kCrc64Poly 0xC96C5795D7870F42
+UInt64 g_Crc64Table[256];
+
+void MY_FAST_CALL Crc64GenerateTable(void)
+{
+  UInt32 i;
+  for (i = 0; i < 256; i++)
+  {
+    UInt64 r = i;
+    int j;
+    for (j = 0; j < 8; j++)
+      r = (r >> 1) ^ ((UInt64)kCrc64Poly & ~((r & 1) - 1));
+    g_Crc64Table[i] = r;
+  }
+}
+
+UInt64 MY_FAST_CALL Crc64Update(UInt64 v, const void *data, size_t size)
+{
+  const Byte *p = (const Byte *)data;
+  for (; size > 0 ; size--, p++)
+    v = CRC64_UPDATE_BYTE(v, *p);
+  return v;
+}
+
+UInt64 MY_FAST_CALL Crc64Calc(const void *data, size_t size)
+{
+  return CRC64_GET_DIGEST(Crc64Update(CRC64_INIT_VAL, data, size));
+}
diff --git a/C/XzCrc64.h b/C/XzCrc64.h
new file mode 100755
index 00000000..37a67dc2
--- /dev/null
+++ b/C/XzCrc64.h
@@ -0,0 +1,30 @@
+/* XzCrc64.c -- CRC64 calculation
+2009-04-15 : Igor Pavlov : Public domain */
+
+#ifndef __XZ_CRC64_H
+#define __XZ_CRC64_H
+
+#include <stddef.h>
+
+#include "Types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern UInt64 g_Crc64Table[];
+
+void MY_FAST_CALL Crc64GenerateTable(void);
+
+#define CRC64_INIT_VAL 0xFFFFFFFFFFFFFFFF
+#define CRC64_GET_DIGEST(crc) ((crc) ^ 0xFFFFFFFFFFFFFFFF)
+#define CRC64_UPDATE_BYTE(crc, b) (g_Crc64Table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
+
+UInt64 MY_FAST_CALL Crc64Update(UInt64 crc, const void *data, size_t size);
+UInt64 MY_FAST_CALL Crc64Calc(const void *data, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/C/XzDec.c b/C/XzDec.c
new file mode 100755
index 00000000..8ae234d0
--- /dev/null
+++ b/C/XzDec.c
@@ -0,0 +1,872 @@
+/* XzDec.c -- Xz Decode
+2009-05-29 : Igor Pavlov : Public domain */
+
+/* #define XZ_DUMP */
+
+#ifdef XZ_DUMP
+#include <stdio.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "7zCrc.h"
+#include "Alloc.h"
+#include "Bra.h"
+#include "CpuArch.h"
+#include "Delta.h"
+#include "Lzma2Dec.h"
+
+#ifdef USE_SUBBLOCK
+#include "SbDec.h"
+#endif
+
+#include "Xz.h"
+
+#define XZ_CHECK_SIZE_MAX 64
+
+#define CODER_BUF_SIZE (1 << 17)
+
+unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value)
+{
+  int i, limit;
+  *value = 0;
+  limit = (maxSize > 9) ? 9 : (int)maxSize;
+
+  for (i = 0; i < limit;)
+  {
+    Byte b = p[i];
+    *value |= (UInt64)(b & 0x7F) << (7 * i++);
+    if ((b & 0x80) == 0)
+      return (b == 0 && i != 1) ? 0 : i;
+  }
+  return 0;
+}
+
+/* ---------- BraState ---------- */
+
+#define BRA_BUF_SIZE (1 << 14)
+
+typedef struct
+{
+  size_t bufPos;
+  size_t bufConv;
+  size_t bufTotal;
+
+  UInt32 methodId;
+  int encodeMode;
+  UInt32 delta;
+  UInt32 ip;
+  UInt32 x86State;
+  Byte deltaState[DELTA_STATE_SIZE];
+
+  Byte buf[BRA_BUF_SIZE];
+} CBraState;
+
+void BraState_Free(void *pp, ISzAlloc *alloc)
+{
+  alloc->Free(alloc, pp);
+}
+
+SRes BraState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAlloc *alloc)
+{
+  CBraState *p = ((CBraState *)pp);
+  alloc = alloc;
+  p->encodeMode = 0;
+  p->ip = 0;
+  if (p->methodId == XZ_ID_Delta)
+  {
+    if (propSize != 1)
+      return SZ_ERROR_UNSUPPORTED;
+    p->delta = (unsigned)props[0] + 1;
+  }
+  else
+  {
+    if (propSize == 4)
+    {
+      UInt32 v = GetUi32(props);
+      switch(p->methodId)
+      {
+        case XZ_ID_PPC:
+        case XZ_ID_ARM:
+        case XZ_ID_SPARC:
+          if ((v & 3) != 0)
+            return SZ_ERROR_UNSUPPORTED;
+          break;
+        case XZ_ID_ARMT:
+          if ((v & 1) != 0)
+            return SZ_ERROR_UNSUPPORTED;
+          break;
+        case XZ_ID_IA64:
+          if ((v & 0xF) != 0)
+            return SZ_ERROR_UNSUPPORTED;
+          break;
+      }
+      p->ip = v;
+    }
+    else if (propSize != 0)
+      return SZ_ERROR_UNSUPPORTED;
+  }
+  return SZ_OK;
+}
+
+void BraState_Init(void *pp)
+{
+  CBraState *p = ((CBraState *)pp);
+  p->bufPos = p->bufConv = p->bufTotal = 0;
+  x86_Convert_Init(p->x86State);
+  if (p->methodId == XZ_ID_Delta)
+    Delta_Init(p->deltaState);
+}
+
+#define CASE_BRA_CONV(isa) case XZ_ID_ ## isa: p->bufConv = isa ## _Convert(p->buf, p->bufTotal, p->ip, p->encodeMode); break;
+
+static SRes BraState_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
+    int srcWasFinished, ECoderFinishMode finishMode, int *wasFinished)
+{
+  CBraState *p = ((CBraState *)pp);
+  SizeT destLenOrig = *destLen;
+  SizeT srcLenOrig = *srcLen;
+  *destLen = 0;
+  *srcLen = 0;
+  finishMode = finishMode;
+  *wasFinished = 0;
+  while (destLenOrig > 0)
+  {
+    if (p->bufPos != p->bufConv)
+    {
+      size_t curSize = p->bufConv - p->bufPos;
+      if (curSize > destLenOrig)
+        curSize = destLenOrig;
+      memcpy(dest, p->buf + p->bufPos, curSize);
+      p->bufPos += curSize;
+      *destLen += curSize;
+      dest += curSize;
+      destLenOrig -= curSize;
+      continue;
+    }
+    p->bufTotal -= p->bufPos;
+    memmove(p->buf, p->buf + p->bufPos, p->bufTotal);
+    p->bufPos = 0;
+    p->bufConv = 0;
+    {
+      size_t curSize = BRA_BUF_SIZE - p->bufTotal;
+      if (curSize > srcLenOrig)
+        curSize = srcLenOrig;
+      memcpy(p->buf + p->bufTotal, src, curSize);
+      *srcLen += curSize;
+      src += curSize;
+      srcLenOrig -= curSize;
+      p->bufTotal += curSize;
+    }
+    if (p->bufTotal == 0)
+      break;
+    switch(p->methodId)
+    {
+      case XZ_ID_Delta:
+        if (p->encodeMode)
+          Delta_Encode(p->deltaState, p->delta, p->buf, p->bufTotal);
+        else
+          Delta_Decode(p->deltaState, p->delta, p->buf, p->bufTotal);
+        p->bufConv = p->bufTotal;
+        break;
+      case XZ_ID_X86:
+        p->bufConv = x86_Convert(p->buf, p->bufTotal, p->ip, &p->x86State, p->encodeMode);
+        break;
+      CASE_BRA_CONV(PPC)
+      CASE_BRA_CONV(IA64)
+      CASE_BRA_CONV(ARM)
+      CASE_BRA_CONV(ARMT)
+      CASE_BRA_CONV(SPARC)
+      default:
+        return SZ_ERROR_UNSUPPORTED;
+    }
+    p->ip += (UInt32)p->bufConv;
+
+    if (p->bufConv == 0)
+    {
+      if (!srcWasFinished)
+        break;
+      p->bufConv = p->bufTotal;
+    }
+  }
+  if (p->bufTotal == p->bufPos && srcLenOrig == 0 && srcWasFinished)
+    *wasFinished = 1;
+  return SZ_OK;
+}
+
+SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, ISzAlloc *alloc)
+{
+  CBraState *decoder;
+  if (id != XZ_ID_Delta &&
+      id != XZ_ID_X86 &&
+      id != XZ_ID_PPC &&
+      id != XZ_ID_IA64 &&
+      id != XZ_ID_ARM &&
+      id != XZ_ID_ARMT &&
+      id != XZ_ID_SPARC)
+    return SZ_ERROR_UNSUPPORTED;
+  p->p = 0;
+  decoder = alloc->Alloc(alloc, sizeof(CBraState));
+  if (decoder == 0)
+    return SZ_ERROR_MEM;
+  decoder->methodId = (UInt32)id;
+  p->p = decoder;
+  p->Free = BraState_Free;
+  p->SetProps = BraState_SetProps;
+  p->Init = BraState_Init;
+  p->Code = BraState_Code;
+  return SZ_OK;
+}
+
+/* ---------- SbState ---------- */
+
+#ifdef USE_SUBBLOCK
+
+static void SbState_Free(void *pp, ISzAlloc *alloc)
+{
+  CSubblockDec *p = (CSubblockDec *)pp;
+  SubblockDec_Free(p, alloc);
+  alloc->Free(alloc, pp);
+}
+
+static SRes SbState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAlloc *alloc)
+{
+  pp = pp;
+  props = props;
+  alloc = alloc;
+  return (propSize == 0) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
+}
+
+static void SbState_Init(void *pp)
+{
+  SubblockDec_Init((CSubblockDec *)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);
+  srcWasFinished = srcWasFinished;
+  *wasFinished = (status == LZMA_STATUS_FINISHED_WITH_MARK);
+  return res;
+}
+
+SRes SbState_SetFromMethod(IStateCoder *p, ISzAlloc *alloc)
+{
+  CSubblockDec *decoder;
+  p->p = 0;
+  decoder = alloc->Alloc(alloc, sizeof(CSubblockDec));
+  if (decoder == 0)
+    return SZ_ERROR_MEM;
+  p->p = decoder;
+  p->Free = SbState_Free;
+  p->SetProps = SbState_SetProps;
+  p->Init = SbState_Init;
+  p->Code = SbState_Code;
+  SubblockDec_Construct(decoder);
+  return SZ_OK;
+}
+#endif
+
+/* ---------- Lzma2State ---------- */
+
+static void Lzma2State_Free(void *pp, ISzAlloc *alloc)
+{
+  Lzma2Dec_Free((CLzma2Dec *)pp, alloc);
+  alloc->Free(alloc, pp);
+}
+
+static SRes Lzma2State_SetProps(void *pp, const Byte *props, size_t propSize, ISzAlloc *alloc)
+{
+  if (propSize != 1)
+    return SZ_ERROR_UNSUPPORTED;
+  return Lzma2Dec_Allocate((CLzma2Dec *)pp, props[0], alloc);
+}
+
+static void Lzma2State_Init(void *pp)
+{
+  Lzma2Dec_Init((CLzma2Dec *)pp);
+}
+
+static SRes Lzma2State_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
+    int srcWasFinished, ELzmaFinishMode finishMode, int *wasFinished)
+{
+  ELzmaStatus status;
+  SRes res = Lzma2Dec_DecodeToBuf((CLzma2Dec *)pp, dest, destLen, src, srcLen, finishMode, &status);
+  srcWasFinished = srcWasFinished;
+  *wasFinished = (status == LZMA_STATUS_FINISHED_WITH_MARK);
+  return res;
+}
+
+static SRes Lzma2State_SetFromMethod(IStateCoder *p, ISzAlloc *alloc)
+{
+  CLzma2Dec *decoder = alloc->Alloc(alloc, sizeof(CLzma2Dec));
+  p->p = decoder;
+  if (decoder == 0)
+    return SZ_ERROR_MEM;
+  p->Free = Lzma2State_Free;
+  p->SetProps = Lzma2State_SetProps;
+  p->Init = Lzma2State_Init;
+  p->Code = Lzma2State_Code;
+  Lzma2Dec_Construct(decoder);
+  return SZ_OK;
+}
+
+
+void MixCoder_Construct(CMixCoder *p, ISzAlloc *alloc)
+{
+  int i;
+  p->alloc = alloc;
+  p->buf = 0;
+  p->numCoders = 0;
+  for (i = 0; i < MIXCODER_NUM_FILTERS_MAX; i++)
+    p->coders[i].p = NULL;
+}
+
+void MixCoder_Free(CMixCoder *p)
+{
+  int i;
+  for (i = 0; i < p->numCoders; i++)
+  {
+    IStateCoder *sc = &p->coders[i];
+    if (p->alloc && sc->p)
+      sc->Free(sc->p, p->alloc);
+  }
+  p->numCoders = 0;
+  if (p->buf)
+    p->alloc->Free(p->alloc, p->buf);
+}
+
+void MixCoder_Init(CMixCoder *p)
+{
+  int i;
+  for (i = 0; i < p->numCoders - 1; i++)
+  {
+    p->size[i] = 0;
+    p->pos[i] = 0;
+    p->finished[i] = 0;
+  }
+  for (i = 0; i < p->numCoders; i++)
+  {
+    IStateCoder *coder = &p->coders[i];
+    coder->Init(coder->p);
+  }
+}
+
+SRes MixCoder_SetFromMethod(CMixCoder *p, int coderIndex, UInt64 methodId)
+{
+  IStateCoder *sc = &p->coders[coderIndex];
+  p->ids[coderIndex] = methodId;
+  switch(methodId)
+  {
+    case XZ_ID_LZMA2: return Lzma2State_SetFromMethod(sc, p->alloc);
+    #ifdef USE_SUBBLOCK
+    case XZ_ID_Subblock: return SbState_SetFromMethod(sc, p->alloc);
+    #endif
+  }
+  if (coderIndex == 0)
+    return SZ_ERROR_UNSUPPORTED;
+  return BraState_SetFromMethod(sc, methodId, p->alloc);
+}
+
+SRes MixCoder_Code(CMixCoder *p, Byte *dest, SizeT *destLen,
+    const Byte *src, SizeT *srcLen, int srcWasFinished,
+    ELzmaFinishMode finishMode, ECoderStatus *status)
+{
+  SizeT destLenOrig = *destLen;
+  SizeT srcLenOrig = *srcLen;
+  Bool allFinished = True;
+  *destLen = 0;
+  *srcLen = 0;
+  *status = CODER_STATUS_NOT_FINISHED;
+
+  if (p->buf == 0)
+  {
+    p->buf = p->alloc->Alloc(p->alloc, CODER_BUF_SIZE * (MIXCODER_NUM_FILTERS_MAX - 1));
+    if (p->buf == 0)
+      return SZ_ERROR_MEM;
+  }
+
+  if (p->numCoders != 1)
+    finishMode = CODER_FINISH_ANY;
+
+  for (;;)
+  {
+    Bool processed = False;
+    int i;
+    /*
+    if (p->numCoders == 1 && *destLen == destLenOrig && finishMode == LZMA_FINISH_ANY)
+      break;
+    */
+
+    for (i = 0; i < p->numCoders; i++)
+    {
+      SRes res;
+      IStateCoder *coder = &p->coders[i];
+      Byte *destCur;
+      SizeT destLenCur, srcLenCur;
+      const Byte *srcCur;
+      int srcFinishedCur;
+      int encodingWasFinished;
+      
+      if (i == 0)
+      {
+        srcCur = src;
+        srcLenCur = srcLenOrig - *srcLen;
+        srcFinishedCur = srcWasFinished;
+      }
+      else
+      {
+        srcCur = p->buf + (CODER_BUF_SIZE * (i - 1)) + p->pos[i - 1];
+        srcLenCur = p->size[i - 1] - p->pos[i - 1];
+        srcFinishedCur = p->finished[i - 1];
+      }
+      
+      if (i == p->numCoders - 1)
+      {
+        destCur = dest;
+        destLenCur = destLenOrig - *destLen;
+      }
+      else
+      {
+        if (p->pos[i] != p->size[i])
+          continue;
+        destCur = p->buf + (CODER_BUF_SIZE * i);
+        destLenCur = CODER_BUF_SIZE;
+      }
+      
+      res = coder->Code(coder->p, destCur, &destLenCur, srcCur, &srcLenCur, srcFinishedCur, finishMode, &encodingWasFinished);
+
+      if (!encodingWasFinished)
+        allFinished = False;
+
+      if (i == 0)
+      {
+        *srcLen += srcLenCur;
+        src += srcLenCur;
+      }
+      else
+      {
+        p->pos[i - 1] += srcLenCur;
+      }
+
+      if (i == p->numCoders - 1)
+      {
+        *destLen += destLenCur;
+        dest += destLenCur;
+      }
+      else
+      {
+        p->size[i] = destLenCur;
+        p->pos[i] = 0;
+        p->finished[i] = encodingWasFinished;
+      }
+      
+      if (res != SZ_OK)
+        return res;
+
+      if (destLenCur != 0 || srcLenCur != 0)
+        processed = True;
+    }
+    if (!processed)
+      break;
+  }
+  if (allFinished)
+    *status = CODER_STATUS_FINISHED_WITH_MARK;
+  return SZ_OK;
+}
+
+SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf)
+{
+  *p = (CXzStreamFlags)GetBe16(buf + XZ_SIG_SIZE);
+  if (CrcCalc(buf + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE) !=
+      GetUi32(buf + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE))
+    return SZ_ERROR_NO_ARCHIVE;
+  return XzFlags_IsSupported(*p) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
+}
+
+static Bool Xz_CheckFooter(CXzStreamFlags flags, UInt64 indexSize, const Byte *buf)
+{
+  return
+      indexSize == (((UInt64)GetUi32(buf + 4) + 1) << 2) &&
+      (GetUi32(buf) == CrcCalc(buf + 4, 6) &&
+      flags == GetBe16(buf + 8) &&
+      memcmp(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) == 0);
+}
+
+#define READ_VARINT_AND_CHECK(buf, pos, size, res) \
+  { unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \
+  if (s == 0) return SZ_ERROR_ARCHIVE; pos += s; }
+
+
+SRes XzBlock_Parse(CXzBlock *p, const Byte *header)
+{
+  unsigned pos;
+  int numFilters, i;
+  UInt32 headerSize = (UInt32)header[0] << 2;
+
+  if (CrcCalc(header, headerSize) != GetUi32(header + headerSize))
+    return SZ_ERROR_ARCHIVE;
+
+  pos = 1;
+  if (pos == headerSize)
+    return SZ_ERROR_ARCHIVE;
+  p->flags = header[pos++];
+
+  if (XzBlock_HasPackSize(p))
+  {
+    READ_VARINT_AND_CHECK(header, pos, headerSize, &p->packSize);
+    if (p->packSize == 0 || p->packSize + headerSize >= (UInt64)1 << 63)
+      return SZ_ERROR_ARCHIVE;
+  }
+
+  if (XzBlock_HasUnpackSize(p))
+    READ_VARINT_AND_CHECK(header, pos, headerSize, &p->unpackSize);
+
+  numFilters = XzBlock_GetNumFilters(p);
+  for (i = 0; i < numFilters; i++)
+  {
+    CXzFilter *filter = p->filters + i;
+    UInt64 size;
+    READ_VARINT_AND_CHECK(header, pos, headerSize, &filter->id);
+    READ_VARINT_AND_CHECK(header, pos, headerSize, &size);
+    if (size > headerSize - pos || size > XZ_FILTER_PROPS_SIZE_MAX)
+      return SZ_ERROR_ARCHIVE;
+    filter->propsSize = (UInt32)size;
+    memcpy(filter->props, header + pos, (size_t)size);
+    pos += (unsigned)size;
+
+    #ifdef XZ_DUMP
+    printf("\nf[%d] = %2X: ", i, filter->id);
+    {
+      int i;
+      for (i = 0; i < size; i++)
+        printf(" %2X", filter->props[i]);
+    }
+    #endif
+  }
+
+  while (pos < headerSize)
+    if (header[pos++] != 0)
+      return SZ_ERROR_ARCHIVE;
+  return SZ_OK;
+}
+
+SRes XzDec_Init(CMixCoder *p, const CXzBlock *block)
+{
+  int i;
+  Bool needReInit = True;
+  int numFilters = XzBlock_GetNumFilters(block);
+  if (numFilters == p->numCoders)
+  {
+    for (i = 0; i < numFilters; i++)
+      if (p->ids[i] != block->filters[numFilters - 1 - i].id)
+        break;
+    needReInit = (i != numFilters);
+  }
+  if (needReInit)
+  {
+    MixCoder_Free(p);
+    p->numCoders = numFilters;
+    for (i = 0; i < numFilters; i++)
+    {
+      const CXzFilter *f = &block->filters[numFilters - 1 - i];
+      RINOK(MixCoder_SetFromMethod(p, i, f->id));
+    }
+  }
+  for (i = 0; i < numFilters; i++)
+  {
+    const CXzFilter *f = &block->filters[numFilters - 1 - i];
+    IStateCoder *sc = &p->coders[i];
+    RINOK(sc->SetProps(sc->p, f->props, f->propsSize, p->alloc));
+  }
+  MixCoder_Init(p);
+  return SZ_OK;
+}
+
+SRes XzUnpacker_Create(CXzUnpacker *p, ISzAlloc *alloc)
+{
+  MixCoder_Construct(&p->decoder, alloc);
+  p->state = XZ_STATE_STREAM_HEADER;
+  p->pos = 0;
+  p->numStreams = 0;
+  return SZ_OK;
+}
+
+void XzUnpacker_Free(CXzUnpacker *p)
+{
+  MixCoder_Free(&p->decoder);
+}
+
+SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
+    const Byte *src, SizeT *srcLen, int finishMode, ECoderStatus *status)
+{
+  SizeT destLenOrig = *destLen;
+  SizeT srcLenOrig = *srcLen;
+  *destLen = 0;
+  *srcLen = 0;
+  *status = CODER_STATUS_NOT_SPECIFIED;
+  for (;;)
+  {
+    SizeT srcRem = srcLenOrig - *srcLen;
+
+    if (p->state == XZ_STATE_BLOCK)
+    {
+      SizeT destLen2 = destLenOrig - *destLen;
+      SizeT srcLen2 = srcLenOrig - *srcLen;
+      SRes res;
+      if (srcLen2 == 0 && destLen2 == 0)
+      {
+        *status = CODER_STATUS_NOT_FINISHED;
+        return SZ_OK;
+      }
+      
+      res = MixCoder_Code(&p->decoder, dest, &destLen2, src, &srcLen2, False, finishMode, status);
+      XzCheck_Update(&p->check, dest, destLen2);
+      
+      (*srcLen) += srcLen2;
+      src += srcLen2;
+      p->packSize += srcLen2;
+      
+      (*destLen) += destLen2;
+      dest += destLen2;
+      p->unpackSize += destLen2;
+      
+      RINOK(res);
+      
+      if (*status == CODER_STATUS_FINISHED_WITH_MARK)
+      {
+        Byte temp[32];
+        unsigned num = Xz_WriteVarInt(temp, p->packSize + p->blockHeaderSize + XzFlags_GetCheckSize(p->streamFlags));
+        num += Xz_WriteVarInt(temp + num, p->unpackSize);
+        Sha256_Update(&p->sha, temp, num);
+        p->indexSize += num;
+        p->numBlocks++;
+        
+        p->state = XZ_STATE_BLOCK_FOOTER;
+        p->pos = 0;
+        p->alignPos = 0;
+      }
+      else if (srcLen2 == 0 && destLen2 == 0)
+        return SZ_OK;
+      
+      continue;
+    }
+
+    if (srcRem == 0)
+    {
+      *status = CODER_STATUS_NEEDS_MORE_INPUT;
+      return SZ_OK;
+    }
+
+    switch(p->state)
+    {
+      case XZ_STATE_STREAM_HEADER:
+      {
+        if (p->pos < XZ_STREAM_HEADER_SIZE)
+        {
+          if (p->pos < XZ_SIG_SIZE && *src != XZ_SIG[p->pos])
+            return SZ_ERROR_NO_ARCHIVE;
+          p->buf[p->pos++] = *src++;
+          (*srcLen)++;
+        }
+        else
+        {
+          RINOK(Xz_ParseHeader(&p->streamFlags, p->buf));
+          p->state = XZ_STATE_BLOCK_HEADER;
+          Sha256_Init(&p->sha);
+          p->indexSize = 0;
+          p->numBlocks = 0;
+          p->pos = 0;
+        }
+        break;
+      }
+
+      case XZ_STATE_BLOCK_HEADER:
+      {
+        if (p->pos == 0)
+        {
+          p->buf[p->pos++] = *src++;
+          (*srcLen)++;
+          if (p->buf[0] == 0)
+          {
+            p->indexPreSize = 1 + Xz_WriteVarInt(p->buf + 1, p->numBlocks);
+            p->indexPos = p->indexPreSize;
+            p->indexSize += p->indexPreSize;
+            Sha256_Final(&p->sha, p->shaDigest);
+            Sha256_Init(&p->sha);
+            p->crc = CrcUpdate(CRC_INIT_VAL, p->buf, p->indexPreSize);
+            p->state = XZ_STATE_STREAM_INDEX;
+          }
+          p->blockHeaderSize = ((UInt32)p->buf[0] << 2) + 4;
+        }
+        else if (p->pos != p->blockHeaderSize)
+        {
+          UInt32 cur = p->blockHeaderSize - p->pos;
+          if (cur > srcRem)
+            cur = (UInt32)srcRem;
+          memcpy(p->buf + p->pos, src, cur);
+          p->pos += cur;
+          (*srcLen) += cur;
+          src += cur;
+        }
+        else
+        {
+          RINOK(XzBlock_Parse(&p->block, p->buf));
+          p->state = XZ_STATE_BLOCK;
+          p->packSize = 0;
+          p->unpackSize = 0;
+          XzCheck_Init(&p->check, XzFlags_GetCheckType(p->streamFlags));
+          RINOK(XzDec_Init(&p->decoder, &p->block));
+        }
+        break;
+      }
+
+      case XZ_STATE_BLOCK_FOOTER:
+      {
+        if (((p->packSize + p->alignPos) & 3) != 0)
+        {
+          (*srcLen)++;
+          p->alignPos++;
+          if (*src++ != 0)
+            return SZ_ERROR_CRC;
+        }
+        else
+        {
+          UInt32 checkSize = XzFlags_GetCheckSize(p->streamFlags);
+          UInt32 cur = checkSize - p->pos;
+          if (cur != 0)
+          {
+            if (cur > srcRem)
+              cur = (UInt32)srcRem;
+            memcpy(p->buf + p->pos, src, cur);
+            p->pos += cur;
+            (*srcLen) += cur;
+            src += cur;
+          }
+          else
+          {
+            Byte digest[XZ_CHECK_SIZE_MAX];
+            p->state = XZ_STATE_BLOCK_HEADER;
+            p->pos = 0;
+            if (XzCheck_Final(&p->check, digest) && memcmp(digest, p->buf, checkSize) != 0)
+              return SZ_ERROR_CRC;
+          }
+        }
+        break;
+      }
+
+      case XZ_STATE_STREAM_INDEX:
+      {
+        if (p->pos < p->indexPreSize)
+        {
+          (*srcLen)++;
+          if (*src++ != p->buf[p->pos++])
+            return SZ_ERROR_CRC;
+        }
+        else
+        {
+          if (p->indexPos < p->indexSize)
+          {
+            UInt64 cur = p->indexSize - p->indexPos;
+            if (srcRem > cur)
+              srcRem = (SizeT)cur;
+            p->crc = CrcUpdate(p->crc, src, srcRem);
+            Sha256_Update(&p->sha, src, srcRem);
+            (*srcLen) += srcRem;
+            src += srcRem;
+            p->indexPos += srcRem;
+          }
+          else if ((p->indexPos & 3) != 0)
+          {
+            Byte b = *src++;
+            p->crc = CRC_UPDATE_BYTE(p->crc, b);
+            (*srcLen)++;
+            p->indexPos++;
+            p->indexSize++;
+            if (b != 0)
+              return SZ_ERROR_CRC;
+          }
+          else
+          {
+            Byte digest[SHA256_DIGEST_SIZE];
+            p->state = XZ_STATE_STREAM_INDEX_CRC;
+            p->indexSize += 4;
+            p->pos = 0;
+            Sha256_Final(&p->sha, digest);
+            if (memcmp(digest, p->shaDigest, SHA256_DIGEST_SIZE) != 0)
+              return SZ_ERROR_CRC;
+          }
+        }
+        break;
+      }
+
+      case XZ_STATE_STREAM_INDEX_CRC:
+      {
+        if (p->pos < 4)
+        {
+          (*srcLen)++;
+          p->buf[p->pos++] = *src++;
+        }
+        else
+        {
+          p->state = XZ_STATE_STREAM_FOOTER;
+          p->pos = 0;
+          if (CRC_GET_DIGEST(p->crc) != GetUi32(p->buf))
+            return SZ_ERROR_CRC;
+        }
+        break;
+      }
+
+      case XZ_STATE_STREAM_FOOTER:
+      {
+        UInt32 cur = XZ_STREAM_FOOTER_SIZE - p->pos;
+        if (cur > srcRem)
+          cur = (UInt32)srcRem;
+        memcpy(p->buf + p->pos, src, cur);
+        p->pos += cur;
+        (*srcLen) += cur;
+        src += cur;
+        if (p->pos == XZ_STREAM_FOOTER_SIZE)
+        {
+          p->state = XZ_STATE_STREAM_PADDING;
+          p->numStreams++;
+          p->padSize = 0;
+          if (!Xz_CheckFooter(p->streamFlags, p->indexSize, p->buf))
+            return SZ_ERROR_CRC;
+        }
+        break;
+      }
+
+      case XZ_STATE_STREAM_PADDING:
+      {
+        if (*src != 0)
+        {
+          if (((UInt32)p->padSize & 3) != 0)
+            return SZ_ERROR_NO_ARCHIVE;
+          p->pos = 0;
+          p->state = XZ_STATE_STREAM_HEADER;
+        }
+        else
+        {
+          (*srcLen)++;
+          src++;
+          p->padSize++;
+        }
+        break;
+      }
+    }
+  }
+  /*
+  if (p->state == XZ_STATE_FINISHED)
+    *status = CODER_STATUS_FINISHED_WITH_MARK;
+  return SZ_OK;
+  */
+}
+
+Bool XzUnpacker_IsStreamWasFinished(CXzUnpacker *p)
+{
+  return (p->state == XZ_STATE_STREAM_PADDING) && (((UInt32)p->padSize & 3) == 0);
+}
diff --git a/C/XzEnc.c b/C/XzEnc.c
new file mode 100755
index 00000000..3958308b
--- /dev/null
+++ b/C/XzEnc.c
@@ -0,0 +1,497 @@
+/* XzEnc.c -- Xz Encode
+2009-05-26 : Igor Pavlov : Public domain */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "7zCrc.h"
+#include "Alloc.h"
+#include "Bra.h"
+#include "CpuArch.h"
+#ifdef USE_SUBBLOCK
+#include "SbEnc.h"
+#endif
+
+#include "XzEnc.h"
+
+static void *SzBigAlloc(void *p, size_t size) { p = p; return BigAlloc(size); }
+static void SzBigFree(void *p, void *address) { p = p; BigFree(address); }
+static ISzAlloc g_BigAlloc = { SzBigAlloc, SzBigFree };
+
+static void *SzAlloc(void *p, size_t size) { p = p; return MyAlloc(size); }
+static void SzFree(void *p, void *address) { p = p; MyFree(address); }
+static ISzAlloc g_Alloc = { SzAlloc, SzFree };
+
+#define XzBlock_ClearFlags(p)       (p)->flags = 0;
+#define XzBlock_SetNumFilters(p, n) (p)->flags |= ((n) - 1);
+#define XzBlock_SetHasPackSize(p)   (p)->flags |= XZ_BF_PACK_SIZE;
+#define XzBlock_SetHasUnpackSize(p) (p)->flags |= XZ_BF_UNPACK_SIZE;
+
+static SRes WriteBytes(ISeqOutStream *s, const void *buf, UInt32 size)
+{
+  return (s->Write(s, buf, size) == size) ? SZ_OK : SZ_ERROR_WRITE;
+}
+
+static SRes WriteBytesAndCrc(ISeqOutStream *s, const void *buf, UInt32 size, UInt32 *crc)
+{
+  *crc = CrcUpdate(*crc, buf, size);
+  return WriteBytes(s, buf, size);
+}
+
+SRes Xz_WriteHeader(CXzStreamFlags f, ISeqOutStream *s)
+{
+  UInt32 crc;
+  Byte header[XZ_STREAM_HEADER_SIZE];
+  memcpy(header, XZ_SIG, XZ_SIG_SIZE);
+  header[XZ_SIG_SIZE] = (Byte)(f >> 8);
+  header[XZ_SIG_SIZE + 1] = (Byte)(f & 0xFF);
+  crc = CrcCalc(header + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE);
+  SetUi32(header + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE, crc);
+  return WriteBytes(s, header, XZ_STREAM_HEADER_SIZE);
+}
+
+SRes XzBlock_WriteHeader(const CXzBlock *p, ISeqOutStream *s)
+{
+  Byte header[XZ_BLOCK_HEADER_SIZE_MAX];
+
+  unsigned pos = 1;
+  int numFilters, i;
+  header[pos++] = p->flags;
+
+  if (XzBlock_HasPackSize(p)) pos += Xz_WriteVarInt(header + pos, p->packSize);
+  if (XzBlock_HasUnpackSize(p)) pos += Xz_WriteVarInt(header + pos, p->unpackSize);
+  numFilters = XzBlock_GetNumFilters(p);
+  for (i = 0; i < numFilters; i++)
+  {
+    const CXzFilter *f = &p->filters[i];
+    pos += Xz_WriteVarInt(header + pos, f->id);
+    pos += Xz_WriteVarInt(header + pos, f->propsSize);
+    memcpy(header + pos, f->props, f->propsSize);
+    pos += f->propsSize;
+  }
+  while((pos & 3) != 0)
+    header[pos++] = 0;
+  header[0] = (Byte)(pos >> 2);
+  SetUi32(header + pos, CrcCalc(header, pos));
+  return WriteBytes(s, header, pos + 4);
+}
+
+SRes Xz_WriteFooter(CXzStream *p, ISeqOutStream *s)
+{
+  Byte buf[32];
+  UInt64 globalPos;
+  {
+    UInt32 crc = CRC_INIT_VAL;
+    unsigned pos = 1 + Xz_WriteVarInt(buf + 1, p->numBlocks);
+    size_t i;
+
+    globalPos = pos;
+    buf[0] = 0;
+    RINOK(WriteBytesAndCrc(s, buf, pos, &crc));
+    for (i = 0; i < p->numBlocks; i++)
+    {
+      const CXzBlockSizes *block = &p->blocks[i];
+      pos = Xz_WriteVarInt(buf, block->totalSize);
+      pos += Xz_WriteVarInt(buf + pos, block->unpackSize);
+      globalPos += pos;
+      RINOK(WriteBytesAndCrc(s, buf, pos, &crc));
+    }
+    pos = ((unsigned)globalPos & 3);
+    if (pos != 0)
+    {
+      buf[0] = buf[1] = buf[2] = 0;
+      RINOK(WriteBytesAndCrc(s, buf, 4 - pos, &crc));
+      globalPos += 4 - pos;
+    }
+    {
+      SetUi32(buf, CRC_GET_DIGEST(crc));
+      RINOK(WriteBytes(s, buf, 4));
+      globalPos += 4;
+    }
+  }
+
+  {
+    UInt32 indexSize = (UInt32)((globalPos >> 2) - 1);
+    SetUi32(buf + 4, indexSize);
+    buf[8] = (Byte)(p->flags >> 8);
+    buf[9] = (Byte)(p->flags & 0xFF);
+    SetUi32(buf, CrcCalc(buf + 4, 6));
+    memcpy(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE);
+    return WriteBytes(s, buf, 12);
+  }
+}
+
+SRes Xz_AddIndexRecord(CXzStream *p, UInt64 unpackSize, UInt64 totalSize, ISzAlloc *alloc)
+{
+  if (p->blocks == 0 || p->numBlocksAllocated == p->numBlocks)
+  {
+    size_t num = (p->numBlocks + 1) * 2;
+    size_t newSize = sizeof(CXzBlockSizes) * num;
+    CXzBlockSizes *blocks;
+    if (newSize / sizeof(CXzBlockSizes) != num)
+      return SZ_ERROR_MEM;
+    blocks = alloc->Alloc(alloc, newSize);
+    if (blocks == 0)
+      return SZ_ERROR_MEM;
+    if (p->numBlocks != 0)
+    {
+      memcpy(blocks, p->blocks, p->numBlocks * sizeof(CXzBlockSizes));
+      Xz_Free(p, alloc);
+    }
+    p->blocks = blocks;
+    p->numBlocksAllocated = num;
+  }
+  {
+    CXzBlockSizes *block = &p->blocks[p->numBlocks++];
+    block->totalSize = totalSize;
+    block->unpackSize = unpackSize;
+  }
+  return SZ_OK;
+}
+
+/* ---------- CSeqCheckInStream ---------- */
+
+typedef struct
+{
+  ISeqInStream p;
+  ISeqInStream *realStream;
+  UInt64 processed;
+  CXzCheck check;
+} CSeqCheckInStream;
+
+void SeqCheckInStream_Init(CSeqCheckInStream *p, int mode)
+{
+  p->processed = 0;
+  XzCheck_Init(&p->check, mode);
+}
+
+void SeqCheckInStream_GetDigest(CSeqCheckInStream *p, Byte *digest)
+{
+  XzCheck_Final(&p->check, digest);
+}
+
+static SRes SeqCheckInStream_Read(void *pp, void *data, size_t *size)
+{
+  CSeqCheckInStream *p = (CSeqCheckInStream *)pp;
+  SRes res = p->realStream->Read(p->realStream, data, size);
+  XzCheck_Update(&p->check, data, *size);
+  p->processed += *size;
+  return res;
+}
+
+/* ---------- CSeqSizeOutStream ---------- */
+
+typedef struct
+{
+  ISeqOutStream p;
+  ISeqOutStream *realStream;
+  UInt64 processed;
+} CSeqSizeOutStream;
+
+static size_t MyWrite(void *pp, const void *data, size_t size)
+{
+  CSeqSizeOutStream *p = (CSeqSizeOutStream *)pp;
+  size = p->realStream->Write(p->realStream, data, size);
+  p->processed += size;
+  return 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)
+
+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;
+} CSeqInFilter;
+
+static SRes SeqInFilter_Read(void *pp, void *data, size_t *size)
+{
+  CSeqInFilter *p = (CSeqInFilter *)pp;
+  size_t remSize = *size;
+  *size = 0;
+
+  while (remSize > 0)
+  {
+    int i;
+    if (p->convertedPosBegin != p->convertedPosEnd)
+    {
+      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;
+    }
+    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);
+    }
+  }
+  return SZ_OK;
+}
+*/
+
+/*
+typedef struct
+{
+  ISeqInStream p;
+  ISeqInStream *realStream;
+  CMixCoder mixCoder;
+  Byte buf[FILT_BUF_SIZE];
+  UInt32 bufPos;
+  UInt32 bufSize;
+} CMixCoderSeqInStream;
+
+static SRes CMixCoderSeqInStream_Read(void *pp, void *data, size_t *size)
+{
+  CMixCoderSeqInStream *p = (CMixCoderSeqInStream *)pp;
+  SRes res = SZ_OK;
+  size_t remSize = *size;
+  *size = 0;
+  while (remSize > 0)
+  {
+    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;
+    }
+  }
+  return res;
+}
+*/
+
+#ifdef USE_SUBBLOCK
+typedef struct
+{
+  ISeqInStream p;
+  CSubblockEnc sb;
+  UInt64 processed;
+} 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;
+}
+#endif
+
+typedef struct
+{
+  /* CMixCoderSeqInStream inStream; */
+  CLzma2EncHandle lzma2;
+  #ifdef USE_SUBBLOCK
+  CSbEncInStream sb;
+  #endif
+  ISzAlloc *alloc;
+  ISzAlloc *bigAlloc;
+} CLzma2WithFilters;
+
+
+static void Lzma2WithFilters_Construct(CLzma2WithFilters *p, ISzAlloc *alloc, ISzAlloc *bigAlloc)
+{
+  p->alloc = alloc;
+  p->bigAlloc = bigAlloc;
+  p->lzma2 = NULL;
+  #ifdef USE_SUBBLOCK
+  p->sb.p.Read = SbEncInStream_Read;
+  SubblockEnc_Construct(&p->sb.sb, p->alloc);
+  #endif
+}
+
+static SRes Lzma2WithFilters_Create(CLzma2WithFilters *p)
+{
+  p->lzma2 = Lzma2Enc_Create(p->alloc, p->bigAlloc);
+  if (p->lzma2 == 0)
+    return SZ_ERROR_MEM;
+  return SZ_OK;
+}
+
+static void Lzma2WithFilters_Free(CLzma2WithFilters *p)
+{
+  #ifdef USE_SUBBLOCK
+  SubblockEnc_Free(&p->sb.sb);
+  #endif
+  if (p->lzma2)
+  {
+    Lzma2Enc_Destroy(p->lzma2);
+    p->lzma2 = NULL;
+  }
+}
+
+static SRes Xz_Compress(CXzStream *xz,
+    CLzma2WithFilters *lzmaf,
+    ISeqOutStream *outStream,
+    ISeqInStream *inStream,
+    const CLzma2EncProps *lzma2Props,
+    Bool useSubblock,
+    ICompressProgress *progress)
+{
+  xz->flags = XZ_CHECK_CRC32;
+
+  RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, lzma2Props));
+  RINOK(Xz_WriteHeader(xz->flags, outStream));
+
+  {
+    CSeqCheckInStream checkInStream;
+    CSeqSizeOutStream seqSizeOutStream;
+    CXzBlock block;
+    int filterIndex = 0;
+    
+    XzBlock_ClearFlags(&block);
+    XzBlock_SetNumFilters(&block, 1 + (useSubblock ? 1 : 0));
+    
+    if (useSubblock)
+    {
+      CXzFilter *f = &block.filters[filterIndex++];
+      f->id = XZ_ID_Subblock;
+      f->propsSize = 0;
+    }
+
+    {
+      CXzFilter *f = &block.filters[filterIndex++];
+      f->id = XZ_ID_LZMA2;
+      f->propsSize = 1;
+      f->props[0] = Lzma2Enc_WriteProperties(lzmaf->lzma2);
+    }
+
+    seqSizeOutStream.p.Write = MyWrite;
+    seqSizeOutStream.realStream = outStream;
+    seqSizeOutStream.processed = 0;
+    
+    RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.p));
+    
+    checkInStream.p.Read = SeqCheckInStream_Read;
+    checkInStream.realStream = inStream;
+    SeqCheckInStream_Init(&checkInStream, XzFlags_GetCheckType(xz->flags));
+    
+    #ifdef USE_SUBBLOCK
+    if (useSubblock)
+    {
+      lzmaf->sb.sb.inStream = &checkInStream.p;
+      SubblockEnc_Init(&lzmaf->sb.sb);
+    }
+    #endif
+    
+    {
+      UInt64 packPos = seqSizeOutStream.processed;
+      HRESULT res = Lzma2Enc_Encode(lzmaf->lzma2, &seqSizeOutStream.p,
+        #ifdef USE_SUBBLOCK
+        useSubblock ? &lzmaf->sb.p:
+        #endif
+        &checkInStream.p,
+        progress);
+      RINOK(res);
+      block.unpackSize = checkInStream.processed;
+      block.packSize = seqSizeOutStream.processed - packPos;
+    }
+
+    {
+      unsigned padSize = 0;
+      Byte buf[128];
+      while((((unsigned)block.packSize + padSize) & 3) != 0)
+        buf[padSize++] = 0;
+      SeqCheckInStream_GetDigest(&checkInStream, buf + padSize);
+      RINOK(WriteBytes(&seqSizeOutStream.p, buf, padSize + XzFlags_GetCheckSize(xz->flags)));
+      RINOK(Xz_AddIndexRecord(xz, block.unpackSize, seqSizeOutStream.processed - padSize, &g_Alloc));
+    }
+  }
+  return Xz_WriteFooter(xz, outStream);
+}
+
+SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,
+    const CLzma2EncProps *lzma2Props, Bool useSubblock,
+    ICompressProgress *progress)
+{
+  SRes res;
+  CXzStream xz;
+  CLzma2WithFilters lzmaf;
+  Xz_Construct(&xz);
+  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);
+  Lzma2WithFilters_Free(&lzmaf);
+  Xz_Free(&xz, &g_Alloc);
+  return res;
+}
+
+SRes Xz_EncodeEmpty(ISeqOutStream *outStream)
+{
+  SRes res;
+  CXzStream xz;
+  Xz_Construct(&xz);
+  res = Xz_WriteHeader(xz.flags, outStream);
+  if (res == SZ_OK)
+    res = Xz_WriteFooter(&xz, outStream);
+  Xz_Free(&xz, &g_Alloc);
+  return res;
+}
diff --git a/C/XzEnc.h b/C/XzEnc.h
new file mode 100755
index 00000000..13390df8
--- /dev/null
+++ b/C/XzEnc.h
@@ -0,0 +1,25 @@
+/* XzEnc.h -- Xz Encode
+2009-04-15 : Igor Pavlov : Public domain */
+
+#ifndef __XZ_ENC_H
+#define __XZ_ENC_H
+
+#include "Lzma2Enc.h"
+
+#include "Xz.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,
+    const CLzma2EncProps *lzma2Props, Bool useSubblock,
+    ICompressProgress *progress);
+
+SRes Xz_EncodeEmpty(ISeqOutStream *outStream);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/C/XzIn.c b/C/XzIn.c
new file mode 100755
index 00000000..f8c76bfe
--- /dev/null
+++ b/C/XzIn.c
@@ -0,0 +1,305 @@
+/* XzIn.c - Xz input
+2009-04-15 : Igor Pavlov : Public domain */
+
+#include "Xz.h"
+
+#include "7zCrc.h"
+#include "CpuArch.h"
+
+SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStream *inStream)
+{
+  Byte sig[XZ_STREAM_HEADER_SIZE];
+  RINOK(SeqInStream_Read2(inStream, sig, XZ_STREAM_HEADER_SIZE, SZ_ERROR_NO_ARCHIVE));
+  if (memcmp(sig, XZ_SIG, XZ_SIG_SIZE) != 0)
+    return SZ_ERROR_NO_ARCHIVE;
+  return Xz_ParseHeader(p, sig);
+}
+
+#define READ_VARINT_AND_CHECK(buf, pos, size, res) \
+  { unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \
+  if (s == 0) return SZ_ERROR_ARCHIVE; pos += s; }
+
+SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStream *inStream, Bool *isIndex, UInt32 *headerSizeRes)
+{
+  Byte header[XZ_BLOCK_HEADER_SIZE_MAX];
+  unsigned headerSize;
+  *headerSizeRes = 0;
+  RINOK(SeqInStream_ReadByte(inStream, &header[0]));
+  headerSize = ((unsigned)header[0] << 2) + 4;
+  if (headerSize == 0)
+  {
+    *headerSizeRes = 1;
+    *isIndex = True;
+    return SZ_OK;
+  }
+
+  *isIndex = False;
+  *headerSizeRes = headerSize;
+  RINOK(SeqInStream_Read(inStream, header + 1, headerSize - 1));
+  return XzBlock_Parse(p, header);
+}
+
+#define ADD_SIZE_CHECH(size, val) \
+  { UInt64 newSize = size + (val); if (newSize < size) return XZ_SIZE_OVERFLOW; size = newSize; }
+
+UInt64 Xz_GetUnpackSize(const CXzStream *p)
+{
+  UInt64 size = 0;
+  size_t i;
+  for (i = 0; i < p->numBlocks; i++)
+    ADD_SIZE_CHECH(size, p->blocks[i].unpackSize);
+  return size;
+}
+
+UInt64 Xz_GetPackSize(const CXzStream *p)
+{
+  UInt64 size = 0;
+  size_t i;
+  for (i = 0; i < p->numBlocks; i++)
+    ADD_SIZE_CHECH(size, (p->blocks[i].totalSize + 3) & ~(UInt64)3);
+  return size;
+}
+
+/*
+SRes XzBlock_ReadFooter(CXzBlock *p, CXzStreamFlags f, ISeqInStream *inStream)
+{
+  return SeqInStream_Read(inStream, p->check, XzFlags_GetCheckSize(f));
+}
+*/
+
+static SRes Xz_ReadIndex2(CXzStream *p, const Byte *buf, size_t size, ISzAlloc *alloc)
+{
+  size_t i, numBlocks, crcStartPos, pos = 1;
+  UInt32 crc;
+
+  if (size < 5 || buf[0] != 0)
+    return SZ_ERROR_ARCHIVE;
+
+  size -= 4;
+  crc = CrcCalc(buf, size);
+  if (crc != GetUi32(buf + size))
+    return SZ_ERROR_ARCHIVE;
+
+  {
+    UInt64 numBlocks64;
+    READ_VARINT_AND_CHECK(buf, pos, size, &numBlocks64);
+    numBlocks = (size_t)numBlocks64;
+    if (numBlocks != numBlocks64 || numBlocks * 2 > size)
+      return SZ_ERROR_ARCHIVE;
+  }
+  
+  crcStartPos = pos;
+  Xz_Free(p, alloc);
+  if (numBlocks != 0)
+  {
+    p->numBlocks = numBlocks;
+    p->numBlocksAllocated = numBlocks;
+    p->blocks = alloc->Alloc(alloc, sizeof(CXzBlockSizes) * numBlocks);
+    if (p->blocks == 0)
+      return SZ_ERROR_MEM;
+    for (i = 0; i < numBlocks; i++)
+    {
+      CXzBlockSizes *block = &p->blocks[i];
+      READ_VARINT_AND_CHECK(buf, pos, size, &block->totalSize);
+      READ_VARINT_AND_CHECK(buf, pos, size, &block->unpackSize);
+      if (block->totalSize == 0)
+        return SZ_ERROR_ARCHIVE;
+    }
+  }
+  while ((pos & 3) != 0)
+    if (buf[pos++] != 0)
+      return SZ_ERROR_ARCHIVE;
+  return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;
+}
+
+static SRes Xz_ReadIndex(CXzStream *p, ILookInStream *stream, UInt64 indexSize, ISzAlloc *alloc)
+{
+  SRes res;
+  size_t size;
+  Byte *buf;
+  if (indexSize > ((UInt32)1 << 31))
+    return SZ_ERROR_UNSUPPORTED;
+  size = (size_t)indexSize;
+  if (size != indexSize)
+    return SZ_ERROR_UNSUPPORTED;
+  buf = alloc->Alloc(alloc, size);
+  if (buf == 0)
+    return SZ_ERROR_MEM;
+  res = LookInStream_Read2(stream, buf, size, SZ_ERROR_UNSUPPORTED);
+  if (res == SZ_OK)
+    res = Xz_ReadIndex2(p, buf, size, alloc);
+  alloc->Free(alloc, buf);
+  return res;
+}
+
+static SRes SeekFromCur(ILookInStream *inStream, Int64 *res)
+{
+  return inStream->Seek(inStream, res, SZ_SEEK_CUR);
+}
+
+static SRes Xz_ReadBackward(CXzStream *p, ILookInStream *stream, Int64 *startOffset, ISzAlloc *alloc)
+{
+  UInt64 indexSize;
+  Byte buf[XZ_STREAM_FOOTER_SIZE];
+
+  if ((*startOffset & 3) != 0 || *startOffset < XZ_STREAM_FOOTER_SIZE)
+    return SZ_ERROR_NO_ARCHIVE;
+  *startOffset = -XZ_STREAM_FOOTER_SIZE;
+  RINOK(SeekFromCur(stream, startOffset));
+
+  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)
+  {
+    Int64 i = 0;
+    *startOffset += XZ_STREAM_FOOTER_SIZE;
+    for (;;)
+    {
+      int j;
+      size_t processedSize;
+      #define TEMP_BUF_SIZE (1 << 10)
+      Byte tempBuf[TEMP_BUF_SIZE];
+      if (*startOffset < XZ_STREAM_FOOTER_SIZE || i > (1 << 16))
+        return SZ_ERROR_NO_ARCHIVE;
+      processedSize = (*startOffset > TEMP_BUF_SIZE) ? TEMP_BUF_SIZE : (size_t)*startOffset;
+      i += processedSize;
+      *startOffset = -(Int64)processedSize;
+      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)
+          break;
+      if (j != 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)
+          return SZ_ERROR_NO_ARCHIVE;
+        break;
+      }
+    }
+  }
+  
+  p->flags = (CXzStreamFlags)GetBe16(buf + 8);
+
+  if (!XzFlags_IsSupported(p->flags))
+    return SZ_ERROR_UNSUPPORTED;
+
+  if (GetUi32(buf) != CrcCalc(buf + 4, 6))
+    return SZ_ERROR_ARCHIVE;
+
+  indexSize = ((UInt64)GetUi32(buf + 4) + 1) << 2;
+
+  *startOffset = -(Int64)(indexSize + XZ_STREAM_FOOTER_SIZE);
+  RINOK(SeekFromCur(stream, startOffset));
+
+  RINOK(Xz_ReadIndex(p, stream, indexSize, alloc));
+
+  {
+    UInt64 totalSize = Xz_GetPackSize(p);
+    UInt64 sum = XZ_STREAM_HEADER_SIZE + totalSize + indexSize;
+    if (totalSize == XZ_SIZE_OVERFLOW ||
+      sum >= ((UInt64)1 << 63) ||
+      totalSize >= ((UInt64)1 << 63))
+      return SZ_ERROR_ARCHIVE;
+    *startOffset = -(Int64)sum;
+    RINOK(SeekFromCur(stream, startOffset));
+  }
+  {
+    CXzStreamFlags headerFlags;
+    CSecToRead secToRead;
+    SecToRead_CreateVTable(&secToRead);
+    secToRead.realStream = stream;
+
+    RINOK(Xz_ReadHeader(&headerFlags, &secToRead.s));
+    return (p->flags == headerFlags) ? SZ_OK : SZ_ERROR_ARCHIVE;
+  }
+}
+
+
+/* ---------- Xz Streams ---------- */
+
+void Xzs_Construct(CXzs *p)
+{
+  p->num = p->numAllocated = 0;
+  p->streams = 0;
+}
+
+void Xzs_Free(CXzs *p, ISzAlloc *alloc)
+{
+  size_t i;
+  for (i = 0; i < p->num; i++)
+    Xz_Free(&p->streams[i], alloc);
+  alloc->Free(alloc, p->streams);
+  p->num = p->numAllocated = 0;
+  p->streams = 0;
+}
+
+UInt64 Xzs_GetNumBlocks(const CXzs *p)
+{
+  UInt64 num = 0;
+  size_t i;
+  for (i = 0; i < p->num; i++)
+    num += p->streams[i].numBlocks;
+  return num;
+}
+
+UInt64 Xzs_GetUnpackSize(const CXzs *p)
+{
+  UInt64 size = 0;
+  size_t i;
+  for (i = 0; i < p->num; i++)
+    ADD_SIZE_CHECH(size, Xz_GetUnpackSize(&p->streams[i]));
+  return size;
+}
+
+/*
+UInt64 Xzs_GetPackSize(const CXzs *p)
+{
+  UInt64 size = 0;
+  size_t i;
+  for (i = 0; i < p->num; i++)
+    ADD_SIZE_CHECH(size, Xz_GetTotalSize(&p->streams[i]));
+  return size;
+}
+*/
+
+SRes Xzs_ReadBackward(CXzs *p, ILookInStream *stream, Int64 *startOffset, ICompressProgress *progress, ISzAlloc *alloc)
+{
+  Int64 endOffset = 0;
+  RINOK(stream->Seek(stream, &endOffset, SZ_SEEK_END));
+  *startOffset = endOffset;
+  for (;;)
+  {
+    CXzStream st;
+    SRes res;
+    Xz_Construct(&st);
+    res = Xz_ReadBackward(&st, stream, startOffset, alloc);
+    st.startOffset = *startOffset;
+    RINOK(res);
+    if (p->num == p->numAllocated)
+    {
+      size_t newNum = p->num + p->num / 4 + 1;
+      Byte *data = (Byte *)alloc->Alloc(alloc, newNum * sizeof(CXzStream));
+      if (data == 0)
+        return SZ_ERROR_MEM;
+      p->numAllocated = newNum;
+      memcpy(data, p->streams, p->num * sizeof(CXzStream));
+      alloc->Free(alloc, p->streams);
+      p->streams = (CXzStream *)data;
+    }
+    p->streams[p->num++] = st;
+    if (*startOffset == 0)
+      break;
+    RINOK(stream->Seek(stream, startOffset, SZ_SEEK_SET));
+    if (progress && progress->Progress(progress, endOffset - *startOffset, (UInt64)(Int64)-1) != SZ_OK)
+      return SZ_ERROR_PROGRESS;
+  }
+  return SZ_OK;
+}