From f4bf9c8d29670bb9b5c05e2fcb87e88e5fb97ec0 Mon Sep 17 00:00:00 2001
From: Tino Reichardt <milky-7zip@mcmilk.de>
Date: Thu, 1 Nov 2018 08:00:13 +0100
Subject: [PATCH 01/11] Add xxHash functionss to context menu

---
 CPP/7zip/Bundles/Format7zF/Arc.mak   |  2 ++
 CPP/7zip/Bundles/SFXCon/makefile     |  2 +-
 CPP/7zip/Bundles/SFXWin/makefile     |  3 +-
 CPP/7zip/UI/Explorer/ContextMenu.cpp |  4 +++
 CPP/7zip/UI/Explorer/ContextMenu.h   |  2 ++
 CPP/Common/XXH32Reg.cpp              | 44 ++++++++++++++++++++++++++++
 CPP/Common/XXH64Reg.cpp              | 44 ++++++++++++++++++++++++++++
 7 files changed, 98 insertions(+), 3 deletions(-)
 create mode 100644 CPP/Common/XXH32Reg.cpp
 create mode 100644 CPP/Common/XXH64Reg.cpp

diff --git a/CPP/7zip/Bundles/Format7zF/Arc.mak b/CPP/7zip/Bundles/Format7zF/Arc.mak
index b78e4c1b..b3dabeb9 100644
--- a/CPP/7zip/Bundles/Format7zF/Arc.mak
+++ b/CPP/7zip/Bundles/Format7zF/Arc.mak
@@ -14,6 +14,8 @@ COMMON_OBJS = \
   $O\StringToInt.obj \
   $O\UTFConvert.obj \
   $O\Wildcard.obj \
+  $O\XXH32Reg.obj \
+  $O\XXH64Reg.obj \
   $O\XzCrc64Init.obj \
   $O\XzCrc64Reg.obj \
 
diff --git a/CPP/7zip/Bundles/SFXCon/makefile b/CPP/7zip/Bundles/SFXCon/makefile
index 586df4d7..e6adea09 100644
--- a/CPP/7zip/Bundles/SFXCon/makefile
+++ b/CPP/7zip/Bundles/SFXCon/makefile
@@ -133,8 +133,8 @@ C_OBJS = \
 !include "../../LzmaDec.mak"
 
 COMPRESS_OBJS = $(COMPRESS_OBJS) \
-  $O\ZstdEncoder.obj \
   $O\ZstdDecoder.obj \
+  $O\ZstdEncoder.obj \
   $O\ZstdRegister.obj \
 
 ZSTD_OBJS = \
diff --git a/CPP/7zip/Bundles/SFXWin/makefile b/CPP/7zip/Bundles/SFXWin/makefile
index da6ddb99..8bc02a3f 100644
--- a/CPP/7zip/Bundles/SFXWin/makefile
+++ b/CPP/7zip/Bundles/SFXWin/makefile
@@ -44,7 +44,6 @@ WIN_OBJS = \
   $O\Shell.obj \
   $O\System.obj \
   $O\Synchronization.obj \
-  $O\System.obj \
   $O\Window.obj \
 
 WIN_CTRL_OBJS = \
@@ -152,8 +151,8 @@ C_OBJS = \
 !include "../../LzmaDec.mak"
 
 COMPRESS_OBJS = $(COMPRESS_OBJS) \
-  $O\ZstdEncoder.obj \
   $O\ZstdDecoder.obj \
+  $O\ZstdEncoder.obj \
   $O\ZstdRegister.obj \
 
 ZSTD_OBJS = \
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.cpp b/CPP/7zip/UI/Explorer/ContextMenu.cpp
index ba62bed7..4b2e22c7 100644
--- a/CPP/7zip/UI/Explorer/ContextMenu.cpp
+++ b/CPP/7zip/UI/Explorer/ContextMenu.cpp
@@ -225,6 +225,8 @@ static const CHashCommand g_HashCommands[] =
   { CZipContextMenu::kHash_CRC64,  "CRC-64",  "CRC64" },
   { CZipContextMenu::kHash_SHA1,   "SHA-1",   "SHA1" },
   { CZipContextMenu::kHash_SHA256, "SHA-256", "SHA256" },
+  { CZipContextMenu::kHash_XXH32,  "XXH-32",  "XXH32" },
+  { CZipContextMenu::kHash_XXH64,  "XXH-64",  "XXH64" },
   { CZipContextMenu::kHash_All,    "*",       "*" }
 };
 
@@ -928,6 +930,8 @@ STDMETHODIMP CZipContextMenu::InvokeCommand(LPCMINVOKECOMMANDINFO commandInfo)
       case kHash_CRC64:
       case kHash_SHA1:
       case kHash_SHA256:
+      case kHash_XXH32:
+      case kHash_XXH64:
       case kHash_All:
       {
         for (unsigned i = 0; i < ARRAY_SIZE(g_HashCommands); i++)
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.h b/CPP/7zip/UI/Explorer/ContextMenu.h
index c8ceea74..58f8b253 100644
--- a/CPP/7zip/UI/Explorer/ContextMenu.h
+++ b/CPP/7zip/UI/Explorer/ContextMenu.h
@@ -36,6 +36,8 @@ public:
     kHash_CRC64,
     kHash_SHA1,
     kHash_SHA256,
+    kHash_XXH32,
+    kHash_XXH64,
     kHash_All
   };
   
diff --git a/CPP/Common/XXH32Reg.cpp b/CPP/Common/XXH32Reg.cpp
new file mode 100644
index 00000000..a3f1bfa2
--- /dev/null
+++ b/CPP/Common/XXH32Reg.cpp
@@ -0,0 +1,44 @@
+// XXH32Reg.cpp
+
+#include "StdAfx.h"
+
+#define XXH_STATIC_LINKING_ONLY
+#include "../../C/CpuArch.h"
+#include "../../C/zstd/xxhash.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+class CXXH32Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  XXH32_state_t *_ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CXXH32Hasher() { _ctx = XXH32_createState(); }
+  ~CXXH32Hasher() { XXH32_freeState(_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CXXH32Hasher::Init() throw()
+{
+  XXH32_reset(_ctx, 0);
+}
+
+STDMETHODIMP_(void) CXXH32Hasher::Update(const void *data, UInt32 size) throw()
+{
+  XXH32_update(_ctx, data, size);
+}
+
+STDMETHODIMP_(void) CXXH32Hasher::Final(Byte *digest) throw()
+{
+  UInt32 val = XXH32_digest(_ctx);
+  SetUi32(digest, val);
+}
+
+REGISTER_HASHER(CXXH32Hasher, 0x202, "XXH32", 4)
diff --git a/CPP/Common/XXH64Reg.cpp b/CPP/Common/XXH64Reg.cpp
new file mode 100644
index 00000000..ed924237
--- /dev/null
+++ b/CPP/Common/XXH64Reg.cpp
@@ -0,0 +1,44 @@
+// XXH64Reg.cpp
+
+#include "StdAfx.h"
+
+#define XXH_STATIC_LINKING_ONLY
+#include "../../C/CpuArch.h"
+#include "../../C/zstd/xxhash.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+class CXXH64Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  XXH64_state_t *_ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CXXH64Hasher() { _ctx = XXH64_createState(); }
+  ~CXXH64Hasher() { XXH64_freeState(_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CXXH64Hasher::Init() throw()
+{
+  XXH64_reset(_ctx, 0);
+}
+
+STDMETHODIMP_(void) CXXH64Hasher::Update(const void *data, UInt32 size) throw()
+{
+  XXH64_update(_ctx, data, size);
+}
+
+STDMETHODIMP_(void) CXXH64Hasher::Final(Byte *digest) throw()
+{
+  UInt64 val = XXH64_digest(_ctx);
+  SetUi64(digest, val);
+}
+
+REGISTER_HASHER(CXXH64Hasher, 0x203, "XXH64", 8)

From 7252a465e54975496eae7e4afd901ce5972f5b78 Mon Sep 17 00:00:00 2001
From: Tino Reichardt <milky-7zip@mcmilk.de>
Date: Thu, 1 Nov 2018 18:17:21 +0100
Subject: [PATCH 02/11] Add Blake2s to CPP/Common - was in the Rar5 Code

---
 CPP/7zip/Archive/Rar/Rar5Handler.cpp | 33 +--------------------
 CPP/7zip/Bundles/Format7zF/Arc.mak   |  1 +
 CPP/7zip/Bundles/Format7zFO/Arc.mak  |  1 +
 CPP/Common/Blake2sReg.cpp            | 43 ++++++++++++++++++++++++++++
 4 files changed, 46 insertions(+), 32 deletions(-)
 create mode 100644 CPP/Common/Blake2sReg.cpp

diff --git a/CPP/7zip/Archive/Rar/Rar5Handler.cpp b/CPP/7zip/Archive/Rar/Rar5Handler.cpp
index 61c9fc72..8138725b 100644
--- a/CPP/7zip/Archive/Rar/Rar5Handler.cpp
+++ b/CPP/7zip/Archive/Rar/Rar5Handler.cpp
@@ -2962,35 +2962,4 @@ REGISTER_ARC_I(
   NULL)
 
 }}
-
-
-class CBlake2spHasher:
-  public IHasher,
-  public CMyUnknownImp
-{
-  CBlake2sp _blake;
-  Byte mtDummy[1 << 7];
-
-public:
-  CBlake2spHasher() { Init(); }
-
-  MY_UNKNOWN_IMP
-  INTERFACE_IHasher(;)
-};
-
-STDMETHODIMP_(void) CBlake2spHasher::Init() throw()
-{
-  Blake2sp_Init(&_blake);
-}
-
-STDMETHODIMP_(void) CBlake2spHasher::Update(const void *data, UInt32 size) throw()
-{
-  Blake2sp_Update(&_blake, (const Byte *)data, size);
-}
-
-STDMETHODIMP_(void) CBlake2spHasher::Final(Byte *digest) throw()
-{
-  Blake2sp_Final(&_blake, digest);
-}
-
-REGISTER_HASHER(CBlake2spHasher, 0x202, "BLAKE2sp", BLAKE2S_DIGEST_SIZE)
+

diff --git a/CPP/7zip/Bundles/Format7zF/Arc.mak b/CPP/7zip/Bundles/Format7zF/Arc.mak
index b3dabeb9..990ee120 100644
--- a/CPP/7zip/Bundles/Format7zF/Arc.mak
+++ b/CPP/7zip/Bundles/Format7zF/Arc.mak
@@ -1,4 +1,5 @@
 COMMON_OBJS = \
+  $O\Blake2sReg.obj \
   $O\CRC.obj \
   $O\CrcReg.obj \
   $O\DynLimBuf.obj \
diff --git a/CPP/7zip/Bundles/Format7zFO/Arc.mak b/CPP/7zip/Bundles/Format7zFO/Arc.mak
index b78e4c1b..a678f896 100644
--- a/CPP/7zip/Bundles/Format7zFO/Arc.mak
+++ b/CPP/7zip/Bundles/Format7zFO/Arc.mak
@@ -1,4 +1,5 @@
 COMMON_OBJS = \
+  $O\Blake2sReg.obj \
   $O\CRC.obj \
   $O\CrcReg.obj \
   $O\DynLimBuf.obj \
diff --git a/CPP/Common/Blake2sReg.cpp b/CPP/Common/Blake2sReg.cpp
new file mode 100644
index 00000000..2d4b38fe
--- /dev/null
+++ b/CPP/Common/Blake2sReg.cpp
@@ -0,0 +1,43 @@
+//  Blake2sReg.cpp
+
+#include "StdAfx.h"
+
+#define XXH_STATIC_LINKING_ONLY
+#include "../../C/CpuArch.h"
+#include "../../C/Blake2.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+
+class CBlake2spHasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  CBlake2sp _blake;
+  Byte mtDummy[1 << 7];
+
+public:
+  CBlake2spHasher() { Init(); }
+
+  MY_UNKNOWN_IMP
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CBlake2spHasher::Init() throw()
+{
+  Blake2sp_Init(&_blake);
+}
+
+STDMETHODIMP_(void) CBlake2spHasher::Update(const void *data, UInt32 size) throw()
+{
+  Blake2sp_Update(&_blake, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CBlake2spHasher::Final(Byte *digest) throw()
+{
+  Blake2sp_Final(&_blake, digest);
+}
+
+REGISTER_HASHER(CBlake2spHasher, 0x202, "BLAKE2sp", BLAKE2S_DIGEST_SIZE)

From 1048d4e13356432bf7f27a8b57b8b51c86f4eae4 Mon Sep 17 00:00:00 2001
From: Tino Reichardt <milky-7zip@mcmilk.de>
Date: Thu, 1 Nov 2018 18:18:34 +0100
Subject: [PATCH 03/11] Minor fixes - fix Zstandard Sfx stuff ->
 SetNumberOfThreads() - fix formatting of XXH32Reg.cpp and XXH64Reg.cpp - add
 Blake2s hash to explorer context menu

---
 CPP/7zip/Compress/ZstdDecoder.cpp    | 10 ++--
 CPP/7zip/UI/Explorer/ContextMenu.cpp | 16 ++---
 CPP/7zip/UI/Explorer/ContextMenu.h   |  1 +
 CPP/Common/XXH32Reg.cpp              | 88 ++++++++++++++--------------
 CPP/Common/XXH64Reg.cpp              | 88 ++++++++++++++--------------
 5 files changed, 103 insertions(+), 100 deletions(-)

diff --git a/CPP/7zip/Compress/ZstdDecoder.cpp b/CPP/7zip/Compress/ZstdDecoder.cpp
index 8bad5aef..f807acfe 100644
--- a/CPP/7zip/Compress/ZstdDecoder.cpp
+++ b/CPP/7zip/Compress/ZstdDecoder.cpp
@@ -173,11 +173,6 @@ STDMETHODIMP CDecoder::SetInStream(ISequentialInStream * inStream)
   return S_OK;
 }
 
-STDMETHODIMP CDecoder::SetNumberOfThreads(UInt32 /* numThreads */)
-{
-  return S_OK;
-}
-
 STDMETHODIMP CDecoder::ReleaseInStream()
 {
   _inStream.Release();
@@ -185,6 +180,11 @@ STDMETHODIMP CDecoder::ReleaseInStream()
 }
 #endif
 
+STDMETHODIMP CDecoder::SetNumberOfThreads(UInt32 /* numThreads */)
+{
+  return S_OK;
+}
+
 HRESULT CDecoder::CodeResume(ISequentialOutStream * outStream, const UInt64 * outSize, ICompressProgressInfo * progress)
 {
   RINOK(SetOutStreamSizeResume(outSize));
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.cpp b/CPP/7zip/UI/Explorer/ContextMenu.cpp
index 4b2e22c7..1e00c4f3 100644
--- a/CPP/7zip/UI/Explorer/ContextMenu.cpp
+++ b/CPP/7zip/UI/Explorer/ContextMenu.cpp
@@ -221,13 +221,14 @@ struct CHashCommand
 
 static const CHashCommand g_HashCommands[] =
 {
-  { CZipContextMenu::kHash_CRC32,  "CRC-32",  "CRC32" },
-  { CZipContextMenu::kHash_CRC64,  "CRC-64",  "CRC64" },
-  { CZipContextMenu::kHash_SHA1,   "SHA-1",   "SHA1" },
-  { CZipContextMenu::kHash_SHA256, "SHA-256", "SHA256" },
-  { CZipContextMenu::kHash_XXH32,  "XXH-32",  "XXH32" },
-  { CZipContextMenu::kHash_XXH64,  "XXH-64",  "XXH64" },
-  { CZipContextMenu::kHash_All,    "*",       "*" }
+  { CZipContextMenu::kHash_CRC32,   "CRC-32",  "CRC32" },
+  { CZipContextMenu::kHash_CRC64,   "CRC-64",  "CRC64" },
+  { CZipContextMenu::kHash_SHA1,    "SHA-1",   "SHA1" },
+  { CZipContextMenu::kHash_SHA256,  "SHA-256", "SHA256" },
+  { CZipContextMenu::kHash_BLAKE2s, "BLAKE2s", "BLAKE2s" },
+  { CZipContextMenu::kHash_XXH32,   "XXH-32",  "XXH32" },
+  { CZipContextMenu::kHash_XXH64,   "XXH-64",  "XXH64" },
+  { CZipContextMenu::kHash_All,     "*",       "*" }
 };
 
 static int FindCommand(CZipContextMenu::ECommandInternalID &id)
@@ -930,6 +931,7 @@ STDMETHODIMP CZipContextMenu::InvokeCommand(LPCMINVOKECOMMANDINFO commandInfo)
       case kHash_CRC64:
       case kHash_SHA1:
       case kHash_SHA256:
+      case kHash_BLAKE2s:
       case kHash_XXH32:
       case kHash_XXH64:
       case kHash_All:
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.h b/CPP/7zip/UI/Explorer/ContextMenu.h
index 58f8b253..914ac35c 100644
--- a/CPP/7zip/UI/Explorer/ContextMenu.h
+++ b/CPP/7zip/UI/Explorer/ContextMenu.h
@@ -36,6 +36,7 @@ public:
     kHash_CRC64,
     kHash_SHA1,
     kHash_SHA256,
+    kHash_BLAKE2s,
     kHash_XXH32,
     kHash_XXH64,
     kHash_All
diff --git a/CPP/Common/XXH32Reg.cpp b/CPP/Common/XXH32Reg.cpp
index a3f1bfa2..c0ccea43 100644
--- a/CPP/Common/XXH32Reg.cpp
+++ b/CPP/Common/XXH32Reg.cpp
@@ -1,44 +1,44 @@
-// XXH32Reg.cpp
-
-#include "StdAfx.h"
-
-#define XXH_STATIC_LINKING_ONLY
-#include "../../C/CpuArch.h"
-#include "../../C/zstd/xxhash.h"
-
-#include "../Common/MyCom.h"
-
-#include "../7zip/Common/RegisterCodec.h"
-
-class CXXH32Hasher:
-  public IHasher,
-  public CMyUnknownImp
-{
-  XXH32_state_t *_ctx;
-  Byte mtDummy[1 << 7];
-
-public:
-  CXXH32Hasher() { _ctx = XXH32_createState(); }
-  ~CXXH32Hasher() { XXH32_freeState(_ctx); }
-
-  MY_UNKNOWN_IMP1(IHasher)
-  INTERFACE_IHasher(;)
-};
-
-STDMETHODIMP_(void) CXXH32Hasher::Init() throw()
-{
-  XXH32_reset(_ctx, 0);
-}
-
-STDMETHODIMP_(void) CXXH32Hasher::Update(const void *data, UInt32 size) throw()
-{
-  XXH32_update(_ctx, data, size);
-}
-
-STDMETHODIMP_(void) CXXH32Hasher::Final(Byte *digest) throw()
-{
-  UInt32 val = XXH32_digest(_ctx);
-  SetUi32(digest, val);
-}
-
-REGISTER_HASHER(CXXH32Hasher, 0x202, "XXH32", 4)
+// XXH32Reg.cpp
+
+#include "StdAfx.h"
+
+#define XXH_STATIC_LINKING_ONLY
+#include "../../C/CpuArch.h"
+#include "../../C/zstd/xxhash.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+class CXXH32Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  XXH32_state_t *_ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CXXH32Hasher() { _ctx = XXH32_createState(); }
+  ~CXXH32Hasher() { XXH32_freeState(_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CXXH32Hasher::Init() throw()
+{
+  XXH32_reset(_ctx, 0);
+}
+
+STDMETHODIMP_(void) CXXH32Hasher::Update(const void *data, UInt32 size) throw()
+{
+  XXH32_update(_ctx, data, size);
+}
+
+STDMETHODIMP_(void) CXXH32Hasher::Final(Byte *digest) throw()
+{
+  UInt32 val = XXH32_digest(_ctx);
+  SetUi32(digest, val);
+}
+
+REGISTER_HASHER(CXXH32Hasher, 0x203, "XXH32", 4)
diff --git a/CPP/Common/XXH64Reg.cpp b/CPP/Common/XXH64Reg.cpp
index ed924237..9a316d50 100644
--- a/CPP/Common/XXH64Reg.cpp
+++ b/CPP/Common/XXH64Reg.cpp
@@ -1,44 +1,44 @@
-// XXH64Reg.cpp
-
-#include "StdAfx.h"
-
-#define XXH_STATIC_LINKING_ONLY
-#include "../../C/CpuArch.h"
-#include "../../C/zstd/xxhash.h"
-
-#include "../Common/MyCom.h"
-
-#include "../7zip/Common/RegisterCodec.h"
-
-class CXXH64Hasher:
-  public IHasher,
-  public CMyUnknownImp
-{
-  XXH64_state_t *_ctx;
-  Byte mtDummy[1 << 7];
-
-public:
-  CXXH64Hasher() { _ctx = XXH64_createState(); }
-  ~CXXH64Hasher() { XXH64_freeState(_ctx); }
-
-  MY_UNKNOWN_IMP1(IHasher)
-  INTERFACE_IHasher(;)
-};
-
-STDMETHODIMP_(void) CXXH64Hasher::Init() throw()
-{
-  XXH64_reset(_ctx, 0);
-}
-
-STDMETHODIMP_(void) CXXH64Hasher::Update(const void *data, UInt32 size) throw()
-{
-  XXH64_update(_ctx, data, size);
-}
-
-STDMETHODIMP_(void) CXXH64Hasher::Final(Byte *digest) throw()
-{
-  UInt64 val = XXH64_digest(_ctx);
-  SetUi64(digest, val);
-}
-
-REGISTER_HASHER(CXXH64Hasher, 0x203, "XXH64", 8)
+// XXH64Reg.cpp
+
+#include "StdAfx.h"
+
+#define XXH_STATIC_LINKING_ONLY
+#include "../../C/CpuArch.h"
+#include "../../C/zstd/xxhash.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+class CXXH64Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  XXH64_state_t *_ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CXXH64Hasher() { _ctx = XXH64_createState(); }
+  ~CXXH64Hasher() { XXH64_freeState(_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CXXH64Hasher::Init() throw()
+{
+  XXH64_reset(_ctx, 0);
+}
+
+STDMETHODIMP_(void) CXXH64Hasher::Update(const void *data, UInt32 size) throw()
+{
+  XXH64_update(_ctx, data, size);
+}
+
+STDMETHODIMP_(void) CXXH64Hasher::Final(Byte *digest) throw()
+{
+  UInt64 val = XXH64_digest(_ctx);
+  SetUi64(digest, val);
+}
+
+REGISTER_HASHER(CXXH64Hasher, 0x204, "XXH64", 8)

From 68f3dcfeb97cff0104492ddc711fa8aa985b87bf Mon Sep 17 00:00:00 2001
From: Tino Reichardt <milky-7zip@mcmilk.de>
Date: Thu, 1 Nov 2018 18:28:22 +0100
Subject: [PATCH 04/11] Google has even more windowbits then
 BROTLI_MAX_WINDOW_BITS - it's the BROTLI_LARGE_MAX_WINDOW_BITS ;)

---
 C/zstdmt/brotli-mt_compress.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/C/zstdmt/brotli-mt_compress.c b/C/zstdmt/brotli-mt_compress.c
index a18b2ac7..107d759e 100644
--- a/C/zstdmt/brotli-mt_compress.c
+++ b/C/zstdmt/brotli-mt_compress.c
@@ -267,7 +267,7 @@ static void *pt_compress(void *arg)
 			uint8_t *obuf = (uint8_t*)wl->out.buf + 16;
 			wl->out.size -= 16;
 			rv = BrotliEncoderCompress(ctx->level,
-						   BROTLI_MAX_WINDOW_BITS,
+						   BROTLI_LARGE_MAX_WINDOW_BITS,
 						   BROTLI_MODE_GENERIC, in.size,
 						   ibuf, &wl->out.size, obuf);
 

From 9947dd780b30c60f346af637f949fe20ac566116 Mon Sep 17 00:00:00 2001
From: Tino Reichardt <milky-7zip@mcmilk.de>
Date: Thu, 1 Nov 2018 22:47:25 +0100
Subject: [PATCH 05/11] Fix naming: Blake2s -> Blake2sp

---
 CPP/7zip/Bundles/Format7zF/Arc.mak             |  2 +-
 CPP/7zip/Bundles/Format7zFO/Arc.mak            |  2 +-
 CPP/7zip/UI/Explorer/ContextMenu.cpp           | 18 +++++++++---------
 CPP/7zip/UI/Explorer/ContextMenu.h             |  2 +-
 CPP/Common/{Blake2sReg.cpp => Blake2spReg.cpp} |  0
 5 files changed, 12 insertions(+), 12 deletions(-)
 rename CPP/Common/{Blake2sReg.cpp => Blake2spReg.cpp} (100%)

diff --git a/CPP/7zip/Bundles/Format7zF/Arc.mak b/CPP/7zip/Bundles/Format7zF/Arc.mak
index 990ee120..c76bb7e4 100644
--- a/CPP/7zip/Bundles/Format7zF/Arc.mak
+++ b/CPP/7zip/Bundles/Format7zF/Arc.mak
@@ -1,5 +1,5 @@
 COMMON_OBJS = \
-  $O\Blake2sReg.obj \
+  $O\Blake2spReg.obj \
   $O\CRC.obj \
   $O\CrcReg.obj \
   $O\DynLimBuf.obj \
diff --git a/CPP/7zip/Bundles/Format7zFO/Arc.mak b/CPP/7zip/Bundles/Format7zFO/Arc.mak
index a678f896..f9597f1e 100644
--- a/CPP/7zip/Bundles/Format7zFO/Arc.mak
+++ b/CPP/7zip/Bundles/Format7zFO/Arc.mak
@@ -1,5 +1,5 @@
 COMMON_OBJS = \
-  $O\Blake2sReg.obj \
+  $O\Blake2spReg.obj \
   $O\CRC.obj \
   $O\CrcReg.obj \
   $O\DynLimBuf.obj \
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.cpp b/CPP/7zip/UI/Explorer/ContextMenu.cpp
index 1e00c4f3..78c3a037 100644
--- a/CPP/7zip/UI/Explorer/ContextMenu.cpp
+++ b/CPP/7zip/UI/Explorer/ContextMenu.cpp
@@ -221,14 +221,14 @@ struct CHashCommand
 
 static const CHashCommand g_HashCommands[] =
 {
-  { CZipContextMenu::kHash_CRC32,   "CRC-32",  "CRC32" },
-  { CZipContextMenu::kHash_CRC64,   "CRC-64",  "CRC64" },
-  { CZipContextMenu::kHash_SHA1,    "SHA-1",   "SHA1" },
-  { CZipContextMenu::kHash_SHA256,  "SHA-256", "SHA256" },
-  { CZipContextMenu::kHash_BLAKE2s, "BLAKE2s", "BLAKE2s" },
-  { CZipContextMenu::kHash_XXH32,   "XXH-32",  "XXH32" },
-  { CZipContextMenu::kHash_XXH64,   "XXH-64",  "XXH64" },
-  { CZipContextMenu::kHash_All,     "*",       "*" }
+  { CZipContextMenu::kHash_CRC32,    "CRC-32",   "CRC32" },
+  { CZipContextMenu::kHash_CRC64,    "CRC-64",   "CRC64" },
+  { CZipContextMenu::kHash_SHA1,     "SHA-1",    "SHA1" },
+  { CZipContextMenu::kHash_SHA256,   "SHA-256",  "SHA256" },
+  { CZipContextMenu::kHash_BLAKE2sp, "BLAKE2sp", "BLAKE2sp" },
+  { CZipContextMenu::kHash_XXH32,    "XXH-32",   "XXH32" },
+  { CZipContextMenu::kHash_XXH64,    "XXH-64",   "XXH64" },
+  { CZipContextMenu::kHash_All,      "*",        "*" }
 };
 
 static int FindCommand(CZipContextMenu::ECommandInternalID &id)
@@ -931,7 +931,7 @@ STDMETHODIMP CZipContextMenu::InvokeCommand(LPCMINVOKECOMMANDINFO commandInfo)
       case kHash_CRC64:
       case kHash_SHA1:
       case kHash_SHA256:
-      case kHash_BLAKE2s:
+      case kHash_BLAKE2sp:
       case kHash_XXH32:
       case kHash_XXH64:
       case kHash_All:
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.h b/CPP/7zip/UI/Explorer/ContextMenu.h
index 914ac35c..231db845 100644
--- a/CPP/7zip/UI/Explorer/ContextMenu.h
+++ b/CPP/7zip/UI/Explorer/ContextMenu.h
@@ -36,7 +36,7 @@ public:
     kHash_CRC64,
     kHash_SHA1,
     kHash_SHA256,
-    kHash_BLAKE2s,
+    kHash_BLAKE2sp,
     kHash_XXH32,
     kHash_XXH64,
     kHash_All
diff --git a/CPP/Common/Blake2sReg.cpp b/CPP/Common/Blake2spReg.cpp
similarity index 100%
rename from CPP/Common/Blake2sReg.cpp
rename to CPP/Common/Blake2spReg.cpp

From add56b5aed99ff011fcc20aad5c77cda791eab28 Mon Sep 17 00:00:00 2001
From: Tino Reichardt <milky-7zip@mcmilk.de>
Date: Thu, 1 Nov 2018 23:08:00 +0100
Subject: [PATCH 06/11] Add MD5 hash function

---
 C/md5.c                              | 288 +++++++++++++++++++++++++++
 C/md5.h                              |  43 ++++
 CPP/7zip/Bundles/Format7zF/Arc.mak   |   2 +
 CPP/7zip/Bundles/Format7zFO/Arc.mak  |   2 +
 CPP/7zip/UI/Explorer/ContextMenu.cpp |   2 +
 CPP/7zip/UI/Explorer/ContextMenu.h   |   1 +
 CPP/Common/MD5Reg.cpp                |  40 ++++
 7 files changed, 378 insertions(+)
 create mode 100644 C/md5.c
 create mode 100644 C/md5.h
 create mode 100644 CPP/Common/MD5Reg.cpp

diff --git a/C/md5.c b/C/md5.c
new file mode 100644
index 00000000..7ee33fbb
--- /dev/null
+++ b/C/md5.c
@@ -0,0 +1,288 @@
+
+/*
+ * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
+ * MD5 Message-Digest Algorithm (RFC 1321).
+ *
+ * Homepage:
+ * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
+ *
+ * Author:
+ * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
+ *
+ * This software was written by Alexander Peslyak in 2001.  No copyright is
+ * claimed, and the software is hereby placed in the public domain.
+ * In case this attempt to disclaim copyright and place the software in the
+ * public domain is deemed null and void, then the software is
+ * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
+ * general public under the following terms:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted.
+ *
+ * There's ABSOLUTELY NO WARRANTY, express or implied.
+ *
+ * (This is a heavily cut-down "BSD license".)
+ *
+ * This differs from Colin Plumb's older public domain implementation in that
+ * no exactly 32-bit integer data type is required (any 32-bit or wider
+ * unsigned integer data type will do), there's no compile-time endianness
+ * configuration, and the function prototypes match OpenSSL's.  No code from
+ * Colin Plumb's implementation has been reused; this comment merely compares
+ * the properties of the two independent implementations.
+ *
+ * The primary goals of this implementation are portability and ease of use.
+ * It is meant to be fast, but not as fast as possible.  Some known
+ * optimizations are not included to reduce source code size and avoid
+ * compile-time configuration.
+ */
+
+#include <string.h>
+
+#include "md5.h"
+
+/*
+ * The basic MD5 functions.
+ *
+ * F and G are optimized compared to their RFC 1321 definitions for
+ * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
+ * implementation.
+ */
+#define F(x, y, z)			((z) ^ ((x) & ((y) ^ (z))))
+#define G(x, y, z)			((y) ^ ((z) & ((x) ^ (y))))
+#define H(x, y, z)			(((x) ^ (y)) ^ (z))
+#define H2(x, y, z)			((x) ^ ((y) ^ (z)))
+#define I(x, y, z)			((y) ^ ((x) | ~(z)))
+
+/*
+ * The MD5 transformation for all four rounds.
+ */
+#define STEP(f, a, b, c, d, x, t, s) \
+	(a) += f((b), (c), (d)) + (x) + (t); \
+	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
+	(a) += (b);
+
+/*
+ * SET reads 4 input bytes in little-endian byte order and stores them in a
+ * properly aligned word in host byte order.
+ *
+ * The check for little-endian architectures that tolerate unaligned memory
+ * accesses is just an optimization.  Nothing will break if it fails to detect
+ * a suitable architecture.
+ *
+ * Unfortunately, this optimization may be a C strict aliasing rules violation
+ * if the caller's data buffer has effective type that cannot be aliased by
+ * MD5_u32plus.  In practice, this problem may occur if these MD5 routines are
+ * inlined into a calling function, or with future and dangerously advanced
+ * link-time optimizations.  For the time being, keeping these MD5 routines in
+ * their own translation unit avoids the problem.
+ */
+#if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
+#define SET(n) \
+	(*(MD5_u32plus *)&ptr[(n) * 4])
+#define GET(n) \
+	SET(n)
+#else
+#define SET(n) \
+	(ctx->block[(n)] = \
+	(MD5_u32plus)ptr[(n) * 4] | \
+	((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
+	((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
+	((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
+#define GET(n) \
+	(ctx->block[(n)])
+#endif
+
+/*
+ * This processes one or more 64-byte data blocks, but does NOT update the bit
+ * counters.  There are no alignment requirements.
+ */
+static const void *body(MD5_CTX *ctx, const void *data, unsigned long size)
+{
+	const unsigned char *ptr;
+	MD5_u32plus a, b, c, d;
+	MD5_u32plus saved_a, saved_b, saved_c, saved_d;
+
+	ptr = (const unsigned char *)data;
+
+	a = ctx->a;
+	b = ctx->b;
+	c = ctx->c;
+	d = ctx->d;
+
+	do {
+		saved_a = a;
+		saved_b = b;
+		saved_c = c;
+		saved_d = d;
+
+/* Round 1 */
+		STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
+		STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
+		STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
+		STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
+		STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
+		STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
+		STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
+		STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
+		STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
+		STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
+		STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
+		STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
+		STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
+		STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
+		STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
+		STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
+
+/* Round 2 */
+		STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
+		STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
+		STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
+		STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
+		STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
+		STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
+		STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
+		STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
+		STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
+		STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
+		STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
+		STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
+		STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
+		STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
+		STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
+		STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
+
+/* Round 3 */
+		STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
+		STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11)
+		STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
+		STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23)
+		STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
+		STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11)
+		STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
+		STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23)
+		STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
+		STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11)
+		STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
+		STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23)
+		STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
+		STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11)
+		STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
+		STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23)
+
+/* Round 4 */
+		STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
+		STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
+		STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
+		STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
+		STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
+		STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
+		STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
+		STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
+		STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
+		STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
+		STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
+		STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
+		STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
+		STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
+		STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
+		STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
+
+		a += saved_a;
+		b += saved_b;
+		c += saved_c;
+		d += saved_d;
+
+		ptr += 64;
+	} while (size -= 64);
+
+	ctx->a = a;
+	ctx->b = b;
+	ctx->c = c;
+	ctx->d = d;
+
+	return ptr;
+}
+
+void MD5_Init(MD5_CTX *ctx)
+{
+	ctx->a = 0x67452301;
+	ctx->b = 0xefcdab89;
+	ctx->c = 0x98badcfe;
+	ctx->d = 0x10325476;
+
+	ctx->lo = 0;
+	ctx->hi = 0;
+}
+
+void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size)
+{
+	MD5_u32plus saved_lo;
+	unsigned long used, available;
+
+	saved_lo = ctx->lo;
+	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
+		ctx->hi++;
+	ctx->hi += size >> 29;
+
+	used = saved_lo & 0x3f;
+
+	if (used) {
+		available = 64 - used;
+
+		if (size < available) {
+			memcpy(&ctx->buffer[used], data, size);
+			return;
+		}
+
+		memcpy(&ctx->buffer[used], data, available);
+		data = (const unsigned char *)data + available;
+		size -= available;
+		body(ctx, ctx->buffer, 64);
+	}
+
+	if (size >= 64) {
+		data = body(ctx, data, size & ~(unsigned long)0x3f);
+		size &= 0x3f;
+	}
+
+	memcpy(ctx->buffer, data, size);
+}
+
+#define OUT(dst, src) \
+	(dst)[0] = (unsigned char)(src); \
+	(dst)[1] = (unsigned char)((src) >> 8); \
+	(dst)[2] = (unsigned char)((src) >> 16); \
+	(dst)[3] = (unsigned char)((src) >> 24);
+
+void MD5_Final(MD5_CTX *ctx, unsigned char *result)
+{
+	unsigned long used, available;
+
+	used = ctx->lo & 0x3f;
+
+	ctx->buffer[used++] = 0x80;
+
+	available = 64 - used;
+
+	if (available < 8) {
+		memset(&ctx->buffer[used], 0, available);
+		body(ctx, ctx->buffer, 64);
+		used = 0;
+		available = 64;
+	}
+
+	memset(&ctx->buffer[used], 0, available - 8);
+
+	ctx->lo <<= 3;
+	OUT(&ctx->buffer[56], ctx->lo)
+	OUT(&ctx->buffer[60], ctx->hi)
+
+	body(ctx, ctx->buffer, 64);
+
+	OUT(&result[0], ctx->a)
+	OUT(&result[4], ctx->b)
+	OUT(&result[8], ctx->c)
+	OUT(&result[12], ctx->d)
+
+	memset(ctx, 0, sizeof(*ctx));
+}
diff --git a/C/md5.h b/C/md5.h
new file mode 100644
index 00000000..9bf99d29
--- /dev/null
+++ b/C/md5.h
@@ -0,0 +1,43 @@
+/*
+ * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
+ * MD5 Message-Digest Algorithm (RFC 1321).
+ *
+ * Homepage:
+ * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
+ *
+ * Author:
+ * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
+ *
+ * This software was written by Alexander Peslyak in 2001.  No copyright is
+ * claimed, and the software is hereby placed in the public domain.
+ * In case this attempt to disclaim copyright and place the software in the
+ * public domain is deemed null and void, then the software is
+ * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
+ * general public under the following terms:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted.
+ *
+ * There's ABSOLUTELY NO WARRANTY, express or implied.
+ *
+ * See md5.c for more information.
+ */
+
+#ifndef _MD5_H
+#define _MD5_H
+
+/* Any 32-bit or wider unsigned integer data type will do */
+typedef unsigned int MD5_u32plus;
+
+typedef struct {
+	MD5_u32plus lo, hi;
+	MD5_u32plus a, b, c, d;
+	unsigned char buffer[64];
+	MD5_u32plus block[16];
+} MD5_CTX;
+
+extern void MD5_Init(MD5_CTX *ctx);
+extern void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size);
+extern void MD5_Final(MD5_CTX *ctx, unsigned char *result);
+
+#endif
diff --git a/CPP/7zip/Bundles/Format7zF/Arc.mak b/CPP/7zip/Bundles/Format7zF/Arc.mak
index c76bb7e4..f5026b38 100644
--- a/CPP/7zip/Bundles/Format7zF/Arc.mak
+++ b/CPP/7zip/Bundles/Format7zF/Arc.mak
@@ -4,6 +4,7 @@ COMMON_OBJS = \
   $O\CrcReg.obj \
   $O\DynLimBuf.obj \
   $O\IntToString.obj \
+  $O\MD5Reg.obj \
   $O\MyMap.obj \
   $O\MyString.obj \
   $O\MyVector.obj \
@@ -289,6 +290,7 @@ C_OBJS = \
   $O\XzDec.obj \
   $O\XzEnc.obj \
   $O\XzIn.obj \
+  $O\md5.obj \
 
 !include "../../Aes.mak"
 !include "../../Crc.mak"
diff --git a/CPP/7zip/Bundles/Format7zFO/Arc.mak b/CPP/7zip/Bundles/Format7zFO/Arc.mak
index f9597f1e..ce69689c 100644
--- a/CPP/7zip/Bundles/Format7zFO/Arc.mak
+++ b/CPP/7zip/Bundles/Format7zFO/Arc.mak
@@ -4,6 +4,7 @@ COMMON_OBJS = \
   $O\CrcReg.obj \
   $O\DynLimBuf.obj \
   $O\IntToString.obj \
+  $O\MD5Reg.obj \
   $O\MyMap.obj \
   $O\MyString.obj \
   $O\MyVector.obj \
@@ -287,6 +288,7 @@ C_OBJS = \
   $O\XzDec.obj \
   $O\XzEnc.obj \
   $O\XzIn.obj \
+  $O\md5.obj \
 
 !include "../../Aes.mak"
 !include "../../Crc.mak"
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.cpp b/CPP/7zip/UI/Explorer/ContextMenu.cpp
index 78c3a037..91849827 100644
--- a/CPP/7zip/UI/Explorer/ContextMenu.cpp
+++ b/CPP/7zip/UI/Explorer/ContextMenu.cpp
@@ -223,6 +223,7 @@ static const CHashCommand g_HashCommands[] =
 {
   { CZipContextMenu::kHash_CRC32,    "CRC-32",   "CRC32" },
   { CZipContextMenu::kHash_CRC64,    "CRC-64",   "CRC64" },
+  { CZipContextMenu::kHash_MD5,      "MD5",      "MD5" },
   { CZipContextMenu::kHash_SHA1,     "SHA-1",    "SHA1" },
   { CZipContextMenu::kHash_SHA256,   "SHA-256",  "SHA256" },
   { CZipContextMenu::kHash_BLAKE2sp, "BLAKE2sp", "BLAKE2sp" },
@@ -934,6 +935,7 @@ STDMETHODIMP CZipContextMenu::InvokeCommand(LPCMINVOKECOMMANDINFO commandInfo)
       case kHash_BLAKE2sp:
       case kHash_XXH32:
       case kHash_XXH64:
+      case kHash_MD5:
       case kHash_All:
       {
         for (unsigned i = 0; i < ARRAY_SIZE(g_HashCommands); i++)
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.h b/CPP/7zip/UI/Explorer/ContextMenu.h
index 231db845..41755c04 100644
--- a/CPP/7zip/UI/Explorer/ContextMenu.h
+++ b/CPP/7zip/UI/Explorer/ContextMenu.h
@@ -34,6 +34,7 @@ public:
     kCompressToZipEmail,
     kHash_CRC32,
     kHash_CRC64,
+    kHash_MD5,
     kHash_SHA1,
     kHash_SHA256,
     kHash_BLAKE2sp,
diff --git a/CPP/Common/MD5Reg.cpp b/CPP/Common/MD5Reg.cpp
new file mode 100644
index 00000000..a45ba64f
--- /dev/null
+++ b/CPP/Common/MD5Reg.cpp
@@ -0,0 +1,40 @@
+// MD5Reg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/md5.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+class CMD5Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  MD5_CTX _ctx;
+  Byte mtDummy[1 << 7];
+  
+public:
+  CMD5Hasher() { MD5_Init(&_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CMD5Hasher::Init() throw()
+{
+  MD5_Init(&_ctx);
+}
+
+STDMETHODIMP_(void) CMD5Hasher::Update(const void *data, UInt32 size) throw()
+{
+  MD5_Update(&_ctx, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CMD5Hasher::Final(Byte *digest) throw()
+{
+  MD5_Final(&_ctx, digest);
+}
+
+REGISTER_HASHER(CMD5Hasher, 0x205, "MD5", 16)

From 36a17a5184387ddd823feb2f4da01de9f0a81ade Mon Sep 17 00:00:00 2001
From: Tino Reichardt <milky-7zip@mcmilk.de>
Date: Sat, 3 Nov 2018 00:18:33 +0100
Subject: [PATCH 07/11] Add some hash functions - new: md2, md4, md5, sha384,
 sha512, xxhash-32, xxhash-64 - put Blake2sp hash stuff back to rar code -
 added the hashes to GUI and Explorer Menu code

---
 C/hashes/hash.h                        |  57 +++++
 C/hashes/md2.c                         | 133 +++++++++++
 C/hashes/md2.h                         |  57 +++++
 C/hashes/md4.c                         | 264 ++++++++++++++++++++++
 C/hashes/md4.h                         |  56 +++++
 C/hashes/md5.c                         | 288 ++++++++++++++++++++++++
 C/hashes/md5.h                         |  56 +++++
 C/hashes/sha.h                         |  68 ++++++
 C/hashes/sha512.c                      | 297 +++++++++++++++++++++++++
 C/md5.c                                | 288 ------------------------
 C/md5.h                                |  43 ----
 CPP/7zip/7zip.mak                      |   4 +
 CPP/7zip/Archive/Rar/Rar5Handler.cpp   |  33 ++-
 CPP/7zip/Bundles/Format7zF/Arc.mak     |  15 +-
 CPP/7zip/Bundles/Format7zFO/Arc.mak    |  16 +-
 CPP/7zip/Bundles/Format7zFO/makefile   |   3 +-
 CPP/7zip/Common/RegisterCodec.h        |   2 +-
 CPP/7zip/UI/Explorer/ContextMenu.cpp   |  18 +-
 CPP/7zip/UI/Explorer/ContextMenu.h     |   8 +-
 CPP/7zip/UI/FileManager/MyLoadMenu.cpp |  10 +-
 CPP/7zip/UI/FileManager/resource.h     |  12 +-
 CPP/7zip/UI/FileManager/resource.rc    |   8 +
 CPP/Common/Blake2spReg.cpp             |  43 ----
 CPP/Common/HashesReg.cpp               | 237 ++++++++++++++++++++
 CPP/Common/Md2Reg.cpp                  |  43 ++++
 CPP/Common/Md4Reg.cpp                  |  43 ++++
 CPP/Common/{MD5Reg.cpp => Md5Reg.cpp}  |  17 +-
 CPP/Common/Sha384Reg.cpp               |  43 ++++
 CPP/Common/Sha512Reg.cpp               |  43 ++++
 CPP/Common/XXH32Reg.cpp                |   7 +-
 CPP/Common/XXH64Reg.cpp                |   8 +-
 31 files changed, 1812 insertions(+), 408 deletions(-)
 create mode 100644 C/hashes/hash.h
 create mode 100644 C/hashes/md2.c
 create mode 100644 C/hashes/md2.h
 create mode 100644 C/hashes/md4.c
 create mode 100644 C/hashes/md4.h
 create mode 100644 C/hashes/md5.c
 create mode 100644 C/hashes/md5.h
 create mode 100644 C/hashes/sha.h
 create mode 100644 C/hashes/sha512.c
 delete mode 100644 C/md5.c
 delete mode 100644 C/md5.h
 delete mode 100644 CPP/Common/Blake2spReg.cpp
 create mode 100644 CPP/Common/HashesReg.cpp
 create mode 100644 CPP/Common/Md2Reg.cpp
 create mode 100644 CPP/Common/Md4Reg.cpp
 rename CPP/Common/{MD5Reg.cpp => Md5Reg.cpp} (68%)
 create mode 100644 CPP/Common/Sha384Reg.cpp
 create mode 100644 CPP/Common/Sha512Reg.cpp

diff --git a/C/hashes/hash.h b/C/hashes/hash.h
new file mode 100644
index 00000000..652b184c
--- /dev/null
+++ b/C/hashes/hash.h
@@ -0,0 +1,57 @@
+
+/*
+ * Copyright (c) 1999 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of KTH nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY KTH AND ITS CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KTH OR ITS CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
+
+/* $Id$ */
+
+/* stuff in common between md4, md5, and sha1 */
+
+#ifndef __hash_h__
+#define __hash_h__
+
+#include <string.h>
+
+#include "../7zTypes.h"
+
+#ifndef uint32_t
+typedef UInt32 uint32_t;
+#endif
+
+#ifndef uint64_t
+typedef UInt64 uint64_t;
+#endif
+
+#ifndef min
+#define min(a,b) (((a)>(b))?(b):(a))
+#endif
+
+#endif /* __hash_h__ */
diff --git a/C/hashes/md2.c b/C/hashes/md2.c
new file mode 100644
index 00000000..3bc1ab24
--- /dev/null
+++ b/C/hashes/md2.c
@@ -0,0 +1,133 @@
+
+/*
+ * Copyright (c) 2006 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "hash.h"
+#include "md2.h"
+
+static const unsigned char subst[256] = {
+  41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6,
+  19, 98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188,
+  76, 130, 202, 30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24,
+  138, 23, 229, 18, 190, 78, 196, 214, 218, 158, 222, 73, 160, 251,
+  245, 142, 187, 47, 238, 122, 169, 104, 121, 145, 21, 178, 7, 63,
+  148, 194, 16, 137, 11, 34, 95, 33, 128, 127, 93, 154, 90, 144, 50,
+  39, 53, 62, 204, 231, 191, 247, 151, 3, 255, 25, 48, 179, 72, 165,
+  181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56, 210,
+  150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157,
+  112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27,
+  96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15,
+  85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197,
+  234, 38, 44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65,
+  129, 77, 82, 106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123,
+  8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99, 232, 109, 233,
+  203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88, 208, 228,
+  166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237,
+  31, 26, 219, 153, 141, 51, 159, 17, 131, 20
+};
+
+void
+MD2_Init (struct md2 *m)
+{
+    memset(m, 0, sizeof(*m));
+}
+
+static void
+calc(struct md2 *m, const void *v)
+{
+    unsigned char x[48], L;
+    const unsigned char *p = v;
+    int i, j, t;
+
+    L = m->checksum[15];
+    for (i = 0; i < 16; i++)
+	L = m->checksum[i] ^= subst[p[i] ^ L];
+
+    for (i = 0; i < 16; i++) {
+	x[i]      = m->state[i];
+	x[i + 16] = p[i];
+	x[i + 32] = x[i] ^ p[i];
+    }
+
+    t = 0;
+    for (i = 0; i < 18; i++) {
+	for (j = 0; j < 48; j++)
+	    t = x[j] ^= subst[t];
+	t = (t + i) & 0xff;
+    }
+
+    memcpy(m->state, x, 16);
+    memset(x, 0, sizeof(x));
+}
+
+void
+MD2_Update (struct md2 *m, const void *v, size_t len)
+{
+    size_t idx = m->len & 0xf;
+    const unsigned char *p = v;
+
+    m->len += len;
+    if (len + idx >= 16) {
+	if (idx) {
+	    memcpy(m->data + idx, p, 16 - idx);
+	    calc(m, m->data);
+	    p += 16;
+	    len -= 16 - idx;
+	}
+	while (len >= 16) {
+	    calc(m, p);
+	    p += 16;
+	    len -= 16;
+	}
+	idx = 0;
+    }
+
+    memcpy(m->data + idx, p, len);
+}
+
+void
+MD2_Final (void *res, struct md2 *m)
+{
+    unsigned char pad[16];
+    size_t padlen;
+
+    padlen = 16 - (m->len % 16);
+    memset(pad, (int)padlen, padlen);
+
+    MD2_Update(m, pad, padlen);
+    memcpy(pad, m->checksum, 16);
+    MD2_Update(m, pad, 16);
+
+    memcpy(res, m->state, MD2_DIGEST_LENGTH);
+    memset(m, 0, sizeof(*m));
+}
diff --git a/C/hashes/md2.h b/C/hashes/md2.h
new file mode 100644
index 00000000..1985e98d
--- /dev/null
+++ b/C/hashes/md2.h
@@ -0,0 +1,57 @@
+
+/*
+ * Copyright (c) 2006 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* $Id$ */
+
+#ifndef HEIM_MD2_H
+#define HEIM_MD2_H 1
+
+#include "hash.h"
+
+#define MD2_DIGEST_LENGTH 16
+
+struct md2 {
+    size_t len;
+    unsigned char data[16]; /* stored unalligned data between Update's */
+    unsigned char checksum[16];
+    unsigned char state[16]; /* lower 16 bytes of X */
+};
+
+typedef struct md2 MD2_CTX;
+
+void MD2_Init (struct md2 *m);
+void MD2_Update (struct md2 *m, const void *p, size_t len);
+void MD2_Final (void *res, struct md2 *m);
+
+#endif /* HEIM_MD2_H */
diff --git a/C/hashes/md4.c b/C/hashes/md4.c
new file mode 100644
index 00000000..e61ffb2b
--- /dev/null
+++ b/C/hashes/md4.c
@@ -0,0 +1,264 @@
+
+/*
+ * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "hash.h"
+#include "md4.h"
+
+#define A m->counter[0]
+#define B m->counter[1]
+#define C m->counter[2]
+#define D m->counter[3]
+#define X data
+
+/* Vector Crays doesn't have a good 32-bit type, or more precisely,
+   int32_t as defined by <bind/bitypes.h> isn't 32 bits, and we don't
+   want to depend in being able to redefine this type.  To cope with
+   this we have to clamp the result in some places to [0,2^32); no
+   need to do this on other machines.  Did I say this was a mess?
+   */
+
+#ifdef _CRAY
+#define CRAYFIX(X) ((X) & 0xffffffff)
+#else
+#define CRAYFIX(X) (X)
+#endif
+
+static uint32_t cshift (uint32_t x, unsigned int n)
+{
+    x = CRAYFIX(x);
+    return CRAYFIX((x << n) | (x >> (32 - n)));
+}
+
+void
+MD4_Init (struct md4 *m)
+{
+  m->sz[0] = 0;
+  m->sz[1] = 0;
+  D = 0x10325476;
+  C = 0x98badcfe;
+  B = 0xefcdab89;
+  A = 0x67452301;
+}
+
+#define F(x,y,z) CRAYFIX((x & y) | (~x & z))
+#define G(x,y,z) ((x & y) | (x & z) | (y & z))
+#define H(x,y,z) (x ^ y ^ z)
+
+#define DOIT(a,b,c,d,k,s,i,OP) \
+a = cshift(a + OP(b,c,d) + X[k] + i, s)
+
+#define DO1(a,b,c,d,k,s,i) DOIT(a,b,c,d,k,s,i,F)
+#define DO2(a,b,c,d,k,s,i) DOIT(a,b,c,d,k,s,i,G)
+#define DO3(a,b,c,d,k,s,i) DOIT(a,b,c,d,k,s,i,H)
+
+static void
+calc (struct md4 *m, uint32_t *data)
+{
+  uint32_t AA, BB, CC, DD;
+
+  AA = A;
+  BB = B;
+  CC = C;
+  DD = D;
+
+  /* Round 1 */
+
+  DO1(A,B,C,D,0,3,0);
+  DO1(D,A,B,C,1,7,0);
+  DO1(C,D,A,B,2,11,0);
+  DO1(B,C,D,A,3,19,0);
+
+  DO1(A,B,C,D,4,3,0);
+  DO1(D,A,B,C,5,7,0);
+  DO1(C,D,A,B,6,11,0);
+  DO1(B,C,D,A,7,19,0);
+
+  DO1(A,B,C,D,8,3,0);
+  DO1(D,A,B,C,9,7,0);
+  DO1(C,D,A,B,10,11,0);
+  DO1(B,C,D,A,11,19,0);
+
+  DO1(A,B,C,D,12,3,0);
+  DO1(D,A,B,C,13,7,0);
+  DO1(C,D,A,B,14,11,0);
+  DO1(B,C,D,A,15,19,0);
+
+  /* Round 2 */
+
+  DO2(A,B,C,D,0,3,0x5A827999);
+  DO2(D,A,B,C,4,5,0x5A827999);
+  DO2(C,D,A,B,8,9,0x5A827999);
+  DO2(B,C,D,A,12,13,0x5A827999);
+
+  DO2(A,B,C,D,1,3,0x5A827999);
+  DO2(D,A,B,C,5,5,0x5A827999);
+  DO2(C,D,A,B,9,9,0x5A827999);
+  DO2(B,C,D,A,13,13,0x5A827999);
+
+  DO2(A,B,C,D,2,3,0x5A827999);
+  DO2(D,A,B,C,6,5,0x5A827999);
+  DO2(C,D,A,B,10,9,0x5A827999);
+  DO2(B,C,D,A,14,13,0x5A827999);
+
+  DO2(A,B,C,D,3,3,0x5A827999);
+  DO2(D,A,B,C,7,5,0x5A827999);
+  DO2(C,D,A,B,11,9,0x5A827999);
+  DO2(B,C,D,A,15,13,0x5A827999);
+
+  /* Round 3 */
+
+  DO3(A,B,C,D,0,3,0x6ED9EBA1);
+  DO3(D,A,B,C,8,9,0x6ED9EBA1);
+  DO3(C,D,A,B,4,11,0x6ED9EBA1);
+  DO3(B,C,D,A,12,15,0x6ED9EBA1);
+
+  DO3(A,B,C,D,2,3,0x6ED9EBA1);
+  DO3(D,A,B,C,10,9,0x6ED9EBA1);
+  DO3(C,D,A,B,6,11,0x6ED9EBA1);
+  DO3(B,C,D,A,14,15,0x6ED9EBA1);
+
+  DO3(A,B,C,D,1,3,0x6ED9EBA1);
+  DO3(D,A,B,C,9,9,0x6ED9EBA1);
+  DO3(C,D,A,B,5,11,0x6ED9EBA1);
+  DO3(B,C,D,A,13,15,0x6ED9EBA1);
+
+  DO3(A,B,C,D,3,3,0x6ED9EBA1);
+  DO3(D,A,B,C,11,9,0x6ED9EBA1);
+  DO3(C,D,A,B,7,11,0x6ED9EBA1);
+  DO3(B,C,D,A,15,15,0x6ED9EBA1);
+
+  A += AA;
+  B += BB;
+  C += CC;
+  D += DD;
+}
+
+/*
+ * From `Performance analysis of MD5' by Joseph D. Touch <touch@isi.edu>
+ */
+
+#if defined(WORDS_BIGENDIAN)
+static uint32_t
+swap_uint32_t (uint32_t t)
+{
+  uint32_t temp1, temp2;
+
+  temp1   = cshift(t, 16);
+  temp2   = temp1 >> 8;
+  temp1  &= 0x00ff00ff;
+  temp2  &= 0x00ff00ff;
+  temp1 <<= 8;
+  return temp1 | temp2;
+}
+#endif
+
+struct x32{
+  unsigned int a:32;
+  unsigned int b:32;
+};
+
+void
+MD4_Update (struct md4 *m, const void *v, size_t len)
+{
+    const unsigned char *p = v;
+    size_t old_sz = m->sz[0];
+    size_t offset;
+
+    m->sz[0] += (unsigned int)len * 8;
+    if (m->sz[0] < old_sz)
+	++m->sz[1];
+    offset = (old_sz / 8)  % 64;
+    while(len > 0) {
+	size_t l = min(len, 64 - offset);
+	memcpy(m->save + offset, p, l);
+	offset += l;
+	p += l;
+	len -= l;
+	if(offset == 64) {
+#if defined(WORDS_BIGENDIAN)
+	    int i;
+	    uint32_t current[16];
+	    struct x32 *us = (struct x32*)m->save;
+	    for(i = 0; i < 8; i++){
+		current[2*i+0] = swap_uint32_t(us[i].a);
+		current[2*i+1] = swap_uint32_t(us[i].b);
+	    }
+	    calc(m, current);
+#else
+	    calc(m, (uint32_t*)m->save);
+#endif
+	    offset = 0;
+	}
+    }
+}
+
+void
+MD4_Final (void *res, struct md4 *m)
+{
+  unsigned char zeros[72];
+  unsigned offset = (m->sz[0] / 8) % 64;
+  unsigned int dstart = (120 - offset - 1) % 64 + 1;
+
+  *zeros = 0x80;
+  memset (zeros + 1, 0, sizeof(zeros) - 1);
+  zeros[dstart+0] = (m->sz[0] >> 0) & 0xff;
+  zeros[dstart+1] = (m->sz[0] >> 8) & 0xff;
+  zeros[dstart+2] = (m->sz[0] >> 16) & 0xff;
+  zeros[dstart+3] = (m->sz[0] >> 24) & 0xff;
+  zeros[dstart+4] = (m->sz[1] >> 0) & 0xff;
+  zeros[dstart+5] = (m->sz[1] >> 8) & 0xff;
+  zeros[dstart+6] = (m->sz[1] >> 16) & 0xff;
+  zeros[dstart+7] = (m->sz[1] >> 24) & 0xff;
+  MD4_Update (m, zeros, dstart + 8);
+  {
+      int i;
+      unsigned char *r = (unsigned char *)res;
+
+      for (i = 0; i < 4; ++i) {
+	  r[4*i]   = m->counter[i] & 0xFF;
+	  r[4*i+1] = (m->counter[i] >> 8) & 0xFF;
+	  r[4*i+2] = (m->counter[i] >> 16) & 0xFF;
+	  r[4*i+3] = (m->counter[i] >> 24) & 0xFF;
+      }
+  }
+#if 0
+  {
+    int i;
+    uint32_t *r = (uint32_t *)res;
+
+    for (i = 0; i < 4; ++i)
+      r[i] = swap_uint32_t (m->counter[i]);
+  }
+#endif
+}
diff --git a/C/hashes/md4.h b/C/hashes/md4.h
new file mode 100644
index 00000000..30c6bfc4
--- /dev/null
+++ b/C/hashes/md4.h
@@ -0,0 +1,56 @@
+
+/*
+ * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* $Id$ */
+
+#ifndef HEIM_MD4_H
+#define HEIM_MD4_H 1
+
+#include "hash.h"
+
+#define MD4_DIGEST_LENGTH 16
+
+struct md4 {
+  unsigned int sz[2];
+  uint32_t counter[4];
+  unsigned char save[64];
+};
+
+typedef struct md4 MD4_CTX;
+
+void MD4_Init (struct md4 *m);
+void MD4_Update (struct md4 *m, const void *p, size_t len);
+void MD4_Final (void *res, struct md4 *m);
+
+#endif /* HEIM_MD4_H */
diff --git a/C/hashes/md5.c b/C/hashes/md5.c
new file mode 100644
index 00000000..82fe8a1b
--- /dev/null
+++ b/C/hashes/md5.c
@@ -0,0 +1,288 @@
+
+/*
+ * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "hash.h"
+#include "md5.h"
+
+#define A m->counter[0]
+#define B m->counter[1]
+#define C m->counter[2]
+#define D m->counter[3]
+#define X data
+
+/* Vector Crays doesn't have a good 32-bit type, or more precisely,
+   int32_t as defined by <bind/bitypes.h> isn't 32 bits, and we don't
+   want to depend in being able to redefine this type.  To cope with
+   this we have to clamp the result in some places to [0,2^32); no
+   need to do this on other machines.  Did I say this was a mess?
+   */
+
+#ifdef _CRAY
+#define CRAYFIX(X) ((X) & 0xffffffff)
+#else
+#define CRAYFIX(X) (X)
+#endif
+
+static uint32_t cshift (uint32_t x, unsigned int n)
+{
+    x = CRAYFIX(x);
+    return CRAYFIX((x << n) | (x >> (32 - n)));
+}
+
+void
+MD5_Init (struct md5 *m)
+{
+  m->sz[0] = 0;
+  m->sz[1] = 0;
+  D = 0x10325476;
+  C = 0x98badcfe;
+  B = 0xefcdab89;
+  A = 0x67452301;
+}
+
+#define F(x,y,z) CRAYFIX((x & y) | (~x & z))
+#define G(x,y,z) CRAYFIX((x & z) | (y & ~z))
+#define H(x,y,z) (x ^ y ^ z)
+#define I(x,y,z) CRAYFIX(y ^ (x | ~z))
+
+#define DOIT(a,b,c,d,k,s,i,OP) \
+a = b + cshift(a + OP(b,c,d) + X[k] + (i), s)
+
+#define DO1(a,b,c,d,k,s,i) DOIT(a,b,c,d,k,s,i,F)
+#define DO2(a,b,c,d,k,s,i) DOIT(a,b,c,d,k,s,i,G)
+#define DO3(a,b,c,d,k,s,i) DOIT(a,b,c,d,k,s,i,H)
+#define DO4(a,b,c,d,k,s,i) DOIT(a,b,c,d,k,s,i,I)
+
+static void
+calc (struct md5 *m, uint32_t *data)
+{
+  uint32_t AA, BB, CC, DD;
+
+  AA = A;
+  BB = B;
+  CC = C;
+  DD = D;
+
+  /* Round 1 */
+
+  DO1(A,B,C,D,0,7,0xd76aa478);
+  DO1(D,A,B,C,1,12,0xe8c7b756);
+  DO1(C,D,A,B,2,17,0x242070db);
+  DO1(B,C,D,A,3,22,0xc1bdceee);
+
+  DO1(A,B,C,D,4,7,0xf57c0faf);
+  DO1(D,A,B,C,5,12,0x4787c62a);
+  DO1(C,D,A,B,6,17,0xa8304613);
+  DO1(B,C,D,A,7,22,0xfd469501);
+
+  DO1(A,B,C,D,8,7,0x698098d8);
+  DO1(D,A,B,C,9,12,0x8b44f7af);
+  DO1(C,D,A,B,10,17,0xffff5bb1);
+  DO1(B,C,D,A,11,22,0x895cd7be);
+
+  DO1(A,B,C,D,12,7,0x6b901122);
+  DO1(D,A,B,C,13,12,0xfd987193);
+  DO1(C,D,A,B,14,17,0xa679438e);
+  DO1(B,C,D,A,15,22,0x49b40821);
+
+  /* Round 2 */
+
+  DO2(A,B,C,D,1,5,0xf61e2562);
+  DO2(D,A,B,C,6,9,0xc040b340);
+  DO2(C,D,A,B,11,14,0x265e5a51);
+  DO2(B,C,D,A,0,20,0xe9b6c7aa);
+
+  DO2(A,B,C,D,5,5,0xd62f105d);
+  DO2(D,A,B,C,10,9,0x2441453);
+  DO2(C,D,A,B,15,14,0xd8a1e681);
+  DO2(B,C,D,A,4,20,0xe7d3fbc8);
+
+  DO2(A,B,C,D,9,5,0x21e1cde6);
+  DO2(D,A,B,C,14,9,0xc33707d6);
+  DO2(C,D,A,B,3,14,0xf4d50d87);
+  DO2(B,C,D,A,8,20,0x455a14ed);
+
+  DO2(A,B,C,D,13,5,0xa9e3e905);
+  DO2(D,A,B,C,2,9,0xfcefa3f8);
+  DO2(C,D,A,B,7,14,0x676f02d9);
+  DO2(B,C,D,A,12,20,0x8d2a4c8a);
+
+  /* Round 3 */
+
+  DO3(A,B,C,D,5,4,0xfffa3942);
+  DO3(D,A,B,C,8,11,0x8771f681);
+  DO3(C,D,A,B,11,16,0x6d9d6122);
+  DO3(B,C,D,A,14,23,0xfde5380c);
+
+  DO3(A,B,C,D,1,4,0xa4beea44);
+  DO3(D,A,B,C,4,11,0x4bdecfa9);
+  DO3(C,D,A,B,7,16,0xf6bb4b60);
+  DO3(B,C,D,A,10,23,0xbebfbc70);
+
+  DO3(A,B,C,D,13,4,0x289b7ec6);
+  DO3(D,A,B,C,0,11,0xeaa127fa);
+  DO3(C,D,A,B,3,16,0xd4ef3085);
+  DO3(B,C,D,A,6,23,0x4881d05);
+
+  DO3(A,B,C,D,9,4,0xd9d4d039);
+  DO3(D,A,B,C,12,11,0xe6db99e5);
+  DO3(C,D,A,B,15,16,0x1fa27cf8);
+  DO3(B,C,D,A,2,23,0xc4ac5665);
+
+  /* Round 4 */
+
+  DO4(A,B,C,D,0,6,0xf4292244);
+  DO4(D,A,B,C,7,10,0x432aff97);
+  DO4(C,D,A,B,14,15,0xab9423a7);
+  DO4(B,C,D,A,5,21,0xfc93a039);
+
+  DO4(A,B,C,D,12,6,0x655b59c3);
+  DO4(D,A,B,C,3,10,0x8f0ccc92);
+  DO4(C,D,A,B,10,15,0xffeff47d);
+  DO4(B,C,D,A,1,21,0x85845dd1);
+
+  DO4(A,B,C,D,8,6,0x6fa87e4f);
+  DO4(D,A,B,C,15,10,0xfe2ce6e0);
+  DO4(C,D,A,B,6,15,0xa3014314);
+  DO4(B,C,D,A,13,21,0x4e0811a1);
+
+  DO4(A,B,C,D,4,6,0xf7537e82);
+  DO4(D,A,B,C,11,10,0xbd3af235);
+  DO4(C,D,A,B,2,15,0x2ad7d2bb);
+  DO4(B,C,D,A,9,21,0xeb86d391);
+
+  A += AA;
+  B += BB;
+  C += CC;
+  D += DD;
+}
+
+/*
+ * From `Performance analysis of MD5' by Joseph D. Touch <touch@isi.edu>
+ */
+
+#if defined(WORDS_BIGENDIAN)
+static uint32_t
+swap_uint32_t (uint32_t t)
+{
+  uint32_t temp1, temp2;
+
+  temp1   = cshift(t, 16);
+  temp2   = temp1 >> 8;
+  temp1  &= 0x00ff00ff;
+  temp2  &= 0x00ff00ff;
+  temp1 <<= 8;
+  return temp1 | temp2;
+}
+#endif
+
+struct x32{
+  unsigned int a:32;
+  unsigned int b:32;
+};
+
+void
+MD5_Update (struct md5 *m, const void *v, size_t len)
+{
+  const unsigned char *p = v;
+  size_t old_sz = m->sz[0];
+  size_t offset;
+
+  m->sz[0] += (unsigned int)len * 8;
+  if (m->sz[0] < old_sz)
+      ++m->sz[1];
+  offset = (old_sz / 8)  % 64;
+  while(len > 0){
+    size_t l = min(len, 64 - offset);
+    memcpy(m->save + offset, p, l);
+    offset += l;
+    p += l;
+    len -= l;
+    if(offset == 64){
+#if defined(WORDS_BIGENDIAN)
+      int i;
+      uint32_t current[16];
+      struct x32 *us = (struct x32*)m->save;
+      for(i = 0; i < 8; i++){
+	current[2*i+0] = swap_uint32_t(us[i].a);
+	current[2*i+1] = swap_uint32_t(us[i].b);
+      }
+      calc(m, current);
+#else
+      calc(m, (uint32_t*)m->save);
+#endif
+      offset = 0;
+    }
+  }
+}
+
+void
+MD5_Final (void *res, struct md5 *m)
+{
+  unsigned char zeros[72];
+  unsigned offset = (m->sz[0] / 8) % 64;
+  unsigned int dstart = (120 - offset - 1) % 64 + 1;
+
+  *zeros = 0x80;
+  memset (zeros + 1, 0, sizeof(zeros) - 1);
+  zeros[dstart+0] = (m->sz[0] >> 0) & 0xff;
+  zeros[dstart+1] = (m->sz[0] >> 8) & 0xff;
+  zeros[dstart+2] = (m->sz[0] >> 16) & 0xff;
+  zeros[dstart+3] = (m->sz[0] >> 24) & 0xff;
+  zeros[dstart+4] = (m->sz[1] >> 0) & 0xff;
+  zeros[dstart+5] = (m->sz[1] >> 8) & 0xff;
+  zeros[dstart+6] = (m->sz[1] >> 16) & 0xff;
+  zeros[dstart+7] = (m->sz[1] >> 24) & 0xff;
+  MD5_Update (m, zeros, dstart + 8);
+  {
+      int i;
+      unsigned char *r = (unsigned char *)res;
+
+      for (i = 0; i < 4; ++i) {
+	  r[4*i]   = m->counter[i] & 0xFF;
+	  r[4*i+1] = (m->counter[i] >> 8) & 0xFF;
+	  r[4*i+2] = (m->counter[i] >> 16) & 0xFF;
+	  r[4*i+3] = (m->counter[i] >> 24) & 0xFF;
+      }
+  }
+#if 0
+  {
+    int i;
+    uint32_t *r = (uint32_t *)res;
+
+    for (i = 0; i < 4; ++i)
+      r[i] = swap_uint32_t (m->counter[i]);
+  }
+#endif
+}
diff --git a/C/hashes/md5.h b/C/hashes/md5.h
new file mode 100644
index 00000000..3918edd5
--- /dev/null
+++ b/C/hashes/md5.h
@@ -0,0 +1,56 @@
+
+/*
+ * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* $Id$ */
+
+#ifndef HEIM_MD5_H
+#define HEIM_MD5_H 1
+
+#include "hash.h"
+
+#define MD5_DIGEST_LENGTH 16
+
+struct md5 {
+  unsigned int sz[2];
+  uint32_t counter[4];
+  unsigned char save[64];
+};
+
+typedef struct md5 MD5_CTX;
+
+void MD5_Init (struct md5 *m);
+void MD5_Update (struct md5 *m, const void *p, size_t len);
+void MD5_Final (void *res, struct md5 *m); /* uint32_t res[4] */
+
+#endif /* HEIM_MD5_H */
diff --git a/C/hashes/sha.h b/C/hashes/sha.h
new file mode 100644
index 00000000..537c2ba3
--- /dev/null
+++ b/C/hashes/sha.h
@@ -0,0 +1,68 @@
+
+/*
+ * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* $Id$ */
+
+#ifndef HEIM_SHA_H
+#define HEIM_SHA_H 1
+
+#include "hash.h"
+
+/*
+ * SHA-2 512
+ */
+
+#define SHA512_DIGEST_LENGTH 64
+
+struct hc_sha512state {
+  uint64_t sz[2];
+  uint64_t counter[8];
+  unsigned char save[128];
+};
+
+typedef struct hc_sha512state SHA512_CTX;
+
+void SHA512_Init (SHA512_CTX *);
+void SHA512_Update (SHA512_CTX *, const void *, size_t);
+void SHA512_Final (void *, SHA512_CTX *);
+
+#define SHA384_DIGEST_LENGTH 48
+
+typedef struct hc_sha512state SHA384_CTX;
+
+void SHA384_Init (SHA384_CTX *);
+void SHA384_Update (SHA384_CTX *, const void *, size_t);
+void SHA384_Final (void *, SHA384_CTX *);
+
+#endif /* HEIM_SHA_H */
diff --git a/C/hashes/sha512.c b/C/hashes/sha512.c
new file mode 100644
index 00000000..6d1cc060
--- /dev/null
+++ b/C/hashes/sha512.c
@@ -0,0 +1,297 @@
+
+/*
+ * Copyright (c) 2006, 2010 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "hash.h"
+#include "sha.h"
+
+#define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
+#define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
+
+#define ROTR(x,n)   (((x)>>(n)) | ((x) << (64 - (n))))
+
+#define Sigma0(x)	(ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
+#define Sigma1(x)	(ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
+#define sigma0(x)	(ROTR(x,1)  ^ ROTR(x,8)  ^ ((x)>>7))
+#define sigma1(x)	(ROTR(x,19) ^ ROTR(x,61) ^ ((x)>>6))
+
+#define A m->counter[0]
+#define B m->counter[1]
+#define C m->counter[2]
+#define D m->counter[3]
+#define E m->counter[4]
+#define F m->counter[5]
+#define G m->counter[6]
+#define H m->counter[7]
+
+static uint64_t cshift64 (uint64_t x, unsigned int n)
+{
+  return ((uint64_t)x << (uint64_t)n) | ((uint64_t)x >> ((uint64_t)64 - (uint64_t)n));
+}
+
+static const uint64_t constant_512[80] = {
+    0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,
+    0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
+    0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
+    0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
+    0xd807aa98a3030242ULL, 0x12835b0145706fbeULL,
+    0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
+    0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL,
+    0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
+    0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
+    0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,
+    0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL,
+    0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
+    0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL,
+    0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,
+    0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
+    0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
+    0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL,
+    0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
+    0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL,
+    0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
+    0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
+    0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,
+    0xd192e819d6ef5218ULL, 0xd69906245565a910ULL,
+    0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
+    0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL,
+    0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,
+    0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
+    0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
+    0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL,
+    0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
+    0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL,
+    0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
+    0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
+    0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,
+    0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL,
+    0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
+    0x28db77f523047d84ULL, 0x32caab7b40c72493ULL,
+    0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,
+    0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
+    0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL
+};
+
+void
+SHA512_Init (SHA512_CTX *m)
+{
+    m->sz[0] = 0;
+    m->sz[1] = 0;
+    A = 0x6a09e667f3bcc908ULL;
+    B = 0xbb67ae8584caa73bULL;
+    C = 0x3c6ef372fe94f82bULL;
+    D = 0xa54ff53a5f1d36f1ULL;
+    E = 0x510e527fade682d1ULL;
+    F = 0x9b05688c2b3e6c1fULL;
+    G = 0x1f83d9abfb41bd6bULL;
+    H = 0x5be0cd19137e2179ULL;
+}
+
+static void
+calc (SHA512_CTX *m, uint64_t *in)
+{
+    uint64_t AA, BB, CC, DD, EE, FF, GG, HH;
+    uint64_t data[80];
+    int i;
+
+    AA = A;
+    BB = B;
+    CC = C;
+    DD = D;
+    EE = E;
+    FF = F;
+    GG = G;
+    HH = H;
+
+    for (i = 0; i < 16; ++i)
+	data[i] = in[i];
+    for (i = 16; i < 80; ++i)
+	data[i] = sigma1(data[i-2]) + data[i-7] +
+	    sigma0(data[i-15]) + data[i - 16];
+
+    for (i = 0; i < 80; i++) {
+	uint64_t T1, T2;
+
+	T1 = HH + Sigma1(EE) + Ch(EE, FF, GG) + constant_512[i] + data[i];
+	T2 = Sigma0(AA) + Maj(AA,BB,CC);
+
+	HH = GG;
+	GG = FF;
+	FF = EE;
+	EE = DD + T1;
+	DD = CC;
+	CC = BB;
+	BB = AA;
+	AA = T1 + T2;
+    }
+
+    A += AA;
+    B += BB;
+    C += CC;
+    D += DD;
+    E += EE;
+    F += FF;
+    G += GG;
+    H += HH;
+}
+
+/*
+ * From `Performance analysis of MD5' by Joseph D. Touch <touch@isi.edu>
+ */
+
+#if !defined(WORDS_BIGENDIAN) || defined(_CRAY)
+static uint64_t
+swap_uint64_t (uint64_t t)
+{
+    uint64_t temp;
+
+    temp   = cshift64(t, 32);
+    temp = ((temp & 0xff00ff00ff00ff00ULL) >> 8) |
+           ((temp & 0x00ff00ff00ff00ffULL) << 8);
+    return ((temp & 0xffff0000ffff0000ULL) >> 16) |
+           ((temp & 0x0000ffff0000ffffULL) << 16);
+}
+
+struct x64{
+    uint64_t a;
+    uint64_t b;
+};
+#endif
+
+void
+SHA512_Update (SHA512_CTX *m, const void *v, size_t len)
+{
+    const unsigned char *p = v;
+    size_t old_sz = m->sz[0];
+    size_t offset;
+
+    m->sz[0] += len * 8;
+    if (m->sz[0] < old_sz)
+	++m->sz[1];
+    offset = (old_sz / 8) % 128;
+    while(len > 0){
+	size_t l = min(len, 128 - offset);
+	memcpy(m->save + offset, p, l);
+	offset += l;
+	p += l;
+	len -= l;
+	if(offset == 128){
+#if !defined(WORDS_BIGENDIAN) || defined(_CRAY)
+	    int i;
+	    uint64_t current[16];
+	    struct x64 *us = (struct x64*)m->save;
+	    for(i = 0; i < 8; i++){
+		current[2*i+0] = swap_uint64_t(us[i].a);
+		current[2*i+1] = swap_uint64_t(us[i].b);
+	    }
+	    calc(m, current);
+#else
+	    calc(m, (uint64_t*)m->save);
+#endif
+	    offset = 0;
+	}
+    }
+}
+
+void
+SHA512_Final (void *res, SHA512_CTX *m)
+{
+    unsigned char zeros[128 + 16];
+    unsigned offset = (m->sz[0] / 8) % 128;
+    unsigned int dstart = (240 - offset - 1) % 128 + 1;
+
+    *zeros = 0x80;
+    memset (zeros + 1, 0, sizeof(zeros) - 1);
+    zeros[dstart+15] = (m->sz[0] >> 0) & 0xff;
+    zeros[dstart+14] = (m->sz[0] >> 8) & 0xff;
+    zeros[dstart+13] = (m->sz[0] >> 16) & 0xff;
+    zeros[dstart+12] = (m->sz[0] >> 24) & 0xff;
+    zeros[dstart+11] = (m->sz[0] >> 32) & 0xff;
+    zeros[dstart+10] = (m->sz[0] >> 40) & 0xff;
+    zeros[dstart+9]  = (m->sz[0] >> 48) & 0xff;
+    zeros[dstart+8]  = (m->sz[0] >> 56) & 0xff;
+
+    zeros[dstart+7] = (m->sz[1] >> 0) & 0xff;
+    zeros[dstart+6] = (m->sz[1] >> 8) & 0xff;
+    zeros[dstart+5] = (m->sz[1] >> 16) & 0xff;
+    zeros[dstart+4] = (m->sz[1] >> 24) & 0xff;
+    zeros[dstart+3] = (m->sz[1] >> 32) & 0xff;
+    zeros[dstart+2] = (m->sz[1] >> 40) & 0xff;
+    zeros[dstart+1] = (m->sz[1] >> 48) & 0xff;
+    zeros[dstart+0] = (m->sz[1] >> 56) & 0xff;
+    SHA512_Update (m, zeros, dstart + 16);
+    {
+	int i;
+	unsigned char *r = (unsigned char*)res;
+
+	for (i = 0; i < 8; ++i) {
+	    r[8*i+7] = m->counter[i] & 0xFF;
+	    r[8*i+6] = (m->counter[i] >> 8) & 0xFF;
+	    r[8*i+5] = (m->counter[i] >> 16) & 0xFF;
+	    r[8*i+4] = (m->counter[i] >> 24) & 0xFF;
+	    r[8*i+3] = (m->counter[i] >> 32) & 0XFF;
+	    r[8*i+2] = (m->counter[i] >> 40) & 0xFF;
+	    r[8*i+1] = (m->counter[i] >> 48) & 0xFF;
+	    r[8*i]   = (m->counter[i] >> 56) & 0xFF;
+	}
+    }
+}
+
+void
+SHA384_Init(SHA384_CTX *m)
+{
+    m->sz[0] = 0;
+    m->sz[1] = 0;
+    A = 0xcbbb9d5dc1059ed8ULL;
+    B = 0x629a292a367cd507ULL;
+    C = 0x9159015a3070dd17ULL;
+    D = 0x152fecd8f70e5939ULL;
+    E = 0x67332667ffc00b31ULL;
+    F = 0x8eb44a8768581511ULL;
+    G = 0xdb0c2e0d64f98fa7ULL;
+    H = 0x47b5481dbefa4fa4ULL;
+}
+
+void
+SHA384_Update (SHA384_CTX *m, const void *v, size_t len)
+{
+    SHA512_Update(m, v, len);
+}
+
+void
+SHA384_Final (void *res, SHA384_CTX *m)
+{
+    unsigned char data[SHA512_DIGEST_LENGTH];
+    SHA512_Final(data, m);
+    memcpy(res, data, SHA384_DIGEST_LENGTH);
+}
diff --git a/C/md5.c b/C/md5.c
deleted file mode 100644
index 7ee33fbb..00000000
--- a/C/md5.c
+++ /dev/null
@@ -1,288 +0,0 @@
-
-/*
- * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
- * MD5 Message-Digest Algorithm (RFC 1321).
- *
- * Homepage:
- * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
- *
- * Author:
- * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
- *
- * This software was written by Alexander Peslyak in 2001.  No copyright is
- * claimed, and the software is hereby placed in the public domain.
- * In case this attempt to disclaim copyright and place the software in the
- * public domain is deemed null and void, then the software is
- * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
- * general public under the following terms:
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted.
- *
- * There's ABSOLUTELY NO WARRANTY, express or implied.
- *
- * (This is a heavily cut-down "BSD license".)
- *
- * This differs from Colin Plumb's older public domain implementation in that
- * no exactly 32-bit integer data type is required (any 32-bit or wider
- * unsigned integer data type will do), there's no compile-time endianness
- * configuration, and the function prototypes match OpenSSL's.  No code from
- * Colin Plumb's implementation has been reused; this comment merely compares
- * the properties of the two independent implementations.
- *
- * The primary goals of this implementation are portability and ease of use.
- * It is meant to be fast, but not as fast as possible.  Some known
- * optimizations are not included to reduce source code size and avoid
- * compile-time configuration.
- */
-
-#include <string.h>
-
-#include "md5.h"
-
-/*
- * The basic MD5 functions.
- *
- * F and G are optimized compared to their RFC 1321 definitions for
- * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
- * implementation.
- */
-#define F(x, y, z)			((z) ^ ((x) & ((y) ^ (z))))
-#define G(x, y, z)			((y) ^ ((z) & ((x) ^ (y))))
-#define H(x, y, z)			(((x) ^ (y)) ^ (z))
-#define H2(x, y, z)			((x) ^ ((y) ^ (z)))
-#define I(x, y, z)			((y) ^ ((x) | ~(z)))
-
-/*
- * The MD5 transformation for all four rounds.
- */
-#define STEP(f, a, b, c, d, x, t, s) \
-	(a) += f((b), (c), (d)) + (x) + (t); \
-	(a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
-	(a) += (b);
-
-/*
- * SET reads 4 input bytes in little-endian byte order and stores them in a
- * properly aligned word in host byte order.
- *
- * The check for little-endian architectures that tolerate unaligned memory
- * accesses is just an optimization.  Nothing will break if it fails to detect
- * a suitable architecture.
- *
- * Unfortunately, this optimization may be a C strict aliasing rules violation
- * if the caller's data buffer has effective type that cannot be aliased by
- * MD5_u32plus.  In practice, this problem may occur if these MD5 routines are
- * inlined into a calling function, or with future and dangerously advanced
- * link-time optimizations.  For the time being, keeping these MD5 routines in
- * their own translation unit avoids the problem.
- */
-#if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
-#define SET(n) \
-	(*(MD5_u32plus *)&ptr[(n) * 4])
-#define GET(n) \
-	SET(n)
-#else
-#define SET(n) \
-	(ctx->block[(n)] = \
-	(MD5_u32plus)ptr[(n) * 4] | \
-	((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \
-	((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \
-	((MD5_u32plus)ptr[(n) * 4 + 3] << 24))
-#define GET(n) \
-	(ctx->block[(n)])
-#endif
-
-/*
- * This processes one or more 64-byte data blocks, but does NOT update the bit
- * counters.  There are no alignment requirements.
- */
-static const void *body(MD5_CTX *ctx, const void *data, unsigned long size)
-{
-	const unsigned char *ptr;
-	MD5_u32plus a, b, c, d;
-	MD5_u32plus saved_a, saved_b, saved_c, saved_d;
-
-	ptr = (const unsigned char *)data;
-
-	a = ctx->a;
-	b = ctx->b;
-	c = ctx->c;
-	d = ctx->d;
-
-	do {
-		saved_a = a;
-		saved_b = b;
-		saved_c = c;
-		saved_d = d;
-
-/* Round 1 */
-		STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
-		STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
-		STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
-		STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
-		STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
-		STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
-		STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
-		STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
-		STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
-		STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
-		STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
-		STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
-		STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
-		STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
-		STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
-		STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
-
-/* Round 2 */
-		STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
-		STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
-		STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
-		STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
-		STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
-		STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
-		STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
-		STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
-		STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
-		STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
-		STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
-		STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
-		STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
-		STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
-		STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
-		STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
-
-/* Round 3 */
-		STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
-		STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11)
-		STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
-		STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23)
-		STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
-		STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11)
-		STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
-		STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23)
-		STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
-		STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11)
-		STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
-		STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23)
-		STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
-		STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11)
-		STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
-		STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23)
-
-/* Round 4 */
-		STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
-		STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
-		STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
-		STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
-		STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
-		STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
-		STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
-		STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
-		STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
-		STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
-		STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
-		STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
-		STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
-		STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
-		STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
-		STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
-
-		a += saved_a;
-		b += saved_b;
-		c += saved_c;
-		d += saved_d;
-
-		ptr += 64;
-	} while (size -= 64);
-
-	ctx->a = a;
-	ctx->b = b;
-	ctx->c = c;
-	ctx->d = d;
-
-	return ptr;
-}
-
-void MD5_Init(MD5_CTX *ctx)
-{
-	ctx->a = 0x67452301;
-	ctx->b = 0xefcdab89;
-	ctx->c = 0x98badcfe;
-	ctx->d = 0x10325476;
-
-	ctx->lo = 0;
-	ctx->hi = 0;
-}
-
-void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size)
-{
-	MD5_u32plus saved_lo;
-	unsigned long used, available;
-
-	saved_lo = ctx->lo;
-	if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
-		ctx->hi++;
-	ctx->hi += size >> 29;
-
-	used = saved_lo & 0x3f;
-
-	if (used) {
-		available = 64 - used;
-
-		if (size < available) {
-			memcpy(&ctx->buffer[used], data, size);
-			return;
-		}
-
-		memcpy(&ctx->buffer[used], data, available);
-		data = (const unsigned char *)data + available;
-		size -= available;
-		body(ctx, ctx->buffer, 64);
-	}
-
-	if (size >= 64) {
-		data = body(ctx, data, size & ~(unsigned long)0x3f);
-		size &= 0x3f;
-	}
-
-	memcpy(ctx->buffer, data, size);
-}
-
-#define OUT(dst, src) \
-	(dst)[0] = (unsigned char)(src); \
-	(dst)[1] = (unsigned char)((src) >> 8); \
-	(dst)[2] = (unsigned char)((src) >> 16); \
-	(dst)[3] = (unsigned char)((src) >> 24);
-
-void MD5_Final(MD5_CTX *ctx, unsigned char *result)
-{
-	unsigned long used, available;
-
-	used = ctx->lo & 0x3f;
-
-	ctx->buffer[used++] = 0x80;
-
-	available = 64 - used;
-
-	if (available < 8) {
-		memset(&ctx->buffer[used], 0, available);
-		body(ctx, ctx->buffer, 64);
-		used = 0;
-		available = 64;
-	}
-
-	memset(&ctx->buffer[used], 0, available - 8);
-
-	ctx->lo <<= 3;
-	OUT(&ctx->buffer[56], ctx->lo)
-	OUT(&ctx->buffer[60], ctx->hi)
-
-	body(ctx, ctx->buffer, 64);
-
-	OUT(&result[0], ctx->a)
-	OUT(&result[4], ctx->b)
-	OUT(&result[8], ctx->c)
-	OUT(&result[12], ctx->d)
-
-	memset(ctx, 0, sizeof(*ctx));
-}
diff --git a/C/md5.h b/C/md5.h
deleted file mode 100644
index 9bf99d29..00000000
--- a/C/md5.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
- * MD5 Message-Digest Algorithm (RFC 1321).
- *
- * Homepage:
- * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
- *
- * Author:
- * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
- *
- * This software was written by Alexander Peslyak in 2001.  No copyright is
- * claimed, and the software is hereby placed in the public domain.
- * In case this attempt to disclaim copyright and place the software in the
- * public domain is deemed null and void, then the software is
- * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
- * general public under the following terms:
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted.
- *
- * There's ABSOLUTELY NO WARRANTY, express or implied.
- *
- * See md5.c for more information.
- */
-
-#ifndef _MD5_H
-#define _MD5_H
-
-/* Any 32-bit or wider unsigned integer data type will do */
-typedef unsigned int MD5_u32plus;
-
-typedef struct {
-	MD5_u32plus lo, hi;
-	MD5_u32plus a, b, c, d;
-	unsigned char buffer[64];
-	MD5_u32plus block[16];
-} MD5_CTX;
-
-extern void MD5_Init(MD5_CTX *ctx);
-extern void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size);
-extern void MD5_Final(MD5_CTX *ctx, unsigned char *result);
-
-#endif
diff --git a/CPP/7zip/7zip.mak b/CPP/7zip/7zip.mak
index 4ff0eaba..d319b58b 100644
--- a/CPP/7zip/7zip.mak
+++ b/CPP/7zip/7zip.mak
@@ -28,6 +28,7 @@ OBJS = \
   $(CRYPTO_OBJS) \
   $(C_OBJS) \
   $(BROTLI_OBJS) \
+  $(HASHES_OBJS) \
   $(LIZARD_OBJS) \
   $(LZ4_OBJS) \
   $(LZ5_OBJS) \
@@ -272,6 +273,8 @@ $(ZSTDMT_OBJS): ../../../../C/zstdmt/$(*B).c
 	$(COMPLB_O2)
 {../../../../C/brotli}.c{$O}.obj::
 	$(COMPLB_O2)
+{../../../../C/hashes}.c{$O}.obj::
+	$(COMPLB_O2)
 {../../../../C/lizard}.c{$O}.obj::
 	$(COMPLB_O2)
 {../../../../C/lz4}.c{$O}.obj::
@@ -283,6 +286,7 @@ $(ZSTDMT_OBJS): ../../../../C/zstdmt/$(*B).c
 {../../../../C/zstdmt}.c{$O}.obj::
 	$(COMPLB_O2) \
 	-I ../../../../C/brotli \
+	-I ../../../../C/hashes \
 	-I ../../../../C/lizard \
 	-I ../../../../C/lz4 \
 	-I ../../../../C/lz5 \
diff --git a/CPP/7zip/Archive/Rar/Rar5Handler.cpp b/CPP/7zip/Archive/Rar/Rar5Handler.cpp
index 8138725b..61c9fc72 100644
--- a/CPP/7zip/Archive/Rar/Rar5Handler.cpp
+++ b/CPP/7zip/Archive/Rar/Rar5Handler.cpp
@@ -2962,4 +2962,35 @@ REGISTER_ARC_I(
   NULL)
 
 }}
-

+
+
+class CBlake2spHasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  CBlake2sp _blake;
+  Byte mtDummy[1 << 7];
+
+public:
+  CBlake2spHasher() { Init(); }
+
+  MY_UNKNOWN_IMP
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CBlake2spHasher::Init() throw()
+{
+  Blake2sp_Init(&_blake);
+}
+
+STDMETHODIMP_(void) CBlake2spHasher::Update(const void *data, UInt32 size) throw()
+{
+  Blake2sp_Update(&_blake, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CBlake2spHasher::Final(Byte *digest) throw()
+{
+  Blake2sp_Final(&_blake, digest);
+}
+
+REGISTER_HASHER(CBlake2spHasher, 0x202, "BLAKE2sp", BLAKE2S_DIGEST_SIZE)
diff --git a/CPP/7zip/Bundles/Format7zF/Arc.mak b/CPP/7zip/Bundles/Format7zF/Arc.mak
index f5026b38..4f28e05c 100644
--- a/CPP/7zip/Bundles/Format7zF/Arc.mak
+++ b/CPP/7zip/Bundles/Format7zF/Arc.mak
@@ -1,10 +1,11 @@
 COMMON_OBJS = \
-  $O\Blake2spReg.obj \
   $O\CRC.obj \
   $O\CrcReg.obj \
   $O\DynLimBuf.obj \
   $O\IntToString.obj \
-  $O\MD5Reg.obj \
+  $O\Md2Reg.obj \
+  $O\Md4Reg.obj \
+  $O\Md5Reg.obj \
   $O\MyMap.obj \
   $O\MyString.obj \
   $O\MyVector.obj \
@@ -12,6 +13,8 @@ COMMON_OBJS = \
   $O\NewHandler.obj \
   $O\Sha1Reg.obj \
   $O\Sha256Reg.obj \
+  $O\Sha384Reg.obj \
+  $O\Sha512Reg.obj \
   $O\StringConvert.obj \
   $O\StringToInt.obj \
   $O\UTFConvert.obj \
@@ -253,7 +256,14 @@ CRYPTO_OBJS = \
   $O\ZipCrypto.obj \
   $O\ZipStrong.obj \
 
+HASHES_OBJS = \
+  $O\md2.obj \
+  $O\md4.obj \
+  $O\md5.obj \
+  $O\sha512.obj \
+
 C_OBJS = \
+  $O\sha512.obj \
   $O\7zBuf2.obj \
   $O\7zStream.obj \
   $O\Alloc.obj \
@@ -290,7 +300,6 @@ C_OBJS = \
   $O\XzDec.obj \
   $O\XzEnc.obj \
   $O\XzIn.obj \
-  $O\md5.obj \
 
 !include "../../Aes.mak"
 !include "../../Crc.mak"
diff --git a/CPP/7zip/Bundles/Format7zFO/Arc.mak b/CPP/7zip/Bundles/Format7zFO/Arc.mak
index ce69689c..9b9ae22a 100644
--- a/CPP/7zip/Bundles/Format7zFO/Arc.mak
+++ b/CPP/7zip/Bundles/Format7zFO/Arc.mak
@@ -1,10 +1,11 @@
 COMMON_OBJS = \
-  $O\Blake2spReg.obj \
   $O\CRC.obj \
   $O\CrcReg.obj \
   $O\DynLimBuf.obj \
   $O\IntToString.obj \
-  $O\MD5Reg.obj \
+  $O\Md2Reg.obj \
+  $O\Md4Reg.obj \
+  $O\Md5Reg.obj \
   $O\MyMap.obj \
   $O\MyString.obj \
   $O\MyVector.obj \
@@ -12,10 +13,14 @@ COMMON_OBJS = \
   $O\NewHandler.obj \
   $O\Sha1Reg.obj \
   $O\Sha256Reg.obj \
+  $O\Sha384Reg.obj \
+  $O\Sha512Reg.obj \
   $O\StringConvert.obj \
   $O\StringToInt.obj \
   $O\UTFConvert.obj \
   $O\Wildcard.obj \
+  $O\XXH32Reg.obj \
+  $O\XXH64Reg.obj \
   $O\XzCrc64Init.obj \
   $O\XzCrc64Reg.obj \
 
@@ -251,6 +256,12 @@ CRYPTO_OBJS = \
   $O\ZipCrypto.obj \
   $O\ZipStrong.obj \
 
+HASHES_OBJS = \
+  $O\md2.obj \
+  $O\md4.obj \
+  $O\md5.obj \
+  $O\sha512.obj \
+
 C_OBJS = \
   $O\7zBuf2.obj \
   $O\7zStream.obj \
@@ -288,7 +299,6 @@ C_OBJS = \
   $O\XzDec.obj \
   $O\XzEnc.obj \
   $O\XzIn.obj \
-  $O\md5.obj \
 
 !include "../../Aes.mak"
 !include "../../Crc.mak"
diff --git a/CPP/7zip/Bundles/Format7zFO/makefile b/CPP/7zip/Bundles/Format7zFO/makefile
index 4efb869a..b271a09c 100644
--- a/CPP/7zip/Bundles/Format7zFO/makefile
+++ b/CPP/7zip/Bundles/Format7zFO/makefile
@@ -1,7 +1,6 @@
 PROG = 7z.dll
 DEF_FILE = ../../Archive/Archive2.def
-CFLAGS = $(CFLAGS) \
-  -DEXTERNAL_CODECS -DNEED_7ZIP_GUID -DZSTD_LEGACY_SUPPORT \
+CFLAGS = $(CFLAGS) -DNEED_7ZIP_GUID -DEXTERNAL_CODECS -DZSTD_LEGACY_SUPPORT -DZSTD_MULTITHREAD
 
 !IFNDEF UNDER_CE
 CFLAGS = $(CFLAGS) -DNEED_7ZIP_GUID -D_7ZIP_LARGE_PAGES
diff --git a/CPP/7zip/Common/RegisterCodec.h b/CPP/7zip/Common/RegisterCodec.h
index b5660658..7b52b927 100644
--- a/CPP/7zip/Common/RegisterCodec.h
+++ b/CPP/7zip/Common/RegisterCodec.h
@@ -102,5 +102,5 @@ void RegisterHasher(const CHasherInfo *hasher) throw();
     static const CHasherInfo g_HasherInfo = { CreateHasherSpec, id, name, size }; \
     struct REGISTER_HASHER_NAME(cls) { REGISTER_HASHER_NAME(cls)() { RegisterHasher(&g_HasherInfo); }}; \
     static REGISTER_HASHER_NAME(cls) g_RegisterHasher;
-
+
 #endif
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.cpp b/CPP/7zip/UI/Explorer/ContextMenu.cpp
index 91849827..59d78e5c 100644
--- a/CPP/7zip/UI/Explorer/ContextMenu.cpp
+++ b/CPP/7zip/UI/Explorer/ContextMenu.cpp
@@ -223,12 +223,16 @@ static const CHashCommand g_HashCommands[] =
 {
   { CZipContextMenu::kHash_CRC32,    "CRC-32",   "CRC32" },
   { CZipContextMenu::kHash_CRC64,    "CRC-64",   "CRC64" },
+  { CZipContextMenu::kHash_XXH32,    "XXH-32",   "XXH32" },
+  { CZipContextMenu::kHash_XXH64,    "XXH-64",   "XXH64" },
+  { CZipContextMenu::kHash_MD5,      "MD2",      "MD2" },
+  { CZipContextMenu::kHash_MD5,      "MD4",      "MD4" },
   { CZipContextMenu::kHash_MD5,      "MD5",      "MD5" },
   { CZipContextMenu::kHash_SHA1,     "SHA-1",    "SHA1" },
   { CZipContextMenu::kHash_SHA256,   "SHA-256",  "SHA256" },
+  { CZipContextMenu::kHash_SHA256,   "SHA-384",  "SHA384" },
+  { CZipContextMenu::kHash_SHA256,   "SHA-512",  "SHA512" },
   { CZipContextMenu::kHash_BLAKE2sp, "BLAKE2sp", "BLAKE2sp" },
-  { CZipContextMenu::kHash_XXH32,    "XXH-32",   "XXH32" },
-  { CZipContextMenu::kHash_XXH64,    "XXH-64",   "XXH64" },
   { CZipContextMenu::kHash_All,      "*",        "*" }
 };
 
@@ -930,12 +934,16 @@ STDMETHODIMP CZipContextMenu::InvokeCommand(LPCMINVOKECOMMANDINFO commandInfo)
       
       case kHash_CRC32:
       case kHash_CRC64:
-      case kHash_SHA1:
-      case kHash_SHA256:
-      case kHash_BLAKE2sp:
       case kHash_XXH32:
       case kHash_XXH64:
+      case kHash_MD2:
+      case kHash_MD4:
       case kHash_MD5:
+      case kHash_SHA1:
+      case kHash_SHA256:
+      case kHash_SHA384:
+      case kHash_SHA512:
+      case kHash_BLAKE2sp:
       case kHash_All:
       {
         for (unsigned i = 0; i < ARRAY_SIZE(g_HashCommands); i++)
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.h b/CPP/7zip/UI/Explorer/ContextMenu.h
index 41755c04..ec0489d5 100644
--- a/CPP/7zip/UI/Explorer/ContextMenu.h
+++ b/CPP/7zip/UI/Explorer/ContextMenu.h
@@ -34,12 +34,16 @@ public:
     kCompressToZipEmail,
     kHash_CRC32,
     kHash_CRC64,
+    kHash_XXH32,
+    kHash_XXH64,
+    kHash_MD2,
+    kHash_MD4,
     kHash_MD5,
     kHash_SHA1,
     kHash_SHA256,
+    kHash_SHA384,
+    kHash_SHA512,
     kHash_BLAKE2sp,
-    kHash_XXH32,
-    kHash_XXH64,
     kHash_All
   };
   
diff --git a/CPP/7zip/UI/FileManager/MyLoadMenu.cpp b/CPP/7zip/UI/FileManager/MyLoadMenu.cpp
index 925d4ca3..b5c8c41c 100644
--- a/CPP/7zip/UI/FileManager/MyLoadMenu.cpp
+++ b/CPP/7zip/UI/FileManager/MyLoadMenu.cpp
@@ -578,8 +578,16 @@ bool ExecuteFileCommand(int id)
     case IDM_HASH_ALL: g_App.CalculateCrc("*"); break;
     case IDM_CRC32: g_App.CalculateCrc("CRC32"); break;
     case IDM_CRC64: g_App.CalculateCrc("CRC64"); break;
-    case IDM_SHA1: g_App.CalculateCrc("SHA1"); break;
+    case IDM_XXH32: g_App.CalculateCrc("XXH32"); break;
+    case IDM_XXH64: g_App.CalculateCrc("XXH64"); break;
+    case IDM_MD2:   g_App.CalculateCrc("MD2"); break;
+    case IDM_MD4:   g_App.CalculateCrc("MD4"); break;
+    case IDM_MD5:   g_App.CalculateCrc("MD5"); break;
+    case IDM_SHA1:  g_App.CalculateCrc("SHA1"); break;
     case IDM_SHA256: g_App.CalculateCrc("SHA256"); break;
+    case IDM_SHA384: g_App.CalculateCrc("SHA384"); break;
+    case IDM_SHA512: g_App.CalculateCrc("SHA512"); break;
+    case IDM_BLAKE2sp: g_App.CalculateCrc("BLAKE2sp"); break;
     
     case IDM_DIFF: g_App.DiffFiles(); break;
     case IDM_SPLIT: g_App.Split(); break;
diff --git a/CPP/7zip/UI/FileManager/resource.h b/CPP/7zip/UI/FileManager/resource.h
index 46662692..302889ce 100644
--- a/CPP/7zip/UI/FileManager/resource.h
+++ b/CPP/7zip/UI/FileManager/resource.h
@@ -23,8 +23,16 @@
 #define IDM_HASH_ALL             101
 #define IDM_CRC32                102
 #define IDM_CRC64                103
-#define IDM_SHA1                 104
-#define IDM_SHA256               105
+#define IDM_XXH32                104
+#define IDM_XXH64                105
+#define IDM_MD2                  106
+#define IDM_MD4                  107
+#define IDM_MD5                  108
+#define IDM_SHA1                 109
+#define IDM_SHA256               110
+#define IDM_SHA384               111
+#define IDM_SHA512               112
+#define IDM_BLAKE2sp             113
 
 #define IDM_OPEN                 540
 #define IDM_OPEN_INSIDE          541
diff --git a/CPP/7zip/UI/FileManager/resource.rc b/CPP/7zip/UI/FileManager/resource.rc
index 5dbe55ab..45c927e6 100644
--- a/CPP/7zip/UI/FileManager/resource.rc
+++ b/CPP/7zip/UI/FileManager/resource.rc
@@ -40,8 +40,16 @@ BEGIN
     BEGIN
       MENUITEM "CRC-32",                    IDM_CRC32
       MENUITEM "CRC-64",                    IDM_CRC64
+      MENUITEM "xxHash-32",                 IDM_XXH32
+      MENUITEM "xxHash-64",                 IDM_XXH64
+      MENUITEM "MD2",                       IDM_MD2
+      MENUITEM "MD4",                       IDM_MD4
+      MENUITEM "MD5",                       IDM_MD5
       MENUITEM "SHA-1",                     IDM_SHA1
       MENUITEM "SHA-256",                   IDM_SHA256
+      MENUITEM "SHA-384",                   IDM_SHA384
+      MENUITEM "SHA-512",                   IDM_SHA512
+      MENUITEM "Blake2sp",                  IDM_BLAKE2sp
       MENUITEM "*",                         IDM_HASH_ALL
     END
     MENUITEM "Di&ff",                       IDM_DIFF
diff --git a/CPP/Common/Blake2spReg.cpp b/CPP/Common/Blake2spReg.cpp
deleted file mode 100644
index 2d4b38fe..00000000
--- a/CPP/Common/Blake2spReg.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//  Blake2sReg.cpp
-
-#include "StdAfx.h"
-
-#define XXH_STATIC_LINKING_ONLY
-#include "../../C/CpuArch.h"
-#include "../../C/Blake2.h"
-
-#include "../Common/MyCom.h"
-
-#include "../7zip/Common/RegisterCodec.h"
-
-
-class CBlake2spHasher:
-  public IHasher,
-  public CMyUnknownImp
-{
-  CBlake2sp _blake;
-  Byte mtDummy[1 << 7];
-
-public:
-  CBlake2spHasher() { Init(); }
-
-  MY_UNKNOWN_IMP
-  INTERFACE_IHasher(;)
-};
-
-STDMETHODIMP_(void) CBlake2spHasher::Init() throw()
-{
-  Blake2sp_Init(&_blake);
-}
-
-STDMETHODIMP_(void) CBlake2spHasher::Update(const void *data, UInt32 size) throw()
-{
-  Blake2sp_Update(&_blake, (const Byte *)data, size);
-}
-
-STDMETHODIMP_(void) CBlake2spHasher::Final(Byte *digest) throw()
-{
-  Blake2sp_Final(&_blake, digest);
-}
-
-REGISTER_HASHER(CBlake2spHasher, 0x202, "BLAKE2sp", BLAKE2S_DIGEST_SIZE)
diff --git a/CPP/Common/HashesReg.cpp b/CPP/Common/HashesReg.cpp
new file mode 100644
index 00000000..f3d9479f
--- /dev/null
+++ b/CPP/Common/HashesReg.cpp
@@ -0,0 +1,237 @@
+// XXH32Reg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+
+#define XXH_STATIC_LINKING_ONLY
+#include "../../C/zstd/xxhash.h"
+#include "../../C/hashes/md2.h"
+#include "../../C/hashes/md4.h"
+#include "../../C/hashes/md5.h"
+#include "../../C/hashes/sha.h"
+
+#include "../Common/MyCom.h"
+#include "../7zip/Common/RegisterCodec.h"
+
+// XXH32
+class CXXH32Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  XXH32_state_t *_ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CXXH32Hasher() { _ctx = XXH32_createState(); }
+  ~CXXH32Hasher() { XXH32_freeState(_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CXXH32Hasher::Init() throw()
+{
+  XXH32_reset(_ctx, 0);
+}
+
+STDMETHODIMP_(void) CXXH32Hasher::Update(const void *data, UInt32 size) throw()
+{
+  XXH32_update(_ctx, data, size);
+}
+
+STDMETHODIMP_(void) CXXH32Hasher::Final(Byte *digest) throw()
+{
+  UInt32 val = XXH32_digest(_ctx);
+  SetUi32(digest, val);
+}
+
+REGISTER_HASHER(CXXH32Hasher, 0x203, "XXH32", 4)
+
+// XXH64
+class CXXH64Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  XXH64_state_t *_ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CXXH64Hasher() { _ctx = XXH64_createState(); }
+  ~CXXH64Hasher() { XXH64_freeState(_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CXXH64Hasher::Init() throw()
+{
+  XXH64_reset(_ctx, 0);
+}
+
+STDMETHODIMP_(void) CXXH64Hasher::Update(const void *data, UInt32 size) throw()
+{
+  XXH64_update(_ctx, data, size);
+}
+
+STDMETHODIMP_(void) CXXH64Hasher::Final(Byte *digest) throw()
+{
+  UInt64 val = XXH64_digest(_ctx);
+  SetUi64(digest, val);
+}
+REGISTER_HASHER(CXXH64Hasher, 0x204, "XXH64", 8)
+
+// MD2
+class CMD2Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  MD2_CTX _ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CMD2Hasher() { MD2_Init(&_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CMD2Hasher::Init() throw()
+{
+  MD2_Init(&_ctx);
+}
+
+STDMETHODIMP_(void) CMD2Hasher::Update(const void *data, UInt32 size) throw()
+{
+  MD2_Update(&_ctx, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CMD2Hasher::Final(Byte *digest) throw()
+{
+  MD2_Final(digest, &_ctx);
+}
+REGISTER_HASHER(CMD2Hasher, 0x205, "MD2", MD2_DIGEST_LENGTH)
+
+// MD4
+class CMD4Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  MD4_CTX _ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CMD4Hasher() { MD4_Init(&_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CMD4Hasher::Init() throw()
+{
+  MD4_Init(&_ctx);
+}
+
+STDMETHODIMP_(void) CMD4Hasher::Update(const void *data, UInt32 size) throw()
+{
+  MD4_Update(&_ctx, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CMD4Hasher::Final(Byte *digest) throw()
+{
+  MD4_Final(digest, &_ctx);
+}
+REGISTER_HASHER(CMD4Hasher, 0x206, "MD4", MD4_DIGEST_LENGTH)
+
+// MD5
+class CMD5Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  MD5_CTX _ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CMD5Hasher() { MD5_Init(&_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CMD5Hasher::Init() throw()
+{
+  MD5_Init(&_ctx);
+}
+
+STDMETHODIMP_(void) CMD5Hasher::Update(const void *data, UInt32 size) throw()
+{
+  MD5_Update(&_ctx, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CMD5Hasher::Final(Byte *digest) throw()
+{
+  MD5_Final(digest, &_ctx);
+}
+REGISTER_HASHER(CMD5Hasher, 0x207, "MD5", MD5_DIGEST_LENGTH)
+
+// SHA384
+class CSHA384Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  SHA384_CTX _ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CSHA384Hasher() { SHA384_Init(&_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CSHA384Hasher::Init() throw()
+{
+  SHA384_Init(&_ctx);
+}
+
+STDMETHODIMP_(void) CSHA384Hasher::Update(const void *data, UInt32 size) throw()
+{
+  SHA384_Update(&_ctx, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CSHA384Hasher::Final(Byte *digest) throw()
+{
+  SHA384_Final(digest, &_ctx);
+}
+REGISTER_HASHER(CSHA384Hasher, 0x208, "SHA384", SHA384_DIGEST_LENGTH)
+
+// SHA512
+class CSHA512Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  SHA512_CTX _ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CSHA512Hasher() { SHA512_Init(&_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CSHA512Hasher::Init() throw()
+{
+  SHA512_Init(&_ctx);
+}
+
+STDMETHODIMP_(void) CSHA512Hasher::Update(const void *data, UInt32 size) throw()
+{
+  SHA512_Update(&_ctx, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CSHA512Hasher::Final(Byte *digest) throw()
+{
+  SHA512_Final(digest, &_ctx);
+}
+REGISTER_HASHER(CSHA512Hasher, 0x209, "SHA512", SHA512_DIGEST_LENGTH)
diff --git a/CPP/Common/Md2Reg.cpp b/CPP/Common/Md2Reg.cpp
new file mode 100644
index 00000000..7fea3793
--- /dev/null
+++ b/CPP/Common/Md2Reg.cpp
@@ -0,0 +1,43 @@
+// Md2Reg.cpp /TR 2018-11-02
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+
+EXTERN_C_BEGIN
+#include "../../C/hashes/md2.h"
+EXTERN_C_END
+
+#include "../Common/MyCom.h"
+#include "../7zip/Common/RegisterCodec.h"
+
+// MD2
+class CMD2Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  MD2_CTX _ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CMD2Hasher() { MD2_Init(&_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CMD2Hasher::Init() throw()
+{
+  MD2_Init(&_ctx);
+}
+
+STDMETHODIMP_(void) CMD2Hasher::Update(const void *data, UInt32 size) throw()
+{
+  MD2_Update(&_ctx, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CMD2Hasher::Final(Byte *digest) throw()
+{
+  MD2_Final(digest, &_ctx);
+}
+REGISTER_HASHER(CMD2Hasher, 0x205, "MD2", MD2_DIGEST_LENGTH)
diff --git a/CPP/Common/Md4Reg.cpp b/CPP/Common/Md4Reg.cpp
new file mode 100644
index 00000000..2b83f7d8
--- /dev/null
+++ b/CPP/Common/Md4Reg.cpp
@@ -0,0 +1,43 @@
+// Md4Reg.cpp /TR 2018-11-02
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+
+EXTERN_C_BEGIN
+#include "../../C/hashes/md4.h"
+EXTERN_C_END
+
+#include "../Common/MyCom.h"
+#include "../7zip/Common/RegisterCodec.h"
+
+// MD4
+class CMD4Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  MD4_CTX _ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CMD4Hasher() { MD4_Init(&_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CMD4Hasher::Init() throw()
+{
+  MD4_Init(&_ctx);
+}
+
+STDMETHODIMP_(void) CMD4Hasher::Update(const void *data, UInt32 size) throw()
+{
+  MD4_Update(&_ctx, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CMD4Hasher::Final(Byte *digest) throw()
+{
+  MD4_Final(digest, &_ctx);
+}
+REGISTER_HASHER(CMD4Hasher, 0x206, "MD4", MD4_DIGEST_LENGTH)
diff --git a/CPP/Common/MD5Reg.cpp b/CPP/Common/Md5Reg.cpp
similarity index 68%
rename from CPP/Common/MD5Reg.cpp
rename to CPP/Common/Md5Reg.cpp
index a45ba64f..853c78d9 100644
--- a/CPP/Common/MD5Reg.cpp
+++ b/CPP/Common/Md5Reg.cpp
@@ -1,20 +1,24 @@
-// MD5Reg.cpp
+// Md5Reg.cpp /TR 2018-11-02
 
 #include "StdAfx.h"
 
-#include "../../C/md5.h"
+#include "../../C/CpuArch.h"
+
+EXTERN_C_BEGIN
+#include "../../C/hashes/md5.h"
+EXTERN_C_END
 
 #include "../Common/MyCom.h"
-
 #include "../7zip/Common/RegisterCodec.h"
 
+// MD5
 class CMD5Hasher:
   public IHasher,
   public CMyUnknownImp
 {
   MD5_CTX _ctx;
   Byte mtDummy[1 << 7];
-  
+
 public:
   CMD5Hasher() { MD5_Init(&_ctx); }
 
@@ -34,7 +38,6 @@ STDMETHODIMP_(void) CMD5Hasher::Update(const void *data, UInt32 size) throw()
 
 STDMETHODIMP_(void) CMD5Hasher::Final(Byte *digest) throw()
 {
-  MD5_Final(&_ctx, digest);
+  MD5_Final(digest, &_ctx);
 }
-
-REGISTER_HASHER(CMD5Hasher, 0x205, "MD5", 16)
+REGISTER_HASHER(CMD5Hasher, 0x207, "MD5", MD5_DIGEST_LENGTH)
diff --git a/CPP/Common/Sha384Reg.cpp b/CPP/Common/Sha384Reg.cpp
new file mode 100644
index 00000000..adc35e22
--- /dev/null
+++ b/CPP/Common/Sha384Reg.cpp
@@ -0,0 +1,43 @@
+// Sha384Reg.cpp /TR 2018-11-02
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+
+EXTERN_C_BEGIN
+#include "../../C/hashes/sha.h"
+EXTERN_C_END
+
+#include "../Common/MyCom.h"
+#include "../7zip/Common/RegisterCodec.h"
+
+// SHA384
+class CSHA384Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  SHA384_CTX _ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CSHA384Hasher() { SHA384_Init(&_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CSHA384Hasher::Init() throw()
+{
+  SHA384_Init(&_ctx);
+}
+
+STDMETHODIMP_(void) CSHA384Hasher::Update(const void *data, UInt32 size) throw()
+{
+  SHA384_Update(&_ctx, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CSHA384Hasher::Final(Byte *digest) throw()
+{
+  SHA384_Final(digest, &_ctx);
+}
+REGISTER_HASHER(CSHA384Hasher, 0x208, "SHA384", SHA384_DIGEST_LENGTH)
diff --git a/CPP/Common/Sha512Reg.cpp b/CPP/Common/Sha512Reg.cpp
new file mode 100644
index 00000000..9634e4c9
--- /dev/null
+++ b/CPP/Common/Sha512Reg.cpp
@@ -0,0 +1,43 @@
+// Sha512Reg.cpp /TR 2018-11-02
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+
+EXTERN_C_BEGIN
+#include "../../C/hashes/sha.h"
+EXTERN_C_END
+
+#include "../Common/MyCom.h"
+#include "../7zip/Common/RegisterCodec.h"
+
+// SHA512
+class CSHA512Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  SHA512_CTX _ctx;
+  Byte mtDummy[1 << 7];
+
+public:
+  CSHA512Hasher() { SHA512_Init(&_ctx); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CSHA512Hasher::Init() throw()
+{
+  SHA512_Init(&_ctx);
+}
+
+STDMETHODIMP_(void) CSHA512Hasher::Update(const void *data, UInt32 size) throw()
+{
+  SHA512_Update(&_ctx, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CSHA512Hasher::Final(Byte *digest) throw()
+{
+  SHA512_Final(digest, &_ctx);
+}
+REGISTER_HASHER(CSHA512Hasher, 0x209, "SHA512", SHA512_DIGEST_LENGTH)
diff --git a/CPP/Common/XXH32Reg.cpp b/CPP/Common/XXH32Reg.cpp
index c0ccea43..fdf8fd7b 100644
--- a/CPP/Common/XXH32Reg.cpp
+++ b/CPP/Common/XXH32Reg.cpp
@@ -1,15 +1,16 @@
-// XXH32Reg.cpp
+// XXH32Reg.cpp /TR 2018-11-02
 
 #include "StdAfx.h"
 
-#define XXH_STATIC_LINKING_ONLY
 #include "../../C/CpuArch.h"
+
+#define XXH_STATIC_LINKING_ONLY
 #include "../../C/zstd/xxhash.h"
 
 #include "../Common/MyCom.h"
-
 #include "../7zip/Common/RegisterCodec.h"
 
+// XXH32
 class CXXH32Hasher:
   public IHasher,
   public CMyUnknownImp
diff --git a/CPP/Common/XXH64Reg.cpp b/CPP/Common/XXH64Reg.cpp
index 9a316d50..b1d9b064 100644
--- a/CPP/Common/XXH64Reg.cpp
+++ b/CPP/Common/XXH64Reg.cpp
@@ -1,15 +1,16 @@
-// XXH64Reg.cpp
+// XXH64Reg.cpp /TR 2018-11-02
 
 #include "StdAfx.h"
 
-#define XXH_STATIC_LINKING_ONLY
 #include "../../C/CpuArch.h"
+
+#define XXH_STATIC_LINKING_ONLY
 #include "../../C/zstd/xxhash.h"
 
 #include "../Common/MyCom.h"
-
 #include "../7zip/Common/RegisterCodec.h"
 
+// XXH64
 class CXXH64Hasher:
   public IHasher,
   public CMyUnknownImp
@@ -40,5 +41,4 @@ STDMETHODIMP_(void) CXXH64Hasher::Final(Byte *digest) throw()
   UInt64 val = XXH64_digest(_ctx);
   SetUi64(digest, val);
 }
-
 REGISTER_HASHER(CXXH64Hasher, 0x204, "XXH64", 8)

From 1a09f6fc0d20f3cf41f9777b3c3aeaf4ed2fbcbe Mon Sep 17 00:00:00 2001
From: Tino Reichardt <milky-7zip@mcmilk.de>
Date: Sat, 3 Nov 2018 10:03:54 +0100
Subject: [PATCH 08/11] Fix zstd decompression - todo: make zstd ldm
 compression optional

---
 CPP/7zip/Compress/ZstdDecoder.cpp | 8 ++------
 CPP/7zip/Compress/ZstdEncoder.cpp | 4 ++++
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/CPP/7zip/Compress/ZstdDecoder.cpp b/CPP/7zip/Compress/ZstdDecoder.cpp
index f807acfe..baccadf0 100644
--- a/CPP/7zip/Compress/ZstdDecoder.cpp
+++ b/CPP/7zip/Compress/ZstdDecoder.cpp
@@ -84,11 +84,6 @@ HRESULT CDecoder::CodeSpec(ISequentialInStream * inStream,
     ZSTD_resetDStream(_ctx);
   }
 
-// _processedOut += zOut.pos;
-// RINOK(ReadStream(inStream, _srcBuf, &size));
-// RINOK(WriteStream(outStream, _dstBuf, zOut.pos));
-// RINOK(progress->SetRatioInfo(&_processedIn, &_processedOut));
-
   zIn.src = _srcBuf;
   zIn.size = _srcBufSize;
   zIn.pos = 0;
@@ -141,10 +136,11 @@ HRESULT CDecoder::CodeSpec(ISequentialInStream * inStream,
         result = ZSTD_resetDStream(_ctx);
         if (ZSTD_isError(result))
           return E_FAIL;
+        /* read next input, or eof */
+        break;
       }
     } /* for() decompress */
 
-
     /* read next input */
     srcBufLen = _srcBufSize;
     RINOK(ReadStream(inStream, _srcBuf, &srcBufLen));
diff --git a/CPP/7zip/Compress/ZstdEncoder.cpp b/CPP/7zip/Compress/ZstdEncoder.cpp
index 02cf36da..ff74f426 100644
--- a/CPP/7zip/Compress/ZstdEncoder.cpp
+++ b/CPP/7zip/Compress/ZstdEncoder.cpp
@@ -104,15 +104,19 @@ STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream,
     if (!_dstBuf)
       return E_OUTOFMEMORY;
 
+    /* setup level */
     err = ZSTD_CCtx_setParameter(_ctx, ZSTD_p_compressionLevel, _props._level);
     if (ZSTD_isError(err)) return E_FAIL;
 
+    /* setup thread count */
     err = ZSTD_CCtx_setParameter(_ctx, ZSTD_p_nbWorkers, _numThreads);
     if (ZSTD_isError(err)) return E_FAIL;
 
+    /* set the content size flag */
     err = ZSTD_CCtx_setParameter(_ctx, ZSTD_p_contentSizeFlag, 1);
     if (ZSTD_isError(err)) return E_FAIL;
 
+    /* todo: make this optional */
     err = ZSTD_CCtx_setParameter(_ctx, ZSTD_p_enableLongDistanceMatching, 1);
     if (ZSTD_isError(err)) return E_FAIL;
   }

From 41ddee9d44dd8c08c734485e5c0b4eb7c7febd52 Mon Sep 17 00:00:00 2001
From: Tino Reichardt <milky-7zip@mcmilk.de>
Date: Sat, 3 Nov 2018 12:37:10 +0100
Subject: [PATCH 09/11] Fix double sha512.obj in Ark.mak

---
 CPP/7zip/Bundles/Format7zF/Arc.mak | 1 -
 1 file changed, 1 deletion(-)

diff --git a/CPP/7zip/Bundles/Format7zF/Arc.mak b/CPP/7zip/Bundles/Format7zF/Arc.mak
index 4f28e05c..9b9ae22a 100644
--- a/CPP/7zip/Bundles/Format7zF/Arc.mak
+++ b/CPP/7zip/Bundles/Format7zF/Arc.mak
@@ -263,7 +263,6 @@ HASHES_OBJS = \
   $O\sha512.obj \
 
 C_OBJS = \
-  $O\sha512.obj \
   $O\7zBuf2.obj \
   $O\7zStream.obj \
   $O\Alloc.obj \

From 71a295905f1d63a8b4d8172bdc1ccebb7af6eeb1 Mon Sep 17 00:00:00 2001
From: Tino Reichardt <milky-7zip@mcmilk.de>
Date: Sat, 3 Nov 2018 12:46:49 +0100
Subject: [PATCH 10/11] Fix compiling issue on x32 with sha512.c

---
 C/hashes/sha512.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/C/hashes/sha512.c b/C/hashes/sha512.c
index 6d1cc060..23236dbc 100644
--- a/C/hashes/sha512.c
+++ b/C/hashes/sha512.c
@@ -192,7 +192,7 @@ void
 SHA512_Update (SHA512_CTX *m, const void *v, size_t len)
 {
     const unsigned char *p = v;
-    size_t old_sz = m->sz[0];
+    size_t old_sz = (size_t)m->sz[0];
     size_t offset;
 
     m->sz[0] += len * 8;

From 68f3ed1f3c50236e768c9debeb8ee7c5d969b766 Mon Sep 17 00:00:00 2001
From: Tino Reichardt <milky-7zip@mcmilk.de>
Date: Tue, 6 Nov 2018 18:23:53 +0100
Subject: [PATCH 11/11] Compiling fixes - add /TP on old IA64 compiler (sdk71)
 - disable C4389 warning for flzma2

---
 C/fast-lzma2/mem.h  | 3 +++
 C/fast-lzma2/util.h | 1 +
 CPP/appveyor.cmd    | 2 ++
 CPP/build-ia64.cmd  | 2 +-
 4 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/C/fast-lzma2/mem.h b/C/fast-lzma2/mem.h
index 47d23001..f54a45ce 100644
--- a/C/fast-lzma2/mem.h
+++ b/C/fast-lzma2/mem.h
@@ -28,6 +28,9 @@ extern "C" {
 #if defined(_MSC_VER)   /* Visual Studio */
 #   include <stdlib.h>  /* _byteswap_ulong */
 #   include <intrin.h>  /* _byteswap_* */
+#   pragma warning(disable : 4389)  /* disable: C4389: '==' : signed/unsigned mismatch */
+#endif
+
 #endif
 #if defined(__GNUC__)
 #  define MEM_STATIC static __inline __attribute__((unused))
diff --git a/C/fast-lzma2/util.h b/C/fast-lzma2/util.h
index fe8b6fa4..d5688203 100644
--- a/C/fast-lzma2/util.h
+++ b/C/fast-lzma2/util.h
@@ -102,6 +102,7 @@ extern "C" {
 #elif defined(_MSC_VER)
 #  define UTIL_STATIC static __inline
 #  pragma warning(disable : 4996)  /* disable: C4996: 'strncpy': This function or variable may be unsafe. */
+#  pragma warning(disable : 4389)  /* disable: C4389: '==' : signed/unsigned mismatch */
 #else
 #  define UTIL_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
 #endif
diff --git a/CPP/appveyor.cmd b/CPP/appveyor.cmd
index 4e0a015d..14345aca 100644
--- a/CPP/appveyor.cmd
+++ b/CPP/appveyor.cmd
@@ -1,9 +1,11 @@
 @echo off
 
 REM Microsoft Windows SDK 7.1    (VC=sdk71)
+REM Microsoft Visual Studio 2010 (VC=10.0)
 REM Microsoft Visual Studio 2012 (VC=11.0)
 REM Microsoft Visual Studio 2013 (VC=12.0)
 REM Microsoft Visual Studio 2015 (VC=14.0)
+REM Microsoft Visual Studio 2017 (VC=15.0)
 
 REM to many vcvarsall.cmd calls will blow it up!
 set OPATH=%PATH%
diff --git a/CPP/build-ia64.cmd b/CPP/build-ia64.cmd
index 4bd741eb..47cb3d29 100644
--- a/CPP/build-ia64.cmd
+++ b/CPP/build-ia64.cmd
@@ -4,7 +4,7 @@ set ROOT=%cd%\7zip
 if not defined OUTDIR set OUTDIR=%ROOT%\binIA64
 mkdir %OUTDIR%
 
-set OPTS=CPU=IA64 MY_STATIC_LINK=1 /NOLOGO
+set OPTS=CPU=IA64 MY_STATIC_LINK=1 /NOLOGO /TP
 set LFLAGS=/SUBSYSTEM:WINDOWS,"5.02"
 
 cd %ROOT%\Bundles\Format7zExtract