Restoring authorship annotation for Alexey Bykov <alexei4203@yandex.ru>. Commit 2 of 2.

1 files changed, 294 insertions, 294 deletions

diff --git a/contrib/libs/zstd/lib/compress/zstd_lazy.c b/contrib/libs/zstd/lib/compress/zstd_lazy.c
index cc614c3a26..2e38dcb46d 100644
--- a/contrib/libs/zstd/lib/compress/zstd_lazy.c
+++ b/contrib/libs/zstd/lib/compress/zstd_lazy.c
@@ -16,12 +16,12 @@
 *  Binary Tree search
 ***************************************/
 
-static void 
-ZSTD_updateDUBT(ZSTD_matchState_t* ms, 
+static void
+ZSTD_updateDUBT(ZSTD_matchState_t* ms,
                 const BYTE* ip, const BYTE* iend,
                 U32 mls)
 {
-    const ZSTD_compressionParameters* const cParams = &ms->cParams; 
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
     U32* const hashTable = ms->hashTable;
     U32  const hashLog = cParams->hashLog;
 
@@ -60,16 +60,16 @@ ZSTD_updateDUBT(ZSTD_matchState_t* ms,
  *  sort one already inserted but unsorted position
  *  assumption : curr >= btlow == (curr - btmask)
  *  doesn't fail */
-static void 
+static void
 ZSTD_insertDUBT1(const ZSTD_matchState_t* ms,
                  U32 curr, const BYTE* inputEnd,
-                 U32 nbCompares, U32 btLow, 
-                 const ZSTD_dictMode_e dictMode) 
+                 U32 nbCompares, U32 btLow,
+                 const ZSTD_dictMode_e dictMode)
 {
-    const ZSTD_compressionParameters* const cParams = &ms->cParams; 
-    U32* const bt = ms->chainTable; 
-    U32  const btLog  = cParams->chainLog - 1; 
-    U32  const btMask = (1 << btLog) - 1; 
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    U32* const bt = ms->chainTable;
+    U32  const btLog  = cParams->chainLog - 1;
+    U32  const btMask = (1 << btLog) - 1;
     size_t commonLengthSmaller=0, commonLengthLarger=0;
     const BYTE* const base = ms->window.base;
     const BYTE* const dictBase = ms->window.dictBase;
@@ -81,7 +81,7 @@ ZSTD_insertDUBT1(const ZSTD_matchState_t* ms,
     const BYTE* match;
     U32* smallerPtr = bt + 2*(curr&btMask);
     U32* largerPtr  = smallerPtr + 1;
-    U32 matchIndex = *smallerPtr;   /* this candidate is unsorted : next sorted candidate is reached through *smallerPtr, while *largerPtr contains previous unsorted candidate (which is already saved and can be overwritten) */ 
+    U32 matchIndex = *smallerPtr;   /* this candidate is unsorted : next sorted candidate is reached through *smallerPtr, while *largerPtr contains previous unsorted candidate (which is already saved and can be overwritten) */
     U32 dummy32;   /* to be nullified at the end */
     U32 const windowValid = ms->window.lowLimit;
     U32 const maxDistance = 1U << cParams->windowLog;
@@ -97,16 +97,16 @@ ZSTD_insertDUBT1(const ZSTD_matchState_t* ms,
         U32* const nextPtr = bt + 2*(matchIndex & btMask);
         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
         assert(matchIndex < curr);
-        /* note : all candidates are now supposed sorted, 
-         * but it's still possible to have nextPtr[1] == ZSTD_DUBT_UNSORTED_MARK 
-         * when a real index has the same value as ZSTD_DUBT_UNSORTED_MARK */ 
+        /* note : all candidates are now supposed sorted,
+         * but it's still possible to have nextPtr[1] == ZSTD_DUBT_UNSORTED_MARK
+         * when a real index has the same value as ZSTD_DUBT_UNSORTED_MARK */
 
-        if ( (dictMode != ZSTD_extDict) 
+        if ( (dictMode != ZSTD_extDict)
           || (matchIndex+matchLength >= dictLimit)  /* both in current segment*/
           || (curr < dictLimit) /* both in extDict */) {
-            const BYTE* const mBase = ( (dictMode != ZSTD_extDict) 
-                                     || (matchIndex+matchLength >= dictLimit)) ? 
-                                        base : dictBase; 
+            const BYTE* const mBase = ( (dictMode != ZSTD_extDict)
+                                     || (matchIndex+matchLength >= dictLimit)) ?
+                                        base : dictBase;
             assert( (matchIndex+matchLength >= dictLimit)   /* might be wrong if extDict is incorrectly set to 0 */
                  || (curr < dictLimit) );
             match = mBase + matchIndex;
@@ -115,7 +115,7 @@ ZSTD_insertDUBT1(const ZSTD_matchState_t* ms,
             match = dictBase + matchIndex;
             matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
             if (matchIndex+matchLength >= dictLimit)
-                match = base + matchIndex;   /* preparation for next read of match[matchLength] */ 
+                match = base + matchIndex;   /* preparation for next read of match[matchLength] */
         }
 
         DEBUGLOG(8, "ZSTD_insertDUBT1: comparing %u with %u : found %u common bytes ",
@@ -149,92 +149,92 @@ ZSTD_insertDUBT1(const ZSTD_matchState_t* ms,
 }
 
 
-static size_t 
-ZSTD_DUBT_findBetterDictMatch ( 
+static size_t
+ZSTD_DUBT_findBetterDictMatch (
         const ZSTD_matchState_t* ms,
-        const BYTE* const ip, const BYTE* const iend, 
-        size_t* offsetPtr, 
-        size_t bestLength, 
-        U32 nbCompares, 
-        U32 const mls, 
-        const ZSTD_dictMode_e dictMode) 
+        const BYTE* const ip, const BYTE* const iend,
+        size_t* offsetPtr,
+        size_t bestLength,
+        U32 nbCompares,
+        U32 const mls,
+        const ZSTD_dictMode_e dictMode)
 {
-    const ZSTD_matchState_t * const dms = ms->dictMatchState; 
-    const ZSTD_compressionParameters* const dmsCParams = &dms->cParams; 
-    const U32 * const dictHashTable = dms->hashTable; 
-    U32         const hashLog = dmsCParams->hashLog; 
-    size_t      const h  = ZSTD_hashPtr(ip, hashLog, mls); 
-    U32               dictMatchIndex = dictHashTable[h]; 
- 
-    const BYTE* const base = ms->window.base; 
-    const BYTE* const prefixStart = base + ms->window.dictLimit; 
+    const ZSTD_matchState_t * const dms = ms->dictMatchState;
+    const ZSTD_compressionParameters* const dmsCParams = &dms->cParams;
+    const U32 * const dictHashTable = dms->hashTable;
+    U32         const hashLog = dmsCParams->hashLog;
+    size_t      const h  = ZSTD_hashPtr(ip, hashLog, mls);
+    U32               dictMatchIndex = dictHashTable[h];
+
+    const BYTE* const base = ms->window.base;
+    const BYTE* const prefixStart = base + ms->window.dictLimit;
     U32         const curr = (U32)(ip-base);
-    const BYTE* const dictBase = dms->window.base; 
-    const BYTE* const dictEnd = dms->window.nextSrc; 
-    U32         const dictHighLimit = (U32)(dms->window.nextSrc - dms->window.base); 
-    U32         const dictLowLimit = dms->window.lowLimit; 
-    U32         const dictIndexDelta = ms->window.lowLimit - dictHighLimit; 
- 
-    U32*        const dictBt = dms->chainTable; 
-    U32         const btLog  = dmsCParams->chainLog - 1; 
-    U32         const btMask = (1 << btLog) - 1; 
-    U32         const btLow = (btMask >= dictHighLimit - dictLowLimit) ? dictLowLimit : dictHighLimit - btMask; 
- 
-    size_t commonLengthSmaller=0, commonLengthLarger=0; 
- 
-    (void)dictMode; 
-    assert(dictMode == ZSTD_dictMatchState); 
- 
+    const BYTE* const dictBase = dms->window.base;
+    const BYTE* const dictEnd = dms->window.nextSrc;
+    U32         const dictHighLimit = (U32)(dms->window.nextSrc - dms->window.base);
+    U32         const dictLowLimit = dms->window.lowLimit;
+    U32         const dictIndexDelta = ms->window.lowLimit - dictHighLimit;
+
+    U32*        const dictBt = dms->chainTable;
+    U32         const btLog  = dmsCParams->chainLog - 1;
+    U32         const btMask = (1 << btLog) - 1;
+    U32         const btLow = (btMask >= dictHighLimit - dictLowLimit) ? dictLowLimit : dictHighLimit - btMask;
+
+    size_t commonLengthSmaller=0, commonLengthLarger=0;
+
+    (void)dictMode;
+    assert(dictMode == ZSTD_dictMatchState);
+
     for (; nbCompares && (dictMatchIndex > dictLowLimit); --nbCompares) {
-        U32* const nextPtr = dictBt + 2*(dictMatchIndex & btMask); 
-        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */ 
-        const BYTE* match = dictBase + dictMatchIndex; 
-        matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart); 
-        if (dictMatchIndex+matchLength >= dictHighLimit) 
-            match = base + dictMatchIndex + dictIndexDelta;   /* to prepare for next usage of match[matchLength] */ 
- 
-        if (matchLength > bestLength) { 
-            U32 matchIndex = dictMatchIndex + dictIndexDelta; 
+        U32* const nextPtr = dictBt + 2*(dictMatchIndex & btMask);
+        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
+        const BYTE* match = dictBase + dictMatchIndex;
+        matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
+        if (dictMatchIndex+matchLength >= dictHighLimit)
+            match = base + dictMatchIndex + dictIndexDelta;   /* to prepare for next usage of match[matchLength] */
+
+        if (matchLength > bestLength) {
+            U32 matchIndex = dictMatchIndex + dictIndexDelta;
             if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(curr-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) ) {
-                DEBUGLOG(9, "ZSTD_DUBT_findBetterDictMatch(%u) : found better match length %u -> %u and offsetCode %u -> %u (dictMatchIndex %u, matchIndex %u)", 
+                DEBUGLOG(9, "ZSTD_DUBT_findBetterDictMatch(%u) : found better match length %u -> %u and offsetCode %u -> %u (dictMatchIndex %u, matchIndex %u)",
                     curr, (U32)bestLength, (U32)matchLength, (U32)*offsetPtr, STORE_OFFSET(curr - matchIndex), dictMatchIndex, matchIndex);
                 bestLength = matchLength, *offsetPtr = STORE_OFFSET(curr - matchIndex);
-            } 
-            if (ip+matchLength == iend) {   /* reached end of input : ip[matchLength] is not valid, no way to know if it's larger or smaller than match */ 
-                break;   /* drop, to guarantee consistency (miss a little bit of compression) */ 
-            } 
-        } 
- 
-        if (match[matchLength] < ip[matchLength]) { 
-            if (dictMatchIndex <= btLow) { break; }   /* beyond tree size, stop the search */ 
-            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */ 
-            dictMatchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */ 
-        } else { 
-            /* match is larger than current */ 
-            if (dictMatchIndex <= btLow) { break; }   /* beyond tree size, stop the search */ 
-            commonLengthLarger = matchLength; 
-            dictMatchIndex = nextPtr[0]; 
-        } 
-    } 
- 
-    if (bestLength >= MINMATCH) { 
+            }
+            if (ip+matchLength == iend) {   /* reached end of input : ip[matchLength] is not valid, no way to know if it's larger or smaller than match */
+                break;   /* drop, to guarantee consistency (miss a little bit of compression) */
+            }
+        }
+
+        if (match[matchLength] < ip[matchLength]) {
+            if (dictMatchIndex <= btLow) { break; }   /* beyond tree size, stop the search */
+            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
+            dictMatchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
+        } else {
+            /* match is larger than current */
+            if (dictMatchIndex <= btLow) { break; }   /* beyond tree size, stop the search */
+            commonLengthLarger = matchLength;
+            dictMatchIndex = nextPtr[0];
+        }
+    }
+
+    if (bestLength >= MINMATCH) {
         U32 const mIndex = curr - (U32)STORED_OFFSET(*offsetPtr); (void)mIndex;
-        DEBUGLOG(8, "ZSTD_DUBT_findBetterDictMatch(%u) : found match of length %u and offsetCode %u (pos %u)", 
+        DEBUGLOG(8, "ZSTD_DUBT_findBetterDictMatch(%u) : found match of length %u and offsetCode %u (pos %u)",
                     curr, (U32)bestLength, (U32)*offsetPtr, mIndex);
-    } 
-    return bestLength; 
- 
-} 
- 
- 
-static size_t 
-ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms, 
-                        const BYTE* const ip, const BYTE* const iend, 
-                        size_t* offsetPtr, 
-                        U32 const mls, 
-                        const ZSTD_dictMode_e dictMode) 
-{ 
-    const ZSTD_compressionParameters* const cParams = &ms->cParams; 
+    }
+    return bestLength;
+
+}
+
+
+static size_t
+ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
+                        const BYTE* const ip, const BYTE* const iend,
+                        size_t* offsetPtr,
+                        U32 const mls,
+                        const ZSTD_dictMode_e dictMode)
+{
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
     U32*   const hashTable = ms->hashTable;
     U32    const hashLog = cParams->hashLog;
     size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);
@@ -266,7 +266,7 @@ ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
          && (nbCandidates > 1) ) {
         DEBUGLOG(8, "ZSTD_DUBT_findBestMatch: candidate %u is unsorted",
                     matchIndex);
-        *unsortedMark = previousCandidate;  /* the unsortedMark becomes a reversed chain, to move up back to original position */ 
+        *unsortedMark = previousCandidate;  /* the unsortedMark becomes a reversed chain, to move up back to original position */
         previousCandidate = matchIndex;
         matchIndex = *nextCandidate;
         nextCandidate = bt + 2*(matchIndex&btMask);
@@ -274,13 +274,13 @@ ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
         nbCandidates --;
     }
 
-    /* nullify last candidate if it's still unsorted 
-     * simplification, detrimental to compression ratio, beneficial for speed */ 
+    /* nullify last candidate if it's still unsorted
+     * simplification, detrimental to compression ratio, beneficial for speed */
     if ( (matchIndex > unsortLimit)
       && (*unsortedMark==ZSTD_DUBT_UNSORTED_MARK) ) {
         DEBUGLOG(7, "ZSTD_DUBT_findBestMatch: nullify last unsorted candidate %u",
                     matchIndex);
-        *nextCandidate = *unsortedMark = 0; 
+        *nextCandidate = *unsortedMark = 0;
     }
 
     /* batch sort stacked candidates */
@@ -288,14 +288,14 @@ ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
     while (matchIndex) {  /* will end on matchIndex == 0 */
         U32* const nextCandidateIdxPtr = bt + 2*(matchIndex&btMask) + 1;
         U32 const nextCandidateIdx = *nextCandidateIdxPtr;
-        ZSTD_insertDUBT1(ms, matchIndex, iend, 
-                         nbCandidates, unsortLimit, dictMode); 
+        ZSTD_insertDUBT1(ms, matchIndex, iend,
+                         nbCandidates, unsortLimit, dictMode);
         matchIndex = nextCandidateIdx;
         nbCandidates++;
     }
 
     /* find longest match */
-    {   size_t commonLengthSmaller = 0, commonLengthLarger = 0; 
+    {   size_t commonLengthSmaller = 0, commonLengthLarger = 0;
         const BYTE* const dictBase = ms->window.dictBase;
         const U32 dictLimit = ms->window.dictLimit;
         const BYTE* const dictEnd = dictBase + dictLimit;
@@ -314,7 +314,7 @@ ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
             size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
             const BYTE* match;
 
-            if ((dictMode != ZSTD_extDict) || (matchIndex+matchLength >= dictLimit)) { 
+            if ((dictMode != ZSTD_extDict) || (matchIndex+matchLength >= dictLimit)) {
                 match = base + matchIndex;
                 matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
             } else {
@@ -330,11 +330,11 @@ ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
                 if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(curr-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) )
                     bestLength = matchLength, *offsetPtr = STORE_OFFSET(curr - matchIndex);
                 if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */
-                    if (dictMode == ZSTD_dictMatchState) { 
-                        nbCompares = 0; /* in addition to avoiding checking any 
-                                         * further in this loop, make sure we 
-                                         * skip checking in the dictionary. */ 
-                    } 
+                    if (dictMode == ZSTD_dictMatchState) {
+                        nbCompares = 0; /* in addition to avoiding checking any
+                                         * further in this loop, make sure we
+                                         * skip checking in the dictionary. */
+                    }
                     break;   /* drop, to guarantee consistency (miss a little bit of compression) */
                 }
             }
@@ -358,13 +358,13 @@ ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
         *smallerPtr = *largerPtr = 0;
 
         assert(nbCompares <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */
-        if (dictMode == ZSTD_dictMatchState && nbCompares) { 
-            bestLength = ZSTD_DUBT_findBetterDictMatch( 
-                    ms, ip, iend, 
-                    offsetPtr, bestLength, nbCompares, 
-                    mls, dictMode); 
-        } 
- 
+        if (dictMode == ZSTD_dictMatchState && nbCompares) {
+            bestLength = ZSTD_DUBT_findBetterDictMatch(
+                    ms, ip, iend,
+                    offsetPtr, bestLength, nbCompares,
+                    mls, dictMode);
+        }
+
         assert(matchEndIdx > curr+8); /* ensure nextToUpdate is increased */
         ms->nextToUpdate = matchEndIdx - 8;   /* skip repetitive patterns */
         if (bestLength >= MINMATCH) {
@@ -378,17 +378,17 @@ ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
 
 
 /** ZSTD_BtFindBestMatch() : Tree updater, providing best match */
-FORCE_INLINE_TEMPLATE size_t 
-ZSTD_BtFindBestMatch( ZSTD_matchState_t* ms, 
-                const BYTE* const ip, const BYTE* const iLimit, 
-                      size_t* offsetPtr, 
-                const U32 mls /* template */, 
-                const ZSTD_dictMode_e dictMode) 
+FORCE_INLINE_TEMPLATE size_t
+ZSTD_BtFindBestMatch( ZSTD_matchState_t* ms,
+                const BYTE* const ip, const BYTE* const iLimit,
+                      size_t* offsetPtr,
+                const U32 mls /* template */,
+                const ZSTD_dictMode_e dictMode)
 {
     DEBUGLOG(7, "ZSTD_BtFindBestMatch");
     if (ip < ms->window.base + ms->nextToUpdate) return 0;   /* skipped area */
-    ZSTD_updateDUBT(ms, ip, iLimit, mls); 
-    return ZSTD_DUBT_findBestMatch(ms, ip, iLimit, offsetPtr, mls, dictMode); 
+    ZSTD_updateDUBT(ms, ip, iLimit, mls);
+    return ZSTD_DUBT_findBestMatch(ms, ip, iLimit, offsetPtr, mls, dictMode);
 }
 
 /***********************************
@@ -646,12 +646,12 @@ U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip) {
 /* inlining is important to hardwire a hot branch (template emulation) */
 FORCE_INLINE_TEMPLATE
 size_t ZSTD_HcFindBestMatch(
-                        ZSTD_matchState_t* ms, 
+                        ZSTD_matchState_t* ms,
                         const BYTE* const ip, const BYTE* const iLimit,
                         size_t* offsetPtr,
-                        const U32 mls, const ZSTD_dictMode_e dictMode) 
+                        const U32 mls, const ZSTD_dictMode_e dictMode)
 {
-    const ZSTD_compressionParameters* const cParams = &ms->cParams; 
+    const ZSTD_compressionParameters* const cParams = &ms->cParams;
     U32* const chainTable = ms->chainTable;
     const U32 chainSize = (1 << cParams->chainLog);
     const U32 chainMask = chainSize-1;
@@ -688,9 +688,9 @@ size_t ZSTD_HcFindBestMatch(
 
     for ( ; (matchIndex>=lowLimit) & (nbAttempts>0) ; nbAttempts--) {
         size_t currentMl=0;
-        if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) { 
+        if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {
             const BYTE* const match = base + matchIndex;
-            assert(matchIndex >= dictLimit);   /* ensures this is true if dictMode != ZSTD_extDict */ 
+            assert(matchIndex >= dictLimit);   /* ensures this is true if dictMode != ZSTD_extDict */
             if (match[ml] == ip[ml])   /* potentially better */
                 currentMl = ZSTD_count(ip, match, iLimit);
         } else {
@@ -716,39 +716,39 @@ size_t ZSTD_HcFindBestMatch(
         ml = ZSTD_dedicatedDictSearch_lazy_search(offsetPtr, ml, nbAttempts, dms,
                                                   ip, iLimit, prefixStart, curr, dictLimit, ddsIdx);
     } else if (dictMode == ZSTD_dictMatchState) {
-        const U32* const dmsChainTable = dms->chainTable; 
-        const U32 dmsChainSize         = (1 << dms->cParams.chainLog); 
-        const U32 dmsChainMask         = dmsChainSize - 1; 
-        const U32 dmsLowestIndex       = dms->window.dictLimit; 
-        const BYTE* const dmsBase      = dms->window.base; 
-        const BYTE* const dmsEnd       = dms->window.nextSrc; 
-        const U32 dmsSize              = (U32)(dmsEnd - dmsBase); 
-        const U32 dmsIndexDelta        = dictLimit - dmsSize; 
-        const U32 dmsMinChain = dmsSize > dmsChainSize ? dmsSize - dmsChainSize : 0; 
- 
-        matchIndex = dms->hashTable[ZSTD_hashPtr(ip, dms->cParams.hashLog, mls)]; 
- 
+        const U32* const dmsChainTable = dms->chainTable;
+        const U32 dmsChainSize         = (1 << dms->cParams.chainLog);
+        const U32 dmsChainMask         = dmsChainSize - 1;
+        const U32 dmsLowestIndex       = dms->window.dictLimit;
+        const BYTE* const dmsBase      = dms->window.base;
+        const BYTE* const dmsEnd       = dms->window.nextSrc;
+        const U32 dmsSize              = (U32)(dmsEnd - dmsBase);
+        const U32 dmsIndexDelta        = dictLimit - dmsSize;
+        const U32 dmsMinChain = dmsSize > dmsChainSize ? dmsSize - dmsChainSize : 0;
+
+        matchIndex = dms->hashTable[ZSTD_hashPtr(ip, dms->cParams.hashLog, mls)];
+
         for ( ; (matchIndex>=dmsLowestIndex) & (nbAttempts>0) ; nbAttempts--) {
-            size_t currentMl=0; 
-            const BYTE* const match = dmsBase + matchIndex; 
-            assert(match+4 <= dmsEnd); 
-            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */ 
-                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dmsEnd, prefixStart) + 4; 
- 
-            /* save best solution */ 
-            if (currentMl > ml) { 
-                ml = currentMl; 
+            size_t currentMl=0;
+            const BYTE* const match = dmsBase + matchIndex;
+            assert(match+4 <= dmsEnd);
+            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */
+                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dmsEnd, prefixStart) + 4;
+
+            /* save best solution */
+            if (currentMl > ml) {
+                ml = currentMl;
                 assert(curr > matchIndex + dmsIndexDelta);
                 *offsetPtr = STORE_OFFSET(curr - (matchIndex + dmsIndexDelta));
-                if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */ 
-            } 
- 
-            if (matchIndex <= dmsMinChain) break; 
-
-            matchIndex = dmsChainTable[matchIndex & dmsChainMask]; 
-        } 
-    } 
- 
+                if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */
+            }
+
+            if (matchIndex <= dmsMinChain) break;
+
+            matchIndex = dmsChainTable[matchIndex & dmsChainMask];
+        }
+    }
+
     return ml;
 }
 
@@ -1478,16 +1478,16 @@ ZSTD_compressBlock_lazy_generic(
                         U32 rep[ZSTD_REP_NUM],
                         const void* src, size_t srcSize,
                         const searchMethod_e searchMethod, const U32 depth,
-                        ZSTD_dictMode_e const dictMode) 
+                        ZSTD_dictMode_e const dictMode)
 {
     const BYTE* const istart = (const BYTE*)src;
     const BYTE* ip = istart;
     const BYTE* anchor = istart;
     const BYTE* const iend = istart + srcSize;
     const BYTE* const ilimit = (searchMethod == search_rowHash) ? iend - 8 - ZSTD_ROW_HASH_CACHE_SIZE : iend - 8;
-    const BYTE* const base = ms->window.base; 
-    const U32 prefixLowestIndex = ms->window.dictLimit; 
-    const BYTE* const prefixLowest = base + prefixLowestIndex; 
+    const BYTE* const base = ms->window.base;
+    const U32 prefixLowestIndex = ms->window.dictLimit;
+    const BYTE* const prefixLowest = base + prefixLowestIndex;
 
     searchMax_f const searchMax = ZSTD_selectLazyVTable(ms, searchMethod, dictMode)->searchMax;
     U32 offset_1 = rep[0], offset_2 = rep[1], savedOffset=0;
@@ -1495,21 +1495,21 @@ ZSTD_compressBlock_lazy_generic(
     const int isDMS = dictMode == ZSTD_dictMatchState;
     const int isDDS = dictMode == ZSTD_dedicatedDictSearch;
     const int isDxS = isDMS || isDDS;
-    const ZSTD_matchState_t* const dms = ms->dictMatchState; 
+    const ZSTD_matchState_t* const dms = ms->dictMatchState;
     const U32 dictLowestIndex      = isDxS ? dms->window.dictLimit : 0;
     const BYTE* const dictBase     = isDxS ? dms->window.base : NULL;
     const BYTE* const dictLowest   = isDxS ? dictBase + dictLowestIndex : NULL;
     const BYTE* const dictEnd      = isDxS ? dms->window.nextSrc : NULL;
     const U32 dictIndexDelta       = isDxS ?
-                                     prefixLowestIndex - (U32)(dictEnd - dictBase) : 
-                                     0; 
+                                     prefixLowestIndex - (U32)(dictEnd - dictBase) :
+                                     0;
     const U32 dictAndPrefixLength = (U32)((ip - prefixLowest) + (dictEnd - dictLowest));
- 
+
     assert(searchMax != NULL);
 
     DEBUGLOG(5, "ZSTD_compressBlock_lazy_generic (dictMode=%u) (searchFunc=%u)", (U32)dictMode, (U32)searchMethod);
-    ip += (dictAndPrefixLength == 0); 
-    if (dictMode == ZSTD_noDict) { 
+    ip += (dictAndPrefixLength == 0);
+    if (dictMode == ZSTD_noDict) {
         U32 const curr = (U32)(ip - base);
         U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, curr, ms->cParams.windowLog);
         U32 const maxRep = curr - windowLow;
@@ -1517,11 +1517,11 @@ ZSTD_compressBlock_lazy_generic(
         if (offset_1 > maxRep) savedOffset = offset_1, offset_1 = 0;
     }
     if (isDxS) {
-        /* dictMatchState repCode checks don't currently handle repCode == 0 
-         * disabling. */ 
-        assert(offset_1 <= dictAndPrefixLength); 
-        assert(offset_2 <= dictAndPrefixLength); 
-    } 
+        /* dictMatchState repCode checks don't currently handle repCode == 0
+         * disabling. */
+        assert(offset_1 <= dictAndPrefixLength);
+        assert(offset_2 <= dictAndPrefixLength);
+    }
 
     if (searchMethod == search_rowHash) {
         const U32 rowLog = MAX(4, MIN(6, ms->cParams.searchLog));
@@ -1545,27 +1545,27 @@ ZSTD_compressBlock_lazy_generic(
 
         /* check repCode */
         if (isDxS) {
-            const U32 repIndex = (U32)(ip - base) + 1 - offset_1; 
+            const U32 repIndex = (U32)(ip - base) + 1 - offset_1;
             const BYTE* repMatch = ((dictMode == ZSTD_dictMatchState || dictMode == ZSTD_dedicatedDictSearch)
-                                && repIndex < prefixLowestIndex) ? 
-                                   dictBase + (repIndex - dictIndexDelta) : 
-                                   base + repIndex; 
-            if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */) 
-                && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) { 
-                const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend; 
-                matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4; 
-                if (depth==0) goto _storeSequence; 
-            } 
-        } 
-        if ( dictMode == ZSTD_noDict 
-          && ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1)))) { 
+                                && repIndex < prefixLowestIndex) ?
+                                   dictBase + (repIndex - dictIndexDelta) :
+                                   base + repIndex;
+            if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
+                && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
+                const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
+                matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
+                if (depth==0) goto _storeSequence;
+            }
+        }
+        if ( dictMode == ZSTD_noDict
+          && ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1)))) {
             matchLength = ZSTD_count(ip+1+4, ip+1+4-offset_1, iend) + 4;
             if (depth==0) goto _storeSequence;
         }
 
         /* first search (depth 0) */
-        {   size_t offsetFound = 999999999; 
-            size_t const ml2 = searchMax(ms, ip, iend, &offsetFound); 
+        {   size_t offsetFound = 999999999;
+            size_t const ml2 = searchMax(ms, ip, iend, &offsetFound);
             if (ml2 > matchLength)
                 matchLength = ml2, start = ip, offcode=offsetFound;
         }
@@ -1580,7 +1580,7 @@ ZSTD_compressBlock_lazy_generic(
         while (ip<ilimit) {
             DEBUGLOG(7, "search depth 1");
             ip ++;
-            if ( (dictMode == ZSTD_noDict) 
+            if ( (dictMode == ZSTD_noDict)
               && (offcode) && ((offset_1>0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) {
                 size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4;
                 int const gain2 = (int)(mlRep * 3);
@@ -1589,22 +1589,22 @@ ZSTD_compressBlock_lazy_generic(
                     matchLength = mlRep, offcode = STORE_REPCODE_1, start = ip;
             }
             if (isDxS) {
-                const U32 repIndex = (U32)(ip - base) - offset_1; 
-                const BYTE* repMatch = repIndex < prefixLowestIndex ? 
-                               dictBase + (repIndex - dictIndexDelta) : 
-                               base + repIndex; 
-                if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */) 
-                    && (MEM_read32(repMatch) == MEM_read32(ip)) ) { 
-                    const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend; 
-                    size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4; 
-                    int const gain2 = (int)(mlRep * 3); 
+                const U32 repIndex = (U32)(ip - base) - offset_1;
+                const BYTE* repMatch = repIndex < prefixLowestIndex ?
+                               dictBase + (repIndex - dictIndexDelta) :
+                               base + repIndex;
+                if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
+                    && (MEM_read32(repMatch) == MEM_read32(ip)) ) {
+                    const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
+                    size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
+                    int const gain2 = (int)(mlRep * 3);
                     int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offcode)) + 1);
-                    if ((mlRep >= 4) && (gain2 > gain1)) 
+                    if ((mlRep >= 4) && (gain2 > gain1))
                         matchLength = mlRep, offcode = STORE_REPCODE_1, start = ip;
-                } 
-            } 
-            {   size_t offset2=999999999; 
-                size_t const ml2 = searchMax(ms, ip, iend, &offset2); 
+                }
+            }
+            {   size_t offset2=999999999;
+                size_t const ml2 = searchMax(ms, ip, iend, &offset2);
                 int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offset2)));   /* raw approx */
                 int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offcode)) + 4);
                 if ((ml2 >= 4) && (gain2 > gain1)) {
@@ -1616,31 +1616,31 @@ ZSTD_compressBlock_lazy_generic(
             if ((depth==2) && (ip<ilimit)) {
                 DEBUGLOG(7, "search depth 2");
                 ip ++;
-                if ( (dictMode == ZSTD_noDict) 
+                if ( (dictMode == ZSTD_noDict)
                   && (offcode) && ((offset_1>0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) {
-                    size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4; 
-                    int const gain2 = (int)(mlRep * 4); 
+                    size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4;
+                    int const gain2 = (int)(mlRep * 4);
                     int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offcode)) + 1);
-                    if ((mlRep >= 4) && (gain2 > gain1)) 
+                    if ((mlRep >= 4) && (gain2 > gain1))
                         matchLength = mlRep, offcode = STORE_REPCODE_1, start = ip;
                 }
                 if (isDxS) {
-                    const U32 repIndex = (U32)(ip - base) - offset_1; 
-                    const BYTE* repMatch = repIndex < prefixLowestIndex ? 
-                                   dictBase + (repIndex - dictIndexDelta) : 
-                                   base + repIndex; 
-                    if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */) 
-                        && (MEM_read32(repMatch) == MEM_read32(ip)) ) { 
-                        const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend; 
-                        size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4; 
-                        int const gain2 = (int)(mlRep * 4); 
+                    const U32 repIndex = (U32)(ip - base) - offset_1;
+                    const BYTE* repMatch = repIndex < prefixLowestIndex ?
+                                   dictBase + (repIndex - dictIndexDelta) :
+                                   base + repIndex;
+                    if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
+                        && (MEM_read32(repMatch) == MEM_read32(ip)) ) {
+                        const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
+                        size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
+                        int const gain2 = (int)(mlRep * 4);
                         int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offcode)) + 1);
-                        if ((mlRep >= 4) && (gain2 > gain1)) 
+                        if ((mlRep >= 4) && (gain2 > gain1))
                             matchLength = mlRep, offcode = STORE_REPCODE_1, start = ip;
-                    } 
-                } 
-                {   size_t offset2=999999999; 
-                    size_t const ml2 = searchMax(ms, ip, iend, &offset2); 
+                    }
+                }
+                {   size_t offset2=999999999;
+                    size_t const ml2 = searchMax(ms, ip, iend, &offset2);
                     int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offset2)));   /* raw approx */
                     int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offcode)) + 7);
                     if ((ml2 >= 4) && (gain2 > gain1)) {
@@ -1656,17 +1656,17 @@ ZSTD_compressBlock_lazy_generic(
          */
         /* catch up */
         if (STORED_IS_OFFSET(offcode)) {
-            if (dictMode == ZSTD_noDict) { 
+            if (dictMode == ZSTD_noDict) {
                 while ( ((start > anchor) & (start - STORED_OFFSET(offcode) > prefixLowest))
                      && (start[-1] == (start-STORED_OFFSET(offcode))[-1]) )  /* only search for offset within prefix */
-                    { start--; matchLength++; } 
-            } 
+                    { start--; matchLength++; }
+            }
             if (isDxS) {
                 U32 const matchIndex = (U32)((size_t)(start-base) - STORED_OFFSET(offcode));
-                const BYTE* match = (matchIndex < prefixLowestIndex) ? dictBase + matchIndex - dictIndexDelta : base + matchIndex; 
-                const BYTE* const mStart = (matchIndex < prefixLowestIndex) ? dictLowest : prefixLowest; 
-                while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; }  /* catch up */ 
-            } 
+                const BYTE* match = (matchIndex < prefixLowestIndex) ? dictBase + matchIndex - dictIndexDelta : base + matchIndex;
+                const BYTE* const mStart = (matchIndex < prefixLowestIndex) ? dictLowest : prefixLowest;
+                while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; }  /* catch up */
+            }
             offset_2 = offset_1; offset_1 = (U32)STORED_OFFSET(offcode);
         }
         /* store sequence */
@@ -1678,38 +1678,38 @@ _storeSequence:
 
         /* check immediate repcode */
         if (isDxS) {
-            while (ip <= ilimit) { 
-                U32 const current2 = (U32)(ip-base); 
-                U32 const repIndex = current2 - offset_2; 
+            while (ip <= ilimit) {
+                U32 const current2 = (U32)(ip-base);
+                U32 const repIndex = current2 - offset_2;
                 const BYTE* repMatch = repIndex < prefixLowestIndex ?
-                        dictBase - dictIndexDelta + repIndex : 
-                        base + repIndex; 
-                if ( ((U32)((prefixLowestIndex-1) - (U32)repIndex) >= 3 /* intentional overflow */) 
-                   && (MEM_read32(repMatch) == MEM_read32(ip)) ) { 
-                    const BYTE* const repEnd2 = repIndex < prefixLowestIndex ? dictEnd : iend; 
-                    matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd2, prefixLowest) + 4; 
+                        dictBase - dictIndexDelta + repIndex :
+                        base + repIndex;
+                if ( ((U32)((prefixLowestIndex-1) - (U32)repIndex) >= 3 /* intentional overflow */)
+                   && (MEM_read32(repMatch) == MEM_read32(ip)) ) {
+                    const BYTE* const repEnd2 = repIndex < prefixLowestIndex ? dictEnd : iend;
+                    matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd2, prefixLowest) + 4;
                     offcode = offset_2; offset_2 = offset_1; offset_1 = (U32)offcode;   /* swap offset_2 <=> offset_1 */
                     ZSTD_storeSeq(seqStore, 0, anchor, iend, STORE_REPCODE_1, matchLength);
-                    ip += matchLength; 
-                    anchor = ip; 
-                    continue; 
-                } 
-                break; 
-            } 
-        } 
-
-        if (dictMode == ZSTD_noDict) { 
-            while ( ((ip <= ilimit) & (offset_2>0)) 
-                 && (MEM_read32(ip) == MEM_read32(ip - offset_2)) ) { 
-                /* store sequence */ 
-                matchLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4; 
+                    ip += matchLength;
+                    anchor = ip;
+                    continue;
+                }
+                break;
+            }
+        }
+
+        if (dictMode == ZSTD_noDict) {
+            while ( ((ip <= ilimit) & (offset_2>0))
+                 && (MEM_read32(ip) == MEM_read32(ip - offset_2)) ) {
+                /* store sequence */
+                matchLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4;
                 offcode = offset_2; offset_2 = offset_1; offset_1 = (U32)offcode; /* swap repcodes */
                 ZSTD_storeSeq(seqStore, 0, anchor, iend, STORE_REPCODE_1, matchLength);
-                ip += matchLength; 
-                anchor = ip; 
-                continue;   /* faster when present ... (?) */ 
-    }   }   } 
- 
+                ip += matchLength;
+                anchor = ip;
+                continue;   /* faster when present ... (?) */
+    }   }   }
+
     /* Save reps for next block */
     rep[0] = offset_1 ? offset_1 : savedOffset;
     rep[1] = offset_2 ? offset_2 : savedOffset;
@@ -1721,61 +1721,61 @@ _storeSequence:
 
 size_t ZSTD_compressBlock_btlazy2(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize) 
+        void const* src, size_t srcSize)
 {
     return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2, ZSTD_noDict);
 }
 
 size_t ZSTD_compressBlock_lazy2(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize) 
+        void const* src, size_t srcSize)
 {
     return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2, ZSTD_noDict);
 }
 
 size_t ZSTD_compressBlock_lazy(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize) 
+        void const* src, size_t srcSize)
 {
     return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1, ZSTD_noDict);
 }
 
 size_t ZSTD_compressBlock_greedy(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize) 
+        void const* src, size_t srcSize)
 {
     return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0, ZSTD_noDict);
 }
 
-size_t ZSTD_compressBlock_btlazy2_dictMatchState( 
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
-        void const* src, size_t srcSize) 
-{ 
+size_t ZSTD_compressBlock_btlazy2_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
     return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2, ZSTD_dictMatchState);
-} 
+}
 
-size_t ZSTD_compressBlock_lazy2_dictMatchState( 
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
-        void const* src, size_t srcSize) 
-{ 
+size_t ZSTD_compressBlock_lazy2_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
     return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2, ZSTD_dictMatchState);
-} 
- 
-size_t ZSTD_compressBlock_lazy_dictMatchState( 
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
-        void const* src, size_t srcSize) 
-{ 
+}
+
+size_t ZSTD_compressBlock_lazy_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
     return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1, ZSTD_dictMatchState);
-} 
- 
-size_t ZSTD_compressBlock_greedy_dictMatchState( 
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
-        void const* src, size_t srcSize) 
-{ 
+}
+
+size_t ZSTD_compressBlock_greedy_dictMatchState(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+        void const* src, size_t srcSize)
+{
     return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0, ZSTD_dictMatchState);
-} 
- 
- 
+}
+
+
 size_t ZSTD_compressBlock_lazy2_dedicatedDictSearch(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize)
@@ -1924,8 +1924,8 @@ size_t ZSTD_compressBlock_lazy_extDict_generic(
         }   }
 
         /* first search (depth 0) */
-        {   size_t offsetFound = 999999999; 
-            size_t const ml2 = searchMax(ms, ip, iend, &offsetFound); 
+        {   size_t offsetFound = 999999999;
+            size_t const ml2 = searchMax(ms, ip, iend, &offsetFound);
             if (ml2 > matchLength)
                 matchLength = ml2, start = ip, offcode=offsetFound;
         }
@@ -1959,8 +1959,8 @@ size_t ZSTD_compressBlock_lazy_extDict_generic(
             }   }
 
             /* search match, depth 1 */
-            {   size_t offset2=999999999; 
-                size_t const ml2 = searchMax(ms, ip, iend, &offset2); 
+            {   size_t offset2=999999999;
+                size_t const ml2 = searchMax(ms, ip, iend, &offset2);
                 int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offset2)));   /* raw approx */
                 int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offcode)) + 4);
                 if ((ml2 >= 4) && (gain2 > gain1)) {
@@ -1991,8 +1991,8 @@ size_t ZSTD_compressBlock_lazy_extDict_generic(
                 }   }
 
                 /* search match, depth 2 */
-                {   size_t offset2=999999999; 
-                    size_t const ml2 = searchMax(ms, ip, iend, &offset2); 
+                {   size_t offset2=999999999;
+                    size_t const ml2 = searchMax(ms, ip, iend, &offset2);
                     int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offset2)));   /* raw approx */
                     int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offcode)) + 7);
                     if ((ml2 >= 4) && (gain2 > gain1)) {
@@ -2051,14 +2051,14 @@ _storeSequence:
 
 size_t ZSTD_compressBlock_greedy_extDict(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize) 
+        void const* src, size_t srcSize)
 {
     return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0);
 }
 
 size_t ZSTD_compressBlock_lazy_extDict(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize) 
+        void const* src, size_t srcSize)
 
 {
     return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1);
@@ -2066,7 +2066,7 @@ size_t ZSTD_compressBlock_lazy_extDict(
 
 size_t ZSTD_compressBlock_lazy2_extDict(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize) 
+        void const* src, size_t srcSize)
 
 {
     return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2);
@@ -2074,7 +2074,7 @@ size_t ZSTD_compressBlock_lazy2_extDict(
 
 size_t ZSTD_compressBlock_btlazy2_extDict(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize) 
+        void const* src, size_t srcSize)
 
 {
     return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2);