Run dos2unix on bayou and remove white space at the end of lines.

Change-Id: If13d9a49ece2699885ae3e998173d3d44507b302
Signed-off-by: Stefan Reinauer <reinauer@google.com>
Reviewed-on: http://review.coreboot.org/362
Tested-by: build bot (Jenkins)
Reviewed-by: Peter Stuge <peter@stuge.se>

35 files changed, 2815 insertions, 2815 deletions

diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/InBuffer.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/InBuffer.h
index a59ecefacd..bfa4bc968b 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/InBuffer.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/InBuffer.h
@@ -1,76 +1,76 @@
-// InBuffer.h

-

-#ifndef __INBUFFER_H

-#define __INBUFFER_H

-

-#include "../IStream.h"

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

-

-#ifndef _NO_EXCEPTIONS

-class CInBufferException

-{

-public:

-  HRESULT ErrorCode;

-  CInBufferException(HRESULT errorCode): ErrorCode(errorCode) {}

-};

-#endif

-

-class CInBuffer

-{

-  Byte *_buffer;

-  Byte *_bufferLimit;

-  Byte *_bufferBase;

-  CMyComPtr<ISequentialInStream> _stream;

-  UInt64 _processedSize;

-  UInt32 _bufferSize;

-  bool _wasFinished;

-

-  bool ReadBlock();

-  Byte ReadBlock2();

-

-public:

-  #ifdef _NO_EXCEPTIONS

-  HRESULT ErrorCode;

-  #endif

-

-  CInBuffer();

-  ~CInBuffer() { Free(); }

-

-  bool Create(UInt32 bufferSize);

-  void Free();

-  

-  void SetStream(ISequentialInStream *stream);

-  void Init();

-  void ReleaseStream() { _stream.Release(); }

-

-  bool ReadByte(Byte &b)

-  {

-    if(_buffer >= _bufferLimit)

-      if(!ReadBlock())

-        return false;

-    b = *_buffer++;

-    return true;

-  }

-  Byte ReadByte()

-  {

-    if(_buffer >= _bufferLimit)

-      return ReadBlock2();

-    return *_buffer++;

-  }

-  void ReadBytes(void *data, UInt32 size, UInt32 &processedSize)

-  {

-    for(processedSize = 0; processedSize < size; processedSize++)

-      if (!ReadByte(((Byte *)data)[processedSize]))

-        return;

-  }

-  bool ReadBytes(void *data, UInt32 size)

-  {

-    UInt32 processedSize;

-    ReadBytes(data, size, processedSize);

-    return (processedSize == size);

-  }

-  UInt64 GetProcessedSize() const { return _processedSize + (_buffer - _bufferBase); }

-  bool WasFinished() const { return _wasFinished; }

-};

-

-#endif

+// InBuffer.h
+
+#ifndef __INBUFFER_H
+#define __INBUFFER_H
+
+#include "../IStream.h"
+#include "../../Common/MyCom.h"
+
+#ifndef _NO_EXCEPTIONS
+class CInBufferException
+{
+public:
+  HRESULT ErrorCode;
+  CInBufferException(HRESULT errorCode): ErrorCode(errorCode) {}
+};
+#endif
+
+class CInBuffer
+{
+  Byte *_buffer;
+  Byte *_bufferLimit;
+  Byte *_bufferBase;
+  CMyComPtr<ISequentialInStream> _stream;
+  UInt64 _processedSize;
+  UInt32 _bufferSize;
+  bool _wasFinished;
+
+  bool ReadBlock();
+  Byte ReadBlock2();
+
+public:
+  #ifdef _NO_EXCEPTIONS
+  HRESULT ErrorCode;
+  #endif
+
+  CInBuffer();
+  ~CInBuffer() { Free(); }
+
+  bool Create(UInt32 bufferSize);
+  void Free();
+
+  void SetStream(ISequentialInStream *stream);
+  void Init();
+  void ReleaseStream() { _stream.Release(); }
+
+  bool ReadByte(Byte &b)
+  {
+    if(_buffer >= _bufferLimit)
+      if(!ReadBlock())
+        return false;
+    b = *_buffer++;
+    return true;
+  }
+  Byte ReadByte()
+  {
+    if(_buffer >= _bufferLimit)
+      return ReadBlock2();
+    return *_buffer++;
+  }
+  void ReadBytes(void *data, UInt32 size, UInt32 &processedSize)
+  {
+    for(processedSize = 0; processedSize < size; processedSize++)
+      if (!ReadByte(((Byte *)data)[processedSize]))
+        return;
+  }
+  bool ReadBytes(void *data, UInt32 size)
+  {
+    UInt32 processedSize;
+    ReadBytes(data, size, processedSize);
+    return (processedSize == size);
+  }
+  UInt64 GetProcessedSize() const { return _processedSize + (_buffer - _bufferBase); }
+  bool WasFinished() const { return _wasFinished; }
+};
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/OutBuffer.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/OutBuffer.h
index 37eefbdfcd..659368be30 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/OutBuffer.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/OutBuffer.h
@@ -1,64 +1,64 @@
-// OutBuffer.h

-

-#ifndef __OUTBUFFER_H

-#define __OUTBUFFER_H

-

-#include "../IStream.h"

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

-

-#ifndef _NO_EXCEPTIONS

-struct COutBufferException

-{

-  HRESULT ErrorCode;

-  COutBufferException(HRESULT errorCode): ErrorCode(errorCode) {}

-};

-#endif

-

-class COutBuffer

-{

-protected:

-  Byte *_buffer;

-  UInt32 _pos;

-  UInt32 _limitPos;

-  UInt32 _streamPos;

-  UInt32 _bufferSize;

-  CMyComPtr<ISequentialOutStream> _stream;

-  UInt64 _processedSize;

-  Byte  *_buffer2;

-  bool _overDict;

-

-  HRESULT FlushPart();

-  void FlushWithCheck();

-public:

-  #ifdef _NO_EXCEPTIONS

-  HRESULT ErrorCode;

-  #endif

-

-  COutBuffer(): _buffer(0), _pos(0), _stream(0), _buffer2(0) {}

-  ~COutBuffer() { Free(); }

-  

-  bool Create(UInt32 bufferSize);

-  void Free();

-

-  void SetMemStream(Byte *buffer) { _buffer2 = buffer; }

-  void SetStream(ISequentialOutStream *stream);

-  void Init();

-  HRESULT Flush();

-  void ReleaseStream() {  _stream.Release(); }

-

-  void WriteByte(Byte b)

-  {

-    _buffer[_pos++] = b;

-    if(_pos == _limitPos)

-      FlushWithCheck();

-  }

-  void WriteBytes(const void *data, size_t size)

-  {

-    for (size_t i = 0; i < size; i++)

-      WriteByte(((const Byte *)data)[i]);

-  }

-

-  UInt64 GetProcessedSize() const;

-};

-

-#endif

+// OutBuffer.h
+
+#ifndef __OUTBUFFER_H
+#define __OUTBUFFER_H
+
+#include "../IStream.h"
+#include "../../Common/MyCom.h"
+
+#ifndef _NO_EXCEPTIONS
+struct COutBufferException
+{
+  HRESULT ErrorCode;
+  COutBufferException(HRESULT errorCode): ErrorCode(errorCode) {}
+};
+#endif
+
+class COutBuffer
+{
+protected:
+  Byte *_buffer;
+  UInt32 _pos;
+  UInt32 _limitPos;
+  UInt32 _streamPos;
+  UInt32 _bufferSize;
+  CMyComPtr<ISequentialOutStream> _stream;
+  UInt64 _processedSize;
+  Byte  *_buffer2;
+  bool _overDict;
+
+  HRESULT FlushPart();
+  void FlushWithCheck();
+public:
+  #ifdef _NO_EXCEPTIONS
+  HRESULT ErrorCode;
+  #endif
+
+  COutBuffer(): _buffer(0), _pos(0), _stream(0), _buffer2(0) {}
+  ~COutBuffer() { Free(); }
+
+  bool Create(UInt32 bufferSize);
+  void Free();
+
+  void SetMemStream(Byte *buffer) { _buffer2 = buffer; }
+  void SetStream(ISequentialOutStream *stream);
+  void Init();
+  HRESULT Flush();
+  void ReleaseStream() {  _stream.Release(); }
+
+  void WriteByte(Byte b)
+  {
+    _buffer[_pos++] = b;
+    if(_pos == _limitPos)
+      FlushWithCheck();
+  }
+  void WriteBytes(const void *data, size_t size)
+  {
+    for (size_t i = 0; i < size; i++)
+      WriteByte(((const Byte *)data)[i]);
+  }
+
+  UInt64 GetProcessedSize() const;
+};
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/StdAfx.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/StdAfx.h
index d7d9211b09..ef555ec12a 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/StdAfx.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/StdAfx.h
@@ -1,9 +1,9 @@
-// StdAfx.h

-

-#ifndef __STDAFX_H

-#define __STDAFX_H

-

-#include "../../Common/MyWindows.h"

-#include "../../Common/NewHandler.h"

-

-#endif 

+// StdAfx.h
+
+#ifndef __STDAFX_H
+#define __STDAFX_H
+
+#include "../../Common/MyWindows.h"
+#include "../../Common/NewHandler.h"
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/StreamUtils.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/StreamUtils.h
index c8cd8cef1a..59f88733f6 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/StreamUtils.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Common/StreamUtils.h
@@ -1,11 +1,11 @@
-// StreamUtils.h

-

-#ifndef __STREAMUTILS_H

-#define __STREAMUTILS_H

-

-#include "../IStream.h"

-

-HRESULT ReadStream(ISequentialInStream *stream, void *data, UInt32 size, UInt32 *processedSize);

-HRESULT WriteStream(ISequentialOutStream *stream, const void *data, UInt32 size, UInt32 *processedSize);

-

-#endif

+// StreamUtils.h
+
+#ifndef __STREAMUTILS_H
+#define __STREAMUTILS_H
+
+#include "../IStream.h"
+
+HRESULT ReadStream(ISequentialInStream *stream, void *data, UInt32 size, UInt32 *processedSize);
+HRESULT WriteStream(ISequentialOutStream *stream, const void *data, UInt32 size, UInt32 *processedSize);
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree.h
index d464d3b59c..243d5a3888 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree.h
@@ -1,54 +1,54 @@
-// BinTree.h

-

-#include "../LZInWindow.h"

-#include "../IMatchFinder.h"

- 

-namespace BT_NAMESPACE {

-

-typedef UInt32 CIndex;

-const UInt32 kMaxValForNormalize = (UInt32(1) << 31) - 1;

-

-class CMatchFinder: 

-  public IMatchFinder,

-  public CLZInWindow,

-  public CMyUnknownImp,

-  public IMatchFinderSetNumPasses

-{

-  UInt32 _cyclicBufferPos;

-  UInt32 _cyclicBufferSize; // it must be historySize + 1

-  UInt32 _matchMaxLen;

-  CIndex *_hash;

-  CIndex *_son;

-  UInt32 _hashMask;

-  UInt32 _cutValue;

-  UInt32 _hashSizeSum;

-

-  void Normalize();

-  void FreeThisClassMemory();

-  void FreeMemory();

-

-  MY_UNKNOWN_IMP

-

-  STDMETHOD(SetStream)(ISequentialInStream *inStream);

-  STDMETHOD_(void, ReleaseStream)();

-  STDMETHOD(Init)();

-  HRESULT MovePos();

-  STDMETHOD_(Byte, GetIndexByte)(Int32 index);

-  STDMETHOD_(UInt32, GetMatchLen)(Int32 index, UInt32 back, UInt32 limit);

-  STDMETHOD_(UInt32, GetNumAvailableBytes)();

-  STDMETHOD_(const Byte *, GetPointerToCurrentPos)();

-  STDMETHOD_(Int32, NeedChangeBufferPos)(UInt32 numCheckBytes);

-  STDMETHOD_(void, ChangeBufferPos)();

-

-  STDMETHOD(Create)(UInt32 historySize, UInt32 keepAddBufferBefore, 

-      UInt32 matchMaxLen, UInt32 keepAddBufferAfter);

-  STDMETHOD(GetMatches)(UInt32 *distances);

-  STDMETHOD(Skip)(UInt32 num);

-

-public:

-  CMatchFinder();

-  virtual ~CMatchFinder();

-  virtual void SetNumPasses(UInt32 numPasses) { _cutValue = numPasses; }

-};

-

-}

+// BinTree.h
+
+#include "../LZInWindow.h"
+#include "../IMatchFinder.h"
+
+namespace BT_NAMESPACE {
+
+typedef UInt32 CIndex;
+const UInt32 kMaxValForNormalize = (UInt32(1) << 31) - 1;
+
+class CMatchFinder:
+  public IMatchFinder,
+  public CLZInWindow,
+  public CMyUnknownImp,
+  public IMatchFinderSetNumPasses
+{
+  UInt32 _cyclicBufferPos;
+  UInt32 _cyclicBufferSize; // it must be historySize + 1
+  UInt32 _matchMaxLen;
+  CIndex *_hash;
+  CIndex *_son;
+  UInt32 _hashMask;
+  UInt32 _cutValue;
+  UInt32 _hashSizeSum;
+
+  void Normalize();
+  void FreeThisClassMemory();
+  void FreeMemory();
+
+  MY_UNKNOWN_IMP
+
+  STDMETHOD(SetStream)(ISequentialInStream *inStream);
+  STDMETHOD_(void, ReleaseStream)();
+  STDMETHOD(Init)();
+  HRESULT MovePos();
+  STDMETHOD_(Byte, GetIndexByte)(Int32 index);
+  STDMETHOD_(UInt32, GetMatchLen)(Int32 index, UInt32 back, UInt32 limit);
+  STDMETHOD_(UInt32, GetNumAvailableBytes)();
+  STDMETHOD_(const Byte *, GetPointerToCurrentPos)();
+  STDMETHOD_(Int32, NeedChangeBufferPos)(UInt32 numCheckBytes);
+  STDMETHOD_(void, ChangeBufferPos)();
+
+  STDMETHOD(Create)(UInt32 historySize, UInt32 keepAddBufferBefore,
+      UInt32 matchMaxLen, UInt32 keepAddBufferAfter);
+  STDMETHOD(GetMatches)(UInt32 *distances);
+  STDMETHOD(Skip)(UInt32 num);
+
+public:
+  CMatchFinder();
+  virtual ~CMatchFinder();
+  virtual void SetNumPasses(UInt32 numPasses) { _cutValue = numPasses; }
+};
+
+}
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree2.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree2.h
index c5b3939e47..74ca8d9d0e 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree2.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree2.h
@@ -1,12 +1,12 @@
-// BinTree2.h

-

-#ifndef __BINTREE2_H

-#define __BINTREE2_H

-

-#define BT_NAMESPACE NBT2

-

-#include "BinTreeMain.h"

-

-#undef BT_NAMESPACE

-

-#endif

+// BinTree2.h
+
+#ifndef __BINTREE2_H
+#define __BINTREE2_H
+
+#define BT_NAMESPACE NBT2
+
+#include "BinTreeMain.h"
+
+#undef BT_NAMESPACE
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree3.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree3.h
index 74eb73e293..76bd9ddd43 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree3.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree3.h
@@ -1,16 +1,16 @@
-// BinTree3.h

-

-#ifndef __BINTREE3_H

-#define __BINTREE3_H

-

-#define BT_NAMESPACE NBT3

-

-#define HASH_ARRAY_2

-

-#include "BinTreeMain.h"

-

-#undef HASH_ARRAY_2

-

-#undef BT_NAMESPACE

-

-#endif

+// BinTree3.h
+
+#ifndef __BINTREE3_H
+#define __BINTREE3_H
+
+#define BT_NAMESPACE NBT3
+
+#define HASH_ARRAY_2
+
+#include "BinTreeMain.h"
+
+#undef HASH_ARRAY_2
+
+#undef BT_NAMESPACE
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree4.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree4.h
index 62fc242aac..08e2d1ced6 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree4.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTree4.h
@@ -1,18 +1,18 @@
-// BinTree4.h

-

-#ifndef __BINTREE4_H

-#define __BINTREE4_H

-

-#define BT_NAMESPACE NBT4

-

-#define HASH_ARRAY_2

-#define HASH_ARRAY_3

-

-#include "BinTreeMain.h"

-

-#undef HASH_ARRAY_2

-#undef HASH_ARRAY_3

-

-#undef BT_NAMESPACE

-

-#endif

+// BinTree4.h
+
+#ifndef __BINTREE4_H
+#define __BINTREE4_H
+
+#define BT_NAMESPACE NBT4
+
+#define HASH_ARRAY_2
+#define HASH_ARRAY_3
+
+#include "BinTreeMain.h"
+
+#undef HASH_ARRAY_2
+#undef HASH_ARRAY_3
+
+#undef BT_NAMESPACE
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTreeMain.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTreeMain.h
index 61d1121043..d47a03de90 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTreeMain.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/BinTree/BinTreeMain.h
@@ -1,531 +1,531 @@
-// BinTreeMain.h

-

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

-#include "../../../../Common/CRC.h"

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

-

-#include "BinTree.h"

-

-// #include <xmmintrin.h>

-// It's for prefetch

-// But prefetch doesn't give big gain in K8.

-

-namespace BT_NAMESPACE {

-

-#ifdef HASH_ARRAY_2

-  static const UInt32 kHash2Size = 1 << 10;

-  #define kNumHashDirectBytes 0

-  #ifdef HASH_ARRAY_3

-    static const UInt32 kNumHashBytes = 4;

-    static const UInt32 kHash3Size = 1 << 16;

-  #else

-    static const UInt32 kNumHashBytes = 3;

-  #endif

-  static const UInt32 kHashSize = 0;

-  static const UInt32 kMinMatchCheck = kNumHashBytes;

-  static const UInt32 kStartMaxLen = 1;

-#else

-  #ifdef HASH_ZIP 

-    #define kNumHashDirectBytes 0

-    static const UInt32 kNumHashBytes = 3;

-    static const UInt32 kHashSize = 1 << 16;

-    static const UInt32 kMinMatchCheck = kNumHashBytes;

-    static const UInt32 kStartMaxLen = 1;

-  #else

-    #define kNumHashDirectBytes 2

-    static const UInt32 kNumHashBytes = 2;

-    static const UInt32 kHashSize = 1 << (8 * kNumHashBytes);

-    static const UInt32 kMinMatchCheck = kNumHashBytes + 1;

-    static const UInt32 kStartMaxLen = 1;

-  #endif

-#endif

-

-#ifdef HASH_ARRAY_2

-#ifdef HASH_ARRAY_3

-static const UInt32 kHash3Offset = kHash2Size;

-#endif

-#endif

-

-static const UInt32 kFixHashSize = 0

-    #ifdef HASH_ARRAY_2

-    + kHash2Size

-    #ifdef HASH_ARRAY_3

-    + kHash3Size

-    #endif

-    #endif

-    ;

-

-CMatchFinder::CMatchFinder():

-  _hash(0)

-{

-}

-

-void CMatchFinder::FreeThisClassMemory()

-{

-  BigFree(_hash);

-  _hash = 0;

-}

-

-void CMatchFinder::FreeMemory()

-{

-  FreeThisClassMemory();

-  CLZInWindow::Free();

-}

-

-CMatchFinder::~CMatchFinder()

-{ 

-  FreeMemory();

-}

-

-STDMETHODIMP CMatchFinder::Create(UInt32 historySize, UInt32 keepAddBufferBefore, 

-    UInt32 matchMaxLen, UInt32 keepAddBufferAfter)

-{

-  if (historySize > kMaxValForNormalize - 256)

-  {

-    FreeMemory();

-    return E_INVALIDARG;

-  }

-  _cutValue = 

-  #ifdef _HASH_CHAIN

-    8 + (matchMaxLen >> 2);

-  #else

-    16 + (matchMaxLen >> 1);

-  #endif

-  UInt32 sizeReserv = (historySize + keepAddBufferBefore + 

-      matchMaxLen + keepAddBufferAfter) / 2 + 256;

-  if (CLZInWindow::Create(historySize + keepAddBufferBefore, 

-      matchMaxLen + keepAddBufferAfter, sizeReserv))

-  {

-    _matchMaxLen = matchMaxLen;

-    UInt32 newCyclicBufferSize = historySize + 1;

-    if (_hash != 0 && newCyclicBufferSize == _cyclicBufferSize)

-      return S_OK;

-    FreeThisClassMemory();

-    _cyclicBufferSize = newCyclicBufferSize; // don't change it

-

-    UInt32 hs = kHashSize;

-

-    #ifdef HASH_ARRAY_2

-    hs = historySize - 1;

-    hs |= (hs >> 1);

-    hs |= (hs >> 2);

-    hs |= (hs >> 4);

-    hs |= (hs >> 8);

-    hs >>= 1;

-    hs |= 0xFFFF;

-    if (hs > (1 << 24))

-    {

-      #ifdef HASH_ARRAY_3

-      hs >>= 1;

-      #else

-      hs = (1 << 24) - 1;

-      #endif

-    }

-    _hashMask = hs;

-    hs++;

-    #endif

-    _hashSizeSum = hs + kFixHashSize;

-    UInt32 numItems = _hashSizeSum + _cyclicBufferSize

-    #ifndef _HASH_CHAIN

-     * 2

-    #endif

-    ;

-    size_t sizeInBytes = (size_t)numItems * sizeof(CIndex);

-    if (sizeInBytes / sizeof(CIndex) != numItems)

-      return E_OUTOFMEMORY;

-    _hash = (CIndex *)BigAlloc(sizeInBytes);

-    _son = _hash + _hashSizeSum;

-    if (_hash != 0)

-      return S_OK;

-  }

-  FreeMemory();

-  return E_OUTOFMEMORY;

-}

-

-static const UInt32 kEmptyHashValue = 0;

-

-STDMETHODIMP CMatchFinder::SetStream(ISequentialInStream *stream)

-{

-  CLZInWindow::SetStream(stream);

-  return S_OK;

-}

-

-STDMETHODIMP CMatchFinder::Init()

-{

-  RINOK(CLZInWindow::Init());

-  for(UInt32 i = 0; i < _hashSizeSum; i++)

-    _hash[i] = kEmptyHashValue;

-  _cyclicBufferPos = 0;

-  ReduceOffsets(-1);

-  return S_OK;

-}

-

-STDMETHODIMP_(void) CMatchFinder::ReleaseStream()

-{ 

-  // ReleaseStream(); 

-}

-

-#ifdef HASH_ARRAY_2

-#ifdef HASH_ARRAY_3

-

-#define HASH_CALC { \

-  UInt32 temp = CCRC::Table[cur[0]] ^ cur[1]; \

-  hash2Value = temp & (kHash2Size - 1); \

-  hash3Value = (temp ^ (UInt32(cur[2]) << 8)) & (kHash3Size - 1); \

-  hashValue = (temp ^ (UInt32(cur[2]) << 8) ^ (CCRC::Table[cur[3]] << 5)) & _hashMask; }

-  

-#else // no HASH_ARRAY_3

-#define HASH_CALC { \

-  UInt32 temp = CCRC::Table[cur[0]] ^ cur[1]; \

-  hash2Value = temp & (kHash2Size - 1); \

-  hashValue = (temp ^ (UInt32(cur[2]) << 8)) & _hashMask; }

-#endif // HASH_ARRAY_3

-#else // no HASH_ARRAY_2

-#ifdef HASH_ZIP 

-inline UInt32 Hash(const Byte *pointer)

-{

-  return ((UInt32(pointer[0]) << 8) ^ CCRC::Table[pointer[1]] ^ pointer[2]) & (kHashSize - 1);

-}

-#else // no HASH_ZIP 

-inline UInt32 Hash(const Byte *pointer)

-{

-  return pointer[0] ^ (UInt32(pointer[1]) << 8);

-}

-#endif // HASH_ZIP

-#endif // HASH_ARRAY_2

-

-STDMETHODIMP CMatchFinder::GetMatches(UInt32 *distances)

-{

-  UInt32 lenLimit;

-  if (_pos + _matchMaxLen <= _streamPos)

-    lenLimit = _matchMaxLen;

-  else

-  {

-    lenLimit = _streamPos - _pos;

-    if(lenLimit < kMinMatchCheck)

-    {

-      distances[0] = 0;

-      return MovePos(); 

-    }

-  }

-

-  int offset = 1;

-

-  UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;

-  const Byte *cur = _buffer + _pos;

-

-  UInt32 maxLen = kStartMaxLen; // to avoid items for len < hashSize;

-

-  #ifdef HASH_ARRAY_2

-  UInt32 hash2Value;

-  #ifdef HASH_ARRAY_3

-  UInt32 hash3Value;

-  #endif

-  UInt32 hashValue;

-  HASH_CALC;

-  #else

-  UInt32 hashValue = Hash(cur);

-  #endif

-

-  UInt32 curMatch = _hash[kFixHashSize + hashValue];

-  #ifdef HASH_ARRAY_2

-  UInt32 curMatch2 = _hash[hash2Value];

-  #ifdef HASH_ARRAY_3

-  UInt32 curMatch3 = _hash[kHash3Offset + hash3Value];

-  #endif

-  _hash[hash2Value] = _pos;

-  if(curMatch2 > matchMinPos)

-    if (_buffer[curMatch2] == cur[0])

-    {

-      distances[offset++] = maxLen = 2;

-      distances[offset++] = _pos - curMatch2 - 1;

-    }

-

-  #ifdef HASH_ARRAY_3

-  _hash[kHash3Offset + hash3Value] = _pos;

-  if(curMatch3 > matchMinPos)

-    if (_buffer[curMatch3] == cur[0])

-    {

-      if (curMatch3 == curMatch2)

-        offset -= 2;

-      distances[offset++] = maxLen = 3;

-      distances[offset++] = _pos - curMatch3 - 1;

-      curMatch2 = curMatch3;

-    }

-  #endif

-  if (offset != 1 && curMatch2 == curMatch)

-  {

-    offset -= 2;

-    maxLen = kStartMaxLen;

-  }

-  #endif

-

-  _hash[kFixHashSize + hashValue] = _pos;

-

-  CIndex *son = _son;

-

-  #ifdef _HASH_CHAIN

-  son[_cyclicBufferPos] = curMatch;

-  #else

-  CIndex *ptr0 = son + (_cyclicBufferPos << 1) + 1;

-  CIndex *ptr1 = son + (_cyclicBufferPos << 1);

-

-  UInt32 len0, len1;

-  len0 = len1 = kNumHashDirectBytes;

-  #endif

-

-  #if kNumHashDirectBytes != 0

-  if(curMatch > matchMinPos)

-  {

-    if (_buffer[curMatch + kNumHashDirectBytes] != cur[kNumHashDirectBytes])

-    {

-      distances[offset++] = maxLen = kNumHashDirectBytes;

-      distances[offset++] = _pos - curMatch - 1;

-    }

-  }

-  #endif

-  UInt32 count = _cutValue;

-  while(true)

-  {

-    if(curMatch <= matchMinPos || count-- == 0)

-    {

-      #ifndef _HASH_CHAIN

-      *ptr0 = *ptr1 = kEmptyHashValue;

-      #endif

-      break;

-    }

-    UInt32 delta = _pos - curMatch;

-    UInt32 cyclicPos = (delta <= _cyclicBufferPos) ?

-        (_cyclicBufferPos - delta):

-        (_cyclicBufferPos - delta + _cyclicBufferSize);

-    CIndex *pair = son + 

-    #ifdef _HASH_CHAIN

-      cyclicPos;

-    #else

-      (cyclicPos << 1);

-    #endif

-    

-    // _mm_prefetch((const char *)pair, _MM_HINT_T0);

-    

-    const Byte *pb = _buffer + curMatch;

-    UInt32 len = 

-    #ifdef _HASH_CHAIN

-    kNumHashDirectBytes;

-    if (pb[maxLen] == cur[maxLen])

-    #else

-    MyMin(len0, len1);

-    #endif

-    if (pb[len] == cur[len])

-    {

-      while(++len != lenLimit)

-        if (pb[len] != cur[len])

-          break;

-      if (maxLen < len)

-      {

-        distances[offset++] = maxLen = len;

-        distances[offset++] = delta - 1;

-        if (len == lenLimit)

-        {

-          #ifndef _HASH_CHAIN

-          *ptr1 = pair[0];

-          *ptr0 = pair[1];

-          #endif

-          break;

-        }

-      }

-    }

-    #ifdef _HASH_CHAIN

-    curMatch = *pair;

-    #else

-    if (pb[len] < cur[len])

-    {

-      *ptr1 = curMatch;

-      ptr1 = pair + 1;

-      curMatch = *ptr1;

-      len1 = len;

-    }

-    else

-    {

-      *ptr0 = curMatch;

-      ptr0 = pair;

-      curMatch = *ptr0;

-      len0 = len;

-    }

-    #endif

-  }

-  distances[0] = offset - 1;

-  if (++_cyclicBufferPos == _cyclicBufferSize)

-    _cyclicBufferPos = 0;

-  RINOK(CLZInWindow::MovePos());

-  if (_pos == kMaxValForNormalize)

-    Normalize();

-  return S_OK;

-}

-

-STDMETHODIMP CMatchFinder::Skip(UInt32 num)

-{

-  do

-  {

-  #ifdef _HASH_CHAIN

-  if (_streamPos - _pos < kNumHashBytes)

-  {

-    RINOK(MovePos()); 

-    continue;

-  }

-  #else

-  UInt32 lenLimit;

-  if (_pos + _matchMaxLen <= _streamPos)

-    lenLimit = _matchMaxLen;

-  else

-  {

-    lenLimit = _streamPos - _pos;

-    if(lenLimit < kMinMatchCheck)

-    {

-      RINOK(MovePos());

-      continue;

-    }

-  }

-  UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;

-  #endif

-  const Byte *cur = _buffer + _pos;

-

-  #ifdef HASH_ARRAY_2

-  UInt32 hash2Value;

-  #ifdef HASH_ARRAY_3

-  UInt32 hash3Value;

-  UInt32 hashValue;

-  HASH_CALC;

-  _hash[kHash3Offset + hash3Value] = _pos;

-  #else

-  UInt32 hashValue;

-  HASH_CALC;

-  #endif

-  _hash[hash2Value] = _pos;

-  #else

-  UInt32 hashValue = Hash(cur);

-  #endif

-

-  UInt32 curMatch = _hash[kFixHashSize + hashValue];

-  _hash[kFixHashSize + hashValue] = _pos;

-

-  #ifdef _HASH_CHAIN

-  _son[_cyclicBufferPos] = curMatch;

-  #else

-  CIndex *son = _son;

-  CIndex *ptr0 = son + (_cyclicBufferPos << 1) + 1;

-  CIndex *ptr1 = son + (_cyclicBufferPos << 1);

-

-  UInt32 len0, len1;

-  len0 = len1 = kNumHashDirectBytes;

-  UInt32 count = _cutValue;

-  while(true)

-  {

-    if(curMatch <= matchMinPos || count-- == 0)

-    {

-      *ptr0 = *ptr1 = kEmptyHashValue;

-      break;

-    }

-    

-    UInt32 delta = _pos - curMatch;

-    UInt32 cyclicPos = (delta <= _cyclicBufferPos) ?

-      (_cyclicBufferPos - delta):

-      (_cyclicBufferPos - delta + _cyclicBufferSize);

-    CIndex *pair = son + (cyclicPos << 1);

-    

-    // _mm_prefetch((const char *)pair, _MM_HINT_T0);

-    

-    const Byte *pb = _buffer + curMatch;

-    UInt32 len = MyMin(len0, len1);

-    

-    if (pb[len] == cur[len])

-    {

-      while(++len != lenLimit)

-        if (pb[len] != cur[len])

-          break;

-      if (len == lenLimit)

-      {

-        *ptr1 = pair[0];

-        *ptr0 = pair[1];

-        break;

-      }

-    }

-    if (pb[len] < cur[len])

-    {

-      *ptr1 = curMatch;

-      ptr1 = pair + 1;

-      curMatch = *ptr1;

-      len1 = len;

-    }

-    else

-    {

-      *ptr0 = curMatch;

-      ptr0 = pair;

-      curMatch = *ptr0;

-      len0 = len;

-    }

-  }

-  #endif

-  if (++_cyclicBufferPos == _cyclicBufferSize)

-    _cyclicBufferPos = 0;

-  RINOK(CLZInWindow::MovePos());

-  if (_pos == kMaxValForNormalize)

-    Normalize();

-  }

-  while(--num != 0);

-  return S_OK;

-}

-

-void CMatchFinder::Normalize()

-{

-  UInt32 subValue = _pos - _cyclicBufferSize;

-  CIndex *items = _hash;

-  UInt32 numItems = (_hashSizeSum + _cyclicBufferSize 

-    #ifndef _HASH_CHAIN

-     * 2

-    #endif

-    );

-  for (UInt32 i = 0; i < numItems; i++)

-  {

-    UInt32 value = items[i];

-    if (value <= subValue)

-      value = kEmptyHashValue;

-    else

-      value -= subValue;

-    items[i] = value;

-  }

-  ReduceOffsets(subValue);

-}

-

-HRESULT CMatchFinder::MovePos()

-{

-  if (++_cyclicBufferPos == _cyclicBufferSize)

-    _cyclicBufferPos = 0;

-  RINOK(CLZInWindow::MovePos());

-  if (_pos == kMaxValForNormalize)

-    Normalize();

-  return S_OK;

-}

-

-STDMETHODIMP_(Byte) CMatchFinder::GetIndexByte(Int32 index)

-  { return CLZInWindow::GetIndexByte(index); }

-

-STDMETHODIMP_(UInt32) CMatchFinder::GetMatchLen(Int32 index, 

-    UInt32 back, UInt32 limit)

-  { return CLZInWindow::GetMatchLen(index, back, limit); }

-

-STDMETHODIMP_(UInt32) CMatchFinder::GetNumAvailableBytes()

-  { return CLZInWindow::GetNumAvailableBytes(); }

-

-STDMETHODIMP_(const Byte *) CMatchFinder::GetPointerToCurrentPos()

-  { return CLZInWindow::GetPointerToCurrentPos(); }

-

-STDMETHODIMP_(Int32) CMatchFinder::NeedChangeBufferPos(UInt32 numCheckBytes)

-  { return CLZInWindow::NeedMove(numCheckBytes) ? 1: 0; }

-

-STDMETHODIMP_(void) CMatchFinder::ChangeBufferPos()

-  { CLZInWindow::MoveBlock();}

-

-#undef HASH_CALC

-#undef kNumHashDirectBytes

- 

-}

+// BinTreeMain.h
+
+#include "../../../../Common/Defs.h"
+#include "../../../../Common/CRC.h"
+#include "../../../../Common/Alloc.h"
+
+#include "BinTree.h"
+
+// #include <xmmintrin.h>
+// It's for prefetch
+// But prefetch doesn't give big gain in K8.
+
+namespace BT_NAMESPACE {
+
+#ifdef HASH_ARRAY_2
+  static const UInt32 kHash2Size = 1 << 10;
+  #define kNumHashDirectBytes 0
+  #ifdef HASH_ARRAY_3
+    static const UInt32 kNumHashBytes = 4;
+    static const UInt32 kHash3Size = 1 << 16;
+  #else
+    static const UInt32 kNumHashBytes = 3;
+  #endif
+  static const UInt32 kHashSize = 0;
+  static const UInt32 kMinMatchCheck = kNumHashBytes;
+  static const UInt32 kStartMaxLen = 1;
+#else
+  #ifdef HASH_ZIP
+    #define kNumHashDirectBytes 0
+    static const UInt32 kNumHashBytes = 3;
+    static const UInt32 kHashSize = 1 << 16;
+    static const UInt32 kMinMatchCheck = kNumHashBytes;
+    static const UInt32 kStartMaxLen = 1;
+  #else
+    #define kNumHashDirectBytes 2
+    static const UInt32 kNumHashBytes = 2;
+    static const UInt32 kHashSize = 1 << (8 * kNumHashBytes);
+    static const UInt32 kMinMatchCheck = kNumHashBytes + 1;
+    static const UInt32 kStartMaxLen = 1;
+  #endif
+#endif
+
+#ifdef HASH_ARRAY_2
+#ifdef HASH_ARRAY_3
+static const UInt32 kHash3Offset = kHash2Size;
+#endif
+#endif
+
+static const UInt32 kFixHashSize = 0
+    #ifdef HASH_ARRAY_2
+    + kHash2Size
+    #ifdef HASH_ARRAY_3
+    + kHash3Size
+    #endif
+    #endif
+    ;
+
+CMatchFinder::CMatchFinder():
+  _hash(0)
+{
+}
+
+void CMatchFinder::FreeThisClassMemory()
+{
+  BigFree(_hash);
+  _hash = 0;
+}
+
+void CMatchFinder::FreeMemory()
+{
+  FreeThisClassMemory();
+  CLZInWindow::Free();
+}
+
+CMatchFinder::~CMatchFinder()
+{
+  FreeMemory();
+}
+
+STDMETHODIMP CMatchFinder::Create(UInt32 historySize, UInt32 keepAddBufferBefore,
+    UInt32 matchMaxLen, UInt32 keepAddBufferAfter)
+{
+  if (historySize > kMaxValForNormalize - 256)
+  {
+    FreeMemory();
+    return E_INVALIDARG;
+  }
+  _cutValue =
+  #ifdef _HASH_CHAIN
+    8 + (matchMaxLen >> 2);
+  #else
+    16 + (matchMaxLen >> 1);
+  #endif
+  UInt32 sizeReserv = (historySize + keepAddBufferBefore +
+      matchMaxLen + keepAddBufferAfter) / 2 + 256;
+  if (CLZInWindow::Create(historySize + keepAddBufferBefore,
+      matchMaxLen + keepAddBufferAfter, sizeReserv))
+  {
+    _matchMaxLen = matchMaxLen;
+    UInt32 newCyclicBufferSize = historySize + 1;
+    if (_hash != 0 && newCyclicBufferSize == _cyclicBufferSize)
+      return S_OK;
+    FreeThisClassMemory();
+    _cyclicBufferSize = newCyclicBufferSize; // don't change it
+
+    UInt32 hs = kHashSize;
+
+    #ifdef HASH_ARRAY_2
+    hs = historySize - 1;
+    hs |= (hs >> 1);
+    hs |= (hs >> 2);
+    hs |= (hs >> 4);
+    hs |= (hs >> 8);
+    hs >>= 1;
+    hs |= 0xFFFF;
+    if (hs > (1 << 24))
+    {
+      #ifdef HASH_ARRAY_3
+      hs >>= 1;
+      #else
+      hs = (1 << 24) - 1;
+      #endif
+    }
+    _hashMask = hs;
+    hs++;
+    #endif
+    _hashSizeSum = hs + kFixHashSize;
+    UInt32 numItems = _hashSizeSum + _cyclicBufferSize
+    #ifndef _HASH_CHAIN
+     * 2
+    #endif
+    ;
+    size_t sizeInBytes = (size_t)numItems * sizeof(CIndex);
+    if (sizeInBytes / sizeof(CIndex) != numItems)
+      return E_OUTOFMEMORY;
+    _hash = (CIndex *)BigAlloc(sizeInBytes);
+    _son = _hash + _hashSizeSum;
+    if (_hash != 0)
+      return S_OK;
+  }
+  FreeMemory();
+  return E_OUTOFMEMORY;
+}
+
+static const UInt32 kEmptyHashValue = 0;
+
+STDMETHODIMP CMatchFinder::SetStream(ISequentialInStream *stream)
+{
+  CLZInWindow::SetStream(stream);
+  return S_OK;
+}
+
+STDMETHODIMP CMatchFinder::Init()
+{
+  RINOK(CLZInWindow::Init());
+  for(UInt32 i = 0; i < _hashSizeSum; i++)
+    _hash[i] = kEmptyHashValue;
+  _cyclicBufferPos = 0;
+  ReduceOffsets(-1);
+  return S_OK;
+}
+
+STDMETHODIMP_(void) CMatchFinder::ReleaseStream()
+{
+  // ReleaseStream();
+}
+
+#ifdef HASH_ARRAY_2
+#ifdef HASH_ARRAY_3
+
+#define HASH_CALC { \
+  UInt32 temp = CCRC::Table[cur[0]] ^ cur[1]; \
+  hash2Value = temp & (kHash2Size - 1); \
+  hash3Value = (temp ^ (UInt32(cur[2]) << 8)) & (kHash3Size - 1); \
+  hashValue = (temp ^ (UInt32(cur[2]) << 8) ^ (CCRC::Table[cur[3]] << 5)) & _hashMask; }
+
+#else // no HASH_ARRAY_3
+#define HASH_CALC { \
+  UInt32 temp = CCRC::Table[cur[0]] ^ cur[1]; \
+  hash2Value = temp & (kHash2Size - 1); \
+  hashValue = (temp ^ (UInt32(cur[2]) << 8)) & _hashMask; }
+#endif // HASH_ARRAY_3
+#else // no HASH_ARRAY_2
+#ifdef HASH_ZIP
+inline UInt32 Hash(const Byte *pointer)
+{
+  return ((UInt32(pointer[0]) << 8) ^ CCRC::Table[pointer[1]] ^ pointer[2]) & (kHashSize - 1);
+}
+#else // no HASH_ZIP
+inline UInt32 Hash(const Byte *pointer)
+{
+  return pointer[0] ^ (UInt32(pointer[1]) << 8);
+}
+#endif // HASH_ZIP
+#endif // HASH_ARRAY_2
+
+STDMETHODIMP CMatchFinder::GetMatches(UInt32 *distances)
+{
+  UInt32 lenLimit;
+  if (_pos + _matchMaxLen <= _streamPos)
+    lenLimit = _matchMaxLen;
+  else
+  {
+    lenLimit = _streamPos - _pos;
+    if(lenLimit < kMinMatchCheck)
+    {
+      distances[0] = 0;
+      return MovePos();
+    }
+  }
+
+  int offset = 1;
+
+  UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;
+  const Byte *cur = _buffer + _pos;
+
+  UInt32 maxLen = kStartMaxLen; // to avoid items for len < hashSize;
+
+  #ifdef HASH_ARRAY_2
+  UInt32 hash2Value;
+  #ifdef HASH_ARRAY_3
+  UInt32 hash3Value;
+  #endif
+  UInt32 hashValue;
+  HASH_CALC;
+  #else
+  UInt32 hashValue = Hash(cur);
+  #endif
+
+  UInt32 curMatch = _hash[kFixHashSize + hashValue];
+  #ifdef HASH_ARRAY_2
+  UInt32 curMatch2 = _hash[hash2Value];
+  #ifdef HASH_ARRAY_3
+  UInt32 curMatch3 = _hash[kHash3Offset + hash3Value];
+  #endif
+  _hash[hash2Value] = _pos;
+  if(curMatch2 > matchMinPos)
+    if (_buffer[curMatch2] == cur[0])
+    {
+      distances[offset++] = maxLen = 2;
+      distances[offset++] = _pos - curMatch2 - 1;
+    }
+
+  #ifdef HASH_ARRAY_3
+  _hash[kHash3Offset + hash3Value] = _pos;
+  if(curMatch3 > matchMinPos)
+    if (_buffer[curMatch3] == cur[0])
+    {
+      if (curMatch3 == curMatch2)
+        offset -= 2;
+      distances[offset++] = maxLen = 3;
+      distances[offset++] = _pos - curMatch3 - 1;
+      curMatch2 = curMatch3;
+    }
+  #endif
+  if (offset != 1 && curMatch2 == curMatch)
+  {
+    offset -= 2;
+    maxLen = kStartMaxLen;
+  }
+  #endif
+
+  _hash[kFixHashSize + hashValue] = _pos;
+
+  CIndex *son = _son;
+
+  #ifdef _HASH_CHAIN
+  son[_cyclicBufferPos] = curMatch;
+  #else
+  CIndex *ptr0 = son + (_cyclicBufferPos << 1) + 1;
+  CIndex *ptr1 = son + (_cyclicBufferPos << 1);
+
+  UInt32 len0, len1;
+  len0 = len1 = kNumHashDirectBytes;
+  #endif
+
+  #if kNumHashDirectBytes != 0
+  if(curMatch > matchMinPos)
+  {
+    if (_buffer[curMatch + kNumHashDirectBytes] != cur[kNumHashDirectBytes])
+    {
+      distances[offset++] = maxLen = kNumHashDirectBytes;
+      distances[offset++] = _pos - curMatch - 1;
+    }
+  }
+  #endif
+  UInt32 count = _cutValue;
+  while(true)
+  {
+    if(curMatch <= matchMinPos || count-- == 0)
+    {
+      #ifndef _HASH_CHAIN
+      *ptr0 = *ptr1 = kEmptyHashValue;
+      #endif
+      break;
+    }
+    UInt32 delta = _pos - curMatch;
+    UInt32 cyclicPos = (delta <= _cyclicBufferPos) ?
+        (_cyclicBufferPos - delta):
+        (_cyclicBufferPos - delta + _cyclicBufferSize);
+    CIndex *pair = son +
+    #ifdef _HASH_CHAIN
+      cyclicPos;
+    #else
+      (cyclicPos << 1);
+    #endif
+
+    // _mm_prefetch((const char *)pair, _MM_HINT_T0);
+
+    const Byte *pb = _buffer + curMatch;
+    UInt32 len =
+    #ifdef _HASH_CHAIN
+    kNumHashDirectBytes;
+    if (pb[maxLen] == cur[maxLen])
+    #else
+    MyMin(len0, len1);
+    #endif
+    if (pb[len] == cur[len])
+    {
+      while(++len != lenLimit)
+        if (pb[len] != cur[len])
+          break;
+      if (maxLen < len)
+      {
+        distances[offset++] = maxLen = len;
+        distances[offset++] = delta - 1;
+        if (len == lenLimit)
+        {
+          #ifndef _HASH_CHAIN
+          *ptr1 = pair[0];
+          *ptr0 = pair[1];
+          #endif
+          break;
+        }
+      }
+    }
+    #ifdef _HASH_CHAIN
+    curMatch = *pair;
+    #else
+    if (pb[len] < cur[len])
+    {
+      *ptr1 = curMatch;
+      ptr1 = pair + 1;
+      curMatch = *ptr1;
+      len1 = len;
+    }
+    else
+    {
+      *ptr0 = curMatch;
+      ptr0 = pair;
+      curMatch = *ptr0;
+      len0 = len;
+    }
+    #endif
+  }
+  distances[0] = offset - 1;
+  if (++_cyclicBufferPos == _cyclicBufferSize)
+    _cyclicBufferPos = 0;
+  RINOK(CLZInWindow::MovePos());
+  if (_pos == kMaxValForNormalize)
+    Normalize();
+  return S_OK;
+}
+
+STDMETHODIMP CMatchFinder::Skip(UInt32 num)
+{
+  do
+  {
+  #ifdef _HASH_CHAIN
+  if (_streamPos - _pos < kNumHashBytes)
+  {
+    RINOK(MovePos());
+    continue;
+  }
+  #else
+  UInt32 lenLimit;
+  if (_pos + _matchMaxLen <= _streamPos)
+    lenLimit = _matchMaxLen;
+  else
+  {
+    lenLimit = _streamPos - _pos;
+    if(lenLimit < kMinMatchCheck)
+    {
+      RINOK(MovePos());
+      continue;
+    }
+  }
+  UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;
+  #endif
+  const Byte *cur = _buffer + _pos;
+
+  #ifdef HASH_ARRAY_2
+  UInt32 hash2Value;
+  #ifdef HASH_ARRAY_3
+  UInt32 hash3Value;
+  UInt32 hashValue;
+  HASH_CALC;
+  _hash[kHash3Offset + hash3Value] = _pos;
+  #else
+  UInt32 hashValue;
+  HASH_CALC;
+  #endif
+  _hash[hash2Value] = _pos;
+  #else
+  UInt32 hashValue = Hash(cur);
+  #endif
+
+  UInt32 curMatch = _hash[kFixHashSize + hashValue];
+  _hash[kFixHashSize + hashValue] = _pos;
+
+  #ifdef _HASH_CHAIN
+  _son[_cyclicBufferPos] = curMatch;
+  #else
+  CIndex *son = _son;
+  CIndex *ptr0 = son + (_cyclicBufferPos << 1) + 1;
+  CIndex *ptr1 = son + (_cyclicBufferPos << 1);
+
+  UInt32 len0, len1;
+  len0 = len1 = kNumHashDirectBytes;
+  UInt32 count = _cutValue;
+  while(true)
+  {
+    if(curMatch <= matchMinPos || count-- == 0)
+    {
+      *ptr0 = *ptr1 = kEmptyHashValue;
+      break;
+    }
+
+    UInt32 delta = _pos - curMatch;
+    UInt32 cyclicPos = (delta <= _cyclicBufferPos) ?
+      (_cyclicBufferPos - delta):
+      (_cyclicBufferPos - delta + _cyclicBufferSize);
+    CIndex *pair = son + (cyclicPos << 1);
+
+    // _mm_prefetch((const char *)pair, _MM_HINT_T0);
+
+    const Byte *pb = _buffer + curMatch;
+    UInt32 len = MyMin(len0, len1);
+
+    if (pb[len] == cur[len])
+    {
+      while(++len != lenLimit)
+        if (pb[len] != cur[len])
+          break;
+      if (len == lenLimit)
+      {
+        *ptr1 = pair[0];
+        *ptr0 = pair[1];
+        break;
+      }
+    }
+    if (pb[len] < cur[len])
+    {
+      *ptr1 = curMatch;
+      ptr1 = pair + 1;
+      curMatch = *ptr1;
+      len1 = len;
+    }
+    else
+    {
+      *ptr0 = curMatch;
+      ptr0 = pair;
+      curMatch = *ptr0;
+      len0 = len;
+    }
+  }
+  #endif
+  if (++_cyclicBufferPos == _cyclicBufferSize)
+    _cyclicBufferPos = 0;
+  RINOK(CLZInWindow::MovePos());
+  if (_pos == kMaxValForNormalize)
+    Normalize();
+  }
+  while(--num != 0);
+  return S_OK;
+}
+
+void CMatchFinder::Normalize()
+{
+  UInt32 subValue = _pos - _cyclicBufferSize;
+  CIndex *items = _hash;
+  UInt32 numItems = (_hashSizeSum + _cyclicBufferSize
+    #ifndef _HASH_CHAIN
+     * 2
+    #endif
+    );
+  for (UInt32 i = 0; i < numItems; i++)
+  {
+    UInt32 value = items[i];
+    if (value <= subValue)
+      value = kEmptyHashValue;
+    else
+      value -= subValue;
+    items[i] = value;
+  }
+  ReduceOffsets(subValue);
+}
+
+HRESULT CMatchFinder::MovePos()
+{
+  if (++_cyclicBufferPos == _cyclicBufferSize)
+    _cyclicBufferPos = 0;
+  RINOK(CLZInWindow::MovePos());
+  if (_pos == kMaxValForNormalize)
+    Normalize();
+  return S_OK;
+}
+
+STDMETHODIMP_(Byte) CMatchFinder::GetIndexByte(Int32 index)
+  { return CLZInWindow::GetIndexByte(index); }
+
+STDMETHODIMP_(UInt32) CMatchFinder::GetMatchLen(Int32 index,
+    UInt32 back, UInt32 limit)
+  { return CLZInWindow::GetMatchLen(index, back, limit); }
+
+STDMETHODIMP_(UInt32) CMatchFinder::GetNumAvailableBytes()
+  { return CLZInWindow::GetNumAvailableBytes(); }
+
+STDMETHODIMP_(const Byte *) CMatchFinder::GetPointerToCurrentPos()
+  { return CLZInWindow::GetPointerToCurrentPos(); }
+
+STDMETHODIMP_(Int32) CMatchFinder::NeedChangeBufferPos(UInt32 numCheckBytes)
+  { return CLZInWindow::NeedMove(numCheckBytes) ? 1: 0; }
+
+STDMETHODIMP_(void) CMatchFinder::ChangeBufferPos()
+  { CLZInWindow::MoveBlock();}
+
+#undef HASH_CALC
+#undef kNumHashDirectBytes
+
+}
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/HashChain/HC4.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/HashChain/HC4.h
index 949863be5e..1fda4ac6ba 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/HashChain/HC4.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/HashChain/HC4.h
@@ -1,19 +1,19 @@
-// HC4.h

-

-#ifndef __HC4_H

-#define __HC4_H

-

-#define BT_NAMESPACE NHC4

-

-#define HASH_ARRAY_2

-#define HASH_ARRAY_3

-

-#include "HCMain.h"

-

-#undef HASH_ARRAY_2

-#undef HASH_ARRAY_3

-

-#undef BT_NAMESPACE

-

-#endif

-

+// HC4.h
+
+#ifndef __HC4_H
+#define __HC4_H
+
+#define BT_NAMESPACE NHC4
+
+#define HASH_ARRAY_2
+#define HASH_ARRAY_3
+
+#include "HCMain.h"
+
+#undef HASH_ARRAY_2
+#undef HASH_ARRAY_3
+
+#undef BT_NAMESPACE
+
+#endif
+
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/HashChain/HCMain.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/HashChain/HCMain.h
index fafce39797..d509befea0 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/HashChain/HCMain.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/HashChain/HCMain.h
@@ -1,6 +1,6 @@
-// HCMain.h

-

-#define _HASH_CHAIN

-#include "../BinTree/BinTreeMain.h"

-#undef _HASH_CHAIN

-

+// HCMain.h
+
+#define _HASH_CHAIN
+#include "../BinTree/BinTreeMain.h"
+#undef _HASH_CHAIN
+
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/IMatchFinder.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/IMatchFinder.h
index 4bbc14f35a..a589907dda 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/IMatchFinder.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/IMatchFinder.h
@@ -1,33 +1,33 @@
-// MatchFinders/IMatchFinder.h

-

-#ifndef __IMATCHFINDER_H

-#define __IMATCHFINDER_H

-

-struct IInWindowStream: public IUnknown

-{

-  STDMETHOD(SetStream)(ISequentialInStream *inStream) PURE;

-  STDMETHOD_(void, ReleaseStream)() PURE;

-  STDMETHOD(Init)() PURE;

-  STDMETHOD_(Byte, GetIndexByte)(Int32 index) PURE;

-  STDMETHOD_(UInt32, GetMatchLen)(Int32 index, UInt32 distance, UInt32 limit) PURE;

-  STDMETHOD_(UInt32, GetNumAvailableBytes)() PURE;

-  STDMETHOD_(const Byte *, GetPointerToCurrentPos)() PURE;

-  STDMETHOD_(Int32, NeedChangeBufferPos)(UInt32 numCheckBytes) PURE;

-  STDMETHOD_(void, ChangeBufferPos)() PURE;

-};

- 

-struct IMatchFinder: public IInWindowStream

-{

-  STDMETHOD(Create)(UInt32 historySize, UInt32 keepAddBufferBefore, 

-      UInt32 matchMaxLen, UInt32 keepAddBufferAfter) PURE;

-  STDMETHOD(GetMatches)(UInt32 *distances) PURE;

-  STDMETHOD(Skip)(UInt32 num) PURE;

-};

-

-struct IMatchFinderSetNumPasses

-{

-  //virtual ~IMatchFinderSetNumPasses(){}

-  virtual void SetNumPasses(UInt32 numPasses) PURE;

-};

-

-#endif

+// MatchFinders/IMatchFinder.h
+
+#ifndef __IMATCHFINDER_H
+#define __IMATCHFINDER_H
+
+struct IInWindowStream: public IUnknown
+{
+  STDMETHOD(SetStream)(ISequentialInStream *inStream) PURE;
+  STDMETHOD_(void, ReleaseStream)() PURE;
+  STDMETHOD(Init)() PURE;
+  STDMETHOD_(Byte, GetIndexByte)(Int32 index) PURE;
+  STDMETHOD_(UInt32, GetMatchLen)(Int32 index, UInt32 distance, UInt32 limit) PURE;
+  STDMETHOD_(UInt32, GetNumAvailableBytes)() PURE;
+  STDMETHOD_(const Byte *, GetPointerToCurrentPos)() PURE;
+  STDMETHOD_(Int32, NeedChangeBufferPos)(UInt32 numCheckBytes) PURE;
+  STDMETHOD_(void, ChangeBufferPos)() PURE;
+};
+
+struct IMatchFinder: public IInWindowStream
+{
+  STDMETHOD(Create)(UInt32 historySize, UInt32 keepAddBufferBefore,
+      UInt32 matchMaxLen, UInt32 keepAddBufferAfter) PURE;
+  STDMETHOD(GetMatches)(UInt32 *distances) PURE;
+  STDMETHOD(Skip)(UInt32 num) PURE;
+};
+
+struct IMatchFinderSetNumPasses
+{
+  //virtual ~IMatchFinderSetNumPasses(){}
+  virtual void SetNumPasses(UInt32 numPasses) PURE;
+};
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/LZInWindow.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/LZInWindow.h
index 87cb8e94fa..670a570378 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/LZInWindow.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/LZInWindow.h
@@ -1,87 +1,87 @@
-// LZInWindow.h

-

-#ifndef __LZ_IN_WINDOW_H

-#define __LZ_IN_WINDOW_H

-

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

-

-class CLZInWindow

-{

-  Byte *_bufferBase; // pointer to buffer with data

-  ISequentialInStream *_stream;

-  UInt32 _posLimit;  // offset (from _buffer) when new block reading must be done

-  bool _streamEndWasReached; // if (true) then _streamPos shows real end of stream

-  const Byte *_pointerToLastSafePosition;

-protected:

-  Byte  *_buffer;   // Pointer to virtual Buffer begin

-  UInt32 _blockSize;  // Size of Allocated memory block

-  UInt32 _pos;             // offset (from _buffer) of curent byte

-  UInt32 _keepSizeBefore;  // how many BYTEs must be kept in buffer before _pos

-  UInt32 _keepSizeAfter;   // how many BYTEs must be kept buffer after _pos

-  UInt32 _streamPos;   // offset (from _buffer) of first not read byte from Stream

-

-  void MoveBlock();

-  HRESULT ReadBlock();

-  void Free();

-public:

-  CLZInWindow(): _bufferBase(0) {}

-  virtual ~CLZInWindow() { Free(); }

-

-  // keepSizeBefore + keepSizeAfter + keepSizeReserv < 4G)

-  bool Create(UInt32 keepSizeBefore, UInt32 keepSizeAfter, UInt32 keepSizeReserv = (1<<17));

-

-  void SetStream(ISequentialInStream *stream);

-  HRESULT Init();

-  // void ReleaseStream();

-

-  Byte *GetBuffer() const { return _buffer; }

-

-  const Byte *GetPointerToCurrentPos() const { return _buffer + _pos; }

-

-  HRESULT MovePos()

-  {

-    _pos++;

-    if (_pos > _posLimit)

-    {

-      const Byte *pointerToPostion = _buffer + _pos;

-      if(pointerToPostion > _pointerToLastSafePosition)

-        MoveBlock();

-      return ReadBlock();

-    }

-    else

-      return S_OK;

-  }

-  Byte GetIndexByte(Int32 index) const  {  return _buffer[(size_t)_pos + index]; }

-

-  // index + limit have not to exceed _keepSizeAfter;

-  // -2G <= index < 2G

-  UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit) const

-  {  

-    if(_streamEndWasReached)

-      if ((_pos + index) + limit > _streamPos)

-        limit = _streamPos - (_pos + index);

-    distance++;

-    const Byte *pby = _buffer + (size_t)_pos + index;

-    UInt32 i;

-    for(i = 0; i < limit && pby[i] == pby[(size_t)i - distance]; i++);

-    return i;

-  }

-

-  UInt32 GetNumAvailableBytes() const { return _streamPos - _pos; }

-

-  void ReduceOffsets(Int32 subValue)

-  {

-    _buffer += subValue;

-    _posLimit -= subValue;

-    _pos -= subValue;

-    _streamPos -= subValue;

-  }

-

-  bool NeedMove(UInt32 numCheckBytes)

-  {

-    UInt32 reserv = _pointerToLastSafePosition - (_buffer + _pos);

-    return (reserv <= numCheckBytes);

-  }

-};

-

-#endif

+// LZInWindow.h
+
+#ifndef __LZ_IN_WINDOW_H
+#define __LZ_IN_WINDOW_H
+
+#include "../../IStream.h"
+
+class CLZInWindow
+{
+  Byte *_bufferBase; // pointer to buffer with data
+  ISequentialInStream *_stream;
+  UInt32 _posLimit;  // offset (from _buffer) when new block reading must be done
+  bool _streamEndWasReached; // if (true) then _streamPos shows real end of stream
+  const Byte *_pointerToLastSafePosition;
+protected:
+  Byte  *_buffer;   // Pointer to virtual Buffer begin
+  UInt32 _blockSize;  // Size of Allocated memory block
+  UInt32 _pos;             // offset (from _buffer) of curent byte
+  UInt32 _keepSizeBefore;  // how many BYTEs must be kept in buffer before _pos
+  UInt32 _keepSizeAfter;   // how many BYTEs must be kept buffer after _pos
+  UInt32 _streamPos;   // offset (from _buffer) of first not read byte from Stream
+
+  void MoveBlock();
+  HRESULT ReadBlock();
+  void Free();
+public:
+  CLZInWindow(): _bufferBase(0) {}
+  virtual ~CLZInWindow() { Free(); }
+
+  // keepSizeBefore + keepSizeAfter + keepSizeReserv < 4G)
+  bool Create(UInt32 keepSizeBefore, UInt32 keepSizeAfter, UInt32 keepSizeReserv = (1<<17));
+
+  void SetStream(ISequentialInStream *stream);
+  HRESULT Init();
+  // void ReleaseStream();
+
+  Byte *GetBuffer() const { return _buffer; }
+
+  const Byte *GetPointerToCurrentPos() const { return _buffer + _pos; }
+
+  HRESULT MovePos()
+  {
+    _pos++;
+    if (_pos > _posLimit)
+    {
+      const Byte *pointerToPostion = _buffer + _pos;
+      if(pointerToPostion > _pointerToLastSafePosition)
+        MoveBlock();
+      return ReadBlock();
+    }
+    else
+      return S_OK;
+  }
+  Byte GetIndexByte(Int32 index) const  {  return _buffer[(size_t)_pos + index]; }
+
+  // index + limit have not to exceed _keepSizeAfter;
+  // -2G <= index < 2G
+  UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit) const
+  {
+    if(_streamEndWasReached)
+      if ((_pos + index) + limit > _streamPos)
+        limit = _streamPos - (_pos + index);
+    distance++;
+    const Byte *pby = _buffer + (size_t)_pos + index;
+    UInt32 i;
+    for(i = 0; i < limit && pby[i] == pby[(size_t)i - distance]; i++);
+    return i;
+  }
+
+  UInt32 GetNumAvailableBytes() const { return _streamPos - _pos; }
+
+  void ReduceOffsets(Int32 subValue)
+  {
+    _buffer += subValue;
+    _posLimit -= subValue;
+    _pos -= subValue;
+    _streamPos -= subValue;
+  }
+
+  bool NeedMove(UInt32 numCheckBytes)
+  {
+    UInt32 reserv = _pointerToLastSafePosition - (_buffer + _pos);
+    return (reserv <= numCheckBytes);
+  }
+};
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/StdAfx.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/StdAfx.h
index 3de038a4ff..b637fd4007 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/StdAfx.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZ/StdAfx.h
@@ -1,6 +1,6 @@
-// StdAfx.h

-

-#ifndef __STDAFX_H

-#define __STDAFX_H

-

-#endif 

+// StdAfx.h
+
+#ifndef __STDAFX_H
+#define __STDAFX_H
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZMA/LZMA.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZMA/LZMA.h
index d53296ee70..e262aa2af2 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZMA/LZMA.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZMA/LZMA.h
@@ -1,82 +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

+// 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/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZMA/LZMAEncoder.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZMA/LZMAEncoder.h
index 55ac80c07c..2a41948495 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZMA/LZMAEncoder.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZMA/LZMAEncoder.h
@@ -1,411 +1,411 @@
-// LZMA/Encoder.h

-

-#ifndef __LZMA_ENCODER_H

-#define __LZMA_ENCODER_H

-

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

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

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

-#include "../LZ/IMatchFinder.h"

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

-

-#include "LZMA.h"

-

-namespace NCompress {

-namespace NLZMA {

-

-typedef NRangeCoder::CBitEncoder<kNumMoveBits> CMyBitEncoder;

-

-class CBaseState

-{

-protected:

-  CState _state;

-  Byte _previousByte;

-  UInt32 _repDistances[kNumRepDistances];

-  void Init()

-  {

-    _state.Init();

-    _previousByte = 0;

-    for(UInt32 i = 0 ; i < kNumRepDistances; i++)

-      _repDistances[i] = 0;

-  }

-};

-

-struct COptimal

-{

-  CState State;

-

-  bool Prev1IsChar;

-  bool Prev2;

-

-  UInt32 PosPrev2;

-  UInt32 BackPrev2;     

-

-  UInt32 Price;    

-  UInt32 PosPrev;         // posNext;

-  UInt32 BackPrev;     

-  UInt32 Backs[kNumRepDistances];

-  void MakeAsChar() { BackPrev = UInt32(-1); Prev1IsChar = false; }

-  void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; }

-  bool IsShortRep() { return (BackPrev == 0); }

-};

-

-

-extern Byte g_FastPos[1 << 11];

-inline UInt32 GetPosSlot(UInt32 pos)

-{

-  if (pos < (1 << 11))

-    return g_FastPos[pos];

-  if (pos < (1 << 21))

-    return g_FastPos[pos >> 10] + 20;

-  return g_FastPos[pos >> 20] + 40;

-}

-

-inline UInt32 GetPosSlot2(UInt32 pos)

-{

-  if (pos < (1 << 17))

-    return g_FastPos[pos >> 6] + 12;

-  if (pos < (1 << 27))

-    return g_FastPos[pos >> 16] + 32;

-  return g_FastPos[pos >> 26] + 52;

-}

-

-const UInt32 kIfinityPrice = 0xFFFFFFF;

-

-const UInt32 kNumOpts = 1 << 12;

-

-

-class CLiteralEncoder2

-{

-  CMyBitEncoder _encoders[0x300];

-public:

-  void Init()

-  {

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

-      _encoders[i].Init();

-  }

-  void Encode(NRangeCoder::CEncoder *rangeEncoder, Byte symbol);

-  void EncodeMatched(NRangeCoder::CEncoder *rangeEncoder, Byte matchByte, Byte symbol);

-  UInt32 GetPrice(bool matchMode, Byte matchByte, Byte symbol) const;

-};

-

-class CLiteralEncoder

-{

-  CLiteralEncoder2 *_coders;

-  int _numPrevBits;

-  int _numPosBits;

-  UInt32 _posMask;

-public:

-  CLiteralEncoder(): _coders(0) {}

-  ~CLiteralEncoder()  { 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 = (CLiteralEncoder2 *)MyAlloc(numStates * sizeof(CLiteralEncoder2));

-    }

-    _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();

-  }

-  CLiteralEncoder2 *GetSubCoder(UInt32 pos, Byte prevByte)

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

-};

-

-namespace NLength {

-

-class CEncoder

-{

-  CMyBitEncoder _choice;

-  CMyBitEncoder _choice2;

-  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumLowBits> _lowCoder[kNumPosStatesEncodingMax];

-  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumMidBits> _midCoder[kNumPosStatesEncodingMax];

-  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumHighBits> _highCoder;

-public:

-  void Init(UInt32 numPosStates);

-  void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState);

-  void SetPrices(UInt32 posState, UInt32 numSymbols, UInt32 *prices) const;

-};

-

-const UInt32 kNumSpecSymbols = kNumLowSymbols + kNumMidSymbols;

-

-class CPriceTableEncoder: public CEncoder

-{

-  UInt32 _prices[kNumPosStatesEncodingMax][kNumSymbolsTotal];

-  UInt32 _tableSize;

-  UInt32 _counters[kNumPosStatesEncodingMax];

-public:

-  void SetTableSize(UInt32 tableSize) { _tableSize = tableSize;  }

-  UInt32 GetPrice(UInt32 symbol, UInt32 posState) const { return _prices[posState][symbol]; }

-  void UpdateTable(UInt32 posState)

-  {

-    SetPrices(posState, _tableSize, _prices[posState]);

-    _counters[posState] = _tableSize;

-  }

-  void UpdateTables(UInt32 numPosStates)

-  {

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

-      UpdateTable(posState);

-  }

-  void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState, bool updatePrice)

-  {

-    CEncoder::Encode(rangeEncoder, symbol, posState);

-    if (updatePrice)

-      if (--_counters[posState] == 0)

-        UpdateTable(posState);

-  }

-};

-

-}

-

-class CEncoder : 

-  public ICompressCoder,

-  public ICompressSetOutStream,

-  public ICompressSetCoderProperties,

-  public ICompressWriteCoderProperties,

-  public CBaseState,

-  public CMyUnknownImp

-{

-  COptimal _optimum[kNumOpts];

-  CMyComPtr<IMatchFinder> _matchFinder; // test it

-  NRangeCoder::CEncoder _rangeEncoder;

-

-  CMyBitEncoder _isMatch[kNumStates][NLength::kNumPosStatesEncodingMax];

-  CMyBitEncoder _isRep[kNumStates];

-  CMyBitEncoder _isRepG0[kNumStates];

-  CMyBitEncoder _isRepG1[kNumStates];

-  CMyBitEncoder _isRepG2[kNumStates];

-  CMyBitEncoder _isRep0Long[kNumStates][NLength::kNumPosStatesEncodingMax];

-

-  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumPosSlotBits> _posSlotEncoder[kNumLenToPosStates];

-

-  CMyBitEncoder _posEncoders[kNumFullDistances - kEndPosModelIndex];

-  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumAlignBits> _posAlignEncoder;

-  

-  NLength::CPriceTableEncoder _lenEncoder;

-  NLength::CPriceTableEncoder _repMatchLenEncoder;

-

-  CLiteralEncoder _literalEncoder;

-

-  UInt32 _matchDistances[kMatchMaxLen * 2 + 2 + 1];

-

-  bool _fastMode;

-  // bool _maxMode;

-  UInt32 _numFastBytes;

-  UInt32 _longestMatchLength;    

-  UInt32 _numDistancePairs;

-

-  UInt32 _additionalOffset;

-

-  UInt32 _optimumEndIndex;

-  UInt32 _optimumCurrentIndex;

-

-  bool _longestMatchWasFound;

-

-  UInt32 _posSlotPrices[kNumLenToPosStates][kDistTableSizeMax];

-  

-  UInt32 _distancesPrices[kNumLenToPosStates][kNumFullDistances];

-

-  UInt32 _alignPrices[kAlignTableSize];

-  UInt32 _alignPriceCount;

-

-  UInt32 _distTableSize;

-

-  UInt32 _posStateBits;

-  UInt32 _posStateMask;

-  UInt32 _numLiteralPosStateBits;

-  UInt32 _numLiteralContextBits;

-

-  UInt32 _dictionarySize;

-

-  UInt32 _dictionarySizePrev;

-  UInt32 _numFastBytesPrev;

-

-  UInt32 _matchPriceCount;

-  UInt64 nowPos64;

-  bool _finished;

-  ISequentialInStream *_inStream;

-

-  UInt32 _matchFinderCycles;

-  int _matchFinderIndex;

-  #ifdef COMPRESS_MF_MT

-  bool _multiThread;

-  #endif

-

-  bool _writeEndMark;

-

-  bool _needReleaseMFStream;

-

-  IMatchFinderSetNumPasses *setMfPasses;

-

-  void ReleaseMatchFinder()

-  {

-    setMfPasses = 0;

-    _matchFinder.Release();

-  }

-  

-  HRESULT ReadMatchDistances(UInt32 &len, UInt32 &numDistancePairs);

-

-  HRESULT MovePos(UInt32 num);

-  UInt32 GetRepLen1Price(CState state, UInt32 posState) const

-  {

-    return _isRepG0[state.Index].GetPrice0() +

-        _isRep0Long[state.Index][posState].GetPrice0();

-  }

-  

-  UInt32 GetPureRepPrice(UInt32 repIndex, CState state, UInt32 posState) const

-  {

-    UInt32 price;

-    if(repIndex == 0)

-    {

-      price = _isRepG0[state.Index].GetPrice0();

-      price += _isRep0Long[state.Index][posState].GetPrice1();

-    }

-    else

-    {

-      price = _isRepG0[state.Index].GetPrice1();

-      if (repIndex == 1)

-        price += _isRepG1[state.Index].GetPrice0();

-      else

-      {

-        price += _isRepG1[state.Index].GetPrice1();

-        price += _isRepG2[state.Index].GetPrice(repIndex - 2);

-      }

-    }

-    return price;

-  }

-  UInt32 GetRepPrice(UInt32 repIndex, UInt32 len, CState state, UInt32 posState) const

-  {

-    return _repMatchLenEncoder.GetPrice(len - kMatchMinLen, posState) +

-        GetPureRepPrice(repIndex, state, posState);

-  }

-  /*

-  UInt32 GetPosLen2Price(UInt32 pos, UInt32 posState) const

-  {

-    if (pos >= kNumFullDistances)

-      return kIfinityPrice;

-    return _distancesPrices[0][pos] + _lenEncoder.GetPrice(0, posState);

-  }

-  UInt32 GetPosLen3Price(UInt32 pos, UInt32 len, UInt32 posState) const

-  {

-    UInt32 price;

-    UInt32 lenToPosState = GetLenToPosState(len);

-    if (pos < kNumFullDistances)

-      price = _distancesPrices[lenToPosState][pos];

-    else

-      price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] + 

-          _alignPrices[pos & kAlignMask];

-    return price + _lenEncoder.GetPrice(len - kMatchMinLen, posState);

-  }

-  */

-  UInt32 GetPosLenPrice(UInt32 pos, UInt32 len, UInt32 posState) const

-  {

-    UInt32 price;

-    UInt32 lenToPosState = GetLenToPosState(len);

-    if (pos < kNumFullDistances)

-      price = _distancesPrices[lenToPosState][pos];

-    else

-      price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] + 

-          _alignPrices[pos & kAlignMask];

-    return price + _lenEncoder.GetPrice(len - kMatchMinLen, posState);

-  }

-

-  UInt32 Backward(UInt32 &backRes, UInt32 cur);

-  HRESULT GetOptimum(UInt32 position, UInt32 &backRes, UInt32 &lenRes);

-  HRESULT GetOptimumFast(UInt32 position, UInt32 &backRes, UInt32 &lenRes);

-

-  void FillDistancesPrices();

-  void FillAlignPrices();

-    

-  void ReleaseMFStream()

-  {

-    if (_matchFinder && _needReleaseMFStream)

-    {

-      _matchFinder->ReleaseStream();

-      _needReleaseMFStream = false;

-    }

-  }

-

-  void ReleaseStreams()

-  {

-    ReleaseMFStream();

-    ReleaseOutStream();

-  }

-

-  HRESULT Flush(UInt32 nowPos);

-  class CCoderReleaser

-  {

-    CEncoder *_coder;

-  public:

-    CCoderReleaser(CEncoder *coder): _coder(coder) {}

-    ~CCoderReleaser()

-    {

-      _coder->ReleaseStreams();

-    }

-  };

-  friend class CCoderReleaser;

-

-  void WriteEndMarker(UInt32 posState);

-

-public:

-  CEncoder();

-  void SetWriteEndMarkerMode(bool writeEndMarker)

-    { _writeEndMark= writeEndMarker; }

-

-  HRESULT Create();

-

-  MY_UNKNOWN_IMP3(

-      ICompressSetOutStream,

-      ICompressSetCoderProperties,

-      ICompressWriteCoderProperties

-      )

-    

-  HRESULT Init();

-  

-  // ICompressCoder interface

-  HRESULT SetStreams(ISequentialInStream *inStream,

-      ISequentialOutStream *outStream,

-      const UInt64 *inSize, const UInt64 *outSize);

-  HRESULT CodeOneBlock(UInt64 *inSize, UInt64 *outSize, Int32 *finished);

-

-  HRESULT CodeReal(ISequentialInStream *inStream,

-      ISequentialOutStream *outStream, 

-      const UInt64 *inSize, const UInt64 *outSize,

-      ICompressProgressInfo *progress);

-

-  // ICompressCoder interface

-  STDMETHOD(Code)(ISequentialInStream *inStream,

-      ISequentialOutStream *outStream, 

-      const UInt64 *inSize, const UInt64 *outSize,

-      ICompressProgressInfo *progress);

-

-  // ICompressSetCoderProperties2

-  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, 

-      const PROPVARIANT *properties, UInt32 numProperties);

-  

-  // ICompressWriteCoderProperties

-  STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);

-

-  STDMETHOD(SetOutStream)(ISequentialOutStream *outStream);

-  STDMETHOD(ReleaseOutStream)();

-

-  virtual ~CEncoder() {}

-};

-

-}}

-

-#endif

+// LZMA/Encoder.h
+
+#ifndef __LZMA_ENCODER_H
+#define __LZMA_ENCODER_H
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/Alloc.h"
+#include "../../ICoder.h"
+#include "../LZ/IMatchFinder.h"
+#include "../RangeCoder/RangeCoderBitTree.h"
+
+#include "LZMA.h"
+
+namespace NCompress {
+namespace NLZMA {
+
+typedef NRangeCoder::CBitEncoder<kNumMoveBits> CMyBitEncoder;
+
+class CBaseState
+{
+protected:
+  CState _state;
+  Byte _previousByte;
+  UInt32 _repDistances[kNumRepDistances];
+  void Init()
+  {
+    _state.Init();
+    _previousByte = 0;
+    for(UInt32 i = 0 ; i < kNumRepDistances; i++)
+      _repDistances[i] = 0;
+  }
+};
+
+struct COptimal
+{
+  CState State;
+
+  bool Prev1IsChar;
+  bool Prev2;
+
+  UInt32 PosPrev2;
+  UInt32 BackPrev2;
+
+  UInt32 Price;
+  UInt32 PosPrev;         // posNext;
+  UInt32 BackPrev;
+  UInt32 Backs[kNumRepDistances];
+  void MakeAsChar() { BackPrev = UInt32(-1); Prev1IsChar = false; }
+  void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; }
+  bool IsShortRep() { return (BackPrev == 0); }
+};
+
+
+extern Byte g_FastPos[1 << 11];
+inline UInt32 GetPosSlot(UInt32 pos)
+{
+  if (pos < (1 << 11))
+    return g_FastPos[pos];
+  if (pos < (1 << 21))
+    return g_FastPos[pos >> 10] + 20;
+  return g_FastPos[pos >> 20] + 40;
+}
+
+inline UInt32 GetPosSlot2(UInt32 pos)
+{
+  if (pos < (1 << 17))
+    return g_FastPos[pos >> 6] + 12;
+  if (pos < (1 << 27))
+    return g_FastPos[pos >> 16] + 32;
+  return g_FastPos[pos >> 26] + 52;
+}
+
+const UInt32 kIfinityPrice = 0xFFFFFFF;
+
+const UInt32 kNumOpts = 1 << 12;
+
+
+class CLiteralEncoder2
+{
+  CMyBitEncoder _encoders[0x300];
+public:
+  void Init()
+  {
+    for (int i = 0; i < 0x300; i++)
+      _encoders[i].Init();
+  }
+  void Encode(NRangeCoder::CEncoder *rangeEncoder, Byte symbol);
+  void EncodeMatched(NRangeCoder::CEncoder *rangeEncoder, Byte matchByte, Byte symbol);
+  UInt32 GetPrice(bool matchMode, Byte matchByte, Byte symbol) const;
+};
+
+class CLiteralEncoder
+{
+  CLiteralEncoder2 *_coders;
+  int _numPrevBits;
+  int _numPosBits;
+  UInt32 _posMask;
+public:
+  CLiteralEncoder(): _coders(0) {}
+  ~CLiteralEncoder()  { 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 = (CLiteralEncoder2 *)MyAlloc(numStates * sizeof(CLiteralEncoder2));
+    }
+    _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();
+  }
+  CLiteralEncoder2 *GetSubCoder(UInt32 pos, Byte prevByte)
+    { return &_coders[((pos & _posMask) << _numPrevBits) + (prevByte >> (8 - _numPrevBits))]; }
+};
+
+namespace NLength {
+
+class CEncoder
+{
+  CMyBitEncoder _choice;
+  CMyBitEncoder _choice2;
+  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumLowBits> _lowCoder[kNumPosStatesEncodingMax];
+  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumMidBits> _midCoder[kNumPosStatesEncodingMax];
+  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumHighBits> _highCoder;
+public:
+  void Init(UInt32 numPosStates);
+  void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState);
+  void SetPrices(UInt32 posState, UInt32 numSymbols, UInt32 *prices) const;
+};
+
+const UInt32 kNumSpecSymbols = kNumLowSymbols + kNumMidSymbols;
+
+class CPriceTableEncoder: public CEncoder
+{
+  UInt32 _prices[kNumPosStatesEncodingMax][kNumSymbolsTotal];
+  UInt32 _tableSize;
+  UInt32 _counters[kNumPosStatesEncodingMax];
+public:
+  void SetTableSize(UInt32 tableSize) { _tableSize = tableSize;  }
+  UInt32 GetPrice(UInt32 symbol, UInt32 posState) const { return _prices[posState][symbol]; }
+  void UpdateTable(UInt32 posState)
+  {
+    SetPrices(posState, _tableSize, _prices[posState]);
+    _counters[posState] = _tableSize;
+  }
+  void UpdateTables(UInt32 numPosStates)
+  {
+    for (UInt32 posState = 0; posState < numPosStates; posState++)
+      UpdateTable(posState);
+  }
+  void Encode(NRangeCoder::CEncoder *rangeEncoder, UInt32 symbol, UInt32 posState, bool updatePrice)
+  {
+    CEncoder::Encode(rangeEncoder, symbol, posState);
+    if (updatePrice)
+      if (--_counters[posState] == 0)
+        UpdateTable(posState);
+  }
+};
+
+}
+
+class CEncoder :
+  public ICompressCoder,
+  public ICompressSetOutStream,
+  public ICompressSetCoderProperties,
+  public ICompressWriteCoderProperties,
+  public CBaseState,
+  public CMyUnknownImp
+{
+  COptimal _optimum[kNumOpts];
+  CMyComPtr<IMatchFinder> _matchFinder; // test it
+  NRangeCoder::CEncoder _rangeEncoder;
+
+  CMyBitEncoder _isMatch[kNumStates][NLength::kNumPosStatesEncodingMax];
+  CMyBitEncoder _isRep[kNumStates];
+  CMyBitEncoder _isRepG0[kNumStates];
+  CMyBitEncoder _isRepG1[kNumStates];
+  CMyBitEncoder _isRepG2[kNumStates];
+  CMyBitEncoder _isRep0Long[kNumStates][NLength::kNumPosStatesEncodingMax];
+
+  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumPosSlotBits> _posSlotEncoder[kNumLenToPosStates];
+
+  CMyBitEncoder _posEncoders[kNumFullDistances - kEndPosModelIndex];
+  NRangeCoder::CBitTreeEncoder<kNumMoveBits, kNumAlignBits> _posAlignEncoder;
+
+  NLength::CPriceTableEncoder _lenEncoder;
+  NLength::CPriceTableEncoder _repMatchLenEncoder;
+
+  CLiteralEncoder _literalEncoder;
+
+  UInt32 _matchDistances[kMatchMaxLen * 2 + 2 + 1];
+
+  bool _fastMode;
+  // bool _maxMode;
+  UInt32 _numFastBytes;
+  UInt32 _longestMatchLength;
+  UInt32 _numDistancePairs;
+
+  UInt32 _additionalOffset;
+
+  UInt32 _optimumEndIndex;
+  UInt32 _optimumCurrentIndex;
+
+  bool _longestMatchWasFound;
+
+  UInt32 _posSlotPrices[kNumLenToPosStates][kDistTableSizeMax];
+
+  UInt32 _distancesPrices[kNumLenToPosStates][kNumFullDistances];
+
+  UInt32 _alignPrices[kAlignTableSize];
+  UInt32 _alignPriceCount;
+
+  UInt32 _distTableSize;
+
+  UInt32 _posStateBits;
+  UInt32 _posStateMask;
+  UInt32 _numLiteralPosStateBits;
+  UInt32 _numLiteralContextBits;
+
+  UInt32 _dictionarySize;
+
+  UInt32 _dictionarySizePrev;
+  UInt32 _numFastBytesPrev;
+
+  UInt32 _matchPriceCount;
+  UInt64 nowPos64;
+  bool _finished;
+  ISequentialInStream *_inStream;
+
+  UInt32 _matchFinderCycles;
+  int _matchFinderIndex;
+  #ifdef COMPRESS_MF_MT
+  bool _multiThread;
+  #endif
+
+  bool _writeEndMark;
+
+  bool _needReleaseMFStream;
+
+  IMatchFinderSetNumPasses *setMfPasses;
+
+  void ReleaseMatchFinder()
+  {
+    setMfPasses = 0;
+    _matchFinder.Release();
+  }
+
+  HRESULT ReadMatchDistances(UInt32 &len, UInt32 &numDistancePairs);
+
+  HRESULT MovePos(UInt32 num);
+  UInt32 GetRepLen1Price(CState state, UInt32 posState) const
+  {
+    return _isRepG0[state.Index].GetPrice0() +
+        _isRep0Long[state.Index][posState].GetPrice0();
+  }
+
+  UInt32 GetPureRepPrice(UInt32 repIndex, CState state, UInt32 posState) const
+  {
+    UInt32 price;
+    if(repIndex == 0)
+    {
+      price = _isRepG0[state.Index].GetPrice0();
+      price += _isRep0Long[state.Index][posState].GetPrice1();
+    }
+    else
+    {
+      price = _isRepG0[state.Index].GetPrice1();
+      if (repIndex == 1)
+        price += _isRepG1[state.Index].GetPrice0();
+      else
+      {
+        price += _isRepG1[state.Index].GetPrice1();
+        price += _isRepG2[state.Index].GetPrice(repIndex - 2);
+      }
+    }
+    return price;
+  }
+  UInt32 GetRepPrice(UInt32 repIndex, UInt32 len, CState state, UInt32 posState) const
+  {
+    return _repMatchLenEncoder.GetPrice(len - kMatchMinLen, posState) +
+        GetPureRepPrice(repIndex, state, posState);
+  }
+  /*
+  UInt32 GetPosLen2Price(UInt32 pos, UInt32 posState) const
+  {
+    if (pos >= kNumFullDistances)
+      return kIfinityPrice;
+    return _distancesPrices[0][pos] + _lenEncoder.GetPrice(0, posState);
+  }
+  UInt32 GetPosLen3Price(UInt32 pos, UInt32 len, UInt32 posState) const
+  {
+    UInt32 price;
+    UInt32 lenToPosState = GetLenToPosState(len);
+    if (pos < kNumFullDistances)
+      price = _distancesPrices[lenToPosState][pos];
+    else
+      price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] +
+          _alignPrices[pos & kAlignMask];
+    return price + _lenEncoder.GetPrice(len - kMatchMinLen, posState);
+  }
+  */
+  UInt32 GetPosLenPrice(UInt32 pos, UInt32 len, UInt32 posState) const
+  {
+    UInt32 price;
+    UInt32 lenToPosState = GetLenToPosState(len);
+    if (pos < kNumFullDistances)
+      price = _distancesPrices[lenToPosState][pos];
+    else
+      price = _posSlotPrices[lenToPosState][GetPosSlot2(pos)] +
+          _alignPrices[pos & kAlignMask];
+    return price + _lenEncoder.GetPrice(len - kMatchMinLen, posState);
+  }
+
+  UInt32 Backward(UInt32 &backRes, UInt32 cur);
+  HRESULT GetOptimum(UInt32 position, UInt32 &backRes, UInt32 &lenRes);
+  HRESULT GetOptimumFast(UInt32 position, UInt32 &backRes, UInt32 &lenRes);
+
+  void FillDistancesPrices();
+  void FillAlignPrices();
+
+  void ReleaseMFStream()
+  {
+    if (_matchFinder && _needReleaseMFStream)
+    {
+      _matchFinder->ReleaseStream();
+      _needReleaseMFStream = false;
+    }
+  }
+
+  void ReleaseStreams()
+  {
+    ReleaseMFStream();
+    ReleaseOutStream();
+  }
+
+  HRESULT Flush(UInt32 nowPos);
+  class CCoderReleaser
+  {
+    CEncoder *_coder;
+  public:
+    CCoderReleaser(CEncoder *coder): _coder(coder) {}
+    ~CCoderReleaser()
+    {
+      _coder->ReleaseStreams();
+    }
+  };
+  friend class CCoderReleaser;
+
+  void WriteEndMarker(UInt32 posState);
+
+public:
+  CEncoder();
+  void SetWriteEndMarkerMode(bool writeEndMarker)
+    { _writeEndMark= writeEndMarker; }
+
+  HRESULT Create();
+
+  MY_UNKNOWN_IMP3(
+      ICompressSetOutStream,
+      ICompressSetCoderProperties,
+      ICompressWriteCoderProperties
+      )
+
+  HRESULT Init();
+
+  // ICompressCoder interface
+  HRESULT SetStreams(ISequentialInStream *inStream,
+      ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize);
+  HRESULT CodeOneBlock(UInt64 *inSize, UInt64 *outSize, Int32 *finished);
+
+  HRESULT CodeReal(ISequentialInStream *inStream,
+      ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize,
+      ICompressProgressInfo *progress);
+
+  // ICompressCoder interface
+  STDMETHOD(Code)(ISequentialInStream *inStream,
+      ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize,
+      ICompressProgressInfo *progress);
+
+  // ICompressSetCoderProperties2
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs,
+      const PROPVARIANT *properties, UInt32 numProperties);
+
+  // ICompressWriteCoderProperties
+  STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
+
+  STDMETHOD(SetOutStream)(ISequentialOutStream *outStream);
+  STDMETHOD(ReleaseOutStream)();
+
+  virtual ~CEncoder() {}
+};
+
+}}
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZMA/StdAfx.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZMA/StdAfx.h
index 83fdd22d58..e7fb6986d2 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZMA/StdAfx.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/LZMA/StdAfx.h
@@ -1,8 +1,8 @@
-// StdAfx.h

-

-#ifndef __STDAFX_H

-#define __STDAFX_H

-

-#include "../../../Common/MyWindows.h"

-

-#endif

+// StdAfx.h
+
+#ifndef __STDAFX_H
+#define __STDAFX_H
+
+#include "../../../Common/MyWindows.h"
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoder.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoder.h
index 9828bc4b94..d77442be45 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoder.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoder.h
@@ -1,205 +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

+// 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/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoderBit.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoderBit.h
index 64538e6879..624f887c94 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoderBit.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoderBit.h
@@ -1,120 +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

+// 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/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoderBitTree.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoderBitTree.h
index 1fa023f3b8..461e2f049f 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoderBitTree.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoderBitTree.h
@@ -1,161 +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

+// 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/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoderOpt.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoderOpt.h
index 829fc83d77..5779277635 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoderOpt.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/RangeCoderOpt.h
@@ -1,31 +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

+// 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
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/StdAfx.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/StdAfx.h
index 21c2fd780c..b637fd4007 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/StdAfx.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/Compress/RangeCoder/StdAfx.h
@@ -1,6 +1,6 @@
-// StdAfx.h

-

-#ifndef __STDAFX_H

-#define __STDAFX_H

-

-#endif

+// StdAfx.h
+
+#ifndef __STDAFX_H
+#define __STDAFX_H
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/ICoder.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/ICoder.h
index 508dac3fd0..3d1d8f01c9 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/ICoder.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/ICoder.h
@@ -1,163 +1,163 @@
-// ICoder.h

-

-#ifndef __ICODER_H

-#define __ICODER_H

-

-#include "IStream.h"

-

-// "23170F69-40C1-278A-0000-000400xx0000"

-#define CODER_INTERFACE(i, x) \

-DEFINE_GUID(IID_ ## i, \

-0x23170F69, 0x40C1, 0x278A, 0x00, 0x00, 0x00, 0x04, 0x00, x, 0x00, 0x00); \

-struct i: public IUnknown

-

-CODER_INTERFACE(ICompressProgressInfo, 0x04)

-{

-  STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize) PURE;

-};

-

-CODER_INTERFACE(ICompressCoder, 0x05)

-{

-  STDMETHOD(Code)(ISequentialInStream *inStream,

-      ISequentialOutStream *outStream, 

-      const UInt64 *inSize, 

-      const UInt64 *outSize,

-      ICompressProgressInfo *progress) PURE;

-};

-

-CODER_INTERFACE(ICompressCoder2, 0x18)

-{

-  STDMETHOD(Code)(ISequentialInStream **inStreams,

-      const UInt64 **inSizes, 

-      UInt32 numInStreams,

-      ISequentialOutStream **outStreams, 

-      const UInt64 **outSizes,

-      UInt32 numOutStreams,

-      ICompressProgressInfo *progress) PURE;

-};

-

-namespace NCoderPropID

-{

-  enum EEnum

-  {

-    kDictionarySize = 0x400,

-    kUsedMemorySize,

-    kOrder,

-    kPosStateBits = 0x440,

-    kLitContextBits,

-    kLitPosBits,

-    kNumFastBytes = 0x450,

-    kMatchFinder,

-    kMatchFinderCycles,

-    kNumPasses = 0x460, 

-    kAlgorithm = 0x470,

-    kMultiThread = 0x480,

-    kNumThreads,

-    kEndMarker = 0x490

-  };

-}

-

-CODER_INTERFACE(ICompressSetCoderProperties, 0x20)

-{

-  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, 

-      const PROPVARIANT *properties, UInt32 numProperties) PURE;

-};

-

-/*

-CODER_INTERFACE(ICompressSetCoderProperties, 0x21)

-{

-  STDMETHOD(SetDecoderProperties)(ISequentialInStream *inStream) PURE;

-};

-*/

-

-CODER_INTERFACE(ICompressSetDecoderProperties2, 0x22)

-{

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

-};

-

-CODER_INTERFACE(ICompressWriteCoderProperties, 0x23)

-{

-  STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStreams) PURE;

-};

-

-CODER_INTERFACE(ICompressGetInStreamProcessedSize, 0x24)

-{

-  STDMETHOD(GetInStreamProcessedSize)(UInt64 *value) PURE;

-};

-

-CODER_INTERFACE(ICompressSetCoderMt, 0x25)

-{

-  STDMETHOD(SetNumberOfThreads)(UInt32 numThreads) PURE;

-};

-

-CODER_INTERFACE(ICompressGetSubStreamSize, 0x30)

-{

-  STDMETHOD(GetSubStreamSize)(UInt64 subStream, UInt64 *value) PURE;

-};

-

-CODER_INTERFACE(ICompressSetInStream, 0x31)

-{

-  STDMETHOD(SetInStream)(ISequentialInStream *inStream) PURE;

-  STDMETHOD(ReleaseInStream)() PURE;

-};

-

-CODER_INTERFACE(ICompressSetOutStream, 0x32)

-{

-  STDMETHOD(SetOutStream)(ISequentialOutStream *outStream) PURE;

-  STDMETHOD(ReleaseOutStream)() PURE;

-};

-

-CODER_INTERFACE(ICompressSetInStreamSize, 0x33)

-{

-  STDMETHOD(SetInStreamSize)(const UInt64 *inSize) PURE;

-};

-

-CODER_INTERFACE(ICompressSetOutStreamSize, 0x34)

-{

-  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize) PURE;

-};

-

-CODER_INTERFACE(ICompressFilter, 0x40)

-{

-  STDMETHOD(Init)() PURE;

-  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size) PURE;

-  // Filter return outSize (UInt32)

-  // if (outSize <= size): Filter have converted outSize bytes

-  // if (outSize > size): Filter have not converted anything.

-  //      and it needs at least outSize bytes to convert one block 

-  //      (it's for crypto block algorithms).

-};

-

-CODER_INTERFACE(ICryptoProperties, 0x80)

-{

-  STDMETHOD(SetKey)(const Byte *data, UInt32 size) PURE;

-  STDMETHOD(SetInitVector)(const Byte *data, UInt32 size) PURE;

-};

-

-CODER_INTERFACE(ICryptoSetPassword, 0x90)

-{

-  STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size) PURE;

-};

-

-CODER_INTERFACE(ICryptoSetCRC, 0xA0)

-{

-  STDMETHOD(CryptoSetCRC)(UInt32 crc) PURE;

-};

-

-//////////////////////

-// It's for DLL file

-namespace NMethodPropID

-{

-  enum EEnum

-  {

-    kID,

-    kName,

-    kDecoder,

-    kEncoder,

-    kInStreams,

-    kOutStreams,

-    kDescription

-  };

-}

-

-#endif

+// ICoder.h
+
+#ifndef __ICODER_H
+#define __ICODER_H
+
+#include "IStream.h"
+
+// "23170F69-40C1-278A-0000-000400xx0000"
+#define CODER_INTERFACE(i, x) \
+DEFINE_GUID(IID_ ## i, \
+0x23170F69, 0x40C1, 0x278A, 0x00, 0x00, 0x00, 0x04, 0x00, x, 0x00, 0x00); \
+struct i: public IUnknown
+
+CODER_INTERFACE(ICompressProgressInfo, 0x04)
+{
+  STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize) PURE;
+};
+
+CODER_INTERFACE(ICompressCoder, 0x05)
+{
+  STDMETHOD(Code)(ISequentialInStream *inStream,
+      ISequentialOutStream *outStream,
+      const UInt64 *inSize,
+      const UInt64 *outSize,
+      ICompressProgressInfo *progress) PURE;
+};
+
+CODER_INTERFACE(ICompressCoder2, 0x18)
+{
+  STDMETHOD(Code)(ISequentialInStream **inStreams,
+      const UInt64 **inSizes,
+      UInt32 numInStreams,
+      ISequentialOutStream **outStreams,
+      const UInt64 **outSizes,
+      UInt32 numOutStreams,
+      ICompressProgressInfo *progress) PURE;
+};
+
+namespace NCoderPropID
+{
+  enum EEnum
+  {
+    kDictionarySize = 0x400,
+    kUsedMemorySize,
+    kOrder,
+    kPosStateBits = 0x440,
+    kLitContextBits,
+    kLitPosBits,
+    kNumFastBytes = 0x450,
+    kMatchFinder,
+    kMatchFinderCycles,
+    kNumPasses = 0x460,
+    kAlgorithm = 0x470,
+    kMultiThread = 0x480,
+    kNumThreads,
+    kEndMarker = 0x490
+  };
+}
+
+CODER_INTERFACE(ICompressSetCoderProperties, 0x20)
+{
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs,
+      const PROPVARIANT *properties, UInt32 numProperties) PURE;
+};
+
+/*
+CODER_INTERFACE(ICompressSetCoderProperties, 0x21)
+{
+  STDMETHOD(SetDecoderProperties)(ISequentialInStream *inStream) PURE;
+};
+*/
+
+CODER_INTERFACE(ICompressSetDecoderProperties2, 0x22)
+{
+  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size) PURE;
+};
+
+CODER_INTERFACE(ICompressWriteCoderProperties, 0x23)
+{
+  STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStreams) PURE;
+};
+
+CODER_INTERFACE(ICompressGetInStreamProcessedSize, 0x24)
+{
+  STDMETHOD(GetInStreamProcessedSize)(UInt64 *value) PURE;
+};
+
+CODER_INTERFACE(ICompressSetCoderMt, 0x25)
+{
+  STDMETHOD(SetNumberOfThreads)(UInt32 numThreads) PURE;
+};
+
+CODER_INTERFACE(ICompressGetSubStreamSize, 0x30)
+{
+  STDMETHOD(GetSubStreamSize)(UInt64 subStream, UInt64 *value) PURE;
+};
+
+CODER_INTERFACE(ICompressSetInStream, 0x31)
+{
+  STDMETHOD(SetInStream)(ISequentialInStream *inStream) PURE;
+  STDMETHOD(ReleaseInStream)() PURE;
+};
+
+CODER_INTERFACE(ICompressSetOutStream, 0x32)
+{
+  STDMETHOD(SetOutStream)(ISequentialOutStream *outStream) PURE;
+  STDMETHOD(ReleaseOutStream)() PURE;
+};
+
+CODER_INTERFACE(ICompressSetInStreamSize, 0x33)
+{
+  STDMETHOD(SetInStreamSize)(const UInt64 *inSize) PURE;
+};
+
+CODER_INTERFACE(ICompressSetOutStreamSize, 0x34)
+{
+  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize) PURE;
+};
+
+CODER_INTERFACE(ICompressFilter, 0x40)
+{
+  STDMETHOD(Init)() PURE;
+  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size) PURE;
+  // Filter return outSize (UInt32)
+  // if (outSize <= size): Filter have converted outSize bytes
+  // if (outSize > size): Filter have not converted anything.
+  //      and it needs at least outSize bytes to convert one block
+  //      (it's for crypto block algorithms).
+};
+
+CODER_INTERFACE(ICryptoProperties, 0x80)
+{
+  STDMETHOD(SetKey)(const Byte *data, UInt32 size) PURE;
+  STDMETHOD(SetInitVector)(const Byte *data, UInt32 size) PURE;
+};
+
+CODER_INTERFACE(ICryptoSetPassword, 0x90)
+{
+  STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size) PURE;
+};
+
+CODER_INTERFACE(ICryptoSetCRC, 0xA0)
+{
+  STDMETHOD(CryptoSetCRC)(UInt32 crc) PURE;
+};
+
+//////////////////////
+// It's for DLL file
+namespace NMethodPropID
+{
+  enum EEnum
+  {
+    kID,
+    kName,
+    kDecoder,
+    kEncoder,
+    kInStreams,
+    kOutStreams,
+    kDescription
+  };
+}
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/7zip/IStream.h b/payloads/bayou/util/pbuilder/lzma/C/7zip/IStream.h
index d92b89aa70..b638efe4ec 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/7zip/IStream.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/7zip/IStream.h
@@ -1,62 +1,62 @@
-// IStream.h

-

-#ifndef __ISTREAM_H

-#define __ISTREAM_H

-

-#include "../Common/MyUnknown.h"

-#include "../Common/Types.h"

-

-// "23170F69-40C1-278A-0000-000300xx0000"

-

-#define STREAM_INTERFACE_SUB(i, b, x) \

-DEFINE_GUID(IID_ ## i, \

-0x23170F69, 0x40C1, 0x278A, 0x00, 0x00, 0x00, 0x03, 0x00, x, 0x00, 0x00); \

-struct i: public b

-

-#define STREAM_INTERFACE(i, x) STREAM_INTERFACE_SUB(i, IUnknown, x)

-

-STREAM_INTERFACE(ISequentialInStream, 0x01)

-{

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

-  /*

-  Out: if size != 0, return_value = S_OK and (*processedSize == 0),

-    then there are no more bytes in stream.

-  if (size > 0) && there are bytes in stream, 

-  this function must read at least 1 byte.

-  This function is allowed to read less than number of remaining bytes in stream.

-  You must call Read function in loop, if you need exact amount of data

-  */

-};

-

-STREAM_INTERFACE(ISequentialOutStream, 0x02)

-{

-  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize) PURE;

-  /*

-  if (size > 0) this function must write at least 1 byte.

-  This function is allowed to write less than "size".

-  You must call Write function in loop, if you need to write exact amount of data

-  */

-};

-

-STREAM_INTERFACE_SUB(IInStream, ISequentialInStream, 0x03)

-{

-  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;

-};

-

-STREAM_INTERFACE_SUB(IOutStream, ISequentialOutStream, 0x04)

-{

-  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;

-  STDMETHOD(SetSize)(Int64 newSize) PURE;

-};

-

-STREAM_INTERFACE(IStreamGetSize, 0x06)

-{

-  STDMETHOD(GetSize)(UInt64 *size) PURE;

-};

-

-STREAM_INTERFACE(IOutStreamFlush, 0x07)

-{

-  STDMETHOD(Flush)() PURE;

-};

-

-#endif

+// IStream.h
+
+#ifndef __ISTREAM_H
+#define __ISTREAM_H
+
+#include "../Common/MyUnknown.h"
+#include "../Common/Types.h"
+
+// "23170F69-40C1-278A-0000-000300xx0000"
+
+#define STREAM_INTERFACE_SUB(i, b, x) \
+DEFINE_GUID(IID_ ## i, \
+0x23170F69, 0x40C1, 0x278A, 0x00, 0x00, 0x00, 0x03, 0x00, x, 0x00, 0x00); \
+struct i: public b
+
+#define STREAM_INTERFACE(i, x) STREAM_INTERFACE_SUB(i, IUnknown, x)
+
+STREAM_INTERFACE(ISequentialInStream, 0x01)
+{
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize) PURE;
+  /*
+  Out: if size != 0, return_value = S_OK and (*processedSize == 0),
+    then there are no more bytes in stream.
+  if (size > 0) && there are bytes in stream,
+  this function must read at least 1 byte.
+  This function is allowed to read less than number of remaining bytes in stream.
+  You must call Read function in loop, if you need exact amount of data
+  */
+};
+
+STREAM_INTERFACE(ISequentialOutStream, 0x02)
+{
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize) PURE;
+  /*
+  if (size > 0) this function must write at least 1 byte.
+  This function is allowed to write less than "size".
+  You must call Write function in loop, if you need to write exact amount of data
+  */
+};
+
+STREAM_INTERFACE_SUB(IInStream, ISequentialInStream, 0x03)
+{
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;
+};
+
+STREAM_INTERFACE_SUB(IOutStream, ISequentialOutStream, 0x04)
+{
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;
+  STDMETHOD(SetSize)(Int64 newSize) PURE;
+};
+
+STREAM_INTERFACE(IStreamGetSize, 0x06)
+{
+  STDMETHOD(GetSize)(UInt64 *size) PURE;
+};
+
+STREAM_INTERFACE(IOutStreamFlush, 0x07)
+{
+  STDMETHOD(Flush)() PURE;
+};
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/Common/Alloc.h b/payloads/bayou/util/pbuilder/lzma/C/Common/Alloc.h
index 2ae3891de6..d444f63193 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/Common/Alloc.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/Common/Alloc.h
@@ -1,29 +1,29 @@
-// Common/Alloc.h

-

-#ifndef __COMMON_ALLOC_H

-#define __COMMON_ALLOC_H

-

-#include <stddef.h>

-

-void *MyAlloc(size_t size) throw();

-void MyFree(void *address) throw();

-

-#ifdef _WIN32

-

-bool SetLargePageSize();

-

-void *MidAlloc(size_t size) throw();

-void MidFree(void *address) throw();

-void *BigAlloc(size_t size) throw();

-void BigFree(void *address) throw();

-

-#else

-

-#define MidAlloc(size) MyAlloc(size)

-#define MidFree(address) MyFree(address)

-#define BigAlloc(size) MyAlloc(size)

-#define BigFree(address) MyFree(address)

-

-#endif

-

-#endif

+// Common/Alloc.h
+
+#ifndef __COMMON_ALLOC_H
+#define __COMMON_ALLOC_H
+
+#include <stddef.h>
+
+void *MyAlloc(size_t size) throw();
+void MyFree(void *address) throw();
+
+#ifdef _WIN32
+
+bool SetLargePageSize();
+
+void *MidAlloc(size_t size) throw();
+void MidFree(void *address) throw();
+void *BigAlloc(size_t size) throw();
+void BigFree(void *address) throw();
+
+#else
+
+#define MidAlloc(size) MyAlloc(size)
+#define MidFree(address) MyFree(address)
+#define BigAlloc(size) MyAlloc(size)
+#define BigFree(address) MyFree(address)
+
+#endif
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/Common/CRC.h b/payloads/bayou/util/pbuilder/lzma/C/Common/CRC.h
index c9d43d0055..f3279a5ef8 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/Common/CRC.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/Common/CRC.h
@@ -1,36 +1,36 @@
-// Common/CRC.h

-

-#ifndef __COMMON_CRC_H

-#define __COMMON_CRC_H

-

-#include <stddef.h>

-#include "Types.h"

-

-class CCRC

-{

-  UInt32 _value;

-public:

-	static UInt32 Table[256];

-	static void InitTable();

-

-  CCRC():  _value(0xFFFFFFFF){};

-  void Init() { _value = 0xFFFFFFFF; }

-  void UpdateByte(Byte v);

-  void UpdateUInt16(UInt16 v);

-  void UpdateUInt32(UInt32 v);

-  void UpdateUInt64(UInt64 v);

-  void Update(const void *data, size_t size);

-  UInt32 GetDigest() const { return _value ^ 0xFFFFFFFF; } 

-  static UInt32 CalculateDigest(const void *data, size_t size)

-  {

-    CCRC crc;

-    crc.Update(data, size);

-    return crc.GetDigest();

-  }

-  static bool VerifyDigest(UInt32 digest, const void *data, size_t size)

-  {

-    return (CalculateDigest(data, size) == digest);

-  }

-};

-

-#endif

+// Common/CRC.h
+
+#ifndef __COMMON_CRC_H
+#define __COMMON_CRC_H
+
+#include <stddef.h>
+#include "Types.h"
+
+class CCRC
+{
+  UInt32 _value;
+public:
+	static UInt32 Table[256];
+	static void InitTable();
+
+  CCRC():  _value(0xFFFFFFFF){};
+  void Init() { _value = 0xFFFFFFFF; }
+  void UpdateByte(Byte v);
+  void UpdateUInt16(UInt16 v);
+  void UpdateUInt32(UInt32 v);
+  void UpdateUInt64(UInt64 v);
+  void Update(const void *data, size_t size);
+  UInt32 GetDigest() const { return _value ^ 0xFFFFFFFF; }
+  static UInt32 CalculateDigest(const void *data, size_t size)
+  {
+    CCRC crc;
+    crc.Update(data, size);
+    return crc.GetDigest();
+  }
+  static bool VerifyDigest(UInt32 digest, const void *data, size_t size)
+  {
+    return (CalculateDigest(data, size) == digest);
+  }
+};
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/Common/Defs.h b/payloads/bayou/util/pbuilder/lzma/C/Common/Defs.h
index 69b8ecea82..dad3ae8f11 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/Common/Defs.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/Common/Defs.h
@@ -1,20 +1,20 @@
-// Common/Defs.h

-

-#ifndef __COMMON_DEFS_H

-#define __COMMON_DEFS_H

-

-template <class T> inline T MyMin(T a, T b)

-  {  return a < b ? a : b; }

-template <class T> inline T MyMax(T a, T b)

-  {  return a > b ? a : b; }

-

-template <class T> inline int MyCompare(T a, T b)

-  {  return a < b ? -1 : (a == b ? 0 : 1); }

-

-inline int BoolToInt(bool value)

-  { return (value ? 1: 0); }

-

-inline bool IntToBool(int value)

-  { return (value != 0); }

-

-#endif

+// Common/Defs.h
+
+#ifndef __COMMON_DEFS_H
+#define __COMMON_DEFS_H
+
+template <class T> inline T MyMin(T a, T b)
+  {  return a < b ? a : b; }
+template <class T> inline T MyMax(T a, T b)
+  {  return a > b ? a : b; }
+
+template <class T> inline int MyCompare(T a, T b)
+  {  return a < b ? -1 : (a == b ? 0 : 1); }
+
+inline int BoolToInt(bool value)
+  { return (value ? 1: 0); }
+
+inline bool IntToBool(int value)
+  { return (value != 0); }
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/Common/MyCom.h b/payloads/bayou/util/pbuilder/lzma/C/Common/MyCom.h
index 8476b57282..b8dbf38999 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/Common/MyCom.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/Common/MyCom.h
@@ -1,203 +1,203 @@
-// MyCom.h

-

-#ifndef __MYCOM_H

-#define __MYCOM_H

-

-#include "MyWindows.h"

-

-#define RINOK(x) { HRESULT __result_ = (x); if(__result_ != S_OK) return __result_; }

-

-template <class T>

-class CMyComPtr

-{

-  T* _p;

-public:

-  // typedef T _PtrClass;

-  CMyComPtr() { _p = NULL;}

-  CMyComPtr(T* p) {if ((_p = p) != NULL) p->AddRef(); }

-  CMyComPtr(const CMyComPtr<T>& lp)

-  {

-    if ((_p = lp._p) != NULL)

-      _p->AddRef();

-  }

-  ~CMyComPtr() { if (_p) _p->Release(); }

-  void Release() { if (_p) { _p->Release(); _p = NULL; } }

-  operator T*() const {  return (T*)_p;  }

-  // T& operator*() const {  return *_p; }

-  T** operator&() { return &_p; }

-  T* operator->() const { return _p; }

-  T* operator=(T* p) 

-  { 

-    if (p != 0)

-      p->AddRef();

-    if (_p) 

-      _p->Release();

-    _p = p;

-    return p;

-  }

-  T* operator=(const CMyComPtr<T>& lp) { return (*this = lp._p); }

-  bool operator!() const { return (_p == NULL); }

-  // bool operator==(T* pT) const {  return _p == pT; }

-  // Compare two objects for equivalence

-  void Attach(T* p2)

-  {

-    Release();

-    _p = p2;

-  }

-  T* Detach()

-  {

-    T* pt = _p;

-    _p = NULL;

-    return pt;

-  }

-  #ifdef _WIN32

-  HRESULT CoCreateInstance(REFCLSID rclsid, REFIID iid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)

-  {

-    return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, (void**)&_p);

-  }

-  #endif

-  /*

-  HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)

-  {

-    CLSID clsid;

-    HRESULT hr = CLSIDFromProgID(szProgID, &clsid);

-    ATLASSERT(_p == NULL);

-    if (SUCCEEDED(hr))

-      hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&_p);

-    return hr;

-  }

-  */

-  template <class Q>

-  HRESULT QueryInterface(REFGUID iid, Q** pp) const

-  {

-    return _p->QueryInterface(iid, (void**)pp);

-  }

-};

-

-//////////////////////////////////////////////////////////

-

-class CMyComBSTR

-{

-public:

-  BSTR m_str;

-  CMyComBSTR() { m_str = NULL; }

-  CMyComBSTR(LPCOLESTR pSrc) {  m_str = ::SysAllocString(pSrc);  }

-  // CMyComBSTR(int nSize) { m_str = ::SysAllocStringLen(NULL, nSize); }

-  // CMyComBSTR(int nSize, LPCOLESTR sz) { m_str = ::SysAllocStringLen(sz, nSize);  }

-  CMyComBSTR(const CMyComBSTR& src) { m_str = src.MyCopy(); }

-  /*

-  CMyComBSTR(REFGUID src)

-  {

-    LPOLESTR szGuid;

-    StringFromCLSID(src, &szGuid);

-    m_str = ::SysAllocString(szGuid);

-    CoTaskMemFree(szGuid);

-  }

-  */

-  ~CMyComBSTR() { ::SysFreeString(m_str); }

-  CMyComBSTR& operator=(const CMyComBSTR& src)

-  {

-    if (m_str != src.m_str)

-    {

-      if (m_str)

-        ::SysFreeString(m_str);

-      m_str = src.MyCopy();

-    }

-    return *this;

-  }

-  CMyComBSTR& operator=(LPCOLESTR pSrc)

-  {

-    ::SysFreeString(m_str);

-    m_str = ::SysAllocString(pSrc);

-    return *this;

-  }

-  unsigned int Length() const { return ::SysStringLen(m_str); }

-  operator BSTR() const { return m_str; }

-  BSTR* operator&() { return &m_str; }

-  BSTR MyCopy() const 

-  { 

-    int byteLen = ::SysStringByteLen(m_str);

-    BSTR res = ::SysAllocStringByteLen(NULL, byteLen);

-    memmove(res, m_str, byteLen);

-    return res;

-  }

-  void Attach(BSTR src) {  m_str = src; }

-  BSTR Detach()

-  {

-    BSTR s = m_str;

-    m_str = NULL;

-    return s;

-  }

-  void Empty()

-  {

-    ::SysFreeString(m_str);

-    m_str = NULL;

-  }

-  bool operator!() const {  return (m_str == NULL); }

-};

-

-

-//////////////////////////////////////////////////////////

-

-class CMyUnknownImp

-{

-public:

-  ULONG __m_RefCount;

-  CMyUnknownImp(): __m_RefCount(0) {}

-};

-

-#define MY_QUERYINTERFACE_BEGIN STDMETHOD(QueryInterface) \

-    (REFGUID iid, void **outObject) { 

-

-#define MY_QUERYINTERFACE_ENTRY(i) if (iid == IID_ ## i) \

-    { *outObject = (void *)(i *)this; AddRef(); return S_OK; }

-

-#define MY_QUERYINTERFACE_END return E_NOINTERFACE; }

-

-#define MY_ADDREF_RELEASE \

-STDMETHOD_(ULONG, AddRef)() { return ++__m_RefCount; } \

-STDMETHOD_(ULONG, Release)() { if (--__m_RefCount != 0)  \

-  return __m_RefCount; delete this; return 0; }

-

-#define MY_UNKNOWN_IMP_SPEC(i) \

-  MY_QUERYINTERFACE_BEGIN \

-  i \

-  MY_QUERYINTERFACE_END \

-  MY_ADDREF_RELEASE

-

-

-#define MY_UNKNOWN_IMP STDMETHOD(QueryInterface)(REFGUID, void **) { \

-  MY_QUERYINTERFACE_END \

-  MY_ADDREF_RELEASE

-

-#define MY_UNKNOWN_IMP1(i) MY_UNKNOWN_IMP_SPEC( \

-  MY_QUERYINTERFACE_ENTRY(i) \

-  )

-

-#define MY_UNKNOWN_IMP2(i1, i2) MY_UNKNOWN_IMP_SPEC( \

-  MY_QUERYINTERFACE_ENTRY(i1) \

-  MY_QUERYINTERFACE_ENTRY(i2) \

-  )

-

-#define MY_UNKNOWN_IMP3(i1, i2, i3) MY_UNKNOWN_IMP_SPEC( \

-  MY_QUERYINTERFACE_ENTRY(i1) \

-  MY_QUERYINTERFACE_ENTRY(i2) \

-  MY_QUERYINTERFACE_ENTRY(i3) \

-  )

-

-#define MY_UNKNOWN_IMP4(i1, i2, i3, i4) MY_UNKNOWN_IMP_SPEC( \

-  MY_QUERYINTERFACE_ENTRY(i1) \

-  MY_QUERYINTERFACE_ENTRY(i2) \

-  MY_QUERYINTERFACE_ENTRY(i3) \

-  MY_QUERYINTERFACE_ENTRY(i4) \

-  )

-

-#define MY_UNKNOWN_IMP5(i1, i2, i3, i4, i5) MY_UNKNOWN_IMP_SPEC( \

-  MY_QUERYINTERFACE_ENTRY(i1) \

-  MY_QUERYINTERFACE_ENTRY(i2) \

-  MY_QUERYINTERFACE_ENTRY(i3) \

-  MY_QUERYINTERFACE_ENTRY(i4) \

-  MY_QUERYINTERFACE_ENTRY(i5) \

-  )

-

-#endif

+// MyCom.h
+
+#ifndef __MYCOM_H
+#define __MYCOM_H
+
+#include "MyWindows.h"
+
+#define RINOK(x) { HRESULT __result_ = (x); if(__result_ != S_OK) return __result_; }
+
+template <class T>
+class CMyComPtr
+{
+  T* _p;
+public:
+  // typedef T _PtrClass;
+  CMyComPtr() { _p = NULL;}
+  CMyComPtr(T* p) {if ((_p = p) != NULL) p->AddRef(); }
+  CMyComPtr(const CMyComPtr<T>& lp)
+  {
+    if ((_p = lp._p) != NULL)
+      _p->AddRef();
+  }
+  ~CMyComPtr() { if (_p) _p->Release(); }
+  void Release() { if (_p) { _p->Release(); _p = NULL; } }
+  operator T*() const {  return (T*)_p;  }
+  // T& operator*() const {  return *_p; }
+  T** operator&() { return &_p; }
+  T* operator->() const { return _p; }
+  T* operator=(T* p)
+  {
+    if (p != 0)
+      p->AddRef();
+    if (_p)
+      _p->Release();
+    _p = p;
+    return p;
+  }
+  T* operator=(const CMyComPtr<T>& lp) { return (*this = lp._p); }
+  bool operator!() const { return (_p == NULL); }
+  // bool operator==(T* pT) const {  return _p == pT; }
+  // Compare two objects for equivalence
+  void Attach(T* p2)
+  {
+    Release();
+    _p = p2;
+  }
+  T* Detach()
+  {
+    T* pt = _p;
+    _p = NULL;
+    return pt;
+  }
+  #ifdef _WIN32
+  HRESULT CoCreateInstance(REFCLSID rclsid, REFIID iid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
+  {
+    return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, (void**)&_p);
+  }
+  #endif
+  /*
+  HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
+  {
+    CLSID clsid;
+    HRESULT hr = CLSIDFromProgID(szProgID, &clsid);
+    ATLASSERT(_p == NULL);
+    if (SUCCEEDED(hr))
+      hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&_p);
+    return hr;
+  }
+  */
+  template <class Q>
+  HRESULT QueryInterface(REFGUID iid, Q** pp) const
+  {
+    return _p->QueryInterface(iid, (void**)pp);
+  }
+};
+
+//////////////////////////////////////////////////////////
+
+class CMyComBSTR
+{
+public:
+  BSTR m_str;
+  CMyComBSTR() { m_str = NULL; }
+  CMyComBSTR(LPCOLESTR pSrc) {  m_str = ::SysAllocString(pSrc);  }
+  // CMyComBSTR(int nSize) { m_str = ::SysAllocStringLen(NULL, nSize); }
+  // CMyComBSTR(int nSize, LPCOLESTR sz) { m_str = ::SysAllocStringLen(sz, nSize);  }
+  CMyComBSTR(const CMyComBSTR& src) { m_str = src.MyCopy(); }
+  /*
+  CMyComBSTR(REFGUID src)
+  {
+    LPOLESTR szGuid;
+    StringFromCLSID(src, &szGuid);
+    m_str = ::SysAllocString(szGuid);
+    CoTaskMemFree(szGuid);
+  }
+  */
+  ~CMyComBSTR() { ::SysFreeString(m_str); }
+  CMyComBSTR& operator=(const CMyComBSTR& src)
+  {
+    if (m_str != src.m_str)
+    {
+      if (m_str)
+        ::SysFreeString(m_str);
+      m_str = src.MyCopy();
+    }
+    return *this;
+  }
+  CMyComBSTR& operator=(LPCOLESTR pSrc)
+  {
+    ::SysFreeString(m_str);
+    m_str = ::SysAllocString(pSrc);
+    return *this;
+  }
+  unsigned int Length() const { return ::SysStringLen(m_str); }
+  operator BSTR() const { return m_str; }
+  BSTR* operator&() { return &m_str; }
+  BSTR MyCopy() const
+  {
+    int byteLen = ::SysStringByteLen(m_str);
+    BSTR res = ::SysAllocStringByteLen(NULL, byteLen);
+    memmove(res, m_str, byteLen);
+    return res;
+  }
+  void Attach(BSTR src) {  m_str = src; }
+  BSTR Detach()
+  {
+    BSTR s = m_str;
+    m_str = NULL;
+    return s;
+  }
+  void Empty()
+  {
+    ::SysFreeString(m_str);
+    m_str = NULL;
+  }
+  bool operator!() const {  return (m_str == NULL); }
+};
+
+
+//////////////////////////////////////////////////////////
+
+class CMyUnknownImp
+{
+public:
+  ULONG __m_RefCount;
+  CMyUnknownImp(): __m_RefCount(0) {}
+};
+
+#define MY_QUERYINTERFACE_BEGIN STDMETHOD(QueryInterface) \
+    (REFGUID iid, void **outObject) {
+
+#define MY_QUERYINTERFACE_ENTRY(i) if (iid == IID_ ## i) \
+    { *outObject = (void *)(i *)this; AddRef(); return S_OK; }
+
+#define MY_QUERYINTERFACE_END return E_NOINTERFACE; }
+
+#define MY_ADDREF_RELEASE \
+STDMETHOD_(ULONG, AddRef)() { return ++__m_RefCount; } \
+STDMETHOD_(ULONG, Release)() { if (--__m_RefCount != 0)  \
+  return __m_RefCount; delete this; return 0; }
+
+#define MY_UNKNOWN_IMP_SPEC(i) \
+  MY_QUERYINTERFACE_BEGIN \
+  i \
+  MY_QUERYINTERFACE_END \
+  MY_ADDREF_RELEASE
+
+
+#define MY_UNKNOWN_IMP STDMETHOD(QueryInterface)(REFGUID, void **) { \
+  MY_QUERYINTERFACE_END \
+  MY_ADDREF_RELEASE
+
+#define MY_UNKNOWN_IMP1(i) MY_UNKNOWN_IMP_SPEC( \
+  MY_QUERYINTERFACE_ENTRY(i) \
+  )
+
+#define MY_UNKNOWN_IMP2(i1, i2) MY_UNKNOWN_IMP_SPEC( \
+  MY_QUERYINTERFACE_ENTRY(i1) \
+  MY_QUERYINTERFACE_ENTRY(i2) \
+  )
+
+#define MY_UNKNOWN_IMP3(i1, i2, i3) MY_UNKNOWN_IMP_SPEC( \
+  MY_QUERYINTERFACE_ENTRY(i1) \
+  MY_QUERYINTERFACE_ENTRY(i2) \
+  MY_QUERYINTERFACE_ENTRY(i3) \
+  )
+
+#define MY_UNKNOWN_IMP4(i1, i2, i3, i4) MY_UNKNOWN_IMP_SPEC( \
+  MY_QUERYINTERFACE_ENTRY(i1) \
+  MY_QUERYINTERFACE_ENTRY(i2) \
+  MY_QUERYINTERFACE_ENTRY(i3) \
+  MY_QUERYINTERFACE_ENTRY(i4) \
+  )
+
+#define MY_UNKNOWN_IMP5(i1, i2, i3, i4, i5) MY_UNKNOWN_IMP_SPEC( \
+  MY_QUERYINTERFACE_ENTRY(i1) \
+  MY_QUERYINTERFACE_ENTRY(i2) \
+  MY_QUERYINTERFACE_ENTRY(i3) \
+  MY_QUERYINTERFACE_ENTRY(i4) \
+  MY_QUERYINTERFACE_ENTRY(i5) \
+  )
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/Common/MyGuidDef.h b/payloads/bayou/util/pbuilder/lzma/C/Common/MyGuidDef.h
index 889ea417b0..7de64333cb 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/Common/MyGuidDef.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/Common/MyGuidDef.h
@@ -1,54 +1,54 @@
-// Common/MyGuidDef.h

-

-#ifndef GUID_DEFINED

-#define GUID_DEFINED

-

-#include "Types.h"

-

-typedef struct {

-  UInt32 Data1;

-  UInt16 Data2;

-  UInt16 Data3;

-  unsigned char Data4[8];

-} GUID;

-

-#ifdef __cplusplus

-#define REFGUID const GUID &

-#else

-#define REFGUID const GUID *

-#endif

-

-#define REFCLSID REFGUID

-#define REFIID REFGUID

-

-#ifdef __cplusplus

-inline bool operator==(REFGUID g1, REFGUID g2)

-{ 

-  for (int i = 0; i < (int)sizeof(g1); i++)

-    if (((const unsigned char *)&g1)[i] != ((const unsigned char *)&g2)[i])

-      return false;

-  return true;

-}

-inline bool operator!=(REFGUID g1, REFGUID g2) { return !(g1 == g2); }

-#endif

-

-#ifdef __cplusplus

-  #define MY_EXTERN_C extern "C"

-#else

-  #define MY_EXTERN_C extern

-#endif

-

-#endif // GUID_DEFINED

-

-

-#ifdef DEFINE_GUID

-#undef DEFINE_GUID

-#endif

-

-#ifdef INITGUID

-  #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \

-    MY_EXTERN_C const GUID name = { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }

-#else

-  #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \

-    MY_EXTERN_C const GUID name

-#endif

+// Common/MyGuidDef.h
+
+#ifndef GUID_DEFINED
+#define GUID_DEFINED
+
+#include "Types.h"
+
+typedef struct {
+  UInt32 Data1;
+  UInt16 Data2;
+  UInt16 Data3;
+  unsigned char Data4[8];
+} GUID;
+
+#ifdef __cplusplus
+#define REFGUID const GUID &
+#else
+#define REFGUID const GUID *
+#endif
+
+#define REFCLSID REFGUID
+#define REFIID REFGUID
+
+#ifdef __cplusplus
+inline bool operator==(REFGUID g1, REFGUID g2)
+{
+  for (int i = 0; i < (int)sizeof(g1); i++)
+    if (((const unsigned char *)&g1)[i] != ((const unsigned char *)&g2)[i])
+      return false;
+  return true;
+}
+inline bool operator!=(REFGUID g1, REFGUID g2) { return !(g1 == g2); }
+#endif
+
+#ifdef __cplusplus
+  #define MY_EXTERN_C extern "C"
+#else
+  #define MY_EXTERN_C extern
+#endif
+
+#endif // GUID_DEFINED
+
+
+#ifdef DEFINE_GUID
+#undef DEFINE_GUID
+#endif
+
+#ifdef INITGUID
+  #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+    MY_EXTERN_C const GUID name = { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }
+#else
+  #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+    MY_EXTERN_C const GUID name
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/Common/MyInitGuid.h b/payloads/bayou/util/pbuilder/lzma/C/Common/MyInitGuid.h
index 53b0f03428..5bdfeed564 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/Common/MyInitGuid.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/Common/MyInitGuid.h
@@ -1,13 +1,13 @@
-// Common/MyInitGuid.h

-

-#ifndef __COMMON_MYINITGUID_H

-#define __COMMON_MYINITGUID_H

-

-#ifdef _WIN32

-#include <initguid.h>

-#else

-#define INITGUID

-#include "MyGuidDef.h"

-#endif

-

-#endif

+// Common/MyInitGuid.h
+
+#ifndef __COMMON_MYINITGUID_H
+#define __COMMON_MYINITGUID_H
+
+#ifdef _WIN32
+#include <initguid.h>
+#else
+#define INITGUID
+#include "MyGuidDef.h"
+#endif
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/Common/MyUnknown.h b/payloads/bayou/util/pbuilder/lzma/C/Common/MyUnknown.h
index 6cd32caddb..052c284f41 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/Common/MyUnknown.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/Common/MyUnknown.h
@@ -1,24 +1,24 @@
-// MyUnknown.h

-

-#ifndef __MYUNKNOWN_H

-#define __MYUNKNOWN_H

-

-#ifdef _WIN32

-

-#ifdef _WIN32_WCE

-#if (_WIN32_WCE > 300)

-#include <basetyps.h>

-#else

-#define MIDL_INTERFACE(x) struct 

-#endif

-#else

-#include <basetyps.h>

-#endif

-

-#include <unknwn.h>

-

-#else 

-#include "MyWindows.h"

-#endif

-  

-#endif

+// MyUnknown.h
+
+#ifndef __MYUNKNOWN_H
+#define __MYUNKNOWN_H
+
+#ifdef _WIN32
+
+#ifdef _WIN32_WCE
+#if (_WIN32_WCE > 300)
+#include <basetyps.h>
+#else
+#define MIDL_INTERFACE(x) struct
+#endif
+#else
+#include <basetyps.h>
+#endif
+
+#include <unknwn.h>
+
+#else
+#include "MyWindows.h"
+#endif
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/Common/MyWindows.h b/payloads/bayou/util/pbuilder/lzma/C/Common/MyWindows.h
index 2929be7c30..f09a4423fe 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/Common/MyWindows.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/Common/MyWindows.h
@@ -1,201 +1,201 @@
-// MyWindows.h

-

-#ifndef __MYWINDOWS_H

-#define __MYWINDOWS_H

-

-#ifdef _WIN32

-

-#include <windows.h>

-

-#define CHAR_PATH_SEPARATOR '\\'

-#define WCHAR_PATH_SEPARATOR L'\\'

-#define STRING_PATH_SEPARATOR "\\"

-#define WSTRING_PATH_SEPARATOR L"\\"

-

-#else

-

-#define CHAR_PATH_SEPARATOR '/'

-#define WCHAR_PATH_SEPARATOR L'/'

-#define STRING_PATH_SEPARATOR "/"

-#define WSTRING_PATH_SEPARATOR L"/"

-

-#include <stddef.h> // for wchar_t

-#include <string.h>

-

-#include "MyGuidDef.h"

-

-typedef char CHAR;

-typedef unsigned char UCHAR;

-

-#undef BYTE

-typedef unsigned char BYTE;

-

-typedef short SHORT;

-typedef unsigned short USHORT;

-

-#undef WORD

-typedef unsigned short WORD;

-typedef short VARIANT_BOOL;

-

-typedef int INT;

-typedef Int32 INT32;

-typedef unsigned int UINT;

-typedef UInt32 UINT32;

-typedef INT32 LONG;   // LONG, ULONG and DWORD must be 32-bit

-typedef UINT32 ULONG;

-

-#undef DWORD

-typedef UINT32 DWORD;

-

-typedef Int64 LONGLONG;

-typedef UInt64 ULONGLONG;

-

-typedef struct LARGE_INTEGER { LONGLONG QuadPart; }LARGE_INTEGER;

-typedef struct _ULARGE_INTEGER { ULONGLONG QuadPart;} ULARGE_INTEGER;

-

-typedef const CHAR *LPCSTR;

-typedef CHAR TCHAR;

-typedef const TCHAR *LPCTSTR;

-typedef wchar_t WCHAR;

-typedef WCHAR OLECHAR;

-typedef const WCHAR *LPCWSTR;

-typedef OLECHAR *BSTR;

-typedef const OLECHAR *LPCOLESTR;

-typedef OLECHAR *LPOLESTR;

-

-typedef struct _FILETIME

-{

-  DWORD dwLowDateTime;

-  DWORD dwHighDateTime;

-}FILETIME;

-

-#define HRESULT LONG

-#define FAILED(Status) ((HRESULT)(Status)<0)

-typedef ULONG PROPID;

-typedef LONG SCODE;

-

-#define S_OK    ((HRESULT)0x00000000L)

-#define S_FALSE ((HRESULT)0x00000001L)

-#define E_NOTIMPL ((HRESULT)0x80004001L)

-#define E_NOINTERFACE ((HRESULT)0x80004002L)

-#define E_ABORT ((HRESULT)0x80004004L)

-#define E_FAIL ((HRESULT)0x80004005L)

-#define STG_E_INVALIDFUNCTION ((HRESULT)0x80030001L)

-#define E_OUTOFMEMORY ((HRESULT)0x8007000EL)

-#define E_INVALIDARG ((HRESULT)0x80070057L)

-

-#ifdef _MSC_VER

-#define STDMETHODCALLTYPE __stdcall 

-#else

-#define STDMETHODCALLTYPE 

-#endif

-

-#define STDMETHOD_(t, f) virtual t STDMETHODCALLTYPE f

-#define STDMETHOD(f) STDMETHOD_(HRESULT, f)

-#define STDMETHODIMP_(type) type STDMETHODCALLTYPE

-#define STDMETHODIMP STDMETHODIMP_(HRESULT)

-

-#define PURE = 0

-

-#define MIDL_INTERFACE(x) struct 

-

-struct IUnknown

-{

-  //virtual ~IUnknown() {}

-  STDMETHOD(QueryInterface) (REFIID iid, void **outObject) PURE;

-  STDMETHOD_(ULONG, AddRef)() PURE;

-  STDMETHOD_(ULONG, Release)() PURE;

-};

-

-typedef IUnknown *LPUNKNOWN;

-

-#define VARIANT_TRUE ((VARIANT_BOOL)-1)

-#define VARIANT_FALSE ((VARIANT_BOOL)0)

-

-enum VARENUM

-{	

-  VT_EMPTY	= 0,

-	VT_NULL	= 1,

-	VT_I2	= 2,

-	VT_I4	= 3,

-	VT_R4	= 4,

-	VT_R8	= 5,

-	VT_CY	= 6,

-	VT_DATE	= 7,

-	VT_BSTR	= 8,

-	VT_DISPATCH	= 9,

-	VT_ERROR	= 10,

-	VT_BOOL	= 11,

-	VT_VARIANT	= 12,

-	VT_UNKNOWN	= 13,

-	VT_DECIMAL	= 14,

-	VT_I1	= 16,

-	VT_UI1	= 17,

-	VT_UI2	= 18,

-	VT_UI4	= 19,

-	VT_I8	= 20,

-	VT_UI8	= 21,

-	VT_INT	= 22,

-	VT_UINT	= 23,

-	VT_VOID	= 24,

-	VT_HRESULT	= 25,

-	VT_FILETIME	= 64

-};

-

-typedef unsigned short VARTYPE;

-typedef WORD PROPVAR_PAD1;

-typedef WORD PROPVAR_PAD2;

-typedef WORD PROPVAR_PAD3;

-

-typedef struct tagPROPVARIANT

-{

-  VARTYPE vt;

-  PROPVAR_PAD1 wReserved1;

-  PROPVAR_PAD2 wReserved2;

-  PROPVAR_PAD3 wReserved3;

-  union 

-  {

-    CHAR cVal;

-    UCHAR bVal;

-    SHORT iVal;

-    USHORT uiVal;

-    LONG lVal;

-    ULONG ulVal;

-    INT intVal;

-    UINT uintVal;

-    LARGE_INTEGER hVal;

-    ULARGE_INTEGER uhVal;

-    VARIANT_BOOL boolVal;

-    SCODE scode;

-    FILETIME filetime;

-    BSTR bstrVal;

-  };

-} PROPVARIANT;

-

-typedef PROPVARIANT tagVARIANT;

-typedef tagVARIANT VARIANT;

-typedef VARIANT VARIANTARG;

-

-MY_EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);

-MY_EXTERN_C BSTR SysAllocString(const OLECHAR *sz);

-MY_EXTERN_C void SysFreeString(BSTR bstr);

-MY_EXTERN_C UINT SysStringByteLen(BSTR bstr);

-MY_EXTERN_C UINT SysStringLen(BSTR bstr);

-

-MY_EXTERN_C DWORD GetLastError();

-MY_EXTERN_C HRESULT VariantClear(VARIANTARG *prop);

-MY_EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, VARIANTARG *src);

-MY_EXTERN_C LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2);

-

-#define CP_ACP    0

-#define CP_OEMCP  1

-

-typedef enum tagSTREAM_SEEK

-{	

-  STREAM_SEEK_SET	= 0,

-  STREAM_SEEK_CUR	= 1,

-  STREAM_SEEK_END	= 2

-} STREAM_SEEK;

-

-#endif

-#endif

+// MyWindows.h
+
+#ifndef __MYWINDOWS_H
+#define __MYWINDOWS_H
+
+#ifdef _WIN32
+
+#include <windows.h>
+
+#define CHAR_PATH_SEPARATOR '\\'
+#define WCHAR_PATH_SEPARATOR L'\\'
+#define STRING_PATH_SEPARATOR "\\"
+#define WSTRING_PATH_SEPARATOR L"\\"
+
+#else
+
+#define CHAR_PATH_SEPARATOR '/'
+#define WCHAR_PATH_SEPARATOR L'/'
+#define STRING_PATH_SEPARATOR "/"
+#define WSTRING_PATH_SEPARATOR L"/"
+
+#include <stddef.h> // for wchar_t
+#include <string.h>
+
+#include "MyGuidDef.h"
+
+typedef char CHAR;
+typedef unsigned char UCHAR;
+
+#undef BYTE
+typedef unsigned char BYTE;
+
+typedef short SHORT;
+typedef unsigned short USHORT;
+
+#undef WORD
+typedef unsigned short WORD;
+typedef short VARIANT_BOOL;
+
+typedef int INT;
+typedef Int32 INT32;
+typedef unsigned int UINT;
+typedef UInt32 UINT32;
+typedef INT32 LONG;   // LONG, ULONG and DWORD must be 32-bit
+typedef UINT32 ULONG;
+
+#undef DWORD
+typedef UINT32 DWORD;
+
+typedef Int64 LONGLONG;
+typedef UInt64 ULONGLONG;
+
+typedef struct LARGE_INTEGER { LONGLONG QuadPart; }LARGE_INTEGER;
+typedef struct _ULARGE_INTEGER { ULONGLONG QuadPart;} ULARGE_INTEGER;
+
+typedef const CHAR *LPCSTR;
+typedef CHAR TCHAR;
+typedef const TCHAR *LPCTSTR;
+typedef wchar_t WCHAR;
+typedef WCHAR OLECHAR;
+typedef const WCHAR *LPCWSTR;
+typedef OLECHAR *BSTR;
+typedef const OLECHAR *LPCOLESTR;
+typedef OLECHAR *LPOLESTR;
+
+typedef struct _FILETIME
+{
+  DWORD dwLowDateTime;
+  DWORD dwHighDateTime;
+}FILETIME;
+
+#define HRESULT LONG
+#define FAILED(Status) ((HRESULT)(Status)<0)
+typedef ULONG PROPID;
+typedef LONG SCODE;
+
+#define S_OK    ((HRESULT)0x00000000L)
+#define S_FALSE ((HRESULT)0x00000001L)
+#define E_NOTIMPL ((HRESULT)0x80004001L)
+#define E_NOINTERFACE ((HRESULT)0x80004002L)
+#define E_ABORT ((HRESULT)0x80004004L)
+#define E_FAIL ((HRESULT)0x80004005L)
+#define STG_E_INVALIDFUNCTION ((HRESULT)0x80030001L)
+#define E_OUTOFMEMORY ((HRESULT)0x8007000EL)
+#define E_INVALIDARG ((HRESULT)0x80070057L)
+
+#ifdef _MSC_VER
+#define STDMETHODCALLTYPE __stdcall
+#else
+#define STDMETHODCALLTYPE
+#endif
+
+#define STDMETHOD_(t, f) virtual t STDMETHODCALLTYPE f
+#define STDMETHOD(f) STDMETHOD_(HRESULT, f)
+#define STDMETHODIMP_(type) type STDMETHODCALLTYPE
+#define STDMETHODIMP STDMETHODIMP_(HRESULT)
+
+#define PURE = 0
+
+#define MIDL_INTERFACE(x) struct
+
+struct IUnknown
+{
+  //virtual ~IUnknown() {}
+  STDMETHOD(QueryInterface) (REFIID iid, void **outObject) PURE;
+  STDMETHOD_(ULONG, AddRef)() PURE;
+  STDMETHOD_(ULONG, Release)() PURE;
+};
+
+typedef IUnknown *LPUNKNOWN;
+
+#define VARIANT_TRUE ((VARIANT_BOOL)-1)
+#define VARIANT_FALSE ((VARIANT_BOOL)0)
+
+enum VARENUM
+{
+  VT_EMPTY	= 0,
+	VT_NULL	= 1,
+	VT_I2	= 2,
+	VT_I4	= 3,
+	VT_R4	= 4,
+	VT_R8	= 5,
+	VT_CY	= 6,
+	VT_DATE	= 7,
+	VT_BSTR	= 8,
+	VT_DISPATCH	= 9,
+	VT_ERROR	= 10,
+	VT_BOOL	= 11,
+	VT_VARIANT	= 12,
+	VT_UNKNOWN	= 13,
+	VT_DECIMAL	= 14,
+	VT_I1	= 16,
+	VT_UI1	= 17,
+	VT_UI2	= 18,
+	VT_UI4	= 19,
+	VT_I8	= 20,
+	VT_UI8	= 21,
+	VT_INT	= 22,
+	VT_UINT	= 23,
+	VT_VOID	= 24,
+	VT_HRESULT	= 25,
+	VT_FILETIME	= 64
+};
+
+typedef unsigned short VARTYPE;
+typedef WORD PROPVAR_PAD1;
+typedef WORD PROPVAR_PAD2;
+typedef WORD PROPVAR_PAD3;
+
+typedef struct tagPROPVARIANT
+{
+  VARTYPE vt;
+  PROPVAR_PAD1 wReserved1;
+  PROPVAR_PAD2 wReserved2;
+  PROPVAR_PAD3 wReserved3;
+  union
+  {
+    CHAR cVal;
+    UCHAR bVal;
+    SHORT iVal;
+    USHORT uiVal;
+    LONG lVal;
+    ULONG ulVal;
+    INT intVal;
+    UINT uintVal;
+    LARGE_INTEGER hVal;
+    ULARGE_INTEGER uhVal;
+    VARIANT_BOOL boolVal;
+    SCODE scode;
+    FILETIME filetime;
+    BSTR bstrVal;
+  };
+} PROPVARIANT;
+
+typedef PROPVARIANT tagVARIANT;
+typedef tagVARIANT VARIANT;
+typedef VARIANT VARIANTARG;
+
+MY_EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);
+MY_EXTERN_C BSTR SysAllocString(const OLECHAR *sz);
+MY_EXTERN_C void SysFreeString(BSTR bstr);
+MY_EXTERN_C UINT SysStringByteLen(BSTR bstr);
+MY_EXTERN_C UINT SysStringLen(BSTR bstr);
+
+MY_EXTERN_C DWORD GetLastError();
+MY_EXTERN_C HRESULT VariantClear(VARIANTARG *prop);
+MY_EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, VARIANTARG *src);
+MY_EXTERN_C LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2);
+
+#define CP_ACP    0
+#define CP_OEMCP  1
+
+typedef enum tagSTREAM_SEEK
+{
+  STREAM_SEEK_SET	= 0,
+  STREAM_SEEK_CUR	= 1,
+  STREAM_SEEK_END	= 2
+} STREAM_SEEK;
+
+#endif
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/Common/NewHandler.h b/payloads/bayou/util/pbuilder/lzma/C/Common/NewHandler.h
index 4c1727f824..215ba05f10 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/Common/NewHandler.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/Common/NewHandler.h
@@ -1,16 +1,16 @@
-// Common/NewHandler.h

-

-#ifndef __COMMON_NEWHANDLER_H

-#define __COMMON_NEWHANDLER_H

-

-class CNewException {};

-

-#ifdef _WIN32

-void 

-#ifdef _MSC_VER

-__cdecl 

-#endif

-operator delete(void *p) throw();

-#endif 

-

-#endif 

+// Common/NewHandler.h
+
+#ifndef __COMMON_NEWHANDLER_H
+#define __COMMON_NEWHANDLER_H
+
+class CNewException {};
+
+#ifdef _WIN32
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p) throw();
+#endif
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/Common/StdAfx.h b/payloads/bayou/util/pbuilder/lzma/C/Common/StdAfx.h
index 2547611bd7..b8ba1d5c4c 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/Common/StdAfx.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/Common/StdAfx.h
@@ -1,9 +1,9 @@
-// StdAfx.h

-

-#ifndef __STDAFX_H

-#define __STDAFX_H

-

-// #include "MyWindows.h"

-#include "NewHandler.h"

-

-#endif 

+// StdAfx.h
+
+#ifndef __STDAFX_H
+#define __STDAFX_H
+
+// #include "MyWindows.h"
+#include "NewHandler.h"
+
+#endif
diff --git a/payloads/bayou/util/pbuilder/lzma/C/Common/Types.h b/payloads/bayou/util/pbuilder/lzma/C/Common/Types.h
index 52d07081e8..0bf66e086b 100644
--- a/payloads/bayou/util/pbuilder/lzma/C/Common/Types.h
+++ b/payloads/bayou/util/pbuilder/lzma/C/Common/Types.h
@@ -1,19 +1,19 @@
-// Common/Types.h

-

-#ifndef __COMMON_TYPES_H

-#define __COMMON_TYPES_H

-

-typedef unsigned char Byte;

-typedef short Int16;

-typedef unsigned short UInt16;

-typedef int Int32;

-typedef unsigned int UInt32;

-#ifdef _MSC_VER

-typedef __int64 Int64;

-typedef unsigned __int64 UInt64;

-#else

-typedef long long int Int64;

-typedef unsigned long long int UInt64;

-#endif

-

-#endif

+// Common/Types.h
+
+#ifndef __COMMON_TYPES_H
+#define __COMMON_TYPES_H
+
+typedef unsigned char Byte;
+typedef short Int16;
+typedef unsigned short UInt16;
+typedef int Int32;
+typedef unsigned int UInt32;
+#ifdef _MSC_VER
+typedef __int64 Int64;
+typedef unsigned __int64 UInt64;
+#else
+typedef long long int Int64;
+typedef unsigned long long int UInt64;
+#endif
+
+#endif