Update lzma_sdk sources to 15.14.

third_party/lzma_sdk/LzmaEnc.c

 /* LzmaEnc.c -- LZMA Encoder
-2010-04-16 : Igor Pavlov : Public domain */
+2015-11-08 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
 
 #include <string.h>
 
 /* #define SHOW_STAT */
 /* #define SHOW_STAT2 */
 
 #if defined(SHOW_STAT) || defined(SHOW_STAT2)
 #include <stdio.h>
 #endif
 
 #include "LzmaEnc.h"
 
 #include "LzFind.h"
 #ifndef _7ZIP_ST
 #include "LzFindMt.h"
 #endif
 
 #ifdef SHOW_STAT
-static int ttt = 0;
+static unsigned g_STAT_OFFSET = 0;
 #endif
 
+#define kMaxHistorySize ((UInt32)3 << 29)
+/* #define kMaxHistorySize ((UInt32)7 << 29) */
+
 #define kBlockSizeMax ((1 << LZMA_NUM_BLOCK_SIZE_BITS) - 1)
 
 #define kBlockSize (9 << 10)
 #define kUnpackBlockSize (1 << 18)
 #define kMatchArraySize (1 << 21)
 #define kMatchRecordMaxSize ((LZMA_MATCH_LEN_MAX * 2 + 3) * LZMA_MATCH_LEN_MAX)
 
 #define kNumMaxDirectBits (31)
 
 #define kNumTopBits 24
 #define kTopValue ((UInt32)1 << kNumTopBits)
 
 #define kNumBitModelTotalBits 11
 #define kBitModelTotal (1 << kNumBitModelTotalBits)
 #define kNumMoveBits 5
 #define kProbInitValue (kBitModelTotal >> 1)
 
 #define kNumMoveReducingBits 4
 #define kNumBitPriceShiftBits 4
 #define kBitPrice (1 << kNumBitPriceShiftBits)
 
 void LzmaEncProps_Init(CLzmaEncProps *p)
 {
   p->level = 5;
   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->writeEndMark = 0;
 }
 
 void LzmaEncProps_Normalize(CLzmaEncProps *p)
 {
   int level = p->level;
   if (level < 0) level = 5;
   p->level = level;
+  
   if (p->dictSize == 0) p->dictSize = (level <= 5 ? (1 << (level * 2 + 14)) : (level == 6 ? (1 << 25) : (1 << 26)));
+  if (p->dictSize > p->reduceSize)
+  {
+    unsigned i;
+    for (i = 11; i <= 30; i++)
+    {
+      if ((UInt32)p->reduceSize <= ((UInt32)2 << i)) { p->dictSize = ((UInt32)2 << i); break; }
+      if ((UInt32)p->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 = (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 = 4;
-  if (p->mc == 0)  p->mc = (16 + (p->fb >> 1)) >> (p->btMode ? 0 : 1);
+  if (p->mc == 0) p->mc = (16 + (p->fb >> 1)) >> (p->btMode ? 0 : 1);
+  
   if (p->numThreads < 0)
     p->numThreads =
       #ifndef _7ZIP_ST
       ((p->btMode && p->algo) ? 2 : 1);
       #else
       1;
       #endif
 }
 
 UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2)
 {
   CLzmaEncProps props = *props2;
   LzmaEncProps_Normalize(&props);
   return props.dictSize;
 }
 
+#if (_MSC_VER >= 1400)
+/* BSR code is fast for some new CPUs */
 /* #define LZMA_LOG_BSR */
-/* Define it for Intel's CPU */
-
+#endif
 
 #ifdef LZMA_LOG_BSR
 
-#define kDicLogSizeMaxCompress 30
+#define kDicLogSizeMaxCompress 32
 
 #define BSR2_RET(pos, res) { unsigned long i; _BitScanReverse(&i, (pos)); res = (i + i) + ((pos >> (i - 1)) & 1); }
 
-UInt32 GetPosSlot1(UInt32 pos)
+static UInt32 GetPosSlot1(UInt32 pos)
 {
   UInt32 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); }
 
 #else
 
-#define kNumLogBits (9 + (int)sizeof(size_t) / 2)
+#define kNumLogBits (9 + sizeof(size_t) / 2)
+/* #define kNumLogBits (11 + sizeof(size_t) / 8 * 3) */
+
 #define kDicLogSizeMaxCompress ((kNumLogBits - 1) * 2 + 7)
 
-void LzmaEnc_FastPosInit(Byte *g_FastPos)
+static void LzmaEnc_FastPosInit(Byte *g_FastPos)
 {
-  int c = 2, slotFast;
+  unsigned slot;
   g_FastPos[0] = 0;
   g_FastPos[1] = 1;
+  g_FastPos += 2;
   
-  for (slotFast = 2; slotFast < kNumLogBits * 2; slotFast++)
+  for (slot = 2; slot < kNumLogBits * 2; slot++)
   {
-    UInt32 k = (1 << ((slotFast >> 1) - 1));
-    UInt32 j;
-    for (j = 0; j < k; j++, c++)
-      g_FastPos[c] = (Byte)slotFast;
+    size_t k = ((size_t)1 << ((slot >> 1) - 1));
+    size_t j;
+    for (j = 0; j < k; j++)
+      g_FastPos[j] = (Byte)slot;
+    g_FastPos += k;
   }
 }
 
+/* we can use ((limit - pos) >> 31) only if (pos < ((UInt32)1 << 31)) */
+/*
 #define BSR2_RET(pos, res) { UInt32 i = 6 + ((kNumLogBits - 1) & \
   (0 - (((((UInt32)1 << (kNumLogBits + 6)) - 1) - pos) >> 31))); \
   res = p->g_FastPos[pos >> i] + (i * 2); }
+*/
+
+/*
+#define BSR2_RET(pos, res) { UInt32 i = 6 + ((kNumLogBits - 1) & \
+  (0 - (((((UInt32)1 << (kNumLogBits)) - 1) - (pos >> 6)) >> 31))); \
+  res = p->g_FastPos[pos >> i] + (i * 2); }
+*/
+
+#define BSR2_RET(pos, res) { UInt32 i = (pos < (1 << (kNumLogBits + 6))) ? 6 : 6 + kNumLogBits - 1; \
+  res = p->g_FastPos[pos >> i] + (i * 2); }
+
 /*
 #define BSR2_RET(pos, res) { res = (pos < (1 << (kNumLogBits + 6))) ? \
   p->g_FastPos[pos >> 6] + 12 : \
   p->g_FastPos[pos >> (6 + kNumLogBits - 1)] + (6 + (kNumLogBits - 1)) * 2; }
 */
 
 #define GetPosSlot1(pos) p->g_FastPos[pos]
 #define GetPosSlot2(pos, res) { BSR2_RET(pos, res); }
 #define GetPosSlot(pos, res) { if (pos < kNumFullDistances) res = p->g_FastPos[pos]; else BSR2_RET(pos, res); }
 
@@ skipping 59 matching lines @@
 #define kLenNumHighBits 8
 #define kLenNumHighSymbols (1 << kLenNumHighBits)
 
 #define kLenNumSymbolsTotal (kLenNumLowSymbols + kLenNumMidSymbols + kLenNumHighSymbols)
 
 #define LZMA_MATCH_LEN_MIN 2
 #define LZMA_MATCH_LEN_MAX (LZMA_MATCH_LEN_MIN + kLenNumSymbolsTotal - 1)
 
 #define kNumStates 12
 
+
 typedef struct
 {
   CLzmaProb choice;
   CLzmaProb choice2;
   CLzmaProb low[LZMA_NUM_PB_STATES_MAX << kLenNumLowBits];
   CLzmaProb mid[LZMA_NUM_PB_STATES_MAX << kLenNumMidBits];
   CLzmaProb high[kLenNumHighSymbols];
 } CLenEnc;
 
+
 typedef struct
 {
   CLenEnc p;
+  UInt32 tableSize;
   UInt32 prices[LZMA_NUM_PB_STATES_MAX][kLenNumSymbolsTotal];
-  UInt32 tableSize;
   UInt32 counters[LZMA_NUM_PB_STATES_MAX];
 } CLenPriceEnc;
 
+
 typedef struct
 {
   UInt32 range;
   Byte cache;
   UInt64 low;
   UInt64 cacheSize;
   Byte *buf;
   Byte *bufLim;
   Byte *bufBase;
   ISeqOutStream *outStream;
   UInt64 processed;
   SRes res;
 } CRangeEnc;
 
+
 typedef struct
 {
   CLzmaProb *litProbs;
 
+  UInt32 state;
+  UInt32 reps[LZMA_NUM_REPS];
+
   CLzmaProb isMatch[kNumStates][LZMA_NUM_PB_STATES_MAX];
   CLzmaProb isRep[kNumStates];
   CLzmaProb isRepG0[kNumStates];
   CLzmaProb isRepG1[kNumStates];
   CLzmaProb isRepG2[kNumStates];
   CLzmaProb isRep0Long[kNumStates][LZMA_NUM_PB_STATES_MAX];
 
   CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];
   CLzmaProb posEncoders[kNumFullDistances - kEndPosModelIndex];
   CLzmaProb posAlignEncoder[1 << kNumAlignBits];
   
   CLenPriceEnc lenEnc;
   CLenPriceEnc repLenEnc;
+} CSaveState;
 
-  UInt32 reps[LZMA_NUM_REPS];
-  UInt32 state;
-} CSaveState;
 
 typedef struct
 {
+  void *matchFinderObj;
   IMatchFinder matchFinder;
-  void *matchFinderObj;
+
+  UInt32 optimumEndIndex;
+  UInt32 optimumCurrentIndex;
+
+  UInt32 longestMatchLength;
+  UInt32 numPairs;
+  UInt32 numAvail;
+
+  UInt32 numFastBytes;
+  UInt32 additionalOffset;
+  UInt32 reps[LZMA_NUM_REPS];
+  UInt32 state;
+
+  unsigned lc, lp, pb;
+  unsigned lpMask, pbMask;
+  unsigned lclp;
+
+  CLzmaProb *litProbs;
+
+  Bool fastMode;
+  Bool writeEndMark;
+  Bool finished;
+  Bool multiThread;
+  Bool needInit;
+
+  UInt64 nowPos64;
+  
+  UInt32 matchPriceCount;
+  UInt32 alignPriceCount;
+
+  UInt32 distTableSize;
+
+  UInt32 dictSize;
+  SRes result;
+
+  CRangeEnc rc;
 
   #ifndef _7ZIP_ST
   Bool mtMode;
   CMatchFinderMt matchFinderMt;
   #endif
 
   CMatchFinder matchFinderBase;
 
   #ifndef _7ZIP_ST
   Byte pad[128];
   #endif
   
-  UInt32 optimumEndIndex;
-  UInt32 optimumCurrentIndex;
-
-  UInt32 longestMatchLength;
-  UInt32 numPairs;
-  UInt32 numAvail;
   COptimal opt[kNumOpts];
   
   #ifndef LZMA_LOG_BSR
   Byte g_FastPos[1 << kNumLogBits];
   #endif
 
   UInt32 ProbPrices[kBitModelTotal >> kNumMoveReducingBits];
   UInt32 matches[LZMA_MATCH_LEN_MAX * 2 + 2 + 1];
-  UInt32 numFastBytes;
-  UInt32 additionalOffset;
-  UInt32 reps[LZMA_NUM_REPS];
-  UInt32 state;
 
   UInt32 posSlotPrices[kNumLenToPosStates][kDistTableSizeMax];
   UInt32 distancesPrices[kNumLenToPosStates][kNumFullDistances];
   UInt32 alignPrices[kAlignTableSize];
-  UInt32 alignPriceCount;
-
-  UInt32 distTableSize;
-
-  unsigned lc, lp, pb;
-  unsigned lpMask, pbMask;
-
-  CLzmaProb *litProbs;
 
   CLzmaProb isMatch[kNumStates][LZMA_NUM_PB_STATES_MAX];
   CLzmaProb isRep[kNumStates];
   CLzmaProb isRepG0[kNumStates];
   CLzmaProb isRepG1[kNumStates];
   CLzmaProb isRepG2[kNumStates];
   CLzmaProb isRep0Long[kNumStates][LZMA_NUM_PB_STATES_MAX];
 
   CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];
   CLzmaProb posEncoders[kNumFullDistances - kEndPosModelIndex];
   CLzmaProb posAlignEncoder[1 << kNumAlignBits];
   
   CLenPriceEnc lenEnc;
   CLenPriceEnc repLenEnc;
 
-  unsigned lclp;
+  CSaveState saveState;
 
-  Bool fastMode;
-  
-  CRangeEnc rc;
+  #ifndef _7ZIP_ST
+  Byte pad2[128];
+  #endif
+} CLzmaEnc;
 
-  Bool writeEndMark;
-  UInt64 nowPos64;
-  UInt32 matchPriceCount;
-  Bool finished;
-  Bool multiThread;
-
-  SRes result;
-  UInt32 dictSize;
-  UInt32 matchFinderCycles;
-
-  int needInit;
-
-  CSaveState saveState;
-} CLzmaEnc;
 
 void LzmaEnc_SaveState(CLzmaEncHandle pp)
 {
   CLzmaEnc *p = (CLzmaEnc *)pp;
   CSaveState *dest = &p->saveState;
   int i;
   dest->lenEnc = p->lenEnc;
   dest->repLenEnc = p->repLenEnc;
   dest->state = p->state;
 
   for (i = 0; i < kNumStates; i++)
   {
     memcpy(dest->isMatch[i], p->isMatch[i], sizeof(p->isMatch[i]));
     memcpy(dest->isRep0Long[i], p->isRep0Long[i], sizeof(p->isRep0Long[i]));
   }
   for (i = 0; i < kNumLenToPosStates; i++)
     memcpy(dest->posSlotEncoder[i], p->posSlotEncoder[i], sizeof(p->posSlotEncoder[i]));
   memcpy(dest->isRep, p->isRep, sizeof(p->isRep));
   memcpy(dest->isRepG0, p->isRepG0, sizeof(p->isRepG0));
   memcpy(dest->isRepG1, p->isRepG1, sizeof(p->isRepG1));
   memcpy(dest->isRepG2, p->isRepG2, sizeof(p->isRepG2));
   memcpy(dest->posEncoders, p->posEncoders, sizeof(p->posEncoders));
   memcpy(dest->posAlignEncoder, p->posAlignEncoder, sizeof(p->posAlignEncoder));
   memcpy(dest->reps, p->reps, sizeof(p->reps));
-  memcpy(dest->litProbs, p->litProbs, (0x300 << p->lclp) * sizeof(CLzmaProb));
+  memcpy(dest->litProbs, p->litProbs, ((UInt32)0x300 << p->lclp) * sizeof(CLzmaProb));
 }
 
 void LzmaEnc_RestoreState(CLzmaEncHandle pp)
 {
   CLzmaEnc *dest = (CLzmaEnc *)pp;
   const CSaveState *p = &dest->saveState;
   int i;
   dest->lenEnc = p->lenEnc;
   dest->repLenEnc = p->repLenEnc;
   dest->state = p->state;
 
   for (i = 0; i < kNumStates; i++)
   {
     memcpy(dest->isMatch[i], p->isMatch[i], sizeof(p->isMatch[i]));
     memcpy(dest->isRep0Long[i], p->isRep0Long[i], sizeof(p->isRep0Long[i]));
   }
   for (i = 0; i < kNumLenToPosStates; i++)
     memcpy(dest->posSlotEncoder[i], p->posSlotEncoder[i], sizeof(p->posSlotEncoder[i]));
   memcpy(dest->isRep, p->isRep, sizeof(p->isRep));
   memcpy(dest->isRepG0, p->isRepG0, sizeof(p->isRepG0));
   memcpy(dest->isRepG1, p->isRepG1, sizeof(p->isRepG1));
   memcpy(dest->isRepG2, p->isRepG2, sizeof(p->isRepG2));
   memcpy(dest->posEncoders, p->posEncoders, sizeof(p->posEncoders));
   memcpy(dest->posAlignEncoder, p->posAlignEncoder, sizeof(p->posAlignEncoder));
   memcpy(dest->reps, p->reps, sizeof(p->reps));
-  memcpy(dest->litProbs, p->litProbs, (0x300 << dest->lclp) * sizeof(CLzmaProb));
+  memcpy(dest->litProbs, p->litProbs, ((UInt32)0x300 << dest->lclp) * sizeof(CLzmaProb));
 }
 
 SRes LzmaEnc_SetProps(CLzmaEncHandle pp, const CLzmaEncProps *props2)
 {
   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.dictSize > ((UInt32)1 << kDicLogSizeMaxCompress) || props.dictSize > ((UInt32)1 << 30))
+  if (props.lc > LZMA_LC_MAX
+      || props.lp > LZMA_LP_MAX
+      || props.pb > LZMA_PB_MAX
+      || props.dictSize > ((UInt64)1 << kDicLogSizeMaxCompress)
+      || props.dictSize > kMaxHistorySize)
     return SZ_ERROR_PARAM;
+
   p->dictSize = props.dictSize;
-  p->matchFinderCycles = props.mc;
   {
     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 = props.lc;
   p->lp = props.lp;
   p->pb = props.pb;
   p->fastMode = (props.algo == 0);
-  p->matchFinderBase.btMode = props.btMode;
+  p->matchFinderBase.btMode = (Byte)(props.btMode ? 1 : 0);
   {
     UInt32 numHashBytes = 4;
     if (props.btMode)
     {
       if (props.numHashBytes < 2)
         numHashBytes = 2;
       else if (props.numHashBytes < 4)
         numHashBytes = props.numHashBytes;
     }
     p->matchFinderBase.numHashBytes = numHashBytes;
@@ skipping 23 matching lines @@
 static const int kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};
 
 #define IsCharState(s) ((s) < 7)
 
 #define GetLenToPosState(len) (((len) < kNumLenToPosStates + 1) ? (len) - 2 : kNumLenToPosStates - 1)
 
 #define kInfinityPrice (1 << 30)
 
 static void RangeEnc_Construct(CRangeEnc *p)
 {
-  p->outStream = 0;
-  p->bufBase = 0;
+  p->outStream = NULL;
+  p->bufBase = NULL;
 }
 
 #define RangeEnc_GetProcessed(p) ((p)->processed + ((p)->buf - (p)->bufBase) + (p)->cacheSize)
 
 #define RC_BUF_SIZE (1 << 16)
 static int RangeEnc_Alloc(CRangeEnc *p, ISzAlloc *alloc)
 {
-  if (p->bufBase == 0)
+  if (!p->bufBase)
   {
     p->bufBase = (Byte *)alloc->Alloc(alloc, RC_BUF_SIZE);
-    if (p->bufBase == 0)
+    if (!p->bufBase)
       return 0;
     p->bufLim = p->bufBase + RC_BUF_SIZE;
   }
   return 1;
 }
 
 static void RangeEnc_Free(CRangeEnc *p, ISzAlloc *alloc)
 {
   alloc->Free(alloc, p->bufBase);
   p->bufBase = 0;
@@ skipping 20 matching lines @@
     return;
   num = p->buf - p->bufBase;
   if (num != p->outStream->Write(p->outStream, p->bufBase, num))
     p->res = SZ_ERROR_WRITE;
   p->processed += num;
   p->buf = p->bufBase;
 }
 
 static void MY_FAST_CALL RangeEnc_ShiftLow(CRangeEnc *p)
 {
-  if ((UInt32)p->low < (UInt32)0xFF000000 || (int)(p->low >> 32) != 0)
+  if ((UInt32)p->low < (UInt32)0xFF000000 || (unsigned)(p->low >> 32) != 0)
   {
     Byte temp = p->cache;
     do
     {
       Byte *buf = p->buf;
       *buf++ = (Byte)(temp + (Byte)(p->low >> 32));
       p->buf = buf;
       if (buf == p->bufLim)
         RangeEnc_FlushStream(p);
       temp = 0xFF;
     }
     while (--p->cacheSize != 0);
     p->cache = (Byte)((UInt32)p->low >> 24);
   }
   p->cacheSize++;
   p->low = (UInt32)p->low << 8;
 }
 
 static void RangeEnc_FlushData(CRangeEnc *p)
 {
   int i;
   for (i = 0; i < 5; i++)
     RangeEnc_ShiftLow(p);
 }
 
-static void RangeEnc_EncodeDirectBits(CRangeEnc *p, UInt32 value, int numBits)
+static void RangeEnc_EncodeDirectBits(CRangeEnc *p, UInt32 value, unsigned numBits)
 {
   do
   {
     p->range >>= 1;
     p->low += p->range & (0 - ((value >> --numBits) & 1));
     if (p->range < kTopValue)
     {
       p->range <<= 8;
       RangeEnc_ShiftLow(p);
     }
@@ skipping 42 matching lines @@
   do
   {
     matchByte <<= 1;
     RangeEnc_EncodeBit(p, probs + (offs + (matchByte & offs) + (symbol >> 8)), (symbol >> 7) & 1);
     symbol <<= 1;
     offs &= ~(matchByte ^ symbol);
   }
   while (symbol < 0x10000);
 }
 
-void LzmaEnc_InitPriceTables(UInt32 *ProbPrices)
+static void LzmaEnc_InitPriceTables(UInt32 *ProbPrices)
 {
   UInt32 i;
   for (i = (1 << kNumMoveReducingBits) / 2; i < kBitModelTotal; i += (1 << kNumMoveReducingBits))
   {
     const int kCyclesBits = kNumBitPriceShiftBits;
     UInt32 w = i;
     UInt32 bitCount = 0;
     int j;
     for (j = 0; j < kCyclesBits; j++)
     {
@@ skipping 15 matching lines @@
 
 #define GET_PRICEa(prob, symbol) \
   ProbPrices[((prob) ^ ((-((int)(symbol))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits];
 
 #define GET_PRICE_0(prob) p->ProbPrices[(prob) >> kNumMoveReducingBits]
 #define GET_PRICE_1(prob) p->ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]
 
 #define GET_PRICE_0a(prob) ProbPrices[(prob) >> kNumMoveReducingBits]
 #define GET_PRICE_1a(prob) ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]
 
-static UInt32 LitEnc_GetPrice(const CLzmaProb *probs, UInt32 symbol, UInt32 *ProbPrices)
+static UInt32 LitEnc_GetPrice(const CLzmaProb *probs, UInt32 symbol, const UInt32 *ProbPrices)
 {
   UInt32 price = 0;
   symbol |= 0x100;
   do
   {
     price += GET_PRICEa(probs[symbol >> 8], (symbol >> 7) & 1);
     symbol <<= 1;
   }
   while (symbol < 0x10000);
   return price;
 }
 
-static UInt32 LitEnc_GetPriceMatched(const CLzmaProb *probs, UInt32 symbol, UInt32 matchByte, UInt32 *ProbPrices)
+static UInt32 LitEnc_GetPriceMatched(const CLzmaProb *probs, UInt32 symbol, UInt32 matchByte, const UInt32 *ProbPrices)
 {
   UInt32 price = 0;
   UInt32 offs = 0x100;
   symbol |= 0x100;
   do
   {
     matchByte <<= 1;
     price += GET_PRICEa(probs[offs + (matchByte & offs) + (symbol >> 8)], (symbol >> 7) & 1);
     symbol <<= 1;
     offs &= ~(matchByte ^ symbol);
@@ skipping 23 matching lines @@
   int i;
   for (i = 0; i < numBitLevels; i++)
   {
     UInt32 bit = symbol & 1;
     RangeEnc_EncodeBit(rc, probs + m, bit);
     m = (m << 1) | bit;
     symbol >>= 1;
   }
 }
 
-static UInt32 RcTree_GetPrice(const CLzmaProb *probs, int numBitLevels, UInt32 symbol, UInt32 *ProbPrices)
+static UInt32 RcTree_GetPrice(const CLzmaProb *probs, int numBitLevels, UInt32 symbol, const UInt32 *ProbPrices)
 {
   UInt32 price = 0;
   symbol |= (1 << numBitLevels);
   while (symbol != 1)
   {
     price += GET_PRICEa(probs[symbol >> 1], symbol & 1);
     symbol >>= 1;
   }
   return price;
 }
 
-static UInt32 RcTree_ReverseGetPrice(const CLzmaProb *probs, int numBitLevels, UInt32 symbol, UInt32 *ProbPrices)
+static UInt32 RcTree_ReverseGetPrice(const CLzmaProb *probs, int numBitLevels, UInt32 symbol, const UInt32 *ProbPrices)
 {
   UInt32 price = 0;
   UInt32 m = 1;
   int i;
   for (i = numBitLevels; i != 0; i--)
   {
     UInt32 bit = symbol & 1;
     symbol >>= 1;
     price += GET_PRICEa(probs[m], bit);
     m = (m << 1) | bit;
@@ skipping 30 matching lines @@
       RcTree_Encode(rc, p->mid + (posState << kLenNumMidBits), kLenNumMidBits, symbol - kLenNumLowSymbols);
     }
     else
     {
       RangeEnc_EncodeBit(rc, &p->choice2, 1);
       RcTree_Encode(rc, p->high, kLenNumHighBits, symbol - kLenNumLowSymbols - kLenNumMidSymbols);
     }
   }
 }
 
-static void LenEnc_SetPrices(CLenEnc *p, UInt32 posState, UInt32 numSymbols, UInt32 *prices, UInt32 *ProbPrices)
+static void LenEnc_SetPrices(CLenEnc *p, UInt32 posState, UInt32 numSymbols, UInt32 *prices, const UInt32 *ProbPrices)
 {
   UInt32 a0 = GET_PRICE_0a(p->choice);
   UInt32 a1 = GET_PRICE_1a(p->choice);
   UInt32 b0 = a1 + GET_PRICE_0a(p->choice2);
   UInt32 b1 = a1 + GET_PRICE_1a(p->choice2);
   UInt32 i = 0;
   for (i = 0; i < kLenNumLowSymbols; i++)
   {
     if (i >= numSymbols)
       return;
     prices[i] = a0 + RcTree_GetPrice(p->low + (posState << kLenNumLowBits), kLenNumLowBits, i, ProbPrices);
   }
   for (; i < kLenNumLowSymbols + kLenNumMidSymbols; i++)
   {
     if (i >= numSymbols)
       return;
     prices[i] = b0 + RcTree_GetPrice(p->mid + (posState << kLenNumMidBits), kLenNumMidBits, i - kLenNumLowSymbols, ProbPrices);
   }
   for (; i < numSymbols; i++)
     prices[i] = b1 + RcTree_GetPrice(p->high, kLenNumHighBits, i - kLenNumLowSymbols - kLenNumMidSymbols, ProbPrices);
 }
 
-static void MY_FAST_CALL LenPriceEnc_UpdateTable(CLenPriceEnc *p, UInt32 posState, UInt32 *ProbPrices)
+static void MY_FAST_CALL LenPriceEnc_UpdateTable(CLenPriceEnc *p, UInt32 posState, const UInt32 *ProbPrices)
 {
   LenEnc_SetPrices(&p->p, posState, p->tableSize, p->prices[posState], ProbPrices);
   p->counters[posState] = p->tableSize;
 }
 
-static void LenPriceEnc_UpdateTables(CLenPriceEnc *p, UInt32 numPosStates, UInt32 *ProbPrices)
+static void LenPriceEnc_UpdateTables(CLenPriceEnc *p, UInt32 numPosStates, const UInt32 *ProbPrices)
 {
   UInt32 posState;
   for (posState = 0; posState < numPosStates; posState++)
     LenPriceEnc_UpdateTable(p, posState, ProbPrices);
 }
 
-static void LenEnc_Encode2(CLenPriceEnc *p, CRangeEnc *rc, UInt32 symbol, UInt32 posState, Bool updatePrice, UInt32 *ProbPrices)
+static void LenEnc_Encode2(CLenPriceEnc *p, CRangeEnc *rc, UInt32 symbol, UInt32 posState, Bool updatePrice, const UInt32 *ProbPrices)
 {
   LenEnc_Encode(&p->p, rc, symbol, posState);
   if (updatePrice)
     if (--p->counters[posState] == 0)
       LenPriceEnc_UpdateTable(p, posState, ProbPrices);
 }
 
 
 
 
 static void MovePos(CLzmaEnc *p, UInt32 num)
 {
   #ifdef SHOW_STAT
-  ttt += num;
-  printf("\n MovePos %d", num);
+  g_STAT_OFFSET += num;
+  printf("\n MovePos %u", num);
   #endif
+  
   if (num != 0)
   {
     p->additionalOffset += num;
     p->matchFinder.Skip(p->matchFinderObj, num);
   }
 }
 
 static UInt32 ReadMatchDistances(CLzmaEnc *p, UInt32 *numDistancePairsRes)
 {
   UInt32 lenRes = 0, numPairs;
   p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
   numPairs = p->matchFinder.GetMatches(p->matchFinderObj, p->matches);
+  
   #ifdef SHOW_STAT
-  printf("\n i = %d numPairs = %d    ", ttt, numPairs / 2);
-  ttt++;
+  printf("\n i = %u numPairs = %u    ", g_STAT_OFFSET, numPairs / 2);
+  g_STAT_OFFSET++;
   {
     UInt32 i;
     for (i = 0; i < numPairs; i += 2)
-      printf("%2d %6d   | ", p->matches[i], p->matches[i + 1]);
+      printf("%2u %6u   | ", p->matches[i], p->matches[i + 1]);
   }
   #endif
+  
   if (numPairs > 0)
   {
     lenRes = p->matches[numPairs - 2];
     if (lenRes == p->numFastBytes)
     {
-      const Byte *pby = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
-      UInt32 distance = p->matches[numPairs - 1] + 1;
       UInt32 numAvail = p->numAvail;
       if (numAvail > LZMA_MATCH_LEN_MAX)
         numAvail = LZMA_MATCH_LEN_MAX;
       {
-        const Byte *pby2 = pby - distance;
-        for (; lenRes < numAvail && pby[lenRes] == pby2[lenRes]; lenRes++);
+        const Byte *pbyCur = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
+        const Byte *pby = pbyCur + lenRes;
+        ptrdiff_t dif = (ptrdiff_t)-1 - p->matches[numPairs - 1];
+        const Byte *pbyLim = pbyCur + numAvail;
+        for (; pby != pbyLim && *pby == pby[dif]; pby++);
+        lenRes = (UInt32)(pby - pbyCur);
       }
     }
   }
   p->additionalOffset++;
   *numDistancePairsRes = numPairs;
   return lenRes;
 }
 
 
 #define MakeAsChar(p) (p)->backPrev = (UInt32)(-1); (p)->prev1IsChar = False;
@@ skipping 64 matching lines @@
       p->opt[posPrev].posPrev = cur;
       cur = posPrev;
     }
   }
   while (cur != 0);
   *backRes = p->opt[0].backPrev;
   p->optimumCurrentIndex  = p->opt[0].posPrev;
   return p->optimumCurrentIndex;
 }
 
-#define LIT_PROBS(pos, prevByte) (p->litProbs + ((((pos) & p->lpMask) << p->lc) + ((prevByte) >> (8 - p->lc))) * 0x300)
+#define LIT_PROBS(pos, prevByte) (p->litProbs + ((((pos) & p->lpMask) << p->lc) + ((prevByte) >> (8 - p->lc))) * (UInt32)0x300)
 
 static UInt32 GetOptimum(CLzmaEnc *p, UInt32 position, UInt32 *backRes)
 {
   UInt32 numAvail, mainLen, numPairs, repMaxIndex, i, posState, lenEnd, len, cur;
   UInt32 matchPrice, repMatchPrice, normalMatchPrice;
   UInt32 reps[LZMA_NUM_REPS], repLens[LZMA_NUM_REPS];
   UInt32 *matches;
   const Byte *data;
   Byte curByte, matchByte;
   if (p->optimumEndIndex != p->optimumCurrentIndex)
@@ skipping 23 matching lines @@
   if (numAvail > LZMA_MATCH_LEN_MAX)
     numAvail = LZMA_MATCH_LEN_MAX;
 
   data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
   repMaxIndex = 0;
   for (i = 0; i < LZMA_NUM_REPS; i++)
   {
     UInt32 lenTest;
     const Byte *data2;
     reps[i] = p->reps[i];
-    data2 = data - (reps[i] + 1);
+    data2 = data - reps[i] - 1;
     if (data[0] != data2[0] || data[1] != data2[1])
     {
       repLens[i] = 0;
       continue;
     }
     for (lenTest = 2; lenTest < numAvail && data[lenTest] == data2[lenTest]; lenTest++);
     repLens[i] = lenTest;
     if (lenTest > repLens[repMaxIndex])
       repMaxIndex = i;
   }
@@ skipping 123 matching lines @@
         offs += 2;
         if (offs == numPairs)
           break;
       }
     }
   }
 
   cur = 0;
 
     #ifdef SHOW_STAT2
-    if (position >= 0)
+    /* if (position >= 0) */
     {
       unsigned i;
       printf("\n pos = %4X", position);
       for (i = cur; i <= lenEnd; i++)
-      printf("\nprice[%4X] = %d", position - cur + i, p->opt[i].price);
+      printf("\nprice[%4X] = %u", position - cur + i, p->opt[i].price);
     }
     #endif
 
   for (;;)
   {
     UInt32 numAvailFull, newLen, numPairs, posPrev, state, posState, startLen;
     UInt32 curPrice, curAnd1Price, matchPrice, repMatchPrice;
     Bool nextIsChar;
     Byte curByte, matchByte;
     const Byte *data;
@@ skipping 131 matching lines @@
 
     if (numAvailFull < 2)
       continue;
     numAvail = (numAvailFull <= p->numFastBytes ? numAvailFull : p->numFastBytes);
 
     if (!nextIsChar && matchByte != curByte) /* speed optimization */
     {
       /* try Literal + rep0 */
       UInt32 temp;
       UInt32 lenTest2;
-      const Byte *data2 = data - (reps[0] + 1);
+      const Byte *data2 = data - reps[0] - 1;
       UInt32 limit = p->numFastBytes + 1;
       if (limit > numAvailFull)
         limit = numAvailFull;
 
       for (temp = 1; temp < limit && data[temp] == data2[temp]; temp++);
       lenTest2 = temp - 1;
       if (lenTest2 >= 2)
       {
         UInt32 state2 = kLiteralNextStates[state];
         UInt32 posStateNext = (position + 1) & p->pbMask;
@@ skipping 22 matching lines @@
     }
     
     startLen = 2; /* speed optimization */
     {
     UInt32 repIndex;
     for (repIndex = 0; repIndex < LZMA_NUM_REPS; repIndex++)
     {
       UInt32 lenTest;
       UInt32 lenTestTemp;
       UInt32 price;
-      const Byte *data2 = data - (reps[repIndex] + 1);
+      const Byte *data2 = data - reps[repIndex] - 1;
       if (data[0] != data2[0] || data[1] != data2[1])
         continue;
       for (lenTest = 2; lenTest < numAvail && data[lenTest] == data2[lenTest]; lenTest++);
       while (lenEnd < cur + lenTest)
         p->opt[++lenEnd].price = kInfinityPrice;
       lenTestTemp = lenTest;
       price = repMatchPrice + GetPureRepPrice(p, repIndex, state, posState);
       do
       {
         UInt32 curAndLenPrice = price + p->repLenEnc.prices[posState][lenTest - 2];
         COptimal *opt = &p->opt[cur + lenTest];
         if (curAndLenPrice < opt->price)
         {
           opt->price = curAndLenPrice;
           opt->posPrev = cur;
           opt->backPrev = repIndex;
           opt->prev1IsChar = False;
         }
       }
       while (--lenTest >= 2);
       lenTest = lenTestTemp;
       
       if (repIndex == 0)
         startLen = lenTest + 1;
         
       /* if (_maxMode) */
         {
           UInt32 lenTest2 = lenTest + 1;
           UInt32 limit = lenTest2 + p->numFastBytes;
-          UInt32 nextRepMatchPrice;
           if (limit > numAvailFull)
             limit = numAvailFull;
           for (; lenTest2 < limit && data[lenTest2] == data2[lenTest2]; lenTest2++);
           lenTest2 -= lenTest + 1;
           if (lenTest2 >= 2)
           {
+            UInt32 nextRepMatchPrice;
             UInt32 state2 = kRepNextStates[state];
             UInt32 posStateNext = (position + lenTest) & p->pbMask;
             UInt32 curAndLenCharPrice =
                 price + p->repLenEnc.prices[posState][lenTest - 2] +
                 GET_PRICE_0(p->isMatch[state2][posStateNext]) +
                 LitEnc_GetPriceMatched(LIT_PROBS(position + lenTest, data[lenTest - 1]),
                     data[lenTest], data2[lenTest], p->ProbPrices);
             state2 = kLiteralNextStates[state2];
             posStateNext = (position + lenTest + 1) & p->pbMask;
             nextRepMatchPrice = curAndLenCharPrice +
@@ skipping 60 matching lines @@
         {
           opt->price = curAndLenPrice;
           opt->posPrev = cur;
           opt->backPrev = curBack + LZMA_NUM_REPS;
           opt->prev1IsChar = False;
         }
 
         if (/*_maxMode && */lenTest == matches[offs])
         {
           /* Try Match + Literal + Rep0 */
-          const Byte *data2 = data - (curBack + 1);
+          const Byte *data2 = data - curBack - 1;
           UInt32 lenTest2 = lenTest + 1;
           UInt32 limit = lenTest2 + p->numFastBytes;
-          UInt32 nextRepMatchPrice;
           if (limit > numAvailFull)
             limit = numAvailFull;
           for (; lenTest2 < limit && data[lenTest2] == data2[lenTest2]; lenTest2++);
           lenTest2 -= lenTest + 1;
           if (lenTest2 >= 2)
           {
+            UInt32 nextRepMatchPrice;
             UInt32 state2 = kMatchNextStates[state];
             UInt32 posStateNext = (position + lenTest) & p->pbMask;
             UInt32 curAndLenCharPrice = curAndLenPrice +
                 GET_PRICE_0(p->isMatch[state2][posStateNext]) +
                 LitEnc_GetPriceMatched(LIT_PROBS(position + lenTest, data[lenTest - 1]),
                     data[lenTest], data2[lenTest], p->ProbPrices);
             state2 = kLiteralNextStates[state2];
             posStateNext = (posStateNext + 1) & p->pbMask;
             nextRepMatchPrice = curAndLenCharPrice +
                 GET_PRICE_1(p->isMatch[state2][posStateNext]) +
@@ skipping 53 matching lines @@
   if (numAvail < 2)
     return 1;
   if (numAvail > LZMA_MATCH_LEN_MAX)
     numAvail = LZMA_MATCH_LEN_MAX;
   data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
 
   repLen = repIndex = 0;
   for (i = 0; i < LZMA_NUM_REPS; i++)
   {
     UInt32 len;
-    const Byte *data2 = data - (p->reps[i] + 1);
+    const Byte *data2 = data - p->reps[i] - 1;
     if (data[0] != data2[0] || data[1] != data2[1])
       continue;
     for (len = 2; len < numAvail && data[len] == data2[len]; len++);
     if (len >= p->numFastBytes)
     {
       *backRes = i;
       MovePos(p, len - 1);
       return len;
     }
     if (len > repLen)
@@ skipping 48 matching lines @@
         (p->longestMatchLength == mainLen + 1 && !ChangePair(mainDist, newDistance)) ||
         (p->longestMatchLength > mainLen + 1) ||
         (p->longestMatchLength + 1 >= mainLen && mainLen >= 3 && ChangePair(newDistance, mainDist)))
       return 1;
   }
   
   data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
   for (i = 0; i < LZMA_NUM_REPS; i++)
   {
     UInt32 len, limit;
-    const Byte *data2 = data - (p->reps[i] + 1);
+    const Byte *data2 = data - p->reps[i] - 1;
     if (data[0] != data2[0] || data[1] != data2[1])
       continue;
     limit = mainLen - 1;
     for (len = 2; len < limit && data[len] == data2[len]; len++);
     if (len >= limit)
       return 1;
   }
   *backRes = mainDist + LZMA_NUM_REPS;
   MovePos(p, mainLen - 2);
   return mainLen;
@@ skipping 75 matching lines @@
         distancesPrices[i] = posSlotPrices[GetPosSlot1(i)] + tempPrices[i];
     }
   }
   p->matchPriceCount = 0;
 }
 
 void LzmaEnc_Construct(CLzmaEnc *p)
 {
   RangeEnc_Construct(&p->rc);
   MatchFinder_Construct(&p->matchFinderBase);
+  
   #ifndef _7ZIP_ST
   MatchFinderMt_Construct(&p->matchFinderMt);
   p->matchFinderMt.MatchFinder = &p->matchFinderBase;
   #endif
 
   {
     CLzmaEncProps props;
     LzmaEncProps_Init(&props);
     LzmaEnc_SetProps(p, &props);
   }
 
   #ifndef LZMA_LOG_BSR
   LzmaEnc_FastPosInit(p->g_FastPos);
   #endif
 
   LzmaEnc_InitPriceTables(p->ProbPrices);
-  p->litProbs = 0;
-  p->saveState.litProbs = 0;
+  p->litProbs = NULL;
+  p->saveState.litProbs = NULL;
 }
 
 CLzmaEncHandle LzmaEnc_Create(ISzAlloc *alloc)
 {
   void *p;
   p = alloc->Alloc(alloc, sizeof(CLzmaEnc));
-  if (p != 0)
+  if (p)
     LzmaEnc_Construct((CLzmaEnc *)p);
   return p;
 }
 
 void LzmaEnc_FreeLits(CLzmaEnc *p, ISzAlloc *alloc)
 {
   alloc->Free(alloc, p->litProbs);
   alloc->Free(alloc, p->saveState.litProbs);
-  p->litProbs = 0;
-  p->saveState.litProbs = 0;
+  p->litProbs = NULL;
+  p->saveState.litProbs = NULL;
 }
 
 void LzmaEnc_Destruct(CLzmaEnc *p, ISzAlloc *alloc, ISzAlloc *allocBig)
 {
   #ifndef _7ZIP_ST
   MatchFinderMt_Destruct(&p->matchFinderMt, allocBig);
   #endif
+  
   MatchFinder_Free(&p->matchFinderBase, allocBig);
   LzmaEnc_FreeLits(p, alloc);
   RangeEnc_Free(&p->rc, alloc);
 }
 
 void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAlloc *alloc, ISzAlloc *allocBig)
 {
   LzmaEnc_Destruct((CLzmaEnc *)p, alloc, allocBig);
   alloc->Free(alloc, p);
 }
@@ skipping 16 matching lines @@
 
   if (p->nowPos64 == 0)
   {
     UInt32 numPairs;
     Byte curByte;
     if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0)
       return Flush(p, nowPos32);
     ReadMatchDistances(p, &numPairs);
     RangeEnc_EncodeBit(&p->rc, &p->isMatch[p->state][0], 0);
     p->state = kLiteralNextStates[p->state];
-    curByte = p->matchFinder.GetIndexByte(p->matchFinderObj, 0 - p->additionalOffset);
+    curByte = *(p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset);
     LitEnc_Encode(&p->rc, p->litProbs, curByte);
     p->additionalOffset--;
     nowPos32++;
   }
 
   if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) != 0)
   for (;;)
   {
     UInt32 pos, len, posState;
 
     if (p->fastMode)
       len = GetOptimumFast(p, &pos);
     else
       len = GetOptimum(p, nowPos32, &pos);
 
     #ifdef SHOW_STAT2
-    printf("\n pos = %4X,   len = %d   pos = %d", nowPos32, len, pos);
+    printf("\n pos = %4X,   len = %u   pos = %u", nowPos32, len, pos);
     #endif
 
     posState = nowPos32 & p->pbMask;
     if (len == 1 && pos == (UInt32)-1)
     {
       Byte curByte;
       CLzmaProb *probs;
       const Byte *data;
 
       RangeEnc_EncodeBit(&p->rc, &p->isMatch[p->state][posState], 0);
@@ skipping 88 matching lines @@
       }
       if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0)
         break;
       processed = nowPos32 - startPos32;
       if (useLimits)
       {
         if (processed + kNumOpts + 300 >= maxUnpackSize ||
             RangeEnc_GetProcessed(&p->rc) + kNumOpts * 2 >= maxPackSize)
           break;
       }
-      else if (processed >= (1 << 15))
+      else if (processed >= (1 << 17))
       {
         p->nowPos64 += nowPos32 - startPos32;
         return CheckErrors(p);
       }
     }
   }
   p->nowPos64 += nowPos32 - startPos32;
   return Flush(p, nowPos32);
 }
 
 #define kBigHashDicLimit ((UInt32)1 << 24)
 
 static SRes LzmaEnc_Alloc(CLzmaEnc *p, UInt32 keepWindowSize, ISzAlloc *alloc, ISzAlloc *allocBig)
 {
   UInt32 beforeSize = kNumOpts;
-  Bool btMode;
   if (!RangeEnc_Alloc(&p->rc, alloc))
     return SZ_ERROR_MEM;
-  btMode = (p->matchFinderBase.btMode != 0);
+
   #ifndef _7ZIP_ST
-  p->mtMode = (p->multiThread && !p->fastMode && btMode);
+  p->mtMode = (p->multiThread && !p->fastMode && (p->matchFinderBase.btMode != 0));
   #endif
 
   {
     unsigned lclp = p->lc + p->lp;
-    if (p->litProbs == 0 || p->saveState.litProbs == 0 || p->lclp != lclp)
+    if (!p->litProbs || !p->saveState.litProbs || p->lclp != lclp)
     {
       LzmaEnc_FreeLits(p, alloc);
-      p->litProbs = (CLzmaProb *)alloc->Alloc(alloc, (0x300 << lclp) * sizeof(CLzmaProb));
-      p->saveState.litProbs = (CLzmaProb *)alloc->Alloc(alloc, (0x300 << lclp) * sizeof(CLzmaProb));
-      if (p->litProbs == 0 || p->saveState.litProbs == 0)
+      p->litProbs = (CLzmaProb *)alloc->Alloc(alloc, ((UInt32)0x300 << lclp) * sizeof(CLzmaProb));
+      p->saveState.litProbs = (CLzmaProb *)alloc->Alloc(alloc, ((UInt32)0x300 << lclp) * sizeof(CLzmaProb));
+      if (!p->litProbs || !p->saveState.litProbs)
       {
         LzmaEnc_FreeLits(p, alloc);
         return SZ_ERROR_MEM;
       }
       p->lclp = lclp;
     }
   }
 
-  p->matchFinderBase.bigHash = (p->dictSize > kBigHashDicLimit);
+  p->matchFinderBase.bigHash = (Byte)(p->dictSize > kBigHashDicLimit ? 1 : 0);
 
   if (beforeSize + p->dictSize < keepWindowSize)
     beforeSize = keepWindowSize - p->dictSize;
 
   #ifndef _7ZIP_ST
   if (p->mtMode)
   {
     RINOK(MatchFinderMt_Create(&p->matchFinderMt, p->dictSize, beforeSize, p->numFastBytes, LZMA_MATCH_LEN_MAX, allocBig));
     p->matchFinderObj = &p->matchFinderMt;
     MatchFinderMt_CreateVTable(&p->matchFinderMt, &p->matchFinder);
   }
   else
   #endif
   {
     if (!MatchFinder_Create(&p->matchFinderBase, p->dictSize, beforeSize, p->numFastBytes, LZMA_MATCH_LEN_MAX, allocBig))
       return SZ_ERROR_MEM;
     p->matchFinderObj = &p->matchFinderBase;
     MatchFinder_CreateVTable(&p->matchFinderBase, &p->matchFinder);
   }
+  
   return SZ_OK;
 }
 
 void LzmaEnc_Init(CLzmaEnc *p)
 {
   UInt32 i;
   p->state = 0;
   for (i = 0 ; i < LZMA_NUM_REPS; i++)
     p->reps[i] = 0;
 
   RangeEnc_Init(&p->rc);
 
 
   for (i = 0; i < kNumStates; i++)
   {
     UInt32 j;
     for (j = 0; j < LZMA_NUM_PB_STATES_MAX; j++)
     {
       p->isMatch[i][j] = kProbInitValue;
       p->isRep0Long[i][j] = kProbInitValue;
     }
     p->isRep[i] = kProbInitValue;
     p->isRepG0[i] = kProbInitValue;
     p->isRepG1[i] = kProbInitValue;
     p->isRepG2[i] = kProbInitValue;
   }
 
   {
-    UInt32 num = 0x300 << (p->lp + p->lc);
+    UInt32 num = (UInt32)0x300 << (p->lp + p->lc);
+    CLzmaProb *probs = p->litProbs;
     for (i = 0; i < num; i++)
-      p->litProbs[i] = kProbInitValue;
+      probs[i] = kProbInitValue;
   }
 
   {
     for (i = 0; i < kNumLenToPosStates; i++)
     {
       CLzmaProb *probs = p->posSlotEncoder[i];
       UInt32 j;
       for (j = 0; j < (1 << kNumPosSlotBits); j++)
         probs[j] = kProbInitValue;
     }
@@ skipping 86 matching lines @@
   return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
 }
 
 void LzmaEnc_Finish(CLzmaEncHandle pp)
 {
   #ifndef _7ZIP_ST
   CLzmaEnc *p = (CLzmaEnc *)pp;
   if (p->mtMode)
     MatchFinderMt_ReleaseStream(&p->matchFinderMt);
   #else
-  pp = pp;
+  UNUSED_VAR(pp);
   #endif
 }
 
+
 typedef struct
 {
   ISeqOutStream funcTable;
   Byte *data;
   SizeT rem;
   Bool overflow;
 } CSeqOutStreamBuf;
 
 static size_t MyWrite(void *pp, const void *data, size_t size)
 {
   CSeqOutStreamBuf *p = (CSeqOutStreamBuf *)pp;
   if (p->rem < size)
   {
     size = p->rem;
     p->overflow = True;
   }
   memcpy(p->data, data, size);
   p->rem -= size;
   p->data += size;
   return size;
 }
 
 
 UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle pp)
 {
   const CLzmaEnc *p = (CLzmaEnc *)pp;
   return p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
 }
 
+
 const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle pp)
 {
   const CLzmaEnc *p = (CLzmaEnc *)pp;
   return p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset;
 }
 
+
 SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, Bool reInit,
     Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize)
 {
   CLzmaEnc *p = (CLzmaEnc *)pp;
   UInt64 nowPos64;
   SRes res;
   CSeqOutStreamBuf outStream;
 
   outStream.funcTable.Write = MyWrite;
   outStream.data = dest;
@@ skipping 14 matching lines @@
   res = LzmaEnc_CodeOneBlock(p, True, desiredPackSize, *unpackSize);
   
   *unpackSize = (UInt32)(p->nowPos64 - nowPos64);
   *destLen -= outStream.rem;
   if (outStream.overflow)
     return SZ_ERROR_OUTPUT_EOF;
 
   return res;
 }
 
+
 static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)
 {
   SRes res = SZ_OK;
 
   #ifndef _7ZIP_ST
   Byte allocaDummy[0x300];
-  int i = 0;
-  for (i = 0; i < 16; i++)
-    allocaDummy[i] = (Byte)i;
+  allocaDummy[0] = 0;
+  allocaDummy[1] = allocaDummy[0];
   #endif
 
   for (;;)
   {
     res = LzmaEnc_CodeOneBlock(p, False, 0, 0);
-    if (res != SZ_OK || p->finished != 0)
+    if (res != SZ_OK || p->finished)
       break;
-    if (progress != 0)
+    if (progress)
     {
       res = progress->Progress(progress, p->nowPos64, RangeEnc_GetProcessed(&p->rc));
       if (res != SZ_OK)
       {
         res = SZ_ERROR_PROGRESS;
         break;
       }
     }
   }
+  
   LzmaEnc_Finish(p);
+
+  /*
+  if (res == S_OK && !Inline_MatchFinder_IsFinishedOK(&p->matchFinderBase))
+    res = SZ_ERROR_FAIL;
+  }
+  */
+
   return res;
 }
 
+
 SRes LzmaEnc_Encode(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress,
     ISzAlloc *alloc, ISzAlloc *allocBig)
 {
   RINOK(LzmaEnc_Prepare(pp, outStream, inStream, alloc, allocBig));
   return LzmaEnc_Encode2((CLzmaEnc *)pp, progress);
 }
 
+
 SRes LzmaEnc_WriteProperties(CLzmaEncHandle pp, Byte *props, SizeT *size)
 {
   CLzmaEnc *p = (CLzmaEnc *)pp;
-  int i;
+  unsigned i;
   UInt32 dictSize = p->dictSize;
   if (*size < LZMA_PROPS_SIZE)
     return SZ_ERROR_PARAM;
   *size = LZMA_PROPS_SIZE;
   props[0] = (Byte)((p->pb * 5 + p->lp) * 9 + p->lc);
 
-  for (i = 11; i <= 30; i++)
+  if (dictSize >= ((UInt32)1 << 22))
   {
-    if (dictSize <= ((UInt32)2 << i))
-    {
-      dictSize = (2 << i);
-      break;
-    }
-    if (dictSize <= ((UInt32)3 << i))
-    {
-      dictSize = (3 << i);
-      break;
-    }
+    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;
 }
 
+
 SRes LzmaEnc_MemEncode(CLzmaEncHandle pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
     int writeEndMark, ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig)
 {
   SRes res;
   CLzmaEnc *p = (CLzmaEnc *)pp;
 
   CSeqOutStreamBuf outStream;
 
-  LzmaEnc_SetInputBuf(p, src, srcLen);
-
   outStream.funcTable.Write = MyWrite;
   outStream.data = dest;
   outStream.rem = *destLen;
   outStream.overflow = False;
 
   p->writeEndMark = writeEndMark;
+  p->rc.outStream = &outStream.funcTable;
 
-  p->rc.outStream = &outStream.funcTable;
   res = LzmaEnc_MemPrepare(pp, src, srcLen, 0, alloc, allocBig);
+  
   if (res == SZ_OK)
+  {
     res = LzmaEnc_Encode2(p, progress);
+    if (res == SZ_OK && p->nowPos64 != srcLen)
+      res = SZ_ERROR_FAIL;
+  }
 
   *destLen -= outStream.rem;
   if (outStream.overflow)
     return SZ_ERROR_OUTPUT_EOF;
   return res;
 }
 
+
 SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
     const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
     ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig)
 {
   CLzmaEnc *p = (CLzmaEnc *)LzmaEnc_Create(alloc);
   SRes res;
-  if (p == 0)
+  if (!p)
     return SZ_ERROR_MEM;
 
   res = LzmaEnc_SetProps(p, props);
   if (res == SZ_OK)
   {
     res = LzmaEnc_WriteProperties(p, propsEncoded, propsSize);
     if (res == SZ_OK)
       res = LzmaEnc_MemEncode(p, dest, destLen, src, srcLen,
           writeEndMark, progress, alloc, allocBig);
   }
 
   LzmaEnc_Destroy(p, alloc, allocBig);
   return res;
 }