Add m-esr52 at 52.6.0

21 files changed, 2206 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/7zip/Compress/Branch/BranchCoder.cpp b/other-licenses/7zstub/src/7zip/Compress/Branch/BranchCoder.cpp
new file mode 100644
index 000000000..68e938bde
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/Branch/BranchCoder.cpp
@@ -0,0 +1,18 @@
+// BranchCoder.cpp

+

+#include "StdAfx.h"

+#include "BranchCoder.h"

+

+STDMETHODIMP CBranchConverter::Init()

+{

+  _bufferPos = 0;

+  SubInit();

+  return S_OK;

+}

+

+STDMETHODIMP_(UInt32) CBranchConverter::Filter(Byte *data, UInt32 size)

+{

+  UInt32 processedSize = SubFilter(data, size);

+  _bufferPos += processedSize;

+  return processedSize;

+}

diff --git a/other-licenses/7zstub/src/7zip/Compress/Branch/BranchCoder.h b/other-licenses/7zstub/src/7zip/Compress/Branch/BranchCoder.h
new file mode 100644
index 000000000..b64562dfc
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/Branch/BranchCoder.h
@@ -0,0 +1,54 @@
+// BranchCoder.h

+

+#ifndef __BRANCH_CODER_H

+#define __BRANCH_CODER_H

+

+#include "Common/MyCom.h"

+#include "Common/Types.h"

+#include "Common/Alloc.h"

+

+#include "../../ICoder.h"

+

+class CBranchConverter:

+  public ICompressFilter,

+  public CMyUnknownImp

+{

+protected:

+  UInt32 _bufferPos;

+  virtual void SubInit() {}

+  virtual UInt32 SubFilter(Byte *data, UInt32 size) = 0;

+public:

+  MY_UNKNOWN_IMP;

+  STDMETHOD(Init)();

+  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);

+};

+

+#define MyClassEncoderA(Name) class C ## Name: public CBranchConverter \

+  { public: UInt32 SubFilter(Byte *data, UInt32 size); }; 

+

+#define MyClassDecoderA(Name) class C ## Name: public CBranchConverter \

+  { public: UInt32 SubFilter(Byte *data, UInt32 size); }; 

+

+#define MyClassEncoderB(Name, ADD_ITEMS, ADD_INIT) class C ## Name: public CBranchConverter, public ADD_ITEMS \

+  { public: UInt32 SubFilter(Byte *data, UInt32 size); ADD_INIT}; 

+

+#define MyClassDecoderB(Name, ADD_ITEMS, ADD_INIT) class C ## Name: public CBranchConverter, public ADD_ITEMS \

+  { public: UInt32 SubFilter(Byte *data, UInt32 size); ADD_INIT}; 

+

+#define MyClass2b(Name, id, subId, encodingId)  \

+DEFINE_GUID(CLSID_CCompressConvert ## Name,  \

+0x23170F69, 0x40C1, 0x278B, 0x03, 0x03, id, subId, 0x00, 0x00, encodingId, 0x00); 

+

+#define MyClassA(Name, id, subId)  \

+MyClass2b(Name ## _Encoder, id, subId, 0x01) \

+MyClassEncoderA(Name ## _Encoder) \

+MyClass2b(Name ## _Decoder, id, subId, 0x00) \

+MyClassDecoderA(Name ## _Decoder)

+

+#define MyClassB(Name, id, subId, ADD_ITEMS, ADD_INIT)  \

+MyClass2b(Name ## _Encoder, id, subId, 0x01) \

+MyClassEncoderB(Name ## _Encoder, ADD_ITEMS, ADD_INIT) \

+MyClass2b(Name ## _Decoder, id, subId, 0x00) \

+MyClassDecoderB(Name ## _Decoder, ADD_ITEMS, ADD_INIT)

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/Branch/BranchTypes.h b/other-licenses/7zstub/src/7zip/Compress/Branch/BranchTypes.h
new file mode 100644
index 000000000..730087562
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/Branch/BranchTypes.h
@@ -0,0 +1,15 @@
+/* BranchTypes.h */

+

+#ifndef __BRANCHTYPES_H

+#define __BRANCHTYPES_H

+

+typedef unsigned char Byte;

+typedef unsigned short UInt16;

+

+#ifdef _LZMA_UINT32_IS_ULONG

+typedef unsigned long UInt32;

+#else

+typedef unsigned int UInt32;

+#endif

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/Branch/BranchX86.c b/other-licenses/7zstub/src/7zip/Compress/Branch/BranchX86.c
new file mode 100644
index 000000000..2d2c03d2d
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/Branch/BranchX86.c
@@ -0,0 +1,101 @@
+/* BranchX86.c */

+

+#include "BranchX86.h"

+

+/*

+static int inline Test86MSByte(Byte b)

+{

+  return (b == 0 || b == 0xFF);

+}

+*/

+#define Test86MSByte(b) ((b) == 0 || (b) == 0xFF)

+

+const int kMaskToAllowedStatus[8] = {1, 1, 1, 0, 1, 0, 0, 0};

+const Byte kMaskToBitNumber[8] = {0, 1, 2, 2, 3, 3, 3, 3};

+

+/*

+void x86_Convert_Init(UInt32 *prevMask, UInt32 *prevPos)

+{

+  *prevMask = 0;

+  *prevPos = (UInt32)(-5);

+}

+*/

+

+UInt32 x86_Convert(Byte *buffer, UInt32 endPos, UInt32 nowPos, 

+    UInt32 *prevMask, UInt32 *prevPos, int encoding)

+{

+  UInt32 bufferPos = 0;

+  UInt32 limit;

+

+  if (endPos < 5)

+    return 0;

+  

+  if (nowPos - *prevPos > 5)

+    *prevPos = nowPos - 5;

+  

+  limit = endPos - 5;

+  while(bufferPos <= limit)

+  {

+    Byte b = buffer[bufferPos];

+    UInt32 offset;

+    if (b != 0xE8 && b != 0xE9)

+    {

+      bufferPos++;

+      continue;

+    }

+    offset = (nowPos + bufferPos - *prevPos);

+    *prevPos = (nowPos + bufferPos);

+    if (offset > 5)

+      *prevMask = 0;

+    else

+    {

+      UInt32 i;

+      for (i = 0; i < offset; i++)

+      {

+        *prevMask &= 0x77;

+        *prevMask <<= 1;

+      }

+    }

+    b = buffer[bufferPos + 4];

+    if (Test86MSByte(b) && kMaskToAllowedStatus[(*prevMask >> 1) & 0x7] && 

+      (*prevMask >> 1) < 0x10)

+    {

+      UInt32 src = 

+        ((UInt32)(b) << 24) |

+        ((UInt32)(buffer[bufferPos + 3]) << 16) |

+        ((UInt32)(buffer[bufferPos + 2]) << 8) |

+        (buffer[bufferPos + 1]);

+      

+      UInt32 dest;

+      while(1)

+      {

+        UInt32 index;

+        if (encoding)

+          dest = (nowPos + bufferPos + 5) + src;

+        else

+          dest = src - (nowPos + bufferPos + 5);

+        if (*prevMask == 0)

+          break;

+        index = kMaskToBitNumber[*prevMask >> 1];

+        b = (Byte)(dest >> (24 - index * 8));

+        if (!Test86MSByte(b))

+          break;

+        src = dest ^ ((1 << (32 - index * 8)) - 1);

+      }

+      buffer[bufferPos + 4] = (Byte)(~(((dest >> 24) & 1) - 1));

+      buffer[bufferPos + 3] = (Byte)(dest >> 16);

+      buffer[bufferPos + 2] = (Byte)(dest >> 8);

+      buffer[bufferPos + 1] = (Byte)dest;

+      bufferPos += 5;

+      *prevMask = 0;

+    }

+    else

+    {

+      bufferPos++;

+      *prevMask |= 1;

+      if (Test86MSByte(b))

+        *prevMask |= 0x10;

+    }

+  }

+  return bufferPos;

+}

diff --git a/other-licenses/7zstub/src/7zip/Compress/Branch/BranchX86.h b/other-licenses/7zstub/src/7zip/Compress/Branch/BranchX86.h
new file mode 100644
index 000000000..ff9c71cbe
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/Branch/BranchX86.h
@@ -0,0 +1,13 @@
+/* BranchX86.h */

+

+#ifndef __BRANCHX86_H

+#define __BRANCHX86_H

+

+#include "BranchTypes.h"

+

+#define x86_Convert_Init(prevMask, prevPos) { prevMask = 0; prevPos = (UInt32)(-5); }

+

+UInt32 x86_Convert(Byte *buffer, UInt32 endPos, UInt32 nowPos, 

+    UInt32 *prevMask, UInt32 *prevPos, int encoding);

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/Branch/x86.cpp b/other-licenses/7zstub/src/7zip/Compress/Branch/x86.cpp
new file mode 100644
index 000000000..929484ad6
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/Branch/x86.cpp
@@ -0,0 +1,18 @@
+// x86.cpp

+

+#include "StdAfx.h"

+#include "x86.h"

+

+#include "Windows/Defs.h"

+

+#include "BranchX86.c"

+

+UInt32 CBCJ_x86_Encoder::SubFilter(Byte *data, UInt32 size)

+{

+  return ::x86_Convert(data, size, _bufferPos, &_prevMask, &_prevPos, 1);

+}

+

+UInt32 CBCJ_x86_Decoder::SubFilter(Byte *data, UInt32 size)

+{

+  return ::x86_Convert(data, size, _bufferPos, &_prevMask, &_prevPos, 0);

+}

diff --git a/other-licenses/7zstub/src/7zip/Compress/Branch/x86.h b/other-licenses/7zstub/src/7zip/Compress/Branch/x86.h
new file mode 100644
index 000000000..85882d914
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/Branch/x86.h
@@ -0,0 +1,19 @@
+// x86.h

+

+#ifndef __X86_H

+#define __X86_H

+

+#include "BranchCoder.h"

+#include "BranchX86.h"

+

+struct CBranch86

+{

+  UInt32 _prevMask;

+  UInt32 _prevPos;

+  void x86Init() { x86_Convert_Init(_prevMask, _prevPos); }

+};

+

+MyClassB(BCJ_x86, 0x01, 3, CBranch86 , 

+    virtual void SubInit() { x86Init(); })

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/Branch/x86_2.cpp b/other-licenses/7zstub/src/7zip/Compress/Branch/x86_2.cpp
new file mode 100644
index 000000000..fc87bd937
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/Branch/x86_2.cpp
@@ -0,0 +1,412 @@
+// x86_2.cpp

+

+#include "StdAfx.h"

+#include "x86_2.h"

+

+#include "../../../Common/Alloc.h"

+

+static const int kBufferSize = 1 << 17;

+

+inline bool IsJcc(Byte b0, Byte b1)

+{

+  return (b0 == 0x0F && (b1 & 0xF0) == 0x80);

+}

+

+#ifndef EXTRACT_ONLY

+

+static bool inline Test86MSByte(Byte b)

+{

+  return (b == 0 || b == 0xFF);

+}

+

+bool CBCJ2_x86_Encoder::Create()

+{

+  if (!_mainStream.Create(1 << 16))

+    return false;

+  if (!_callStream.Create(1 << 20))

+    return false;

+  if (!_jumpStream.Create(1 << 20))

+    return false;

+  if (!_rangeEncoder.Create(1 << 20))

+    return false;

+  if (_buffer == 0)

+  {

+    _buffer = (Byte *)MidAlloc(kBufferSize);

+    if (_buffer == 0)

+      return false;

+  }

+  return true;

+}

+

+CBCJ2_x86_Encoder::~CBCJ2_x86_Encoder()

+{

+  ::MidFree(_buffer);

+}

+

+HRESULT CBCJ2_x86_Encoder::Flush()

+{

+  RINOK(_mainStream.Flush());

+  RINOK(_callStream.Flush());

+  RINOK(_jumpStream.Flush());

+  _rangeEncoder.FlushData();

+  return _rangeEncoder.FlushStream();

+}

+

+const UInt32 kDefaultLimit = (1 << 24);

+

+HRESULT CBCJ2_x86_Encoder::CodeReal(ISequentialInStream **inStreams,

+      const UInt64 **inSizes,

+      UInt32 numInStreams,

+      ISequentialOutStream **outStreams,

+      const UInt64 **outSizes,

+      UInt32 numOutStreams,

+      ICompressProgressInfo *progress)

+{

+  if (numInStreams != 1 || numOutStreams != 4)

+    return E_INVALIDARG;

+

+  if (!Create())

+    return E_OUTOFMEMORY;

+

+  bool sizeIsDefined = false;

+  UInt64 inSize;

+  if (inSizes != NULL)

+    if (inSizes[0] != NULL)

+    {

+      inSize = *inSizes[0];

+      if (inSize <= kDefaultLimit)

+        sizeIsDefined = true;

+    }

+

+  ISequentialInStream *inStream = inStreams[0];

+

+  _mainStream.SetStream(outStreams[0]);

+  _mainStream.Init();

+  _callStream.SetStream(outStreams[1]);

+  _callStream.Init();

+  _jumpStream.SetStream(outStreams[2]);

+  _jumpStream.Init();

+  _rangeEncoder.SetStream(outStreams[3]);

+  _rangeEncoder.Init();

+  for (int i = 0; i < 256; i++)

+    _statusE8Encoder[i].Init();

+  _statusE9Encoder.Init();

+  _statusJccEncoder.Init();

+  CCoderReleaser releaser(this);

+

+  CMyComPtr<ICompressGetSubStreamSize> getSubStreamSize;

+  {

+    inStream->QueryInterface(IID_ICompressGetSubStreamSize, (void **)&getSubStreamSize);

+  }

+

+  UInt32 nowPos = 0;

+  UInt64 nowPos64 = 0;

+  UInt32 bufferPos = 0;

+

+  Byte prevByte = 0;

+

+  UInt64 subStreamIndex = 0;

+  UInt64 subStreamStartPos  = 0;

+  UInt64 subStreamEndPos = 0;

+

+  while(true)

+  {

+    UInt32 processedSize = 0;

+    while(true)

+    {

+      UInt32 size = kBufferSize - (bufferPos + processedSize);

+      UInt32 processedSizeLoc;

+      if (size == 0)

+        break;

+      RINOK(inStream->Read(_buffer + bufferPos + processedSize, size, &processedSizeLoc));

+      if (processedSizeLoc == 0)

+        break;

+      processedSize += processedSizeLoc;

+    }

+    UInt32 endPos = bufferPos + processedSize;

+    

+    if (endPos < 5)

+    {

+      // change it 

+      for (bufferPos = 0; bufferPos < endPos; bufferPos++)

+      {

+        Byte b = _buffer[bufferPos];

+        _mainStream.WriteByte(b);

+        if (b == 0xE8)

+          _statusE8Encoder[prevByte].Encode(&_rangeEncoder, 0);

+        else if (b == 0xE9)

+          _statusE9Encoder.Encode(&_rangeEncoder, 0);

+        else if (IsJcc(prevByte, b))

+          _statusJccEncoder.Encode(&_rangeEncoder, 0);

+        prevByte = b;

+      }

+      return Flush();

+    }

+

+    bufferPos = 0;

+

+    UInt32 limit = endPos - 5;

+    while(bufferPos <= limit)

+    {

+      Byte b = _buffer[bufferPos];

+      _mainStream.WriteByte(b);

+      if (b != 0xE8 && b != 0xE9 && !IsJcc(prevByte, b))

+      {

+        bufferPos++;

+        prevByte = b;

+        continue;

+      }

+      Byte nextByte = _buffer[bufferPos + 4];

+      UInt32 src = 

+        (UInt32(nextByte) << 24) |

+        (UInt32(_buffer[bufferPos + 3]) << 16) |

+        (UInt32(_buffer[bufferPos + 2]) << 8) |

+        (_buffer[bufferPos + 1]);

+      UInt32 dest = (nowPos + bufferPos + 5) + src;

+      // if (Test86MSByte(nextByte))

+      bool convert;

+      if (getSubStreamSize != NULL)

+      {

+        UInt64 currentPos = (nowPos64 + bufferPos);

+        while (subStreamEndPos < currentPos)

+        {

+          UInt64 subStreamSize;

+          HRESULT result = getSubStreamSize->GetSubStreamSize(subStreamIndex, &subStreamSize);

+          if (result == S_OK)

+          {

+            subStreamStartPos = subStreamEndPos;

+            subStreamEndPos += subStreamSize;          

+            subStreamIndex++;

+          }

+          else if (result == S_FALSE || result == E_NOTIMPL)

+          {

+            getSubStreamSize.Release();

+            subStreamStartPos = 0;

+            subStreamEndPos = subStreamStartPos - 1;          

+          }

+          else

+            return result;

+        }

+        if (getSubStreamSize == NULL)

+        {

+          if (sizeIsDefined)

+            convert = (dest < inSize);

+          else

+            convert = Test86MSByte(nextByte);

+        }

+        else if (subStreamEndPos - subStreamStartPos > kDefaultLimit)

+          convert = Test86MSByte(nextByte);

+        else

+        {

+          UInt64 dest64 = (currentPos + 5) + Int64(Int32(src));

+          convert = (dest64 >= subStreamStartPos && dest64 < subStreamEndPos);

+        }

+      }

+      else if (sizeIsDefined)

+        convert = (dest < inSize);

+      else

+        convert = Test86MSByte(nextByte);

+      if (convert)

+      {

+        if (b == 0xE8)

+          _statusE8Encoder[prevByte].Encode(&_rangeEncoder, 1);

+        else if (b == 0xE9)

+          _statusE9Encoder.Encode(&_rangeEncoder, 1);

+        else 

+          _statusJccEncoder.Encode(&_rangeEncoder, 1);

+

+        bufferPos += 5;

+        if (b == 0xE8)

+        {

+          _callStream.WriteByte((Byte)(dest >> 24));

+          _callStream.WriteByte((Byte)(dest >> 16));

+          _callStream.WriteByte((Byte)(dest >> 8));

+          _callStream.WriteByte((Byte)(dest));

+        }

+        else 

+        {

+          _jumpStream.WriteByte((Byte)(dest >> 24));

+          _jumpStream.WriteByte((Byte)(dest >> 16));

+          _jumpStream.WriteByte((Byte)(dest >> 8));

+          _jumpStream.WriteByte((Byte)(dest));

+        }

+        prevByte = nextByte;

+      }

+      else

+      {

+        if (b == 0xE8)

+          _statusE8Encoder[prevByte].Encode(&_rangeEncoder, 0);

+        else if (b == 0xE9)

+          _statusE9Encoder.Encode(&_rangeEncoder, 0);

+        else

+          _statusJccEncoder.Encode(&_rangeEncoder, 0);

+        bufferPos++;

+        prevByte = b;

+      }

+    }

+    nowPos += bufferPos;

+    nowPos64 += bufferPos;

+

+    if (progress != NULL)

+    {

+      RINOK(progress->SetRatioInfo(&nowPos64, NULL));

+    }

+ 

+    UInt32 i = 0;

+    while(bufferPos < endPos)

+      _buffer[i++] = _buffer[bufferPos++];

+    bufferPos = i;

+  }

+}

+

+STDMETHODIMP CBCJ2_x86_Encoder::Code(ISequentialInStream **inStreams,

+      const UInt64 **inSizes,

+      UInt32 numInStreams,

+      ISequentialOutStream **outStreams,

+      const UInt64 **outSizes,

+      UInt32 numOutStreams,

+      ICompressProgressInfo *progress)

+{

+  try

+  {

+    return CodeReal(inStreams, inSizes, numInStreams,

+      outStreams, outSizes,numOutStreams, progress);

+  }

+  catch(const COutBufferException &e) { return e.ErrorCode; }

+  catch(...) { return S_FALSE; }

+}

+

+#endif

+

+HRESULT CBCJ2_x86_Decoder::CodeReal(ISequentialInStream **inStreams,

+      const UInt64 **inSizes,

+      UInt32 numInStreams,

+      ISequentialOutStream **outStreams,

+      const UInt64 **outSizes,

+      UInt32 numOutStreams,

+      ICompressProgressInfo *progress)

+{

+  if (numInStreams != 4 || numOutStreams != 1)

+    return E_INVALIDARG;

+

+  if (!_mainInStream.Create(1 << 16))

+    return E_OUTOFMEMORY;

+  if (!_callStream.Create(1 << 20))

+    return E_OUTOFMEMORY;

+  if (!_jumpStream.Create(1 << 16))

+    return E_OUTOFMEMORY;

+  if (!_rangeDecoder.Create(1 << 20))

+    return E_OUTOFMEMORY;

+  if (!_outStream.Create(1 << 16))

+    return E_OUTOFMEMORY;

+

+  _mainInStream.SetStream(inStreams[0]);

+  _callStream.SetStream(inStreams[1]);

+  _jumpStream.SetStream(inStreams[2]);

+  _rangeDecoder.SetStream(inStreams[3]);

+  _outStream.SetStream(outStreams[0]);

+

+  _mainInStream.Init();

+  _callStream.Init();

+  _jumpStream.Init();

+  _rangeDecoder.Init();

+  _outStream.Init();

+

+  for (int i = 0; i < 256; i++)

+    _statusE8Decoder[i].Init();

+  _statusE9Decoder.Init();

+  _statusJccDecoder.Init();

+

+  CCoderReleaser releaser(this);

+

+  Byte prevByte = 0;

+  UInt32 processedBytes = 0;

+  while(true)

+  {

+    if (processedBytes > (1 << 20) && progress != NULL)

+    {

+      UInt64 nowPos64 = _outStream.GetProcessedSize();

+      RINOK(progress->SetRatioInfo(NULL, &nowPos64));

+      processedBytes = 0;

+    }

+    processedBytes++;

+    Byte b;

+    if (!_mainInStream.ReadByte(b))

+      return Flush();

+    _outStream.WriteByte(b);

+    if (b != 0xE8 && b != 0xE9 && !IsJcc(prevByte, b))

+    {

+      prevByte = b;

+      continue;

+    }

+    bool status;

+    if (b == 0xE8)

+      status = (_statusE8Decoder[prevByte].Decode(&_rangeDecoder) == 1);

+    else if (b == 0xE9)

+      status = (_statusE9Decoder.Decode(&_rangeDecoder) == 1);

+    else

+      status = (_statusJccDecoder.Decode(&_rangeDecoder) == 1);

+    if (status)

+    {

+      UInt32 src;

+      if (b == 0xE8)

+      {

+        Byte b0;

+        if(!_callStream.ReadByte(b0))

+          return S_FALSE;

+        src = ((UInt32)b0) << 24;

+        if(!_callStream.ReadByte(b0))

+          return S_FALSE;

+        src |= ((UInt32)b0) << 16;

+        if(!_callStream.ReadByte(b0))

+          return S_FALSE;

+        src |= ((UInt32)b0) << 8;

+        if(!_callStream.ReadByte(b0))

+          return S_FALSE;

+        src |= ((UInt32)b0);

+      }

+      else

+      {

+        Byte b0;

+        if(!_jumpStream.ReadByte(b0))

+          return S_FALSE;

+        src = ((UInt32)b0) << 24;

+        if(!_jumpStream.ReadByte(b0))

+          return S_FALSE;

+        src |= ((UInt32)b0) << 16;

+        if(!_jumpStream.ReadByte(b0))

+          return S_FALSE;

+        src |= ((UInt32)b0) << 8;

+        if(!_jumpStream.ReadByte(b0))

+          return S_FALSE;

+        src |= ((UInt32)b0);

+      }

+      UInt32 dest = src - (UInt32(_outStream.GetProcessedSize()) + 4) ;

+      _outStream.WriteByte((Byte)(dest));

+      _outStream.WriteByte((Byte)(dest >> 8));

+      _outStream.WriteByte((Byte)(dest >> 16));

+      _outStream.WriteByte((Byte)(dest >> 24));

+      prevByte = (dest >> 24);

+      processedBytes += 4;

+    }

+    else

+      prevByte = b;

+  }

+}

+

+STDMETHODIMP CBCJ2_x86_Decoder::Code(ISequentialInStream **inStreams,

+      const UInt64 **inSizes,

+      UInt32 numInStreams,

+      ISequentialOutStream **outStreams,

+      const UInt64 **outSizes,

+      UInt32 numOutStreams,

+      ICompressProgressInfo *progress)

+{

+  try

+  {

+    return CodeReal(inStreams, inSizes, numInStreams,

+        outStreams, outSizes,numOutStreams, progress);

+  }

+  catch(const COutBufferException &e) { return e.ErrorCode; }

+  catch(...) { return S_FALSE; }

+}

diff --git a/other-licenses/7zstub/src/7zip/Compress/Branch/x86_2.h b/other-licenses/7zstub/src/7zip/Compress/Branch/x86_2.h
new file mode 100644
index 000000000..9e7780c80
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/Branch/x86_2.h
@@ -0,0 +1,133 @@
+// x86_2.h

+

+#ifndef __BRANCH_X86_2_H

+#define __BRANCH_X86_2_H

+

+#include "../../../Common/MyCom.h"

+#include "../RangeCoder/RangeCoderBit.h"

+#include "../../ICoder.h"

+

+// {23170F69-40C1-278B-0303-010100000100}

+#define MyClass2_a(Name, id, subId, encodingId)  \

+DEFINE_GUID(CLSID_CCompressConvert ## Name,  \

+0x23170F69, 0x40C1, 0x278B, 0x03, 0x03, id, subId, 0x00, 0x00, encodingId, 0x00);

+

+#define MyClass_a(Name, id, subId)  \

+MyClass2_a(Name ## _Encoder, id, subId, 0x01) \

+MyClass2_a(Name ## _Decoder, id, subId, 0x00) 

+

+MyClass_a(BCJ2_x86, 0x01, 0x1B)

+

+const int kNumMoveBits = 5;

+

+#ifndef EXTRACT_ONLY

+

+class CBCJ2_x86_Encoder:

+  public ICompressCoder2,

+  public CMyUnknownImp

+{

+  Byte *_buffer;

+public:

+  CBCJ2_x86_Encoder(): _buffer(0) {};

+  ~CBCJ2_x86_Encoder();

+  bool Create();

+

+  COutBuffer _mainStream;

+  COutBuffer _callStream;

+  COutBuffer _jumpStream;

+  NCompress::NRangeCoder::CEncoder _rangeEncoder;

+  NCompress::NRangeCoder::CBitEncoder<kNumMoveBits> _statusE8Encoder[256];

+  NCompress::NRangeCoder::CBitEncoder<kNumMoveBits> _statusE9Encoder;

+  NCompress::NRangeCoder::CBitEncoder<kNumMoveBits> _statusJccEncoder;

+

+  HRESULT Flush();

+  void ReleaseStreams()

+  {

+    _mainStream.ReleaseStream();

+    _callStream.ReleaseStream();

+    _jumpStream.ReleaseStream();

+    _rangeEncoder.ReleaseStream();

+  }

+

+  class CCoderReleaser

+  {

+    CBCJ2_x86_Encoder *_coder;

+  public:

+    CCoderReleaser(CBCJ2_x86_Encoder *coder): _coder(coder) {}

+    ~CCoderReleaser() {  _coder->ReleaseStreams(); }

+  };

+

+public: 

+

+  MY_UNKNOWN_IMP

+

+  HRESULT CodeReal(ISequentialInStream **inStreams,

+      const UInt64 **inSizes,

+      UInt32 numInStreams,

+      ISequentialOutStream **outStreams,

+      const UInt64 **outSizes,

+      UInt32 numOutStreams,

+      ICompressProgressInfo *progress);

+  STDMETHOD(Code)(ISequentialInStream **inStreams,

+      const UInt64 **inSizes,

+      UInt32 numInStreams,

+      ISequentialOutStream **outStreams,

+      const UInt64 **outSizes,

+      UInt32 numOutStreams,

+      ICompressProgressInfo *progress);

+}; 

+

+#endif

+

+class CBCJ2_x86_Decoder:

+  public ICompressCoder2,

+  public CMyUnknownImp

+{ 

+public:

+  CInBuffer _mainInStream;

+  CInBuffer _callStream;

+  CInBuffer _jumpStream;

+  NCompress::NRangeCoder::CDecoder _rangeDecoder;

+  NCompress::NRangeCoder::CBitDecoder<kNumMoveBits> _statusE8Decoder[256];

+  NCompress::NRangeCoder::CBitDecoder<kNumMoveBits> _statusE9Decoder;

+  NCompress::NRangeCoder::CBitDecoder<kNumMoveBits> _statusJccDecoder;

+

+  COutBuffer _outStream;

+

+  void ReleaseStreams()

+  {

+    _mainInStream.ReleaseStream();

+    _callStream.ReleaseStream();

+    _jumpStream.ReleaseStream();

+    _rangeDecoder.ReleaseStream();

+    _outStream.ReleaseStream();

+  }

+

+  HRESULT Flush() { return _outStream.Flush(); }

+  class CCoderReleaser

+  {

+    CBCJ2_x86_Decoder *_coder;

+  public:

+    CCoderReleaser(CBCJ2_x86_Decoder *coder): _coder(coder) {}

+    ~CCoderReleaser()  { _coder->ReleaseStreams(); }

+  };

+

+public: 

+  MY_UNKNOWN_IMP

+  HRESULT CodeReal(ISequentialInStream **inStreams,

+      const UInt64 **inSizes,

+      UInt32 numInStreams,

+      ISequentialOutStream **outStreams,

+      const UInt64 **outSizes,

+      UInt32 numOutStreams,

+      ICompressProgressInfo *progress);

+  STDMETHOD(Code)(ISequentialInStream **inStreams,

+      const UInt64 **inSizes,

+      UInt32 numInStreams,

+      ISequentialOutStream **outStreams,

+      const UInt64 **outSizes,

+      UInt32 numOutStreams,

+      ICompressProgressInfo *progress);

+}; 

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/Copy/CopyCoder.cpp b/other-licenses/7zstub/src/7zip/Compress/Copy/CopyCoder.cpp
new file mode 100644
index 000000000..9ced21158
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/Copy/CopyCoder.cpp
@@ -0,0 +1,52 @@
+// Compress/CopyCoder.cpp

+

+#include "StdAfx.h"

+

+#include "CopyCoder.h"

+#include "../../../Common/Alloc.h"

+#include "../../Common/StreamUtils.h"

+

+namespace NCompress {

+

+static const UInt32 kBufferSize = 1 << 17;

+

+CCopyCoder::~CCopyCoder()

+{

+  ::MidFree(_buffer);

+}

+

+STDMETHODIMP CCopyCoder::Code(ISequentialInStream *inStream,

+    ISequentialOutStream *outStream, 

+    const UInt64 *inSize, const UInt64 *outSize,

+    ICompressProgressInfo *progress)

+{

+  if (_buffer == 0)

+  {

+    _buffer = (Byte *)::MidAlloc(kBufferSize);

+    if (_buffer == 0)

+      return E_OUTOFMEMORY;

+  }

+

+  TotalSize = 0;

+  while(true)

+  {

+    UInt32 realProcessedSize;

+    UInt32 size = kBufferSize;

+    if (outSize != 0)

+      if (size > *outSize - TotalSize)

+        size = (UInt32)(*outSize - TotalSize);

+    RINOK(inStream->Read(_buffer, size, &realProcessedSize));

+    if(realProcessedSize == 0)

+      break;

+    RINOK(WriteStream(outStream, _buffer, realProcessedSize, NULL));

+    TotalSize += realProcessedSize;

+    if (progress != NULL)

+    {

+      RINOK(progress->SetRatioInfo(&TotalSize, &TotalSize));

+    }

+  }

+  return S_OK;

+}

+

+}

+

diff --git a/other-licenses/7zstub/src/7zip/Compress/Copy/CopyCoder.h b/other-licenses/7zstub/src/7zip/Compress/Copy/CopyCoder.h
new file mode 100644
index 000000000..c82e469a4
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/Copy/CopyCoder.h
@@ -0,0 +1,31 @@
+// Compress/CopyCoder.h

+

+#ifndef __COMPRESS_COPYCODER_H

+#define __COMPRESS_COPYCODER_H

+

+#include "../../ICoder.h"

+#include "../../../Common/MyCom.h"

+

+namespace NCompress {

+

+class CCopyCoder: 

+  public ICompressCoder,

+  public CMyUnknownImp

+{

+  Byte *_buffer;

+public:

+  UInt64 TotalSize;

+  CCopyCoder(): TotalSize(0) , _buffer(0) {};

+  ~CCopyCoder();

+

+  MY_UNKNOWN_IMP

+

+  STDMETHOD(Code)(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream, 

+      const UInt64 *inSize, const UInt64 *outSize,

+      ICompressProgressInfo *progress);

+};

+

+}

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/LZ/LZOutWindow.cpp b/other-licenses/7zstub/src/7zip/Compress/LZ/LZOutWindow.cpp
new file mode 100644
index 000000000..329a7db35
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/LZ/LZOutWindow.cpp
@@ -0,0 +1,17 @@
+// LZOutWindow.cpp

+

+#include "StdAfx.h"

+

+#include "../../../Common/Alloc.h"

+#include "LZOutWindow.h"

+

+void CLZOutWindow::Init(bool solid)

+{

+  if(!solid)

+    COutBuffer::Init();

+  #ifdef _NO_EXCEPTIONS

+  ErrorCode = S_OK;

+  #endif

+}

+

+

diff --git a/other-licenses/7zstub/src/7zip/Compress/LZ/LZOutWindow.h b/other-licenses/7zstub/src/7zip/Compress/LZ/LZOutWindow.h
new file mode 100644
index 000000000..b64cb927f
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/LZ/LZOutWindow.h
@@ -0,0 +1,56 @@
+// LZOutWindow.h

+

+#ifndef __LZ_OUT_WINDOW_H

+#define __LZ_OUT_WINDOW_H

+

+#include "../../IStream.h"

+#include "../../Common/OutBuffer.h"

+

+#ifndef _NO_EXCEPTIONS

+typedef COutBufferException CLZOutWindowException;

+#endif

+

+class CLZOutWindow: public COutBuffer

+{

+public:

+  void Init(bool solid = false);

+  

+  // distance >= 0, len > 0, 

+  bool CopyBlock(UInt32 distance, UInt32 len)

+  {

+    UInt32 pos = _pos - distance - 1;

+    if (distance >= _pos)

+    {

+      if (!_overDict || distance >= _bufferSize)

+        return false;

+      pos += _bufferSize;

+    }

+    do

+    {

+      if (pos == _bufferSize)

+        pos = 0;

+      _buffer[_pos++] = _buffer[pos++];

+      if (_pos == _limitPos)

+        FlushWithCheck();  

+    }

+    while(--len != 0);

+    return true;

+  }

+  

+  void PutByte(Byte b)

+  {

+    _buffer[_pos++] = b;

+    if (_pos == _limitPos)

+      FlushWithCheck();  

+  }

+  

+  Byte GetByte(UInt32 distance) const

+  {

+    UInt32 pos = _pos - distance - 1;

+    if (pos >= _bufferSize)

+      pos += _bufferSize;

+    return _buffer[pos]; 

+  }

+};

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMA.h b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMA.h
new file mode 100644
index 000000000..d53296ee7
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMA.h
@@ -0,0 +1,82 @@
+// LZMA.h

+

+#ifndef __LZMA_H

+#define __LZMA_H

+

+namespace NCompress {

+namespace NLZMA {

+

+const UInt32 kNumRepDistances = 4;

+

+const int kNumStates = 12;

+

+const Byte kLiteralNextStates[kNumStates] = {0, 0, 0, 0, 1, 2, 3, 4,  5,  6,   4, 5};

+const Byte kMatchNextStates[kNumStates]   = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};

+const Byte kRepNextStates[kNumStates]     = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};

+const Byte kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};

+

+class CState

+{

+public:

+  Byte Index;

+  void Init() { Index = 0; }

+  void UpdateChar() { Index = kLiteralNextStates[Index]; }

+  void UpdateMatch() { Index = kMatchNextStates[Index]; }

+  void UpdateRep() { Index = kRepNextStates[Index]; }

+  void UpdateShortRep() { Index = kShortRepNextStates[Index]; }

+  bool IsCharState() const { return Index < 7; }

+};

+

+const int kNumPosSlotBits = 6; 

+const int kDicLogSizeMin = 0; 

+const int kDicLogSizeMax = 32; 

+const int kDistTableSizeMax = kDicLogSizeMax * 2; 

+

+const UInt32 kNumLenToPosStates = 4;

+

+inline UInt32 GetLenToPosState(UInt32 len)

+{

+  len -= 2;

+  if (len < kNumLenToPosStates)

+    return len;

+  return kNumLenToPosStates - 1;

+}

+

+namespace NLength {

+

+const int kNumPosStatesBitsMax = 4;

+const UInt32 kNumPosStatesMax = (1 << kNumPosStatesBitsMax);

+

+const int kNumPosStatesBitsEncodingMax = 4;

+const UInt32 kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax);

+

+const int kNumLowBits = 3;

+const int kNumMidBits = 3;

+const int kNumHighBits = 8;

+const UInt32 kNumLowSymbols = 1 << kNumLowBits;

+const UInt32 kNumMidSymbols = 1 << kNumMidBits;

+const UInt32 kNumSymbolsTotal = kNumLowSymbols + kNumMidSymbols + (1 << kNumHighBits);

+

+}

+

+const UInt32 kMatchMinLen = 2;

+const UInt32 kMatchMaxLen = kMatchMinLen + NLength::kNumSymbolsTotal - 1;

+

+const int kNumAlignBits = 4;

+const UInt32 kAlignTableSize = 1 << kNumAlignBits;

+const UInt32 kAlignMask = (kAlignTableSize - 1);

+

+const UInt32 kStartPosModelIndex = 4;

+const UInt32 kEndPosModelIndex = 14;

+const UInt32 kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;

+

+const UInt32 kNumFullDistances = 1 << (kEndPosModelIndex / 2);

+

+const int kNumLitPosStatesBitsEncodingMax = 4;

+const int kNumLitContextBitsMax = 8;

+

+const int kNumMoveBits = 5;

+

+}}

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.cpp b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.cpp
new file mode 100644
index 000000000..e5dfb2702
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.cpp
@@ -0,0 +1,337 @@
+// LZMADecoder.cpp

+

+#include "StdAfx.h"

+

+#include "LZMADecoder.h"

+#include "../../../Common/Defs.h"

+

+namespace NCompress {

+namespace NLZMA {

+

+const int kLenIdFinished = -1;

+const int kLenIdNeedInit = -2;

+

+void CDecoder::Init()

+{

+  { 

+    for(int i = 0; i < kNumStates; i++)

+    {

+      for (UInt32 j = 0; j <= _posStateMask; j++)

+      {

+        _isMatch[i][j].Init();

+        _isRep0Long[i][j].Init();

+      }

+      _isRep[i].Init();

+      _isRepG0[i].Init();

+      _isRepG1[i].Init();

+      _isRepG2[i].Init();

+    }

+  }

+  { 

+    for (UInt32 i = 0; i < kNumLenToPosStates; i++)

+    _posSlotDecoder[i].Init();

+  }

+  { 

+    for(UInt32 i = 0; i < kNumFullDistances - kEndPosModelIndex; i++)

+      _posDecoders[i].Init();

+  }

+  _posAlignDecoder.Init();

+  _lenDecoder.Init(_posStateMask + 1);

+  _repMatchLenDecoder.Init(_posStateMask + 1);

+  _literalDecoder.Init();

+

+  _state.Init();

+  _reps[0] = _reps[1] = _reps[2] = _reps[3] = 0;

+}

+

+HRESULT CDecoder::CodeSpec(UInt32 curSize)

+{

+  if (_outSizeDefined)

+  {

+    const UInt64 rem = _outSize - _outWindowStream.GetProcessedSize();

+    if (curSize > rem)

+      curSize = (UInt32)rem;

+  }

+

+  if (_remainLen == kLenIdFinished)

+    return S_OK;

+  if (_remainLen == kLenIdNeedInit)

+  {

+    _rangeDecoder.Init();

+    Init();

+    _remainLen = 0;

+  }

+  if (curSize == 0)

+    return S_OK;

+

+  UInt32 rep0 = _reps[0];

+  UInt32 rep1 = _reps[1];

+  UInt32 rep2 = _reps[2];

+  UInt32 rep3 = _reps[3];

+  CState state = _state;

+  Byte previousByte;

+

+  while(_remainLen > 0 && curSize > 0)

+  {

+    previousByte = _outWindowStream.GetByte(rep0);

+    _outWindowStream.PutByte(previousByte);

+    _remainLen--;

+    curSize--;

+  }

+  UInt64 nowPos64 = _outWindowStream.GetProcessedSize();

+  if (nowPos64 == 0)

+    previousByte = 0;

+  else

+    previousByte = _outWindowStream.GetByte(0);

+

+  while(curSize > 0)

+  {

+    {

+      #ifdef _NO_EXCEPTIONS

+      if (_rangeDecoder.Stream.ErrorCode != S_OK)

+        return _rangeDecoder.Stream.ErrorCode;

+      #endif

+      if (_rangeDecoder.Stream.WasFinished())

+        return S_FALSE;

+      UInt32 posState = UInt32(nowPos64) & _posStateMask;

+      if (_isMatch[state.Index][posState].Decode(&_rangeDecoder) == 0)

+      {

+        if(!state.IsCharState())

+          previousByte = _literalDecoder.DecodeWithMatchByte(&_rangeDecoder, 

+              (UInt32)nowPos64, previousByte, _outWindowStream.GetByte(rep0));

+        else

+          previousByte = _literalDecoder.DecodeNormal(&_rangeDecoder, 

+              (UInt32)nowPos64, previousByte);

+        _outWindowStream.PutByte(previousByte);

+        state.UpdateChar();

+        curSize--;

+        nowPos64++;

+      }

+      else             

+      {

+        UInt32 len;

+        if(_isRep[state.Index].Decode(&_rangeDecoder) == 1)

+        {

+          len = 0;

+          if(_isRepG0[state.Index].Decode(&_rangeDecoder) == 0)

+          {

+            if(_isRep0Long[state.Index][posState].Decode(&_rangeDecoder) == 0)

+            {

+              state.UpdateShortRep();

+              len = 1;

+            }

+          }

+          else

+          {

+            UInt32 distance;

+            if(_isRepG1[state.Index].Decode(&_rangeDecoder) == 0)

+              distance = rep1;

+            else 

+            {

+              if (_isRepG2[state.Index].Decode(&_rangeDecoder) == 0)

+                distance = rep2;

+              else

+              {

+                distance = rep3;

+                rep3 = rep2;

+              }

+              rep2 = rep1;

+            }

+            rep1 = rep0;

+            rep0 = distance;

+          }

+          if (len == 0)

+          {

+            len = _repMatchLenDecoder.Decode(&_rangeDecoder, posState) + kMatchMinLen;

+            state.UpdateRep();

+          }

+        }

+        else

+        {

+          rep3 = rep2;

+          rep2 = rep1;

+          rep1 = rep0;

+          len = kMatchMinLen + _lenDecoder.Decode(&_rangeDecoder, posState);

+          state.UpdateMatch();

+          UInt32 posSlot = _posSlotDecoder[GetLenToPosState(len)].Decode(&_rangeDecoder);

+          if (posSlot >= kStartPosModelIndex)

+          {

+            UInt32 numDirectBits = (posSlot >> 1) - 1;

+            rep0 = ((2 | (posSlot & 1)) << numDirectBits);

+

+            if (posSlot < kEndPosModelIndex)

+              rep0 += NRangeCoder::ReverseBitTreeDecode(_posDecoders + 

+                  rep0 - posSlot - 1, &_rangeDecoder, numDirectBits);

+            else

+            {

+              rep0 += (_rangeDecoder.DecodeDirectBits(

+                  numDirectBits - kNumAlignBits) << kNumAlignBits);

+              rep0 += _posAlignDecoder.ReverseDecode(&_rangeDecoder);

+              if (rep0 == 0xFFFFFFFF)

+              {

+                _remainLen = kLenIdFinished;

+                return S_OK;

+              }

+            }

+          }

+          else

+            rep0 = posSlot;

+        }

+        UInt32 locLen = len;

+        if (len > curSize)

+          locLen = (UInt32)curSize;

+        if (!_outWindowStream.CopyBlock(rep0, locLen))

+          return S_FALSE;

+        previousByte = _outWindowStream.GetByte(0);

+        curSize -= locLen;

+        nowPos64 += locLen;

+        len -= locLen;

+        if (len != 0)

+        {

+          _remainLen = (Int32)len;

+          break;

+        }

+

+        #ifdef _NO_EXCEPTIONS

+        if (_outWindowStream.ErrorCode != S_OK)

+          return _outWindowStream.ErrorCode;

+        #endif

+      }

+    }

+  }

+  if (_rangeDecoder.Stream.WasFinished())

+    return S_FALSE;

+  _reps[0] = rep0;

+  _reps[1] = rep1;

+  _reps[2] = rep2;

+  _reps[3] = rep3;

+  _state = state;

+

+  return S_OK;

+}

+

+STDMETHODIMP CDecoder::CodeReal(ISequentialInStream *inStream,

+    ISequentialOutStream *outStream, 

+    const UInt64 *, const UInt64 *outSize,

+    ICompressProgressInfo *progress)

+{

+  SetInStream(inStream);

+  _outWindowStream.SetStream(outStream);

+  SetOutStreamSize(outSize);

+  CDecoderFlusher flusher(this);

+

+  while (true)

+  {

+    UInt32 curSize = 1 << 18;

+    RINOK(CodeSpec(curSize));

+    if (_remainLen == kLenIdFinished)

+      break;

+    if (progress != NULL)

+    {

+      UInt64 inSize = _rangeDecoder.GetProcessedSize();

+      UInt64 nowPos64 = _outWindowStream.GetProcessedSize();

+      RINOK(progress->SetRatioInfo(&inSize, &nowPos64));

+    }

+    if (_outSizeDefined)

+      if (_outWindowStream.GetProcessedSize() >= _outSize)

+        break;

+  } 

+  flusher.NeedFlush = false;

+  return Flush();

+}

+

+

+#ifdef _NO_EXCEPTIONS

+

+#define LZMA_TRY_BEGIN

+#define LZMA_TRY_END

+

+#else

+

+#define LZMA_TRY_BEGIN try { 

+#define LZMA_TRY_END } \

+  catch(const CInBufferException &e)  { return e.ErrorCode; } \

+  catch(const CLZOutWindowException &e)  { return e.ErrorCode; } \

+  catch(...) { return S_FALSE; }

+

+#endif

+

+

+STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,

+      ICompressProgressInfo *progress)

+{

+  LZMA_TRY_BEGIN

+  return CodeReal(inStream, outStream, inSize, outSize, progress); 

+  LZMA_TRY_END

+}

+

+STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *properties, UInt32 size)

+{

+  if (size < 5)

+    return E_INVALIDARG;

+  int lc = properties[0] % 9;

+  Byte remainder = (Byte)(properties[0] / 9);

+  int lp = remainder % 5;

+  int pb = remainder / 5;

+  if (pb > NLength::kNumPosStatesBitsMax)

+    return E_INVALIDARG;

+  _posStateMask = (1 << pb) - 1;

+  UInt32 dictionarySize = 0;

+  for (int i = 0; i < 4; i++)

+    dictionarySize += ((UInt32)(properties[1 + i])) << (i * 8);

+  if (!_outWindowStream.Create(dictionarySize))

+    return E_OUTOFMEMORY;

+  if (!_literalDecoder.Create(lp, lc))

+    return E_OUTOFMEMORY;

+  if (!_rangeDecoder.Create(1 << 20))

+    return E_OUTOFMEMORY;

+  return S_OK;

+}

+

+STDMETHODIMP CDecoder::GetInStreamProcessedSize(UInt64 *value)

+{

+  *value = _rangeDecoder.GetProcessedSize();

+  return S_OK;

+}

+

+STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream)

+{

+  _rangeDecoder.SetStream(inStream);

+  return S_OK;

+}

+

+STDMETHODIMP CDecoder::ReleaseInStream()

+{

+  _rangeDecoder.ReleaseStream();

+  return S_OK;

+}

+

+STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)

+{

+  if (_outSizeDefined = (outSize != NULL))

+    _outSize = *outSize;

+  _remainLen = kLenIdNeedInit;

+  _outWindowStream.Init();

+  return S_OK;

+}

+

+#ifdef _ST_MODE

+

+STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)

+{

+  LZMA_TRY_BEGIN

+  if (processedSize)

+    *processedSize = 0;

+  const UInt64 startPos = _outWindowStream.GetProcessedSize();

+  _outWindowStream.SetMemStream((Byte *)data);

+  RINOK(CodeSpec(size));

+  if (processedSize)

+    *processedSize = (UInt32)(_outWindowStream.GetProcessedSize() - startPos);

+  return Flush();

+  LZMA_TRY_END

+}

+

+#endif

+

+}}

diff --git a/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.h b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.h
new file mode 100644
index 000000000..d6370e250
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/LZMA/LZMADecoder.h
@@ -0,0 +1,251 @@
+// LZMA/Decoder.h

+

+#ifndef __LZMA_DECODER_H

+#define __LZMA_DECODER_H

+

+#include "../../../Common/MyCom.h"

+#include "../../../Common/Alloc.h"

+#include "../../ICoder.h"

+#include "../LZ/LZOutWindow.h"

+#include "../RangeCoder/RangeCoderBitTree.h"

+

+#include "LZMA.h"

+

+namespace NCompress {

+namespace NLZMA {

+

+typedef NRangeCoder::CBitDecoder<kNumMoveBits> CMyBitDecoder;

+

+class CLiteralDecoder2

+{

+  CMyBitDecoder _decoders[0x300];

+public:

+  void Init()

+  {

+    for (int i = 0; i < 0x300; i++)

+      _decoders[i].Init();

+  }

+  Byte DecodeNormal(NRangeCoder::CDecoder *rangeDecoder)

+  {

+    UInt32 symbol = 1;

+    RC_INIT_VAR

+    do

+    {

+      // symbol = (symbol << 1) | _decoders[0][symbol].Decode(rangeDecoder);

+      RC_GETBIT(kNumMoveBits, _decoders[symbol].Prob, symbol)

+    }

+    while (symbol < 0x100);

+    RC_FLUSH_VAR

+    return (Byte)symbol;

+  }

+  Byte DecodeWithMatchByte(NRangeCoder::CDecoder *rangeDecoder, Byte matchByte)

+  {

+    UInt32 symbol = 1;

+    RC_INIT_VAR

+    do

+    {

+      UInt32 matchBit = (matchByte >> 7) & 1;

+      matchByte <<= 1;

+      // UInt32 bit = _decoders[1 + matchBit][symbol].Decode(rangeDecoder);

+      // symbol = (symbol << 1) | bit;

+      UInt32 bit;

+      RC_GETBIT2(kNumMoveBits, _decoders[0x100 + (matchBit << 8) + symbol].Prob, symbol, 

+          bit = 0, bit = 1)

+      if (matchBit != bit)

+      {

+        while (symbol < 0x100)

+        {

+          // symbol = (symbol << 1) | _decoders[0][symbol].Decode(rangeDecoder);

+          RC_GETBIT(kNumMoveBits, _decoders[symbol].Prob, symbol)

+        }

+        break;

+      }

+    }

+    while (symbol < 0x100);

+    RC_FLUSH_VAR

+    return (Byte)symbol;

+  }

+};

+

+class CLiteralDecoder

+{

+  CLiteralDecoder2 *_coders;

+  int _numPrevBits;

+  int _numPosBits;

+  UInt32 _posMask;

+public:

+  CLiteralDecoder(): _coders(0) {}

+  ~CLiteralDecoder()  { Free(); }

+  void Free()

+  { 

+    MyFree(_coders);

+    _coders = 0;

+  }

+  bool Create(int numPosBits, int numPrevBits)

+  {

+    if (_coders == 0 || (numPosBits + numPrevBits) != 

+        (_numPrevBits + _numPosBits) )

+    {

+      Free();

+      UInt32 numStates = 1 << (numPosBits + numPrevBits);

+      _coders = (CLiteralDecoder2 *)MyAlloc(numStates * sizeof(CLiteralDecoder2));

+    }

+    _numPosBits = numPosBits;

+    _posMask = (1 << numPosBits) - 1;

+    _numPrevBits = numPrevBits;

+    return (_coders != 0);

+  }

+  void Init()

+  {

+    UInt32 numStates = 1 << (_numPrevBits + _numPosBits);

+    for (UInt32 i = 0; i < numStates; i++)

+      _coders[i].Init();

+  }

+  UInt32 GetState(UInt32 pos, Byte prevByte) const

+    { return ((pos & _posMask) << _numPrevBits) + (prevByte >> (8 - _numPrevBits)); }

+  Byte DecodeNormal(NRangeCoder::CDecoder *rangeDecoder, UInt32 pos, Byte prevByte)

+    { return _coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder); }

+  Byte DecodeWithMatchByte(NRangeCoder::CDecoder *rangeDecoder, UInt32 pos, Byte prevByte, Byte matchByte)

+    { return _coders[GetState(pos, prevByte)].DecodeWithMatchByte(rangeDecoder, matchByte); }

+};

+

+namespace NLength {

+

+class CDecoder

+{

+  CMyBitDecoder _choice;

+  CMyBitDecoder _choice2;

+  NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumLowBits>  _lowCoder[kNumPosStatesMax];

+  NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumMidBits>  _midCoder[kNumPosStatesMax];

+  NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumHighBits> _highCoder; 

+public:

+  void Init(UInt32 numPosStates)

+  {

+    _choice.Init();

+    _choice2.Init();

+    for (UInt32 posState = 0; posState < numPosStates; posState++)

+    {

+      _lowCoder[posState].Init();

+      _midCoder[posState].Init();

+    }

+    _highCoder.Init();

+  }

+  UInt32 Decode(NRangeCoder::CDecoder *rangeDecoder, UInt32 posState)

+  {

+    if(_choice.Decode(rangeDecoder) == 0)

+      return _lowCoder[posState].Decode(rangeDecoder);

+    if(_choice2.Decode(rangeDecoder) == 0)

+      return kNumLowSymbols + _midCoder[posState].Decode(rangeDecoder);

+    return kNumLowSymbols + kNumMidSymbols + _highCoder.Decode(rangeDecoder);

+  }

+};

+

+}

+

+class CDecoder: 

+  public ICompressCoder,

+  public ICompressSetDecoderProperties2,

+  public ICompressGetInStreamProcessedSize,

+  #ifdef _ST_MODE

+  public ICompressSetInStream,

+  public ICompressSetOutStreamSize,

+  public ISequentialInStream,

+  #endif

+  public CMyUnknownImp

+{

+  CLZOutWindow _outWindowStream;

+  NRangeCoder::CDecoder _rangeDecoder;

+

+  CMyBitDecoder _isMatch[kNumStates][NLength::kNumPosStatesMax];

+  CMyBitDecoder _isRep[kNumStates];

+  CMyBitDecoder _isRepG0[kNumStates];

+  CMyBitDecoder _isRepG1[kNumStates];

+  CMyBitDecoder _isRepG2[kNumStates];

+  CMyBitDecoder _isRep0Long[kNumStates][NLength::kNumPosStatesMax];

+

+  NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumPosSlotBits> _posSlotDecoder[kNumLenToPosStates];

+

+  CMyBitDecoder _posDecoders[kNumFullDistances - kEndPosModelIndex];

+  NRangeCoder::CBitTreeDecoder<kNumMoveBits, kNumAlignBits> _posAlignDecoder;

+  

+  NLength::CDecoder _lenDecoder;

+  NLength::CDecoder _repMatchLenDecoder;

+

+  CLiteralDecoder _literalDecoder;

+

+  UInt32 _posStateMask;

+

+  ///////////////////

+  // State

+  UInt32 _reps[4];

+  CState _state;

+  Int32 _remainLen; // -1 means end of stream. // -2 means need Init

+  UInt64 _outSize;

+  bool _outSizeDefined;

+

+  void Init();

+  HRESULT CodeSpec(UInt32 size);

+public:

+

+  #ifdef _ST_MODE

+  MY_UNKNOWN_IMP5(

+      ICompressSetDecoderProperties2, 

+      ICompressGetInStreamProcessedSize,

+      ICompressSetInStream, 

+      ICompressSetOutStreamSize, 

+      ISequentialInStream)

+  #else

+  MY_UNKNOWN_IMP2(

+      ICompressSetDecoderProperties2,

+      ICompressGetInStreamProcessedSize)

+  #endif

+

+  void ReleaseStreams()

+  {

+    _outWindowStream.ReleaseStream();

+    ReleaseInStream();

+  }

+

+  class CDecoderFlusher

+  {

+    CDecoder *_decoder;

+  public:

+    bool NeedFlush;

+    CDecoderFlusher(CDecoder *decoder): _decoder(decoder), NeedFlush(true) {}

+    ~CDecoderFlusher() 

+    { 

+      if (NeedFlush)

+        _decoder->Flush();

+      _decoder->ReleaseStreams(); 

+    }

+  };

+

+  HRESULT Flush() {  return _outWindowStream.Flush(); }  

+

+  STDMETHOD(CodeReal)(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,

+      ICompressProgressInfo *progress);

+  

+  STDMETHOD(Code)(ISequentialInStream *inStream,

+      ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,

+      ICompressProgressInfo *progress);

+

+  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);

+

+  STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);

+

+  STDMETHOD(SetInStream)(ISequentialInStream *inStream);

+  STDMETHOD(ReleaseInStream)();

+  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);

+

+  #ifdef _ST_MODE

+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);

+  #endif

+

+  CDecoder(): _outSizeDefined(false) {}

+  virtual ~CDecoder() {}

+};

+

+}}

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoder.h b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoder.h
new file mode 100644
index 000000000..9828bc4b9
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoder.h
@@ -0,0 +1,205 @@
+// Compress/RangeCoder/RangeCoder.h

+

+#ifndef __COMPRESS_RANGECODER_H

+#define __COMPRESS_RANGECODER_H

+

+#include "../../Common/InBuffer.h"

+#include "../../Common/OutBuffer.h"

+

+namespace NCompress {

+namespace NRangeCoder {

+

+const int kNumTopBits = 24;

+const UInt32 kTopValue = (1 << kNumTopBits);

+

+class CEncoder

+{

+  UInt32 _cacheSize;

+  Byte _cache;

+public:

+  UInt64 Low;

+  UInt32 Range;

+  COutBuffer Stream;

+  bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }

+

+  void SetStream(ISequentialOutStream *stream) { Stream.SetStream(stream); }

+  void Init()

+  {

+    Stream.Init();

+    Low = 0;

+    Range = 0xFFFFFFFF;

+    _cacheSize = 1;

+    _cache = 0;

+  }

+

+  void FlushData()

+  {

+    // Low += 1; 

+    for(int i = 0; i < 5; i++)

+      ShiftLow();

+  }

+

+  HRESULT FlushStream() { return Stream.Flush();  }

+

+  void ReleaseStream() { Stream.ReleaseStream(); }

+

+  void Encode(UInt32 start, UInt32 size, UInt32 total)

+  {

+    Low += start * (Range /= total);

+    Range *= size;

+    while (Range < kTopValue)

+    {

+      Range <<= 8;

+      ShiftLow();

+    }

+  }

+

+  void ShiftLow()

+  {

+    if ((UInt32)Low < (UInt32)0xFF000000 || (int)(Low >> 32) != 0) 

+    {

+      Byte temp = _cache;

+      do

+      {

+        Stream.WriteByte((Byte)(temp + (Byte)(Low >> 32)));

+        temp = 0xFF;

+      }

+      while(--_cacheSize != 0);

+      _cache = (Byte)((UInt32)Low >> 24);                      

+    } 

+    _cacheSize++;                               

+    Low = (UInt32)Low << 8;                           

+  }

+  

+  void EncodeDirectBits(UInt32 value, int numTotalBits)

+  {

+    for (int i = numTotalBits - 1; i >= 0; i--)

+    {

+      Range >>= 1;

+      if (((value >> i) & 1) == 1)

+        Low += Range;

+      if (Range < kTopValue)

+      {

+        Range <<= 8;

+        ShiftLow();

+      }

+    }

+  }

+

+  void EncodeBit(UInt32 size0, UInt32 numTotalBits, UInt32 symbol)

+  {

+    UInt32 newBound = (Range >> numTotalBits) * size0;

+    if (symbol == 0)

+      Range = newBound;

+    else

+    {

+      Low += newBound;

+      Range -= newBound;

+    }

+    while (Range < kTopValue)

+    {

+      Range <<= 8;

+      ShiftLow();

+    }

+  }

+

+  UInt64 GetProcessedSize() {  return Stream.GetProcessedSize() + _cacheSize + 4; }

+};

+

+class CDecoder

+{

+public:

+  CInBuffer Stream;

+  UInt32 Range;

+  UInt32 Code;

+  bool Create(UInt32 bufferSize) { return Stream.Create(bufferSize); }

+

+  void Normalize()

+  {

+    while (Range < kTopValue)

+    {

+      Code = (Code << 8) | Stream.ReadByte();

+      Range <<= 8;

+    }

+  }

+  

+  void SetStream(ISequentialInStream *stream) { Stream.SetStream(stream); }

+  void Init()

+  {

+    Stream.Init();

+    Code = 0;

+    Range = 0xFFFFFFFF;

+    for(int i = 0; i < 5; i++)

+      Code = (Code << 8) | Stream.ReadByte();

+  }

+

+  void ReleaseStream() { Stream.ReleaseStream(); }

+

+  UInt32 GetThreshold(UInt32 total)

+  {

+    return (Code) / ( Range /= total);

+  }

+

+  void Decode(UInt32 start, UInt32 size)

+  {

+    Code -= start * Range;

+    Range *= size;

+    Normalize();

+  }

+

+  UInt32 DecodeDirectBits(int numTotalBits)

+  {

+    UInt32 range = Range;

+    UInt32 code = Code;        

+    UInt32 result = 0;

+    for (int i = numTotalBits; i != 0; i--)

+    {

+      range >>= 1;

+      /*

+      result <<= 1;

+      if (code >= range)

+      {

+        code -= range;

+        result |= 1;

+      }

+      */

+      UInt32 t = (code - range) >> 31;

+      code -= range & (t - 1);

+      result = (result << 1) | (1 - t);

+

+      if (range < kTopValue)

+      {

+        code = (code << 8) | Stream.ReadByte();

+        range <<= 8; 

+      }

+    }

+    Range = range;

+    Code = code;

+    return result;

+  }

+

+  UInt32 DecodeBit(UInt32 size0, UInt32 numTotalBits)

+  {

+    UInt32 newBound = (Range >> numTotalBits) * size0;

+    UInt32 symbol;

+    if (Code < newBound)

+    {

+      symbol = 0;

+      Range = newBound;

+    }

+    else

+    {

+      symbol = 1;

+      Code -= newBound;

+      Range -= newBound;

+    }

+    Normalize();

+    return symbol;

+  }

+

+  UInt64 GetProcessedSize() {return Stream.GetProcessedSize(); }

+};

+

+}}

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBit.cpp b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBit.cpp
new file mode 100644
index 000000000..8d273c8f9
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBit.cpp
@@ -0,0 +1,80 @@
+// Compress/RangeCoder/RangeCoderBit.cpp

+

+#include "StdAfx.h"

+

+#include "RangeCoderBit.h"

+

+namespace NCompress {

+namespace NRangeCoder {

+

+UInt32 CPriceTables::ProbPrices[kBitModelTotal >> kNumMoveReducingBits];

+static CPriceTables g_PriceTables;

+

+CPriceTables::CPriceTables() { Init(); }

+

+void CPriceTables::Init()

+{

+  const int kNumBits = (kNumBitModelTotalBits - kNumMoveReducingBits);

+  for(int i = kNumBits - 1; i >= 0; i--)

+  {

+    UInt32 start = 1 << (kNumBits - i - 1);

+    UInt32 end = 1 << (kNumBits - i);

+    for (UInt32 j = start; j < end; j++)

+      ProbPrices[j] = (i << kNumBitPriceShiftBits) + 

+          (((end - j) << kNumBitPriceShiftBits) >> (kNumBits - i - 1));

+  }

+

+  /*

+  // simplest: bad solution

+  for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)

+    ProbPrices[i] = kBitPrice;

+  */

+  

+  /*

+  const double kDummyMultMid = (1.0 / kBitPrice) / 2;

+  const double kDummyMultMid = 0;

+  // float solution

+  double ln2 = log(double(2));

+  double lnAll = log(double(kBitModelTotal >> kNumMoveReducingBits));

+  for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)

+    ProbPrices[i] = UInt32((fabs(lnAll - log(double(i))) / ln2 + kDummyMultMid) * kBitPrice);

+  */

+  

+  /*

+  // experimental, slow, solution:

+  for(UInt32 i = 1; i < (kBitModelTotal >> kNumMoveReducingBits) - 1; i++)

+  {

+    const int kCyclesBits = 5;

+    const UInt32 kCycles = (1 << kCyclesBits);

+

+    UInt32 range = UInt32(-1);

+    UInt32 bitCount = 0;

+    for (UInt32 j = 0; j < kCycles; j++)

+    {

+      range >>= (kNumBitModelTotalBits - kNumMoveReducingBits);

+      range *= i;

+      while(range < (1 << 31))

+      {

+        range <<= 1;

+        bitCount++;

+      }

+    }

+    bitCount <<= kNumBitPriceShiftBits;

+    range -= (1 << 31);

+    for (int k = kNumBitPriceShiftBits - 1; k >= 0; k--)

+    {

+      range <<= 1;

+      if (range > (1 << 31))

+      {

+        bitCount += (1 << k);

+        range -= (1 << 31);

+      }

+    }

+    ProbPrices[i] = (bitCount 

+      // + (1 << (kCyclesBits - 1))

+      ) >> kCyclesBits;

+  }

+  */

+}

+

+}}

diff --git a/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBit.h b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBit.h
new file mode 100644
index 000000000..64538e687
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBit.h
@@ -0,0 +1,120 @@
+// Compress/RangeCoder/RangeCoderBit.h

+

+#ifndef __COMPRESS_RANGECODER_BIT_H

+#define __COMPRESS_RANGECODER_BIT_H

+

+#include "RangeCoder.h"

+

+namespace NCompress {

+namespace NRangeCoder {

+

+const int kNumBitModelTotalBits  = 11;

+const UInt32 kBitModelTotal = (1 << kNumBitModelTotalBits);

+

+const int kNumMoveReducingBits = 2;

+

+const int kNumBitPriceShiftBits = 6;

+const UInt32 kBitPrice = 1 << kNumBitPriceShiftBits;

+

+class CPriceTables

+{

+public:

+  static UInt32 ProbPrices[kBitModelTotal >> kNumMoveReducingBits];

+  static void Init();

+  CPriceTables();

+};

+

+template <int numMoveBits>

+class CBitModel

+{

+public:

+  UInt32 Prob;

+  void UpdateModel(UInt32 symbol)

+  {

+    /*

+    Prob -= (Prob + ((symbol - 1) & ((1 << numMoveBits) - 1))) >> numMoveBits;

+    Prob += (1 - symbol) << (kNumBitModelTotalBits - numMoveBits);

+    */

+    if (symbol == 0)

+      Prob += (kBitModelTotal - Prob) >> numMoveBits;

+    else

+      Prob -= (Prob) >> numMoveBits;

+  }

+public:

+  void Init() { Prob = kBitModelTotal / 2; }

+};

+

+template <int numMoveBits>

+class CBitEncoder: public CBitModel<numMoveBits>

+{

+public:

+  void Encode(CEncoder *encoder, UInt32 symbol)

+  {

+    /*

+    encoder->EncodeBit(this->Prob, kNumBitModelTotalBits, symbol);

+    this->UpdateModel(symbol);

+    */

+    UInt32 newBound = (encoder->Range >> kNumBitModelTotalBits) * this->Prob;

+    if (symbol == 0)

+    {

+      encoder->Range = newBound;

+      this->Prob += (kBitModelTotal - this->Prob) >> numMoveBits;

+    }

+    else

+    {

+      encoder->Low += newBound;

+      encoder->Range -= newBound;

+      this->Prob -= (this->Prob) >> numMoveBits;

+    }

+    if (encoder->Range < kTopValue)

+    {

+      encoder->Range <<= 8;

+      encoder->ShiftLow();

+    }

+  }

+  UInt32 GetPrice(UInt32 symbol) const

+  {

+    return CPriceTables::ProbPrices[

+      (((this->Prob - symbol) ^ ((-(int)symbol))) & (kBitModelTotal - 1)) >> kNumMoveReducingBits];

+  }

+  UInt32 GetPrice0() const { return CPriceTables::ProbPrices[this->Prob >> kNumMoveReducingBits]; }

+  UInt32 GetPrice1() const { return CPriceTables::ProbPrices[(kBitModelTotal - this->Prob) >> kNumMoveReducingBits]; }

+};

+

+

+template <int numMoveBits>

+class CBitDecoder: public CBitModel<numMoveBits>

+{

+public:

+  UInt32 Decode(CDecoder *decoder)

+  {

+    UInt32 newBound = (decoder->Range >> kNumBitModelTotalBits) * this->Prob;

+    if (decoder->Code < newBound)

+    {

+      decoder->Range = newBound;

+      this->Prob += (kBitModelTotal - this->Prob) >> numMoveBits;

+      if (decoder->Range < kTopValue)

+      {

+        decoder->Code = (decoder->Code << 8) | decoder->Stream.ReadByte();

+        decoder->Range <<= 8;

+      }

+      return 0;

+    }

+    else

+    {

+      decoder->Range -= newBound;

+      decoder->Code -= newBound;

+      this->Prob -= (this->Prob) >> numMoveBits;

+      if (decoder->Range < kTopValue)

+      {

+        decoder->Code = (decoder->Code << 8) | decoder->Stream.ReadByte();

+        decoder->Range <<= 8;

+      }

+      return 1;

+    }

+  }

+};

+

+}}

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBitTree.h b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBitTree.h
new file mode 100644
index 000000000..1fa023f3b
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderBitTree.h
@@ -0,0 +1,161 @@
+// Compress/RangeCoder/RangeCoderBitTree.h

+

+#ifndef __COMPRESS_RANGECODER_BIT_TREE_H

+#define __COMPRESS_RANGECODER_BIT_TREE_H

+

+#include "RangeCoderBit.h"

+#include "RangeCoderOpt.h"

+

+namespace NCompress {

+namespace NRangeCoder {

+

+template <int numMoveBits, int NumBitLevels>

+class CBitTreeEncoder

+{

+  CBitEncoder<numMoveBits> Models[1 << NumBitLevels];

+public:

+  void Init()

+  {

+    for(UInt32 i = 1; i < (1 << NumBitLevels); i++)

+      Models[i].Init();

+  }

+  void Encode(CEncoder *rangeEncoder, UInt32 symbol)

+  {

+    UInt32 modelIndex = 1;

+    for (int bitIndex = NumBitLevels; bitIndex != 0 ;)

+    {

+      bitIndex--;

+      UInt32 bit = (symbol >> bitIndex) & 1;

+      Models[modelIndex].Encode(rangeEncoder, bit);

+      modelIndex = (modelIndex << 1) | bit;

+    }

+  };

+  void ReverseEncode(CEncoder *rangeEncoder, UInt32 symbol)

+  {

+    UInt32 modelIndex = 1;

+    for (int i = 0; i < NumBitLevels; i++)

+    {

+      UInt32 bit = symbol & 1;

+      Models[modelIndex].Encode(rangeEncoder, bit);

+      modelIndex = (modelIndex << 1) | bit;

+      symbol >>= 1;

+    }

+  }

+  UInt32 GetPrice(UInt32 symbol) const

+  {

+    symbol |= (1 << NumBitLevels);

+    UInt32 price = 0;

+    while (symbol != 1)

+    {

+      price += Models[symbol >> 1].GetPrice(symbol & 1);

+      symbol >>= 1;

+    }

+    return price;

+  }

+  UInt32 ReverseGetPrice(UInt32 symbol) const

+  {

+    UInt32 price = 0;

+    UInt32 modelIndex = 1;

+    for (int i = NumBitLevels; i != 0; i--)

+    {

+      UInt32 bit = symbol & 1;

+      symbol >>= 1;

+      price += Models[modelIndex].GetPrice(bit);

+      modelIndex = (modelIndex << 1) | bit;

+    }

+    return price;

+  }

+};

+

+template <int numMoveBits, int NumBitLevels>

+class CBitTreeDecoder

+{

+  CBitDecoder<numMoveBits> Models[1 << NumBitLevels];

+public:

+  void Init()

+  {

+    for(UInt32 i = 1; i < (1 << NumBitLevels); i++)

+      Models[i].Init();

+  }

+  UInt32 Decode(CDecoder *rangeDecoder)

+  {

+    UInt32 modelIndex = 1;

+    RC_INIT_VAR

+    for(int bitIndex = NumBitLevels; bitIndex != 0; bitIndex--)

+    {

+      // modelIndex = (modelIndex << 1) + Models[modelIndex].Decode(rangeDecoder);

+      RC_GETBIT(numMoveBits, Models[modelIndex].Prob, modelIndex)

+    }

+    RC_FLUSH_VAR

+    return modelIndex - (1 << NumBitLevels);

+  };

+  UInt32 ReverseDecode(CDecoder *rangeDecoder)

+  {

+    UInt32 modelIndex = 1;

+    UInt32 symbol = 0;

+    RC_INIT_VAR

+    for(int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)

+    {

+      // UInt32 bit = Models[modelIndex].Decode(rangeDecoder);

+      // modelIndex <<= 1;

+      // modelIndex += bit;

+      // symbol |= (bit << bitIndex);

+      RC_GETBIT2(numMoveBits, Models[modelIndex].Prob, modelIndex, ; , symbol |= (1 << bitIndex))

+    }

+    RC_FLUSH_VAR

+    return symbol;

+  }

+};

+

+template <int numMoveBits>

+void ReverseBitTreeEncode(CBitEncoder<numMoveBits> *Models, 

+    CEncoder *rangeEncoder, int NumBitLevels, UInt32 symbol)

+{

+  UInt32 modelIndex = 1;

+  for (int i = 0; i < NumBitLevels; i++)

+  {

+    UInt32 bit = symbol & 1;

+    Models[modelIndex].Encode(rangeEncoder, bit);

+    modelIndex = (modelIndex << 1) | bit;

+    symbol >>= 1;

+  }

+}

+

+template <int numMoveBits>

+UInt32 ReverseBitTreeGetPrice(CBitEncoder<numMoveBits> *Models, 

+    UInt32 NumBitLevels, UInt32 symbol)

+{

+  UInt32 price = 0;

+  UInt32 modelIndex = 1;

+  for (int i = NumBitLevels; i != 0; i--)

+  {

+    UInt32 bit = symbol & 1;

+    symbol >>= 1;

+    price += Models[modelIndex].GetPrice(bit);

+    modelIndex = (modelIndex << 1) | bit;

+  }

+  return price;

+}

+

+template <int numMoveBits>

+UInt32 ReverseBitTreeDecode(CBitDecoder<numMoveBits> *Models, 

+    CDecoder *rangeDecoder, int NumBitLevels)

+{

+  UInt32 modelIndex = 1;

+  UInt32 symbol = 0;

+  RC_INIT_VAR

+  for(int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)

+  {

+    // UInt32 bit = Models[modelIndex].Decode(rangeDecoder);

+    // modelIndex <<= 1;

+    // modelIndex += bit;

+    // symbol |= (bit << bitIndex);

+    RC_GETBIT2(numMoveBits, Models[modelIndex].Prob, modelIndex, ; , symbol |= (1 << bitIndex))

+  }

+  RC_FLUSH_VAR

+  return symbol;

+}

+

+}}

+

+#endif

diff --git a/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderOpt.h b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderOpt.h
new file mode 100644
index 000000000..829fc83d7
--- /dev/null
+++ b/other-licenses/7zstub/src/7zip/Compress/RangeCoder/RangeCoderOpt.h
@@ -0,0 +1,31 @@
+// Compress/RangeCoder/RangeCoderOpt.h

+

+#ifndef __COMPRESS_RANGECODER_OPT_H

+#define __COMPRESS_RANGECODER_OPT_H

+

+#define RC_INIT_VAR \

+  UInt32 range = rangeDecoder->Range; \

+  UInt32 code = rangeDecoder->Code;        

+

+#define RC_FLUSH_VAR \

+  rangeDecoder->Range = range; \

+  rangeDecoder->Code = code;

+

+#define RC_NORMALIZE \

+  if (range < NCompress::NRangeCoder::kTopValue) \

+    { code = (code << 8) | rangeDecoder->Stream.ReadByte(); range <<= 8; }

+

+#define RC_GETBIT2(numMoveBits, prob, mi, A0, A1) \

+  { UInt32 bound = (range >> NCompress::NRangeCoder::kNumBitModelTotalBits) * prob; \

+  if (code < bound) \

+  { A0; range = bound; \

+    prob += (NCompress::NRangeCoder::kBitModelTotal - prob) >> numMoveBits; \

+    mi <<= 1; } \

+  else \

+  { A1; range -= bound; code -= bound; prob -= (prob) >> numMoveBits; \

+    mi = (mi + mi) + 1; }} \

+  RC_NORMALIZE

+

+#define RC_GETBIT(numMoveBits, prob, mi) RC_GETBIT2(numMoveBits, prob, mi, ; , ;)

+

+#endif