react-native-update 10.34.3 → 10.34.5

package/harmony/pushy/src/main/cpp/lzma/C/LzmaEnc.c

@@ -1,5 +1,5 @@
 /* LzmaEnc.c -- LZMA Encoder
-Igor Pavlov : Public domain */
+2019-01-10: Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
@@ -12,36 +12,22 @@ Igor Pavlov : Public domain */
 #include <stdio.h>
 #endif
 
-#include "CpuArch.h"
 #include "LzmaEnc.h"
 
 #include "LzFind.h"
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 #include "LzFindMt.h"
 #endif
 
-/* the following LzmaEnc_* declarations is internal LZMA interface for LZMA2 encoder */
-
-SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle p, ISeqInStreamPtr inStream, UInt32 keepWindowSize,
-    ISzAllocPtr alloc, ISzAllocPtr allocBig);
-SRes LzmaEnc_MemPrepare(CLzmaEncHandle p, const Byte *src, SizeT srcLen,
-    UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig);
-SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle p, BoolInt reInit,
-    Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize);
-const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle p);
-void LzmaEnc_Finish(CLzmaEncHandle p);
-void LzmaEnc_SaveState(CLzmaEncHandle p);
-void LzmaEnc_RestoreState(CLzmaEncHandle p);
-
 #ifdef SHOW_STAT
 static unsigned g_STAT_OFFSET = 0;
 #endif
 
-/* for good normalization speed we still reserve 256 MB before 4 GB range */
-#define kLzmaMaxHistorySize ((UInt32)15 << 28)
+#define kLzmaMaxHistorySize ((UInt32)3 << 29)
+/* #define kLzmaMaxHistorySize ((UInt32)7 << 29) */
 
-// #define kNumTopBits 24
-#define kTopValue ((UInt32)1 << 24)
+#define kNumTopBits 24
+#define kTopValue ((UInt32)1 << kNumTopBits)
 
 #define kNumBitModelTotalBits 11
 #define kBitModelTotal (1 << kNumBitModelTotalBits)
@@ -50,7 +36,7 @@ static unsigned g_STAT_OFFSET = 0;
 
 #define kNumMoveReducingBits 4
 #define kNumBitPriceShiftBits 4
-// #define kBitPrice (1 << kNumBitPriceShiftBits)
+#define kBitPrice (1 << kNumBitPriceShiftBits)
 
 #define REP_LEN_COUNT 64
 
@@ -60,11 +46,7 @@ void LzmaEncProps_Init(CLzmaEncProps *p)
   p->dictSize = p->mc = 0;
   p->reduceSize = (UInt64)(Int64)-1;
   p->lc = p->lp = p->pb = p->algo = p->fb = p->btMode = p->numHashBytes = p->numThreads = -1;
-  p->numHashOutBits = 0;
   p->writeEndMark = 0;
-  p->affinityGroup = -1;
-  p->affinity = 0;
-  p->affinityInGroup = 0;
 }
 
 void LzmaEncProps_Normalize(CLzmaEncProps *p)
@@ -73,36 +55,31 @@ void LzmaEncProps_Normalize(CLzmaEncProps *p)
   if (level < 0) level = 5;
   p->level = level;
   
-  if (p->dictSize == 0)
-    p->dictSize = (unsigned)level <= 4 ?
-        (UInt32)1 << (level * 2 + 16) :
-        (unsigned)level <= sizeof(size_t) / 2 + 4 ?
-          (UInt32)1 << (level + 20) :
-          (UInt32)1 << (sizeof(size_t) / 2 + 24);
-
+  if (p->dictSize == 0) p->dictSize = (level <= 5 ? (1 << (level * 2 + 14)) : (level <= 7 ? (1 << 25) : (1 << 26)));
   if (p->dictSize > p->reduceSize)
   {
-    UInt32 v = (UInt32)p->reduceSize;
-    const UInt32 kReduceMin = ((UInt32)1 << 12);
-    if (v < kReduceMin)
-      v = kReduceMin;
-    if (p->dictSize > v)
-      p->dictSize = v;
+    unsigned i;
+    UInt32 reduceSize = (UInt32)p->reduceSize;
+    for (i = 11; i <= 30; i++)
+    {
+      if (reduceSize <= ((UInt32)2 << i)) { p->dictSize = ((UInt32)2 << i); break; }
+      if (reduceSize <= ((UInt32)3 << i)) { p->dictSize = ((UInt32)3 << i); break; }
+    }
   }
 
   if (p->lc < 0) p->lc = 3;
   if (p->lp < 0) p->lp = 0;
   if (p->pb < 0) p->pb = 2;
 
-  if (p->algo < 0) p->algo = (unsigned)level < 5 ? 0 : 1;
-  if (p->fb < 0) p->fb = (unsigned)level < 7 ? 32 : 64;
+  if (p->algo < 0) p->algo = (level < 5 ? 0 : 1);
+  if (p->fb < 0) p->fb = (level < 7 ? 32 : 64);
   if (p->btMode < 0) p->btMode = (p->algo == 0 ? 0 : 1);
-  if (p->numHashBytes < 0) p->numHashBytes = (p->btMode ? 4 : 5);
-  if (p->mc == 0) p->mc = (16 + ((unsigned)p->fb >> 1)) >> (p->btMode ? 0 : 1);
+  if (p->numHashBytes < 0) p->numHashBytes = 4;
+  if (p->mc == 0) p->mc = (16 + (p->fb >> 1)) >> (p->btMode ? 0 : 1);
   
   if (p->numThreads < 0)
     p->numThreads =
-      #ifndef Z7_ST
+      #ifndef _7ZIP_ST
       ((p->btMode && p->algo) ? 2 : 1);
       #else
       1;
@@ -116,97 +93,30 @@ UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2)
   return props.dictSize;
 }
 
-
-/*
-x86/x64:
-
-BSR:
-  IF (SRC == 0) ZF = 1, DEST is undefined;
-                  AMD : DEST is unchanged;
-  IF (SRC != 0) ZF = 0; DEST is index of top non-zero bit
-  BSR is slow in some processors
-
-LZCNT:
-  IF (SRC  == 0) CF = 1, DEST is size_in_bits_of_register(src) (32 or 64)
-  IF (SRC  != 0) CF = 0, DEST = num_lead_zero_bits
-  IF (DEST == 0) ZF = 1;
-
-LZCNT works only in new processors starting from Haswell.
-if LZCNT is not supported by processor, then it's executed as BSR.
-LZCNT can be faster than BSR, if supported.
-*/
-
-// #define LZMA_LOG_BSR
-
-#if defined(MY_CPU_ARM_OR_ARM64) /* || defined(MY_CPU_X86_OR_AMD64) */
-
-  #if (defined(__clang__) && (__clang_major__ >= 6)) \
-      || (defined(__GNUC__) && (__GNUC__ >= 6))
-      #define LZMA_LOG_BSR
-  #elif defined(_MSC_VER) && (_MSC_VER >= 1300)
-    // #if defined(MY_CPU_ARM_OR_ARM64)
-      #define LZMA_LOG_BSR
-    // #endif
-  #endif
+#if (_MSC_VER >= 1400)
+/* BSR code is fast for some new CPUs */
+/* #define LZMA_LOG_BSR */
 #endif
 
-// #include <intrin.h>
-
 #ifdef LZMA_LOG_BSR
 
-#if defined(__clang__) \
-    || defined(__GNUC__)
-
-/*
-  C code:                  : (30 - __builtin_clz(x))
-    gcc9/gcc10 for x64 /x86  : 30 - (bsr(x) xor 31)
-    clang10 for x64          : 31 + (bsr(x) xor -32)
-*/
+#define kDicLogSizeMaxCompress 32
 
-  #define MY_clz(x)  ((unsigned)__builtin_clz(x))
-  // __lzcnt32
-  // __builtin_ia32_lzcnt_u32
+#define BSR2_RET(pos, res) { unsigned long zz; _BitScanReverse(&zz, (pos)); res = (zz + zz) + ((pos >> (zz - 1)) & 1); }
 
-#else  // #if defined(_MSC_VER)
-
-  #ifdef MY_CPU_ARM_OR_ARM64
-
-    #define MY_clz  _CountLeadingZeros
-
-  #else // if defined(MY_CPU_X86_OR_AMD64)
-
-    // #define MY_clz  __lzcnt  // we can use lzcnt (unsupported by old CPU)
-    // _BitScanReverse code is not optimal for some MSVC compilers
-    #define BSR2_RET(pos, res) { unsigned long zz; _BitScanReverse(&zz, (pos)); zz--; \
-      res = (zz + zz) + (pos >> zz); }
-
-  #endif // MY_CPU_X86_OR_AMD64
-
-#endif // _MSC_VER
-
-
-#ifndef BSR2_RET
-
-    #define BSR2_RET(pos, res) { unsigned zz = 30 - MY_clz(pos); \
-      res = (zz + zz) + (pos >> zz); }
-
-#endif
-
-
-unsigned GetPosSlot1(UInt32 pos);
-unsigned GetPosSlot1(UInt32 pos)
+static unsigned GetPosSlot1(UInt32 pos)
 {
   unsigned res;
-  BSR2_RET(pos, res)
+  BSR2_RET(pos, res);
   return res;
 }
-#define GetPosSlot2(pos, res) { BSR2_RET(pos, res) }
-#define GetPosSlot(pos, res) { if (pos < 2) res = pos; else BSR2_RET(pos, res) }
-
+#define GetPosSlot2(pos, res) { BSR2_RET(pos, res); }
+#define GetPosSlot(pos, res) { if (pos < 2) res = pos; else BSR2_RET(pos, res); }
 
-#else // ! LZMA_LOG_BSR
+#else
 
-#define kNumLogBits (11 + sizeof(size_t) / 8 * 3)
+#define kNumLogBits (9 + sizeof(size_t) / 2)
+/* #define kNumLogBits (11 + sizeof(size_t) / 8 * 3) */
 
 #define kDicLogSizeMaxCompress ((kNumLogBits - 1) * 2 + 7)
 
@@ -253,7 +163,7 @@ static void LzmaEnc_FastPosInit(Byte *g_FastPos)
 #define GetPosSlot2(pos, res) { BSR2_RET(pos, res); }
 #define GetPosSlot(pos, res) { if (pos < kNumFullDistances) res = p->g_FastPos[pos & (kNumFullDistances - 1)]; else BSR2_RET(pos, res); }
 
-#endif // LZMA_LOG_BSR
+#endif
 
 
 #define LZMA_NUM_REPS 4
@@ -283,7 +193,7 @@ typedef struct
 
 #define kNumLenToPosStates 4
 #define kNumPosSlotBits 6
-// #define kDicLogSizeMin 0
+#define kDicLogSizeMin 0
 #define kDicLogSizeMax 32
 #define kDistTableSizeMax (kDicLogSizeMax * 2)
 
@@ -296,7 +206,7 @@ typedef struct
 #define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
 
 typedef
-#ifdef Z7_LZMA_PROB32
+#ifdef _LZMA_PROB32
   UInt32
 #else
   UInt16
@@ -353,7 +263,7 @@ typedef struct
   Byte *buf;
   Byte *bufLim;
   Byte *bufBase;
-  ISeqOutStreamPtr outStream;
+  ISeqOutStream *outStream;
   UInt64 processed;
   SRes res;
 } CRangeEnc;
@@ -386,10 +296,10 @@ typedef struct
 typedef UInt32 CProbPrice;
 
 
-struct CLzmaEnc
+typedef struct
 {
   void *matchFinderObj;
-  IMatchFinder2 matchFinder;
+  IMatchFinder matchFinder;
 
   unsigned optCur;
   unsigned optEnd;
@@ -429,30 +339,24 @@ struct CLzmaEnc
   UInt32 dictSize;
   SRes result;
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   BoolInt mtMode;
   // begin of CMatchFinderMt is used in LZ thread
   CMatchFinderMt matchFinderMt;
   // end of CMatchFinderMt is used in BT and HASH threads
-  // #else
-  // CMatchFinder matchFinderBase;
   #endif
+
   CMatchFinder matchFinderBase;
 
-  
-  // we suppose that we have 8-bytes alignment after CMatchFinder
- 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   Byte pad[128];
   #endif
   
   // LZ thread
   CProbPrice ProbPrices[kBitModelTotal >> kNumMoveReducingBits];
 
-  // we want {len , dist} pairs to be 8-bytes aligned in matches array
-  UInt32 matches[LZMA_MATCH_LEN_MAX * 2 + 2];
+  UInt32 matches[LZMA_MATCH_LEN_MAX * 2 + 2 + 1];
 
-  // we want 8-bytes alignment here
   UInt32 alignPrices[kAlignTableSize];
   UInt32 posSlotPrices[kNumLenToPosStates][kDistTableSizeMax];
   UInt32 distancesPrices[kNumLenToPosStates][kNumFullDistances];
@@ -481,115 +385,113 @@ struct CLzmaEnc
 
   CSaveState saveState;
 
-  // BoolInt mf_Failure;
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   Byte pad2[128];
   #endif
-};
+} CLzmaEnc;
 
 
-#define MFB (p->matchFinderBase)
-/*
-#ifndef Z7_ST
-#define MFB (p->matchFinderMt.MatchFinder)
-#endif
-*/
 
-// #define GET_CLzmaEnc_p  CLzmaEnc *p = (CLzmaEnc*)(void *)p;
-// #define GET_const_CLzmaEnc_p  const CLzmaEnc *p = (const CLzmaEnc*)(const void *)p;
-
-#define COPY_ARR(dest, src, arr)  memcpy((dest)->arr, (src)->arr, sizeof((src)->arr));
-
-#define COPY_LZMA_ENC_STATE(d, s, p)  \
-  (d)->state = (s)->state;  \
-  COPY_ARR(d, s, reps)  \
-  COPY_ARR(d, s, posAlignEncoder)  \
-  COPY_ARR(d, s, isRep)  \
-  COPY_ARR(d, s, isRepG0)  \
-  COPY_ARR(d, s, isRepG1)  \
-  COPY_ARR(d, s, isRepG2)  \
-  COPY_ARR(d, s, isMatch)  \
-  COPY_ARR(d, s, isRep0Long)  \
-  COPY_ARR(d, s, posSlotEncoder)  \
-  COPY_ARR(d, s, posEncoders)  \
-  (d)->lenProbs = (s)->lenProbs;  \
-  (d)->repLenProbs = (s)->repLenProbs;  \
-  memcpy((d)->litProbs, (s)->litProbs, ((size_t)0x300 * sizeof(CLzmaProb)) << (p)->lclp);
-
-void LzmaEnc_SaveState(CLzmaEncHandle p)
-{
-  // GET_CLzmaEnc_p
-  CSaveState *v = &p->saveState;
-  COPY_LZMA_ENC_STATE(v, p, p)
+#define COPY_ARR(dest, src, arr) memcpy(dest->arr, src->arr, sizeof(src->arr));
+
+void LzmaEnc_SaveState(CLzmaEncHandle pp)
+{
+  CLzmaEnc *p = (CLzmaEnc *)pp;
+  CSaveState *dest = &p->saveState;
+  
+  dest->state = p->state;
+  
+  dest->lenProbs = p->lenProbs;
+  dest->repLenProbs = p->repLenProbs;
+
+  COPY_ARR(dest, p, reps);
+
+  COPY_ARR(dest, p, posAlignEncoder);
+  COPY_ARR(dest, p, isRep);
+  COPY_ARR(dest, p, isRepG0);
+  COPY_ARR(dest, p, isRepG1);
+  COPY_ARR(dest, p, isRepG2);
+  COPY_ARR(dest, p, isMatch);
+  COPY_ARR(dest, p, isRep0Long);
+  COPY_ARR(dest, p, posSlotEncoder);
+  COPY_ARR(dest, p, posEncoders);
+
+  memcpy(dest->litProbs, p->litProbs, ((UInt32)0x300 << p->lclp) * sizeof(CLzmaProb));
 }
 
-void LzmaEnc_RestoreState(CLzmaEncHandle p)
+
+void LzmaEnc_RestoreState(CLzmaEncHandle pp)
 {
-  // GET_CLzmaEnc_p
-  const CSaveState *v = &p->saveState;
-  COPY_LZMA_ENC_STATE(p, v, p)
+  CLzmaEnc *dest = (CLzmaEnc *)pp;
+  const CSaveState *p = &dest->saveState;
+
+  dest->state = p->state;
+
+  dest->lenProbs = p->lenProbs;
+  dest->repLenProbs = p->repLenProbs;
+  
+  COPY_ARR(dest, p, reps);
+  
+  COPY_ARR(dest, p, posAlignEncoder);
+  COPY_ARR(dest, p, isRep);
+  COPY_ARR(dest, p, isRepG0);
+  COPY_ARR(dest, p, isRepG1);
+  COPY_ARR(dest, p, isRepG2);
+  COPY_ARR(dest, p, isMatch);
+  COPY_ARR(dest, p, isRep0Long);
+  COPY_ARR(dest, p, posSlotEncoder);
+  COPY_ARR(dest, p, posEncoders);
+
+  memcpy(dest->litProbs, p->litProbs, ((UInt32)0x300 << dest->lclp) * sizeof(CLzmaProb));
 }
 
 
-Z7_NO_INLINE
-SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props2)
+
+SRes LzmaEnc_SetProps(CLzmaEncHandle pp, const CLzmaEncProps *props2)
 {
-  // GET_CLzmaEnc_p
+  CLzmaEnc *p = (CLzmaEnc *)pp;
   CLzmaEncProps props = *props2;
   LzmaEncProps_Normalize(&props);
 
   if (props.lc > LZMA_LC_MAX
       || props.lp > LZMA_LP_MAX
-      || props.pb > LZMA_PB_MAX)
+      || props.pb > LZMA_PB_MAX
+      || props.dictSize > ((UInt64)1 << kDicLogSizeMaxCompress)
+      || props.dictSize > kLzmaMaxHistorySize)
     return SZ_ERROR_PARAM;
 
-
-  if (props.dictSize > kLzmaMaxHistorySize)
-    props.dictSize = kLzmaMaxHistorySize;
-
-  #ifndef LZMA_LOG_BSR
-  {
-    const UInt64 dict64 = props.dictSize;
-    if (dict64 > ((UInt64)1 << kDicLogSizeMaxCompress))
-      return SZ_ERROR_PARAM;
-  }
-  #endif
-
   p->dictSize = props.dictSize;
   {
-    unsigned fb = (unsigned)props.fb;
+    unsigned fb = props.fb;
     if (fb < 5)
       fb = 5;
     if (fb > LZMA_MATCH_LEN_MAX)
       fb = LZMA_MATCH_LEN_MAX;
     p->numFastBytes = fb;
   }
-  p->lc = (unsigned)props.lc;
-  p->lp = (unsigned)props.lp;
-  p->pb = (unsigned)props.pb;
+  p->lc = props.lc;
+  p->lp = props.lp;
+  p->pb = props.pb;
   p->fastMode = (props.algo == 0);
   // p->_maxMode = True;
-  MFB.btMode = (Byte)(props.btMode ? 1 : 0);
-  // MFB.btMode = (Byte)(props.btMode);
+  p->matchFinderBase.btMode = (Byte)(props.btMode ? 1 : 0);
   {
     unsigned numHashBytes = 4;
     if (props.btMode)
     {
-           if (props.numHashBytes <  2) numHashBytes = 2;
-      else if (props.numHashBytes <  4) numHashBytes = (unsigned)props.numHashBytes;
+      if (props.numHashBytes < 2)
+        numHashBytes = 2;
+      else if (props.numHashBytes < 4)
+        numHashBytes = props.numHashBytes;
     }
-    if (props.numHashBytes >= 5) numHashBytes = 5;
-
-    MFB.numHashBytes = numHashBytes;
-    // MFB.numHashBytes_Min = 2;
-    MFB.numHashOutBits = (Byte)props.numHashOutBits;
+    p->matchFinderBase.numHashBytes = numHashBytes;
   }
 
-  MFB.cutValue = props.mc;
+  p->matchFinderBase.cutValue = props.mc;
 
-  p->writeEndMark = (BoolInt)props.writeEndMark;
+  p->writeEndMark = props.writeEndMark;
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   /*
   if (newMultiThread != _multiThread)
   {
@@ -598,22 +500,16 @@ SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props2)
   }
   */
   p->multiThread = (props.numThreads > 1);
-  p->matchFinderMt.btSync.affinity =
-  p->matchFinderMt.hashSync.affinity = props.affinity;
-  p->matchFinderMt.btSync.affinityGroup =
-  p->matchFinderMt.hashSync.affinityGroup = props.affinityGroup;
-  p->matchFinderMt.btSync.affinityInGroup =
-  p->matchFinderMt.hashSync.affinityInGroup = props.affinityInGroup;
   #endif
 
   return SZ_OK;
 }
 
 
-void LzmaEnc_SetDataSize(CLzmaEncHandle p, UInt64 expectedDataSiize)
+void LzmaEnc_SetDataSize(CLzmaEncHandle pp, UInt64 expectedDataSiize)
 {
-  // GET_CLzmaEnc_p
-  MFB.expectedDataSize = expectedDataSiize;
+  CLzmaEnc *p = (CLzmaEnc *)pp;
+  p->matchFinderBase.expectedDataSize = expectedDataSiize;
 }
 
 
@@ -640,8 +536,8 @@ static void RangeEnc_Construct(CRangeEnc *p)
   p->bufBase = NULL;
 }
 
-#define RangeEnc_GetProcessed(p)       (        (p)->processed + (size_t)((p)->buf - (p)->bufBase) +         (p)->cacheSize)
-#define RangeEnc_GetProcessed_sizet(p) ((size_t)(p)->processed + (size_t)((p)->buf - (p)->bufBase) + (size_t)(p)->cacheSize)
+#define RangeEnc_GetProcessed(p)       ((p)->processed + ((p)->buf - (p)->bufBase) + (p)->cacheSize)
+#define RangeEnc_GetProcessed_sizet(p) ((size_t)(p)->processed + ((p)->buf - (p)->bufBase) + (size_t)(p)->cacheSize)
 
 #define RC_BUF_SIZE (1 << 16)
 
@@ -660,11 +556,12 @@ static int RangeEnc_Alloc(CRangeEnc *p, ISzAllocPtr alloc)
 static void RangeEnc_Free(CRangeEnc *p, ISzAllocPtr alloc)
 {
   ISzAlloc_Free(alloc, p->bufBase);
-  p->bufBase = NULL;
+  p->bufBase = 0;
 }
 
 static void RangeEnc_Init(CRangeEnc *p)
 {
+  /* Stream.Init(); */
   p->range = 0xFFFFFFFF;
   p->cache = 0;
   p->low = 0;
@@ -676,19 +573,19 @@ static void RangeEnc_Init(CRangeEnc *p)
   p->res = SZ_OK;
 }
 
-Z7_NO_INLINE static void RangeEnc_FlushStream(CRangeEnc *p)
+MY_NO_INLINE static void RangeEnc_FlushStream(CRangeEnc *p)
 {
-  const size_t num = (size_t)(p->buf - p->bufBase);
-  if (p->res == SZ_OK)
-  {
-    if (num != ISeqOutStream_Write(p->outStream, p->bufBase, num))
-      p->res = SZ_ERROR_WRITE;
-  }
+  size_t num;
+  if (p->res != SZ_OK)
+    return;
+  num = p->buf - p->bufBase;
+  if (num != ISeqOutStream_Write(p->outStream, p->bufBase, num))
+    p->res = SZ_ERROR_WRITE;
   p->processed += num;
   p->buf = p->bufBase;
 }
 
-Z7_NO_INLINE static void Z7_FASTCALL RangeEnc_ShiftLow(CRangeEnc *p)
+MY_NO_INLINE static void MY_FAST_CALL RangeEnc_ShiftLow(CRangeEnc *p)
 {
   UInt32 low = (UInt32)p->low;
   unsigned high = (unsigned)(p->low >> 32);
@@ -733,9 +630,9 @@ static void RangeEnc_FlushData(CRangeEnc *p)
   ttt = *(prob); \
   newBound = (range >> kNumBitModelTotalBits) * ttt;
 
-// #define Z7_LZMA_ENC_USE_BRANCH
+// #define _LZMA_ENC_USE_BRANCH
 
-#ifdef Z7_LZMA_ENC_USE_BRANCH
+#ifdef _LZMA_ENC_USE_BRANCH
 
 #define RC_BIT(p, prob, bit) { \
   RC_BIT_PRE(p, prob) \
@@ -759,7 +656,7 @@ static void RangeEnc_FlushData(CRangeEnc *p)
   range += newBound & mask; \
   mask &= (kBitModelTotal - ((1 << kNumMoveBits) - 1)); \
   mask += ((1 << kNumMoveBits) - 1); \
-  ttt += (UInt32)((Int32)(mask - ttt) >> kNumMoveBits); \
+  ttt += (Int32)(mask - ttt) >> kNumMoveBits; \
   *(prob) = (CLzmaProb)ttt; \
   RC_NORM(p) \
   }
@@ -803,7 +700,7 @@ static void LitEnc_Encode(CRangeEnc *p, CLzmaProb *probs, UInt32 sym)
     CLzmaProb *prob = probs + (sym >> 8);
     UInt32 bit = (sym >> 7) & 1;
     sym <<= 1;
-    RC_BIT(p, prob, bit)
+    RC_BIT(p, prob, bit);
   }
   while (sym < 0x10000);
   p->range = range;
@@ -825,7 +722,7 @@ static void LitEnc_EncodeMatched(CRangeEnc *p, CLzmaProb *probs, UInt32 sym, UIn
     bit = (sym >> 7) & 1;
     sym <<= 1;
     offs &= ~(matchByte ^ sym);
-    RC_BIT(p, prob, bit)
+    RC_BIT(p, prob, bit);
   }
   while (sym < 0x10000);
   p->range = range;
@@ -852,17 +749,17 @@ static void LzmaEnc_InitPriceTables(CProbPrice *ProbPrices)
         bitCount++;
       }
     }
-    ProbPrices[i] = (CProbPrice)(((unsigned)kNumBitModelTotalBits << kCyclesBits) - 15 - bitCount);
+    ProbPrices[i] = (CProbPrice)((kNumBitModelTotalBits << kCyclesBits) - 15 - bitCount);
     // printf("\n%3d: %5d", i, ProbPrices[i]);
   }
 }
 
 
 #define GET_PRICE(prob, bit) \
-  p->ProbPrices[((prob) ^ (unsigned)(((-(int)(bit))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits]
+  p->ProbPrices[((prob) ^ (unsigned)(((-(int)(bit))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits];
 
 #define GET_PRICEa(prob, bit) \
-     ProbPrices[((prob) ^ (unsigned)((-((int)(bit))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits]
+     ProbPrices[((prob) ^ (unsigned)((-((int)(bit))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits];
 
 #define GET_PRICE_0(prob) p->ProbPrices[(prob) >> kNumMoveReducingBits]
 #define GET_PRICE_1(prob) p->ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]
@@ -913,7 +810,7 @@ static void RcTree_ReverseEncode(CRangeEnc *rc, CLzmaProb *probs, unsigned numBi
     unsigned bit = sym & 1;
     // RangeEnc_EncodeBit(rc, probs + m, bit);
     sym >>= 1;
-    RC_BIT(rc, probs + m, bit)
+    RC_BIT(rc, probs + m, bit);
     m = (m << 1) | bit;
   }
   while (--numBits);
@@ -936,15 +833,15 @@ static void LenEnc_Encode(CLenEnc *p, CRangeEnc *rc, unsigned sym, unsigned posS
   UInt32 range, ttt, newBound;
   CLzmaProb *probs = p->low;
   range = rc->range;
-  RC_BIT_PRE(rc, probs)
+  RC_BIT_PRE(rc, probs);
   if (sym >= kLenNumLowSymbols)
   {
-    RC_BIT_1(rc, probs)
+    RC_BIT_1(rc, probs);
     probs += kLenNumLowSymbols;
-    RC_BIT_PRE(rc, probs)
+    RC_BIT_PRE(rc, probs);
     if (sym >= kLenNumLowSymbols * 2)
     {
-      RC_BIT_1(rc, probs)
+      RC_BIT_1(rc, probs);
       rc->range = range;
       // RcTree_Encode(rc, p->high, kLenNumHighBits, sym - kLenNumLowSymbols * 2);
       LitEnc_Encode(rc, p->high, sym - kLenNumLowSymbols * 2);
@@ -957,11 +854,11 @@ static void LenEnc_Encode(CLenEnc *p, CRangeEnc *rc, unsigned sym, unsigned posS
   {
     unsigned m;
     unsigned bit;
-    RC_BIT_0(rc, probs)
+    RC_BIT_0(rc, probs);
     probs += (posState << (1 + kLenNumLowBits));
-    bit = (sym >> 2)    ; RC_BIT(rc, probs + 1, bit)  m = (1 << 1) + bit;
-    bit = (sym >> 1) & 1; RC_BIT(rc, probs + m, bit)  m = (m << 1) + bit;
-    bit =  sym       & 1; RC_BIT(rc, probs + m, bit)
+    bit = (sym >> 2)    ; RC_BIT(rc, probs + 1, bit); m = (1 << 1) + bit;
+    bit = (sym >> 1) & 1; RC_BIT(rc, probs + m, bit); m = (m << 1) + bit;
+    bit =  sym       & 1; RC_BIT(rc, probs + m, bit);
     rc->range = range;
   }
 }
@@ -982,7 +879,7 @@ static void SetPrices_3(const CLzmaProb *probs, UInt32 startPrice, UInt32 *price
 }
 
 
-Z7_NO_INLINE static void Z7_FASTCALL LenPriceEnc_UpdateTables(
+MY_NO_INLINE static void MY_FAST_CALL LenPriceEnc_UpdateTables(
     CLenPriceEnc *p,
     unsigned numPosStates,
     const CLenEnc *enc,
@@ -1046,14 +943,14 @@ Z7_NO_INLINE static void Z7_FASTCALL LenPriceEnc_UpdateTables(
         UInt32 price = b;
         do
         {
-          const unsigned bit = sym & 1;
+          unsigned bit = sym & 1;
           sym >>= 1;
           price += GET_PRICEa(probs[sym], bit);
         }
         while (sym >= 2);
 
         {
-          const unsigned prob = probs[(size_t)i + (1 << (kLenNumHighBits - 1))];
+          unsigned prob = probs[(size_t)i + (1 << (kLenNumHighBits - 1))];
           prices[(size_t)i * 2    ] = price + GET_PRICEa_0(prob);
           prices[(size_t)i * 2 + 1] = price + GET_PRICEa_1(prob);
         }
@@ -1062,7 +959,7 @@ Z7_NO_INLINE static void Z7_FASTCALL LenPriceEnc_UpdateTables(
 
       {
         unsigned posState;
-        const size_t num = (p->tableSize - kLenNumLowSymbols * 2) * sizeof(p->prices[0][0]);
+        size_t num = (p->tableSize - kLenNumLowSymbols * 2) * sizeof(p->prices[0][0]);
         for (posState = 1; posState < numPosStates; posState++)
           memcpy(p->prices[posState] + kLenNumLowSymbols * 2, p->prices[0] + kLenNumLowSymbols * 2, num);
       }
@@ -1088,11 +985,7 @@ static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
   
   p->additionalOffset++;
   p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
-  {
-    const UInt32 *d = p->matchFinder.GetMatches(p->matchFinderObj, p->matches);
-    // if (!d) { p->mf_Failure = True; *numPairsRes = 0;  return 0; }
-    numPairs = (unsigned)(d - p->matches);
-  }
+  numPairs = p->matchFinder.GetMatches(p->matchFinderObj, p->matches);
   *numPairsRes = numPairs;
   
   #ifdef SHOW_STAT
@@ -1108,7 +1001,7 @@ static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
   if (numPairs == 0)
     return 0;
   {
-    const unsigned len = p->matches[(size_t)numPairs - 2];
+    unsigned len = p->matches[(size_t)numPairs - 2];
     if (len != p->numFastBytes)
       return len;
     {
@@ -1118,7 +1011,7 @@ static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
       {
         const Byte *p1 = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
         const Byte *p2 = p1 + len;
-        const ptrdiff_t dif = (ptrdiff_t)-1 - (ptrdiff_t)p->matches[(size_t)numPairs - 1];
+        ptrdiff_t dif = (ptrdiff_t)-1 - p->matches[(size_t)numPairs - 1];
         const Byte *lim = p1 + numAvail;
         for (; p2 != lim && *p2 == p2[dif]; p2++)
         {}
@@ -1144,7 +1037,7 @@ static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
   + GET_PRICE_1(p->isRep[state]) \
   + GET_PRICE_0(p->isRepG0[state])
   
-Z7_FORCE_INLINE
+MY_FORCE_INLINE
 static UInt32 GetPrice_PureRep(const CLzmaEnc *p, unsigned repIndex, size_t state, size_t posState)
 {
   UInt32 price;
@@ -1274,8 +1167,6 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
       repLens[i] = len;
       if (len > repLens[repMaxIndex])
         repMaxIndex = i;
-      if (len == LZMA_MATCH_LEN_MAX) // 21.03 : optimization
-        break;
     }
     
     if (repLens[repMaxIndex] >= p->numFastBytes)
@@ -1288,12 +1179,10 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
     }
     
     matches = p->matches;
-    #define MATCHES  matches
-    // #define MATCHES  p->matches
     
     if (mainLen >= p->numFastBytes)
     {
-      p->backRes = MATCHES[(size_t)numPairs - 1] + LZMA_NUM_REPS;
+      p->backRes = matches[(size_t)numPairs - 1] + LZMA_NUM_REPS;
       MOVE_POS(p, mainLen - 1)
       return mainLen;
     }
@@ -1323,7 +1212,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
           LitEnc_GetPrice(probs, curByte, p->ProbPrices));
     }
 
-    MakeAs_Lit(&p->opt[1])
+    MakeAs_Lit(&p->opt[1]);
     
     matchPrice = GET_PRICE_1(p->isMatch[p->state][posState]);
     repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[p->state]);
@@ -1335,7 +1224,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
       if (shortRepPrice < p->opt[1].price)
       {
         p->opt[1].price = shortRepPrice;
-        MakeAs_ShortRep(&p->opt[1])
+        MakeAs_ShortRep(&p->opt[1]);
       }
       if (last < 2)
       {
@@ -1387,13 +1276,13 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
         if (len < 2)
           len = 2;
         else
-          while (len > MATCHES[offs])
+          while (len > matches[offs])
             offs += 2;
     
         for (; ; len++)
         {
           COptimal *opt;
-          UInt32 dist = MATCHES[(size_t)offs + 1];
+          UInt32 dist = matches[(size_t)offs + 1];
           UInt32 price = normalMatchPrice + GET_PRICE_LEN(&p->lenEnc, posState, len);
           unsigned lenToPosState = GetLenToPosState(len);
        
@@ -1402,7 +1291,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
           else
           {
             unsigned slot;
-            GetPosSlot2(dist, slot)
+            GetPosSlot2(dist, slot);
             price += p->alignPrices[dist & kAlignMask];
             price += p->posSlotPrices[lenToPosState][slot];
           }
@@ -1417,7 +1306,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
             opt->extra = 0;
           }
           
-          if (len == MATCHES[offs])
+          if (len == matches[offs])
           {
             offs += 2;
             if (offs == numPairs)
@@ -1478,7 +1367,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
         unsigned delta = best - cur;
         if (delta != 0)
         {
-          MOVE_POS(p, delta)
+          MOVE_POS(p, delta);
         }
       }
       cur = best;
@@ -1625,7 +1514,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
       {
         nextOpt->price = litPrice;
         nextOpt->len = 1;
-        MakeAs_Lit(nextOpt)
+        MakeAs_Lit(nextOpt);
         nextIsLit = True;
       }
     }
@@ -1659,7 +1548,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
       {
         nextOpt->price = shortRepPrice;
         nextOpt->len = 1;
-        MakeAs_ShortRep(nextOpt)
+        MakeAs_ShortRep(nextOpt);
         nextIsLit = False;
       }
     }
@@ -1838,8 +1727,8 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
     if (newLen > numAvail)
     {
       newLen = numAvail;
-      for (numPairs = 0; newLen > MATCHES[numPairs]; numPairs += 2);
-      MATCHES[numPairs] = (UInt32)newLen;
+      for (numPairs = 0; newLen > matches[numPairs]; numPairs += 2);
+      matches[numPairs] = (UInt32)newLen;
       numPairs += 2;
     }
     
@@ -1858,12 +1747,12 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
       }
 
       offs = 0;
-      while (startLen > MATCHES[offs])
+      while (startLen > matches[offs])
         offs += 2;
-      dist = MATCHES[(size_t)offs + 1];
+      dist = matches[(size_t)offs + 1];
       
       // if (dist >= kNumFullDistances)
-      GetPosSlot2(dist, posSlot)
+      GetPosSlot2(dist, posSlot);
       
       for (len = /*2*/ startLen; ; len++)
       {
@@ -1887,7 +1776,7 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
           }
         }
 
-        if (len == MATCHES[offs])
+        if (len == matches[offs])
         {
           // if (p->_maxMode) {
           // MATCH : LIT : REP_0
@@ -1952,9 +1841,9 @@ static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
           offs += 2;
           if (offs == numPairs)
             break;
-          dist = MATCHES[(size_t)offs + 1];
+          dist = matches[(size_t)offs + 1];
           // if (dist >= kNumFullDistances)
-            GetPosSlot2(dist, posSlot)
+            GetPosSlot2(dist, posSlot);
         }
       }
     }
@@ -2130,7 +2019,7 @@ static void WriteEndMarker(CLzmaEnc *p, unsigned posState)
     {
       UInt32 ttt, newBound;
       RC_BIT_PRE(p, probs + m)
-      RC_BIT_1(&p->rc, probs + m)
+      RC_BIT_1(&p->rc, probs + m);
       m = (m << 1) + 1;
     }
     while (m < (1 << kNumPosSlotBits));
@@ -2155,7 +2044,7 @@ static void WriteEndMarker(CLzmaEnc *p, unsigned posState)
     {
       UInt32 ttt, newBound;
       RC_BIT_PRE(p, probs + m)
-      RC_BIT_1(&p->rc, probs + m)
+      RC_BIT_1(&p->rc, probs + m);
       m = (m << 1) + 1;
     }
     while (m < kAlignTableSize);
@@ -2170,30 +2059,15 @@ static SRes CheckErrors(CLzmaEnc *p)
     return p->result;
   if (p->rc.res != SZ_OK)
     p->result = SZ_ERROR_WRITE;
-
-  #ifndef Z7_ST
-  if (
-      // p->mf_Failure ||
-        (p->mtMode &&
-          ( // p->matchFinderMt.failure_LZ_LZ ||
-            p->matchFinderMt.failure_LZ_BT))
-     )
-  {
-    p->result = MY_HRES_ERROR_INTERNAL_ERROR;
-    // printf("\nCheckErrors p->matchFinderMt.failureLZ\n");
-  }
-  #endif
-
-  if (MFB.result != SZ_OK)
+  if (p->matchFinderBase.result != SZ_OK)
     p->result = SZ_ERROR_READ;
-  
   if (p->result != SZ_OK)
     p->finished = True;
   return p->result;
 }
 
 
-Z7_NO_INLINE static SRes Flush(CLzmaEnc *p, UInt32 nowPos)
+MY_NO_INLINE static SRes Flush(CLzmaEnc *p, UInt32 nowPos)
 {
   /* ReleaseMFStream(); */
   p->finished = True;
@@ -2205,7 +2079,7 @@ Z7_NO_INLINE static SRes Flush(CLzmaEnc *p, UInt32 nowPos)
 }
 
 
-Z7_NO_INLINE static void FillAlignPrices(CLzmaEnc *p)
+MY_NO_INLINE static void FillAlignPrices(CLzmaEnc *p)
 {
   unsigned i;
   const CProbPrice *ProbPrices = p->ProbPrices;
@@ -2229,7 +2103,7 @@ Z7_NO_INLINE static void FillAlignPrices(CLzmaEnc *p)
 }
 
 
-Z7_NO_INLINE static void FillDistancesPrices(CLzmaEnc *p)
+MY_NO_INLINE static void FillDistancesPrices(CLzmaEnc *p)
 {
   // int y; for (y = 0; y < 100; y++) {
 
@@ -2324,20 +2198,20 @@ Z7_NO_INLINE static void FillDistancesPrices(CLzmaEnc *p)
 
 
 
-static void LzmaEnc_Construct(CLzmaEnc *p)
+void LzmaEnc_Construct(CLzmaEnc *p)
 {
   RangeEnc_Construct(&p->rc);
-  MatchFinder_Construct(&MFB);
+  MatchFinder_Construct(&p->matchFinderBase);
   
-  #ifndef Z7_ST
-  p->matchFinderMt.MatchFinder = &MFB;
+  #ifndef _7ZIP_ST
   MatchFinderMt_Construct(&p->matchFinderMt);
+  p->matchFinderMt.MatchFinder = &p->matchFinderBase;
   #endif
 
   {
     CLzmaEncProps props;
     LzmaEncProps_Init(&props);
-    LzmaEnc_SetProps((CLzmaEncHandle)(void *)p, &props);
+    LzmaEnc_SetProps(p, &props);
   }
 
   #ifndef LZMA_LOG_BSR
@@ -2347,6 +2221,7 @@ static void LzmaEnc_Construct(CLzmaEnc *p)
   LzmaEnc_InitPriceTables(p->ProbPrices);
   p->litProbs = NULL;
   p->saveState.litProbs = NULL;
+
 }
 
 CLzmaEncHandle LzmaEnc_Create(ISzAllocPtr alloc)
@@ -2358,7 +2233,7 @@ CLzmaEncHandle LzmaEnc_Create(ISzAllocPtr alloc)
   return p;
 }
 
-static void LzmaEnc_FreeLits(CLzmaEnc *p, ISzAllocPtr alloc)
+void LzmaEnc_FreeLits(CLzmaEnc *p, ISzAllocPtr alloc)
 {
   ISzAlloc_Free(alloc, p->litProbs);
   ISzAlloc_Free(alloc, p->saveState.litProbs);
@@ -2366,44 +2241,36 @@ static void LzmaEnc_FreeLits(CLzmaEnc *p, ISzAllocPtr alloc)
   p->saveState.litProbs = NULL;
 }
 
-static void LzmaEnc_Destruct(CLzmaEnc *p, ISzAllocPtr alloc, ISzAllocPtr allocBig)
+void LzmaEnc_Destruct(CLzmaEnc *p, ISzAllocPtr alloc, ISzAllocPtr allocBig)
 {
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   MatchFinderMt_Destruct(&p->matchFinderMt, allocBig);
   #endif
   
-  MatchFinder_Free(&MFB, allocBig);
+  MatchFinder_Free(&p->matchFinderBase, allocBig);
   LzmaEnc_FreeLits(p, alloc);
   RangeEnc_Free(&p->rc, alloc);
 }
 
 void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAllocPtr alloc, ISzAllocPtr allocBig)
 {
-  // GET_CLzmaEnc_p
-  LzmaEnc_Destruct(p, alloc, allocBig);
+  LzmaEnc_Destruct((CLzmaEnc *)p, alloc, allocBig);
   ISzAlloc_Free(alloc, p);
 }
 
 
-Z7_NO_INLINE
 static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpackSize)
 {
   UInt32 nowPos32, startPos32;
   if (p->needInit)
   {
-    #ifndef Z7_ST
-    if (p->mtMode)
-    {
-      RINOK(MatchFinderMt_InitMt(&p->matchFinderMt))
-    }
-    #endif
     p->matchFinder.Init(p->matchFinderObj);
     p->needInit = 0;
   }
 
   if (p->finished)
     return p->result;
-  RINOK(CheckErrors(p))
+  RINOK(CheckErrors(p));
 
   nowPos32 = (UInt32)p->nowPos64;
   startPos32 = nowPos32;
@@ -2466,7 +2333,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
       const Byte *data;
       unsigned state;
 
-      RC_BIT_0(&p->rc, probs)
+      RC_BIT_0(&p->rc, probs);
       p->rc.range = range;
       data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset;
       probs = LIT_PROBS(nowPos32, *(data - 1));
@@ -2480,53 +2347,53 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
     }
     else
     {
-      RC_BIT_1(&p->rc, probs)
+      RC_BIT_1(&p->rc, probs);
       probs = &p->isRep[p->state];
       RC_BIT_PRE(&p->rc, probs)
       
       if (dist < LZMA_NUM_REPS)
       {
-        RC_BIT_1(&p->rc, probs)
+        RC_BIT_1(&p->rc, probs);
         probs = &p->isRepG0[p->state];
         RC_BIT_PRE(&p->rc, probs)
         if (dist == 0)
         {
-          RC_BIT_0(&p->rc, probs)
+          RC_BIT_0(&p->rc, probs);
           probs = &p->isRep0Long[p->state][posState];
           RC_BIT_PRE(&p->rc, probs)
           if (len != 1)
           {
-            RC_BIT_1_BASE(&p->rc, probs)
+            RC_BIT_1_BASE(&p->rc, probs);
           }
           else
           {
-            RC_BIT_0_BASE(&p->rc, probs)
+            RC_BIT_0_BASE(&p->rc, probs);
             p->state = kShortRepNextStates[p->state];
           }
         }
         else
         {
-          RC_BIT_1(&p->rc, probs)
+          RC_BIT_1(&p->rc, probs);
           probs = &p->isRepG1[p->state];
           RC_BIT_PRE(&p->rc, probs)
           if (dist == 1)
           {
-            RC_BIT_0_BASE(&p->rc, probs)
+            RC_BIT_0_BASE(&p->rc, probs);
             dist = p->reps[1];
           }
           else
           {
-            RC_BIT_1(&p->rc, probs)
+            RC_BIT_1(&p->rc, probs);
             probs = &p->isRepG2[p->state];
             RC_BIT_PRE(&p->rc, probs)
             if (dist == 2)
             {
-              RC_BIT_0_BASE(&p->rc, probs)
+              RC_BIT_0_BASE(&p->rc, probs);
               dist = p->reps[2];
             }
             else
             {
-              RC_BIT_1_BASE(&p->rc, probs)
+              RC_BIT_1_BASE(&p->rc, probs);
               dist = p->reps[3];
               p->reps[3] = p->reps[2];
             }
@@ -2550,7 +2417,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
       else
       {
         unsigned posSlot;
-        RC_BIT_0(&p->rc, probs)
+        RC_BIT_0(&p->rc, probs);
         p->rc.range = range;
         p->state = kMatchNextStates[p->state];
 
@@ -2564,7 +2431,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
         p->reps[0] = dist + 1;
         
         p->matchPriceCount++;
-        GetPosSlot(dist, posSlot)
+        GetPosSlot(dist, posSlot);
         // RcTree_Encode_PosSlot(&p->rc, p->posSlotEncoder[GetLenToPosState(len)], posSlot);
         {
           UInt32 sym = (UInt32)posSlot + (1 << kNumPosSlotBits);
@@ -2575,7 +2442,7 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
             CLzmaProb *prob = probs + (sym >> kNumPosSlotBits);
             UInt32 bit = (sym >> (kNumPosSlotBits - 1)) & 1;
             sym <<= 1;
-            RC_BIT(&p->rc, prob, bit)
+            RC_BIT(&p->rc, prob, bit);
           }
           while (sym < (1 << kNumPosSlotBits * 2));
           p->rc.range = range;
@@ -2619,10 +2486,10 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
             {
               unsigned m = 1;
               unsigned bit;
-              bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit)  m = (m << 1) + bit;
-              bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit)  m = (m << 1) + bit;
-              bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit)  m = (m << 1) + bit;
-              bit = dist & 1;             RC_BIT(&p->rc, p->posAlignEncoder + m, bit)
+              bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit); m = (m << 1) + bit;
+              bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit); m = (m << 1) + bit;
+              bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit); m = (m << 1) + bit;
+              bit = dist & 1;             RC_BIT(&p->rc, p->posAlignEncoder + m, bit);
               p->rc.range = range;
               // p->alignPriceCount++;
             }
@@ -2654,12 +2521,12 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
           // { int y; for (y = 0; y < 100; y++) {
           FillDistancesPrices(p);
           // }}
-          LenPriceEnc_UpdateTables(&p->lenEnc, (unsigned)1 << p->pb, &p->lenProbs, p->ProbPrices);
+          LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, &p->lenProbs, p->ProbPrices);
         }
         if (p->repLenEncCounter <= 0)
         {
           p->repLenEncCounter = REP_LEN_COUNT;
-          LenPriceEnc_UpdateTables(&p->repLenEnc, (unsigned)1 << p->pb, &p->repLenProbs, p->ProbPrices);
+          LenPriceEnc_UpdateTables(&p->repLenEnc, 1 << p->pb, &p->repLenProbs, p->ProbPrices);
         }
       }
     
@@ -2692,22 +2559,20 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpa
 static SRes LzmaEnc_Alloc(CLzmaEnc *p, UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig)
 {
   UInt32 beforeSize = kNumOpts;
-  UInt32 dictSize;
-
   if (!RangeEnc_Alloc(&p->rc, alloc))
     return SZ_ERROR_MEM;
 
-  #ifndef Z7_ST
-  p->mtMode = (p->multiThread && !p->fastMode && (MFB.btMode != 0));
+  #ifndef _7ZIP_ST
+  p->mtMode = (p->multiThread && !p->fastMode && (p->matchFinderBase.btMode != 0));
   #endif
 
   {
-    const unsigned lclp = p->lc + p->lp;
+    unsigned lclp = p->lc + p->lp;
     if (!p->litProbs || !p->saveState.litProbs || p->lclp != lclp)
     {
       LzmaEnc_FreeLits(p, alloc);
-      p->litProbs =           (CLzmaProb *)ISzAlloc_Alloc(alloc, ((size_t)0x300 * sizeof(CLzmaProb)) << lclp);
-      p->saveState.litProbs = (CLzmaProb *)ISzAlloc_Alloc(alloc, ((size_t)0x300 * sizeof(CLzmaProb)) << lclp);
+      p->litProbs = (CLzmaProb *)ISzAlloc_Alloc(alloc, ((UInt32)0x300 << lclp) * sizeof(CLzmaProb));
+      p->saveState.litProbs = (CLzmaProb *)ISzAlloc_Alloc(alloc, ((UInt32)0x300 << lclp) * sizeof(CLzmaProb));
       if (!p->litProbs || !p->saveState.litProbs)
       {
         LzmaEnc_FreeLits(p, alloc);
@@ -2717,55 +2582,36 @@ static SRes LzmaEnc_Alloc(CLzmaEnc *p, UInt32 keepWindowSize, ISzAllocPtr alloc,
     }
   }
 
-  MFB.bigHash = (Byte)(p->dictSize > kBigHashDicLimit ? 1 : 0);
-
+  p->matchFinderBase.bigHash = (Byte)(p->dictSize > kBigHashDicLimit ? 1 : 0);
 
-  dictSize = p->dictSize;
-  if (dictSize == ((UInt32)2 << 30) ||
-      dictSize == ((UInt32)3 << 30))
-  {
-    /* 21.03 : here we reduce the dictionary for 2 reasons:
-       1) we don't want 32-bit back_distance matches in decoder for 2 GB dictionary.
-       2) we want to elimate useless last MatchFinder_Normalize3() for corner cases,
-          where data size is aligned for 1 GB: 5/6/8 GB.
-          That reducing must be >= 1 for such corner cases. */
-    dictSize -= 1;
-  }
+  if (beforeSize + p->dictSize < keepWindowSize)
+    beforeSize = keepWindowSize - p->dictSize;
 
-  if (beforeSize + dictSize < keepWindowSize)
-    beforeSize = keepWindowSize - dictSize;
-
-  /* in worst case we can look ahead for
-        max(LZMA_MATCH_LEN_MAX, numFastBytes + 1 + numFastBytes) bytes.
-     we send larger value for (keepAfter) to MantchFinder_Create():
-        (numFastBytes + LZMA_MATCH_LEN_MAX + 1)
-  */
-
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   if (p->mtMode)
   {
-    RINOK(MatchFinderMt_Create(&p->matchFinderMt, dictSize, beforeSize,
-        p->numFastBytes, LZMA_MATCH_LEN_MAX + 1 /* 18.04 */
-        , allocBig))
+    RINOK(MatchFinderMt_Create(&p->matchFinderMt, p->dictSize, beforeSize, p->numFastBytes,
+        LZMA_MATCH_LEN_MAX
+        + 1  /* 18.04 */
+        , allocBig));
     p->matchFinderObj = &p->matchFinderMt;
-    MFB.bigHash = (Byte)(MFB.hashMask >= 0xFFFFFF ? 1 : 0);
+    p->matchFinderBase.bigHash = (Byte)(
+        (p->dictSize > kBigHashDicLimit && p->matchFinderBase.hashMask >= 0xFFFFFF) ? 1 : 0);
     MatchFinderMt_CreateVTable(&p->matchFinderMt, &p->matchFinder);
   }
   else
   #endif
   {
-    if (!MatchFinder_Create(&MFB, dictSize, beforeSize,
-        p->numFastBytes, LZMA_MATCH_LEN_MAX + 1 /* 21.03 */
-        , allocBig))
+    if (!MatchFinder_Create(&p->matchFinderBase, p->dictSize, beforeSize, p->numFastBytes, LZMA_MATCH_LEN_MAX, allocBig))
       return SZ_ERROR_MEM;
-    p->matchFinderObj = &MFB;
-    MatchFinder_CreateVTable(&MFB, &p->matchFinder);
+    p->matchFinderObj = &p->matchFinderBase;
+    MatchFinder_CreateVTable(&p->matchFinderBase, &p->matchFinder);
   }
   
   return SZ_OK;
 }
 
-static void LzmaEnc_Init(CLzmaEnc *p)
+void LzmaEnc_Init(CLzmaEnc *p)
 {
   unsigned i;
   p->state = 0;
@@ -2808,8 +2654,8 @@ static void LzmaEnc_Init(CLzmaEnc *p)
   }
 
   {
-    const size_t num = (size_t)0x300 << (p->lp + p->lc);
-    size_t k;
+    UInt32 num = (UInt32)0x300 << (p->lp + p->lc);
+    UInt32 k;
     CLzmaProb *probs = p->litProbs;
     for (k = 0; k < num; k++)
       probs[k] = kProbInitValue;
@@ -2829,14 +2675,12 @@ static void LzmaEnc_Init(CLzmaEnc *p)
 
   p->additionalOffset = 0;
 
-  p->pbMask = ((unsigned)1 << p->pb) - 1;
+  p->pbMask = (1 << p->pb) - 1;
   p->lpMask = ((UInt32)0x100 << p->lp) - ((unsigned)0x100 >> p->lc);
-
-  // p->mf_Failure = False;
 }
 
 
-static void LzmaEnc_InitPrices(CLzmaEnc *p)
+void LzmaEnc_InitPrices(CLzmaEnc *p)
 {
   if (!p->fastMode)
   {
@@ -2850,8 +2694,8 @@ static void LzmaEnc_InitPrices(CLzmaEnc *p)
 
   p->repLenEncCounter = REP_LEN_COUNT;
 
-  LenPriceEnc_UpdateTables(&p->lenEnc, (unsigned)1 << p->pb, &p->lenProbs, p->ProbPrices);
-  LenPriceEnc_UpdateTables(&p->repLenEnc, (unsigned)1 << p->pb, &p->repLenProbs, p->ProbPrices);
+  LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, &p->lenProbs, p->ProbPrices);
+  LenPriceEnc_UpdateTables(&p->repLenEnc, 1 << p->pb, &p->repLenProbs, p->ProbPrices);
 }
 
 static SRes LzmaEnc_AllocAndInit(CLzmaEnc *p, UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig)
@@ -2864,53 +2708,59 @@ static SRes LzmaEnc_AllocAndInit(CLzmaEnc *p, UInt32 keepWindowSize, ISzAllocPtr
 
   p->finished = False;
   p->result = SZ_OK;
-  p->nowPos64 = 0;
-  p->needInit = 1;
-  RINOK(LzmaEnc_Alloc(p, keepWindowSize, alloc, allocBig))
+  RINOK(LzmaEnc_Alloc(p, keepWindowSize, alloc, allocBig));
   LzmaEnc_Init(p);
   LzmaEnc_InitPrices(p);
+  p->nowPos64 = 0;
   return SZ_OK;
 }
 
-static SRes LzmaEnc_Prepare(CLzmaEncHandle p,
-    ISeqOutStreamPtr outStream,
-    ISeqInStreamPtr inStream,
+static SRes LzmaEnc_Prepare(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream,
     ISzAllocPtr alloc, ISzAllocPtr allocBig)
 {
-  // GET_CLzmaEnc_p
-  MatchFinder_SET_STREAM(&MFB, inStream)
+  CLzmaEnc *p = (CLzmaEnc *)pp;
+  p->matchFinderBase.stream = inStream;
+  p->needInit = 1;
   p->rc.outStream = outStream;
   return LzmaEnc_AllocAndInit(p, 0, alloc, allocBig);
 }
 
-SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle p,
-    ISeqInStreamPtr inStream, UInt32 keepWindowSize,
+SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp,
+    ISeqInStream *inStream, UInt32 keepWindowSize,
     ISzAllocPtr alloc, ISzAllocPtr allocBig)
 {
-  // GET_CLzmaEnc_p
-  MatchFinder_SET_STREAM(&MFB, inStream)
+  CLzmaEnc *p = (CLzmaEnc *)pp;
+  p->matchFinderBase.stream = inStream;
+  p->needInit = 1;
   return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
 }
 
-SRes LzmaEnc_MemPrepare(CLzmaEncHandle p,
-    const Byte *src, SizeT srcLen,
-    UInt32 keepWindowSize,
-    ISzAllocPtr alloc, ISzAllocPtr allocBig)
+static void LzmaEnc_SetInputBuf(CLzmaEnc *p, const Byte *src, SizeT srcLen)
 {
-  // GET_CLzmaEnc_p
-  MatchFinder_SET_DIRECT_INPUT_BUF(&MFB, src, srcLen)
-  LzmaEnc_SetDataSize(p, srcLen);
+  p->matchFinderBase.directInput = 1;
+  p->matchFinderBase.bufferBase = (Byte *)src;
+  p->matchFinderBase.directInputRem = srcLen;
+}
+
+SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,
+    UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+  CLzmaEnc *p = (CLzmaEnc *)pp;
+  LzmaEnc_SetInputBuf(p, src, srcLen);
+  p->needInit = 1;
+
+  LzmaEnc_SetDataSize(pp, srcLen);
   return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
 }
 
-void LzmaEnc_Finish(CLzmaEncHandle p)
+void LzmaEnc_Finish(CLzmaEncHandle pp)
 {
-  #ifndef Z7_ST
-  // GET_CLzmaEnc_p
+  #ifndef _7ZIP_ST
+  CLzmaEnc *p = (CLzmaEnc *)pp;
   if (p->mtMode)
     MatchFinderMt_ReleaseStream(&p->matchFinderMt);
   #else
-  UNUSED_VAR(p)
+  UNUSED_VAR(pp);
   #endif
 }
 
@@ -2919,48 +2769,43 @@ typedef struct
 {
   ISeqOutStream vt;
   Byte *data;
-  size_t rem;
+  SizeT rem;
   BoolInt overflow;
 } CLzmaEnc_SeqOutStreamBuf;
 
-static size_t SeqOutStreamBuf_Write(ISeqOutStreamPtr pp, const void *data, size_t size)
+static size_t SeqOutStreamBuf_Write(const ISeqOutStream *pp, const void *data, size_t size)
 {
-  Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CLzmaEnc_SeqOutStreamBuf)
+  CLzmaEnc_SeqOutStreamBuf *p = CONTAINER_FROM_VTBL(pp, CLzmaEnc_SeqOutStreamBuf, vt);
   if (p->rem < size)
   {
     size = p->rem;
     p->overflow = True;
   }
-  if (size != 0)
-  {
-    memcpy(p->data, data, size);
-    p->rem -= size;
-    p->data += size;
-  }
+  memcpy(p->data, data, size);
+  p->rem -= size;
+  p->data += size;
   return size;
 }
 
 
-/*
-UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle p)
+UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle pp)
 {
-  GET_const_CLzmaEnc_p
+  const CLzmaEnc *p = (CLzmaEnc *)pp;
   return p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
 }
-*/
 
-const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle p)
+
+const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle pp)
 {
-  // GET_const_CLzmaEnc_p
+  const CLzmaEnc *p = (CLzmaEnc *)pp;
   return p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset;
 }
 
 
-// (desiredPackSize == 0) is not allowed
-SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle p, BoolInt reInit,
+SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, BoolInt reInit,
     Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize)
 {
-  // GET_CLzmaEnc_p
+  CLzmaEnc *p = (CLzmaEnc *)pp;
   UInt64 nowPos64;
   SRes res;
   CLzmaEnc_SeqOutStreamBuf outStream;
@@ -2977,10 +2822,14 @@ SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle p, BoolInt reInit,
   if (reInit)
     LzmaEnc_Init(p);
   LzmaEnc_InitPrices(p);
+
+  nowPos64 = p->nowPos64;
   RangeEnc_Init(&p->rc);
   p->rc.outStream = &outStream.vt;
-  nowPos64 = p->nowPos64;
-  
+
+  if (desiredPackSize == 0)
+    return SZ_ERROR_OUTPUT_EOF;
+
   res = LzmaEnc_CodeOneBlock(p, desiredPackSize, *unpackSize);
   
   *unpackSize = (UInt32)(p->nowPos64 - nowPos64);
@@ -2992,12 +2841,11 @@ SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle p, BoolInt reInit,
 }
 
 
-Z7_NO_INLINE
-static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgressPtr progress)
+static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)
 {
   SRes res = SZ_OK;
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   Byte allocaDummy[0x300];
   allocaDummy[0] = 0;
   allocaDummy[1] = allocaDummy[0];
@@ -3019,10 +2867,10 @@ static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgressPtr progress)
     }
   }
   
-  LzmaEnc_Finish((CLzmaEncHandle)(void *)p);
+  LzmaEnc_Finish(p);
 
   /*
-  if (res == SZ_OK && !Inline_MatchFinder_IsFinishedOK(&MFB))
+  if (res == SZ_OK && !Inline_MatchFinder_IsFinishedOK(&p->matchFinderBase))
     res = SZ_ERROR_FAIL;
   }
   */
@@ -3031,63 +2879,53 @@ static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgressPtr progress)
 }
 
 
-SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream, ICompressProgressPtr progress,
+SRes LzmaEnc_Encode(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress,
     ISzAllocPtr alloc, ISzAllocPtr allocBig)
 {
-  // GET_CLzmaEnc_p
-  RINOK(LzmaEnc_Prepare(p, outStream, inStream, alloc, allocBig))
-  return LzmaEnc_Encode2(p, progress);
+  RINOK(LzmaEnc_Prepare(pp, outStream, inStream, alloc, allocBig));
+  return LzmaEnc_Encode2((CLzmaEnc *)pp, progress);
 }
 
 
-SRes LzmaEnc_WriteProperties(CLzmaEncHandle p, Byte *props, SizeT *size)
+SRes LzmaEnc_WriteProperties(CLzmaEncHandle pp, Byte *props, SizeT *size)
 {
+  CLzmaEnc *p = (CLzmaEnc *)pp;
+  unsigned i;
+  UInt32 dictSize = p->dictSize;
   if (*size < LZMA_PROPS_SIZE)
     return SZ_ERROR_PARAM;
   *size = LZMA_PROPS_SIZE;
-  {
-    // GET_CLzmaEnc_p
-    const UInt32 dictSize = p->dictSize;
-    UInt32 v;
-    props[0] = (Byte)((p->pb * 5 + p->lp) * 9 + p->lc);
-    
-    // we write aligned dictionary value to properties for lzma decoder
-    if (dictSize >= ((UInt32)1 << 21))
-    {
-      const UInt32 kDictMask = ((UInt32)1 << 20) - 1;
-      v = (dictSize + kDictMask) & ~kDictMask;
-      if (v < dictSize)
-        v = dictSize;
-    }
-    else
-    {
-      unsigned i = 11 * 2;
-      do
-      {
-        v = (UInt32)(2 + (i & 1)) << (i >> 1);
-        i++;
-      }
-      while (v < dictSize);
-    }
+  props[0] = (Byte)((p->pb * 5 + p->lp) * 9 + p->lc);
 
-    SetUi32(props + 1, v)
-    return SZ_OK;
+  if (dictSize >= ((UInt32)1 << 22))
+  {
+    UInt32 kDictMask = ((UInt32)1 << 20) - 1;
+    if (dictSize < (UInt32)0xFFFFFFFF - kDictMask)
+      dictSize = (dictSize + kDictMask) & ~kDictMask;
   }
+  else for (i = 11; i <= 30; i++)
+  {
+    if (dictSize <= ((UInt32)2 << i)) { dictSize = (2 << i); break; }
+    if (dictSize <= ((UInt32)3 << i)) { dictSize = (3 << i); break; }
+  }
+
+  for (i = 0; i < 4; i++)
+    props[1 + i] = (Byte)(dictSize >> (8 * i));
+  return SZ_OK;
 }
 
 
-unsigned LzmaEnc_IsWriteEndMark(CLzmaEncHandle p)
+unsigned LzmaEnc_IsWriteEndMark(CLzmaEncHandle pp)
 {
-  // GET_CLzmaEnc_p
-  return (unsigned)p->writeEndMark;
+  return ((CLzmaEnc *)pp)->writeEndMark;
 }
 
 
-SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
-    int writeEndMark, ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)
+SRes LzmaEnc_MemEncode(CLzmaEncHandle pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
+    int writeEndMark, ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)
 {
   SRes res;
-  // GET_CLzmaEnc_p
+  CLzmaEnc *p = (CLzmaEnc *)pp;
 
   CLzmaEnc_SeqOutStreamBuf outStream;
 
@@ -3099,7 +2937,7 @@ SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte
   p->writeEndMark = writeEndMark;
   p->rc.outStream = &outStream.vt;
 
-  res = LzmaEnc_MemPrepare(p, src, srcLen, 0, alloc, allocBig);
+  res = LzmaEnc_MemPrepare(pp, src, srcLen, 0, alloc, allocBig);
   
   if (res == SZ_OK)
   {
@@ -3108,7 +2946,7 @@ SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte
       res = SZ_ERROR_FAIL;
   }
 
-  *destLen -= (SizeT)outStream.rem;
+  *destLen -= outStream.rem;
   if (outStream.overflow)
     return SZ_ERROR_OUTPUT_EOF;
   return res;
@@ -3117,9 +2955,9 @@ SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte
 
 SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
     const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
-    ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)
+    ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)
 {
-  CLzmaEncHandle p = LzmaEnc_Create(alloc);
+  CLzmaEnc *p = (CLzmaEnc *)LzmaEnc_Create(alloc);
   SRes res;
   if (!p)
     return SZ_ERROR_MEM;
@@ -3136,15 +2974,3 @@ SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
   LzmaEnc_Destroy(p, alloc, allocBig);
   return res;
 }
-
-
-/*
-#ifndef Z7_ST
-void LzmaEnc_GetLzThreads(CLzmaEncHandle p, HANDLE lz_threads[2])
-{
-  GET_const_CLzmaEnc_p
-  lz_threads[0] = p->matchFinderMt.hashSync.thread;
-  lz_threads[1] = p->matchFinderMt.btSync.thread;
-}
-#endif
-*/