Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 513 insertions, 513 deletions

diff --git a/contrib/libs/zstd/lib/compress/zstd_lazy.c b/contrib/libs/zstd/lib/compress/zstd_lazy.c
index d43ac04f959..2e38dcb46d2 100644
--- a/contrib/libs/zstd/lib/compress/zstd_lazy.c
+++ b/contrib/libs/zstd/lib/compress/zstd_lazy.c
@@ -1,154 +1,154 @@
-/* 
+/*
  * Copyright (c) Yann Collet, Facebook, Inc.
- * All rights reserved. 
- * 
- * This source code is licensed under both the BSD-style license (found in the 
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found 
- * in the COPYING file in the root directory of this source tree). 
- * You may select, at your option, one of the above-listed licenses. 
- */ 
- 
-#include "zstd_compress_internal.h" 
-#include "zstd_lazy.h" 
- 
- 
-/*-************************************* 
-*  Binary Tree search 
-***************************************/ 
- 
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+#include "zstd_compress_internal.h"
+#include "zstd_lazy.h"
+
+
+/*-*************************************
+*  Binary Tree search
+***************************************/
+
 static void
 ZSTD_updateDUBT(ZSTD_matchState_t* ms,
-                const BYTE* ip, const BYTE* iend, 
-                U32 mls) 
-{ 
+                const BYTE* ip, const BYTE* iend,
+                U32 mls)
+{
     const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const hashTable = ms->hashTable; 
-    U32  const hashLog = cParams->hashLog; 
- 
-    U32* const bt = ms->chainTable; 
-    U32  const btLog  = cParams->chainLog - 1; 
-    U32  const btMask = (1 << btLog) - 1; 
- 
-    const BYTE* const base = ms->window.base; 
-    U32 const target = (U32)(ip - base); 
-    U32 idx = ms->nextToUpdate; 
- 
-    if (idx != target) 
-        DEBUGLOG(7, "ZSTD_updateDUBT, from %u to %u (dictLimit:%u)", 
-                    idx, target, ms->window.dictLimit); 
-    assert(ip + 8 <= iend);   /* condition for ZSTD_hashPtr */ 
-    (void)iend; 
- 
-    assert(idx >= ms->window.dictLimit);   /* condition for valid base+idx */ 
-    for ( ; idx < target ; idx++) { 
-        size_t const h  = ZSTD_hashPtr(base + idx, hashLog, mls);   /* assumption : ip + 8 <= iend */ 
-        U32    const matchIndex = hashTable[h]; 
- 
-        U32*   const nextCandidatePtr = bt + 2*(idx&btMask); 
-        U32*   const sortMarkPtr  = nextCandidatePtr + 1; 
- 
-        DEBUGLOG(8, "ZSTD_updateDUBT: insert %u", idx); 
-        hashTable[h] = idx;   /* Update Hash Table */ 
-        *nextCandidatePtr = matchIndex;   /* update BT like a chain */ 
-        *sortMarkPtr = ZSTD_DUBT_UNSORTED_MARK; 
-    } 
-    ms->nextToUpdate = target; 
-} 
- 
- 
-/** ZSTD_insertDUBT1() : 
- *  sort one already inserted but unsorted position 
+    U32* const hashTable = ms->hashTable;
+    U32  const hashLog = cParams->hashLog;
+
+    U32* const bt = ms->chainTable;
+    U32  const btLog  = cParams->chainLog - 1;
+    U32  const btMask = (1 << btLog) - 1;
+
+    const BYTE* const base = ms->window.base;
+    U32 const target = (U32)(ip - base);
+    U32 idx = ms->nextToUpdate;
+
+    if (idx != target)
+        DEBUGLOG(7, "ZSTD_updateDUBT, from %u to %u (dictLimit:%u)",
+                    idx, target, ms->window.dictLimit);
+    assert(ip + 8 <= iend);   /* condition for ZSTD_hashPtr */
+    (void)iend;
+
+    assert(idx >= ms->window.dictLimit);   /* condition for valid base+idx */
+    for ( ; idx < target ; idx++) {
+        size_t const h  = ZSTD_hashPtr(base + idx, hashLog, mls);   /* assumption : ip + 8 <= iend */
+        U32    const matchIndex = hashTable[h];
+
+        U32*   const nextCandidatePtr = bt + 2*(idx&btMask);
+        U32*   const sortMarkPtr  = nextCandidatePtr + 1;
+
+        DEBUGLOG(8, "ZSTD_updateDUBT: insert %u", idx);
+        hashTable[h] = idx;   /* Update Hash Table */
+        *nextCandidatePtr = matchIndex;   /* update BT like a chain */
+        *sortMarkPtr = ZSTD_DUBT_UNSORTED_MARK;
+    }
+    ms->nextToUpdate = target;
+}
+
+
+/** ZSTD_insertDUBT1() :
+ *  sort one already inserted but unsorted position
  *  assumption : curr >= btlow == (curr - btmask)
- *  doesn't fail */ 
+ *  doesn't fail */
 static void
 ZSTD_insertDUBT1(const ZSTD_matchState_t* ms,
                  U32 curr, const BYTE* inputEnd,
                  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;
-    size_t commonLengthSmaller=0, commonLengthLarger=0; 
-    const BYTE* const base = ms->window.base; 
-    const BYTE* const dictBase = ms->window.dictBase; 
-    const U32 dictLimit = ms->window.dictLimit; 
+    size_t commonLengthSmaller=0, commonLengthLarger=0;
+    const BYTE* const base = ms->window.base;
+    const BYTE* const dictBase = ms->window.dictBase;
+    const U32 dictLimit = ms->window.dictLimit;
     const BYTE* const ip = (curr>=dictLimit) ? base + curr : dictBase + curr;
     const BYTE* const iend = (curr>=dictLimit) ? inputEnd : dictBase + dictLimit;
-    const BYTE* const dictEnd = dictBase + dictLimit; 
-    const BYTE* const prefixStart = base + dictLimit; 
-    const BYTE* match; 
+    const BYTE* const dictEnd = dictBase + dictLimit;
+    const BYTE* const prefixStart = base + dictLimit;
+    const BYTE* match;
     U32* smallerPtr = bt + 2*(curr&btMask);
-    U32* largerPtr  = smallerPtr + 1; 
+    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 dummy32;   /* to be nullified at the end */ 
+    U32 dummy32;   /* to be nullified at the end */
     U32 const windowValid = ms->window.lowLimit;
     U32 const maxDistance = 1U << cParams->windowLog;
     U32 const windowLow = (curr - windowValid > maxDistance) ? curr - maxDistance : windowValid;
- 
 
-    DEBUGLOG(8, "ZSTD_insertDUBT1(%u) (dictLimit=%u, lowLimit=%u)", 
+
+    DEBUGLOG(8, "ZSTD_insertDUBT1(%u) (dictLimit=%u, lowLimit=%u)",
                 curr, dictLimit, windowLow);
     assert(curr >= btLow);
-    assert(ip < iend);   /* condition for ZSTD_count */ 
- 
+    assert(ip < iend);   /* condition for ZSTD_count */
+
     for (; nbCompares && (matchIndex > windowLow); --nbCompares) {
-        U32* const nextPtr = bt + 2*(matchIndex & btMask); 
-        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */ 
+        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 */
- 
+
         if ( (dictMode != ZSTD_extDict)
-          || (matchIndex+matchLength >= dictLimit)  /* both in current segment*/ 
+          || (matchIndex+matchLength >= dictLimit)  /* both in current segment*/
           || (curr < dictLimit) /* both in extDict */) {
             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 */ 
+            assert( (matchIndex+matchLength >= dictLimit)   /* might be wrong if extDict is incorrectly set to 0 */
                  || (curr < dictLimit) );
-            match = mBase + matchIndex; 
-            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend); 
-        } else { 
-            match = dictBase + matchIndex; 
-            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart); 
-            if (matchIndex+matchLength >= dictLimit) 
+            match = mBase + matchIndex;
+            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
+        } else {
+            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] */
-        } 
- 
-        DEBUGLOG(8, "ZSTD_insertDUBT1: comparing %u with %u : found %u common bytes ", 
+        }
+
+        DEBUGLOG(8, "ZSTD_insertDUBT1: comparing %u with %u : found %u common bytes ",
                     curr, matchIndex, (U32)matchLength);
- 
-        if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */ 
-            break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */ 
-        } 
- 
-        if (match[matchLength] < ip[matchLength]) {  /* necessarily within buffer */ 
-            /* match is smaller than current */ 
-            *smallerPtr = matchIndex;             /* update smaller idx */ 
-            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */ 
-            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop searching */ 
-            DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is smaller : next => %u", 
-                        matchIndex, btLow, nextPtr[1]); 
-            smallerPtr = nextPtr+1;               /* new "candidate" => larger than match, which was smaller than target */ 
-            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous and closer to current */ 
-        } else { 
-            /* match is larger than current */ 
-            *largerPtr = matchIndex; 
-            commonLengthLarger = matchLength; 
-            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop searching */ 
-            DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is larger => %u", 
-                        matchIndex, btLow, nextPtr[0]); 
-            largerPtr = nextPtr; 
-            matchIndex = nextPtr[0]; 
-    }   } 
- 
-    *smallerPtr = *largerPtr = 0; 
-} 
- 
- 
+
+        if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */
+            break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */
+        }
+
+        if (match[matchLength] < ip[matchLength]) {  /* necessarily within buffer */
+            /* match is smaller than current */
+            *smallerPtr = matchIndex;             /* update smaller idx */
+            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
+            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
+            DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is smaller : next => %u",
+                        matchIndex, btLow, nextPtr[1]);
+            smallerPtr = nextPtr+1;               /* new "candidate" => larger than match, which was smaller than target */
+            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous and closer to current */
+        } else {
+            /* match is larger than current */
+            *largerPtr = matchIndex;
+            commonLengthLarger = matchLength;
+            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop searching */
+            DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is larger => %u",
+                        matchIndex, btLow, nextPtr[0]);
+            largerPtr = nextPtr;
+            matchIndex = nextPtr[0];
+    }   }
+
+    *smallerPtr = *largerPtr = 0;
+}
+
+
 static size_t
 ZSTD_DUBT_findBetterDictMatch (
         const ZSTD_matchState_t* ms,
@@ -158,7 +158,7 @@ ZSTD_DUBT_findBetterDictMatch (
         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;
@@ -235,128 +235,128 @@ ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
                         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); 
-    U32          matchIndex  = hashTable[h]; 
- 
-    const BYTE* const base = ms->window.base; 
+    U32*   const hashTable = ms->hashTable;
+    U32    const hashLog = cParams->hashLog;
+    size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);
+    U32          matchIndex  = hashTable[h];
+
+    const BYTE* const base = ms->window.base;
     U32    const curr = (U32)(ip-base);
     U32    const windowLow = ZSTD_getLowestMatchIndex(ms, curr, cParams->windowLog);
- 
-    U32*   const bt = ms->chainTable; 
-    U32    const btLog  = cParams->chainLog - 1; 
-    U32    const btMask = (1 << btLog) - 1; 
+
+    U32*   const bt = ms->chainTable;
+    U32    const btLog  = cParams->chainLog - 1;
+    U32    const btMask = (1 << btLog) - 1;
     U32    const btLow = (btMask >= curr) ? 0 : curr - btMask;
-    U32    const unsortLimit = MAX(btLow, windowLow); 
- 
-    U32*         nextCandidate = bt + 2*(matchIndex&btMask); 
-    U32*         unsortedMark = bt + 2*(matchIndex&btMask) + 1; 
-    U32          nbCompares = 1U << cParams->searchLog; 
-    U32          nbCandidates = nbCompares; 
-    U32          previousCandidate = 0; 
- 
+    U32    const unsortLimit = MAX(btLow, windowLow);
+
+    U32*         nextCandidate = bt + 2*(matchIndex&btMask);
+    U32*         unsortedMark = bt + 2*(matchIndex&btMask) + 1;
+    U32          nbCompares = 1U << cParams->searchLog;
+    U32          nbCandidates = nbCompares;
+    U32          previousCandidate = 0;
+
     DEBUGLOG(7, "ZSTD_DUBT_findBestMatch (%u) ", curr);
-    assert(ip <= iend-8);   /* required for h calculation */ 
+    assert(ip <= iend-8);   /* required for h calculation */
     assert(dictMode != ZSTD_dedicatedDictSearch);
- 
-    /* reach end of unsorted candidates list */ 
-    while ( (matchIndex > unsortLimit) 
-         && (*unsortedMark == ZSTD_DUBT_UNSORTED_MARK) 
-         && (nbCandidates > 1) ) { 
-        DEBUGLOG(8, "ZSTD_DUBT_findBestMatch: candidate %u is unsorted", 
-                    matchIndex); 
+
+    /* reach end of unsorted candidates list */
+    while ( (matchIndex > unsortLimit)
+         && (*unsortedMark == ZSTD_DUBT_UNSORTED_MARK)
+         && (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 */
-        previousCandidate = matchIndex; 
-        matchIndex = *nextCandidate; 
-        nextCandidate = bt + 2*(matchIndex&btMask); 
-        unsortedMark = bt + 2*(matchIndex&btMask) + 1; 
-        nbCandidates --; 
-    } 
- 
+        previousCandidate = matchIndex;
+        matchIndex = *nextCandidate;
+        nextCandidate = bt + 2*(matchIndex&btMask);
+        unsortedMark = bt + 2*(matchIndex&btMask) + 1;
+        nbCandidates --;
+    }
+
     /* 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); 
+    if ( (matchIndex > unsortLimit)
+      && (*unsortedMark==ZSTD_DUBT_UNSORTED_MARK) ) {
+        DEBUGLOG(7, "ZSTD_DUBT_findBestMatch: nullify last unsorted candidate %u",
+                    matchIndex);
         *nextCandidate = *unsortedMark = 0;
-    } 
- 
-    /* batch sort stacked candidates */ 
-    matchIndex = previousCandidate; 
-    while (matchIndex) {  /* will end on matchIndex == 0 */ 
-        U32* const nextCandidateIdxPtr = bt + 2*(matchIndex&btMask) + 1; 
-        U32 const nextCandidateIdx = *nextCandidateIdxPtr; 
+    }
+
+    /* batch sort stacked candidates */
+    matchIndex = previousCandidate;
+    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);
-        matchIndex = nextCandidateIdx; 
-        nbCandidates++; 
-    } 
- 
-    /* find longest match */ 
+        matchIndex = nextCandidateIdx;
+        nbCandidates++;
+    }
+
+    /* find longest match */
     {   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; 
-        const BYTE* const prefixStart = base + dictLimit; 
+        const BYTE* const dictBase = ms->window.dictBase;
+        const U32 dictLimit = ms->window.dictLimit;
+        const BYTE* const dictEnd = dictBase + dictLimit;
+        const BYTE* const prefixStart = base + dictLimit;
         U32* smallerPtr = bt + 2*(curr&btMask);
         U32* largerPtr  = bt + 2*(curr&btMask) + 1;
         U32 matchEndIdx = curr + 8 + 1;
-        U32 dummy32;   /* to be nullified at the end */ 
-        size_t bestLength = 0; 
- 
-        matchIndex  = hashTable[h]; 
+        U32 dummy32;   /* to be nullified at the end */
+        size_t bestLength = 0;
+
+        matchIndex  = hashTable[h];
         hashTable[h] = curr;   /* Update Hash Table */
- 
+
         for (; nbCompares && (matchIndex > windowLow); --nbCompares) {
-            U32* const nextPtr = bt + 2*(matchIndex & btMask); 
-            size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */ 
-            const BYTE* match; 
- 
+            U32* const nextPtr = bt + 2*(matchIndex & btMask);
+            size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
+            const BYTE* match;
+
             if ((dictMode != ZSTD_extDict) || (matchIndex+matchLength >= dictLimit)) {
-                match = base + matchIndex; 
-                matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend); 
-            } else { 
-                match = dictBase + matchIndex; 
-                matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart); 
-                if (matchIndex+matchLength >= dictLimit) 
-                    match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */ 
-            } 
- 
-            if (matchLength > bestLength) { 
-                if (matchLength > matchEndIdx - matchIndex) 
-                    matchEndIdx = matchIndex + (U32)matchLength; 
+                match = base + matchIndex;
+                matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
+            } else {
+                match = dictBase + matchIndex;
+                matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
+                if (matchIndex+matchLength >= dictLimit)
+                    match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
+            }
+
+            if (matchLength > bestLength) {
+                if (matchLength > matchEndIdx - matchIndex)
+                    matchEndIdx = matchIndex + (U32)matchLength;
                 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 (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. */
                     }
-                    break;   /* drop, to guarantee consistency (miss a little bit of compression) */ 
-                } 
-            } 
- 
-            if (match[matchLength] < ip[matchLength]) { 
-                /* match is smaller than current */ 
-                *smallerPtr = matchIndex;             /* update smaller idx */ 
-                commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */ 
-                if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */ 
-                smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */ 
-                matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */ 
-            } else { 
-                /* match is larger than current */ 
-                *largerPtr = matchIndex; 
-                commonLengthLarger = matchLength; 
-                if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */ 
-                largerPtr = nextPtr; 
-                matchIndex = nextPtr[0]; 
-        }   } 
- 
-        *smallerPtr = *largerPtr = 0; 
- 
+                    break;   /* drop, to guarantee consistency (miss a little bit of compression) */
+                }
+            }
+
+            if (match[matchLength] < ip[matchLength]) {
+                /* match is smaller than current */
+                *smallerPtr = matchIndex;             /* update smaller idx */
+                commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
+                if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
+                smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
+                matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
+            } else {
+                /* match is larger than current */
+                *largerPtr = matchIndex;
+                commonLengthLarger = matchLength;
+                if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
+                largerPtr = nextPtr;
+                matchIndex = nextPtr[0];
+        }   }
+
+        *smallerPtr = *largerPtr = 0;
+
         assert(nbCompares <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */
         if (dictMode == ZSTD_dictMatchState && nbCompares) {
             bestLength = ZSTD_DUBT_findBetterDictMatch(
@@ -366,35 +366,35 @@ ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
         }
 
         assert(matchEndIdx > curr+8); /* ensure nextToUpdate is increased */
-        ms->nextToUpdate = matchEndIdx - 8;   /* skip repetitive patterns */ 
-        if (bestLength >= MINMATCH) { 
+        ms->nextToUpdate = matchEndIdx - 8;   /* skip repetitive patterns */
+        if (bestLength >= MINMATCH) {
             U32 const mIndex = curr - (U32)STORED_OFFSET(*offsetPtr); (void)mIndex;
-            DEBUGLOG(8, "ZSTD_DUBT_findBestMatch(%u) : found match of length %u and offsetCode %u (pos %u)", 
+            DEBUGLOG(8, "ZSTD_DUBT_findBestMatch(%u) : found match of length %u and offsetCode %u (pos %u)",
                         curr, (U32)bestLength, (U32)*offsetPtr, mIndex);
-        } 
-        return bestLength; 
-    } 
-} 
- 
- 
-/** ZSTD_BtFindBestMatch() : Tree updater, providing best match */ 
+        }
+        return bestLength;
+    }
+}
+
+
+/** 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)
-{ 
-    DEBUGLOG(7, "ZSTD_BtFindBestMatch"); 
-    if (ip < ms->window.base + ms->nextToUpdate) return 0;   /* skipped area */ 
+{
+    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);
-} 
- 
+}
+
 /***********************************
 * Dedicated dict search
-***********************************/ 
- 
+***********************************/
+
 void ZSTD_dedicatedDictSearch_lazy_loadDictionary(ZSTD_matchState_t* ms, const BYTE* const ip)
 {
     const BYTE* const base = ms->window.base;
@@ -408,7 +408,7 @@ void ZSTD_dedicatedDictSearch_lazy_loadDictionary(ZSTD_matchState_t* ms, const B
     U32 const cacheSize = bucketSize - 1;
     U32 const chainAttempts = (1 << ms->cParams.searchLog) - cacheSize;
     U32 const chainLimit = chainAttempts > 255 ? 255 : chainAttempts;
- 
+
     /* We know the hashtable is oversized by a factor of `bucketSize`.
      * We are going to temporarily pretend `bucketSize == 1`, keeping only a
      * single entry. We will use the rest of the space to construct a temporary
@@ -643,23 +643,23 @@ U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip) {
     return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, ms->cParams.minMatch);
 }
 
-/* inlining is important to hardwire a hot branch (template emulation) */ 
-FORCE_INLINE_TEMPLATE 
+/* inlining is important to hardwire a hot branch (template emulation) */
+FORCE_INLINE_TEMPLATE
 size_t ZSTD_HcFindBestMatch(
                         ZSTD_matchState_t* ms,
-                        const BYTE* const ip, const BYTE* const iLimit, 
-                        size_t* offsetPtr, 
+                        const BYTE* const ip, const BYTE* const iLimit,
+                        size_t* offsetPtr,
                         const U32 mls, const ZSTD_dictMode_e dictMode)
-{ 
+{
     const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const chainTable = ms->chainTable; 
-    const U32 chainSize = (1 << cParams->chainLog); 
-    const U32 chainMask = chainSize-1; 
-    const BYTE* const base = ms->window.base; 
-    const BYTE* const dictBase = ms->window.dictBase; 
-    const U32 dictLimit = ms->window.dictLimit; 
-    const BYTE* const prefixStart = base + dictLimit; 
-    const BYTE* const dictEnd = dictBase + dictLimit; 
+    U32* const chainTable = ms->chainTable;
+    const U32 chainSize = (1 << cParams->chainLog);
+    const U32 chainMask = chainSize-1;
+    const BYTE* const base = ms->window.base;
+    const BYTE* const dictBase = ms->window.dictBase;
+    const U32 dictLimit = ms->window.dictLimit;
+    const BYTE* const prefixStart = base + dictLimit;
+    const BYTE* const dictEnd = dictBase + dictLimit;
     const U32 curr = (U32)(ip-base);
     const U32 maxDistance = 1U << cParams->windowLog;
     const U32 lowestValid = ms->window.lowLimit;
@@ -667,9 +667,9 @@ size_t ZSTD_HcFindBestMatch(
     const U32 isDictionary = (ms->loadedDictEnd != 0);
     const U32 lowLimit = isDictionary ? lowestValid : withinMaxDistance;
     const U32 minChain = curr > chainSize ? curr - chainSize : 0;
-    U32 nbAttempts = 1U << cParams->searchLog; 
-    size_t ml=4-1; 
- 
+    U32 nbAttempts = 1U << cParams->searchLog;
+    size_t ml=4-1;
+
     const ZSTD_matchState_t* const dms = ms->dictMatchState;
     const U32 ddsHashLog = dictMode == ZSTD_dedicatedDictSearch
                          ? dms->cParams.hashLog - ZSTD_LAZY_DDSS_BUCKET_LOG : 0;
@@ -683,34 +683,34 @@ size_t ZSTD_HcFindBestMatch(
         PREFETCH_L1(entry);
     }
 
-    /* HC4 match finder */ 
+    /* HC4 match finder */
     matchIndex = ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, mls);
- 
+
     for ( ; (matchIndex>=lowLimit) & (nbAttempts>0) ; nbAttempts--) {
-        size_t currentMl=0; 
+        size_t currentMl=0;
         if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {
-            const BYTE* const match = base + matchIndex; 
+            const BYTE* const match = base + matchIndex;
             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 { 
-            const BYTE* const match = dictBase + matchIndex; 
-            assert(match+4 <= dictEnd); 
-            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */ 
-                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4; 
-        } 
- 
-        /* save best solution */ 
-        if (currentMl > ml) { 
-            ml = currentMl; 
+            if (match[ml] == ip[ml])   /* potentially better */
+                currentMl = ZSTD_count(ip, match, iLimit);
+        } else {
+            const BYTE* const match = dictBase + matchIndex;
+            assert(match+4 <= dictEnd);
+            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */
+                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4;
+        }
+
+        /* save best solution */
+        if (currentMl > ml) {
+            ml = currentMl;
             *offsetPtr = STORE_OFFSET(curr - matchIndex);
-            if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */ 
-        } 
- 
-        if (matchIndex <= minChain) break; 
-        matchIndex = NEXT_IN_CHAIN(matchIndex, chainMask); 
-    } 
- 
+            if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */
+        }
+
+        if (matchIndex <= minChain) break;
+        matchIndex = NEXT_IN_CHAIN(matchIndex, chainMask);
+    }
+
     assert(nbAttempts <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */
     if (dictMode == ZSTD_dedicatedDictSearch) {
         ml = ZSTD_dedicatedDictSearch_lazy_search(offsetPtr, ml, nbAttempts, dms,
@@ -749,9 +749,9 @@ size_t ZSTD_HcFindBestMatch(
         }
     }
 
-    return ml; 
-} 
- 
+    return ml;
+}
+
 /* *********************************
 * (SIMD) Row-based matchfinder
 ***********************************/
@@ -760,7 +760,7 @@ size_t ZSTD_HcFindBestMatch(
 #define ZSTD_ROW_HASH_TAG_BITS 8        /* nb bits to use for the tag */
 #define ZSTD_ROW_HASH_TAG_MASK ((1u << ZSTD_ROW_HASH_TAG_BITS) - 1)
 #define ZSTD_ROW_HASH_MAX_ENTRIES 64    /* absolute maximum number of entries per row, for all configurations */
- 
+
 #define ZSTD_ROW_HASH_CACHE_MASK (ZSTD_ROW_HASH_CACHE_SIZE - 1)
 
 typedef U64 ZSTD_VecMask;   /* Clarifies when we are interacting with a U64 representing a mask of matches */
@@ -1437,9 +1437,9 @@ ZSTD_FOR_EACH_DICT_MODE(ZSTD_FOR_EACH_MLS, GEN_ZSTD_HC_VTABLE)
         X(dedicatedDictSearch)   \
     }
 
-/* ******************************* 
-*  Common parser - lazy strategy 
-*********************************/ 
+/* *******************************
+*  Common parser - lazy strategy
+*********************************/
 typedef enum { search_hashChain=0, search_binaryTree=1, search_rowHash=2 } searchMethod_e;
 
 /**
@@ -1474,24 +1474,24 @@ ZSTD_selectLazyVTable(ZSTD_matchState_t const* ms, searchMethod_e searchMethod,
 
 FORCE_INLINE_TEMPLATE size_t
 ZSTD_compressBlock_lazy_generic(
-                        ZSTD_matchState_t* ms, seqStore_t* seqStore, 
-                        U32 rep[ZSTD_REP_NUM], 
-                        const void* src, size_t srcSize, 
+                        ZSTD_matchState_t* ms, seqStore_t* seqStore,
+                        U32 rep[ZSTD_REP_NUM],
+                        const void* src, size_t srcSize,
                         const searchMethod_e searchMethod, const U32 depth,
                         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 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;
- 
+
     searchMax_f const searchMax = ZSTD_selectLazyVTable(ms, searchMethod, dictMode)->searchMax;
-    U32 offset_1 = rep[0], offset_2 = rep[1], savedOffset=0; 
- 
+    U32 offset_1 = rep[0], offset_2 = rep[1], savedOffset=0;
+
     const int isDMS = dictMode == ZSTD_dictMatchState;
     const int isDDS = dictMode == ZSTD_dedicatedDictSearch;
     const int isDxS = isDMS || isDDS;
@@ -1513,16 +1513,16 @@ ZSTD_compressBlock_lazy_generic(
         U32 const curr = (U32)(ip - base);
         U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, curr, ms->cParams.windowLog);
         U32 const maxRep = curr - windowLow;
-        if (offset_2 > maxRep) savedOffset = offset_2, offset_2 = 0; 
-        if (offset_1 > maxRep) savedOffset = offset_1, offset_1 = 0; 
-    } 
+        if (offset_2 > maxRep) savedOffset = offset_2, offset_2 = 0;
+        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);
     }
- 
+
     if (searchMethod == search_rowHash) {
         const U32 rowLog = MAX(4, MIN(6, ms->cParams.searchLog));
         ZSTD_row_fillHashCache(ms, base, rowLog,
@@ -1530,20 +1530,20 @@ ZSTD_compressBlock_lazy_generic(
                             ms->nextToUpdate, ilimit);
     }
 
-    /* Match Loop */ 
+    /* Match Loop */
 #if defined(__GNUC__) && defined(__x86_64__)
     /* I've measured random a 5% speed loss on levels 5 & 6 (greedy) when the
      * code alignment is perturbed. To fix the instability align the loop on 32-bytes.
      */
     __asm__(".p2align 5");
 #endif
-    while (ip < ilimit) { 
-        size_t matchLength=0; 
+    while (ip < ilimit) {
+        size_t matchLength=0;
         size_t offcode=STORE_REPCODE_1;
-        const BYTE* start=ip+1; 
+        const BYTE* start=ip+1;
         DEBUGLOG(7, "search baseline (depth 0)");
- 
-        /* check repCode */ 
+
+        /* check repCode */
         if (isDxS) {
             const U32 repIndex = (U32)(ip - base) + 1 - offset_1;
             const BYTE* repMatch = ((dictMode == ZSTD_dictMatchState || dictMode == ZSTD_dedicatedDictSearch)
@@ -1559,35 +1559,35 @@ ZSTD_compressBlock_lazy_generic(
         }
         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) */ 
+            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);
-            if (ml2 > matchLength) 
+            if (ml2 > matchLength)
                 matchLength = ml2, start = ip, offcode=offsetFound;
-        } 
- 
-        if (matchLength < 4) { 
-            ip += ((ip-anchor) >> kSearchStrength) + 1;   /* jump faster over incompressible sections */ 
-            continue; 
-        } 
- 
-        /* let's try to find a better solution */ 
-        if (depth>=1) 
-        while (ip<ilimit) { 
+        }
+
+        if (matchLength < 4) {
+            ip += ((ip-anchor) >> kSearchStrength) + 1;   /* jump faster over incompressible sections */
+            continue;
+        }
+
+        /* let's try to find a better solution */
+        if (depth>=1)
+        while (ip<ilimit) {
             DEBUGLOG(7, "search depth 1");
-            ip ++; 
+            ip ++;
             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); 
+                size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 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;
-            } 
+            }
             if (isDxS) {
                 const U32 repIndex = (U32)(ip - base) - offset_1;
                 const BYTE* repMatch = repIndex < prefixLowestIndex ?
@@ -1607,15 +1607,15 @@ ZSTD_compressBlock_lazy_generic(
                 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)) { 
+                if ((ml2 >= 4) && (gain2 > gain1)) {
                     matchLength = ml2, offcode = offset2, start = ip;
-                    continue;   /* search a better one */ 
-            }   } 
- 
-            /* let's find an even better one */ 
-            if ((depth==2) && (ip<ilimit)) { 
+                    continue;   /* search a better one */
+            }   }
+
+            /* let's find an even better one */
+            if ((depth==2) && (ip<ilimit)) {
                 DEBUGLOG(7, "search depth 2");
-                ip ++; 
+                ip ++;
                 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;
@@ -1623,7 +1623,7 @@ ZSTD_compressBlock_lazy_generic(
                     int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offcode)) + 1);
                     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 ?
@@ -1643,18 +1643,18 @@ ZSTD_compressBlock_lazy_generic(
                     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)) { 
+                    if ((ml2 >= 4) && (gain2 > gain1)) {
                         matchLength = ml2, offcode = offset2, start = ip;
-                        continue; 
-            }   }   } 
-            break;  /* nothing found : store previous solution */ 
-        } 
- 
-        /* NOTE: 
+                        continue;
+            }   }   }
+            break;  /* nothing found : store previous solution */
+        }
+
+        /* NOTE:
          * Pay attention that `start[-value]` can lead to strange undefined behavior
          * notably if `value` is unsigned, resulting in a large positive `-value`.
-         */ 
-        /* catch up */ 
+         */
+        /* catch up */
         if (STORED_IS_OFFSET(offcode)) {
             if (dictMode == ZSTD_noDict) {
                 while ( ((start > anchor) & (start - STORED_OFFSET(offcode) > prefixLowest))
@@ -1668,15 +1668,15 @@ ZSTD_compressBlock_lazy_generic(
                 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 */ 
-_storeSequence: 
+        }
+        /* store sequence */
+_storeSequence:
         {   size_t const litLength = (size_t)(start - anchor);
             ZSTD_storeSeq(seqStore, litLength, anchor, iend, (U32)offcode, matchLength);
-            anchor = ip = start + matchLength; 
-        } 
- 
-        /* check immediate repcode */ 
+            anchor = ip = start + matchLength;
+        }
+
+        /* check immediate repcode */
         if (isDxS) {
             while (ip <= ilimit) {
                 U32 const current2 = (U32)(ip-base);
@@ -1697,7 +1697,7 @@ _storeSequence:
                 break;
             }
         }
- 
+
         if (dictMode == ZSTD_noDict) {
             while ( ((ip <= ilimit) & (offset_2>0))
                  && (MEM_read32(ip) == MEM_read32(ip - offset_2)) ) {
@@ -1710,50 +1710,50 @@ _storeSequence:
                 continue;   /* faster when present ... (?) */
     }   }   }
 
-    /* Save reps for next block */ 
-    rep[0] = offset_1 ? offset_1 : savedOffset; 
-    rep[1] = offset_2 ? offset_2 : savedOffset; 
- 
-    /* Return the last literals size */ 
+    /* Save reps for next block */
+    rep[0] = offset_1 ? offset_1 : savedOffset;
+    rep[1] = offset_2 ? offset_2 : savedOffset;
+
+    /* Return the last literals size */
     return (size_t)(iend - anchor);
-} 
- 
- 
-size_t ZSTD_compressBlock_btlazy2( 
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+}
+
+
+size_t ZSTD_compressBlock_btlazy2(
+        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_noDict);
-} 
- 
-size_t ZSTD_compressBlock_lazy2( 
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+}
+
+size_t ZSTD_compressBlock_lazy2(
+        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_noDict);
-} 
- 
-size_t ZSTD_compressBlock_lazy( 
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+}
+
+size_t ZSTD_compressBlock_lazy(
+        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_noDict);
-} 
- 
-size_t ZSTD_compressBlock_greedy( 
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+}
+
+size_t ZSTD_compressBlock_greedy(
+        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_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)
 {
     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)
@@ -1862,223 +1862,223 @@ size_t ZSTD_compressBlock_greedy_dedicatedDictSearch_row(
     return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 0, ZSTD_dedicatedDictSearch);
 }
 
-FORCE_INLINE_TEMPLATE 
-size_t ZSTD_compressBlock_lazy_extDict_generic( 
-                        ZSTD_matchState_t* ms, seqStore_t* seqStore, 
-                        U32 rep[ZSTD_REP_NUM], 
-                        const void* src, size_t srcSize, 
+FORCE_INLINE_TEMPLATE
+size_t ZSTD_compressBlock_lazy_extDict_generic(
+                        ZSTD_matchState_t* ms, seqStore_t* seqStore,
+                        U32 rep[ZSTD_REP_NUM],
+                        const void* src, size_t srcSize,
                         const searchMethod_e searchMethod, const U32 depth)
-{ 
-    const BYTE* const istart = (const BYTE*)src; 
-    const BYTE* ip = istart; 
-    const BYTE* anchor = istart; 
-    const BYTE* const iend = istart + srcSize; 
+{
+    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 dictLimit = ms->window.dictLimit; 
-    const BYTE* const prefixStart = base + dictLimit; 
-    const BYTE* const dictBase = ms->window.dictBase; 
-    const BYTE* const dictEnd  = dictBase + dictLimit; 
+    const BYTE* const base = ms->window.base;
+    const U32 dictLimit = ms->window.dictLimit;
+    const BYTE* const prefixStart = base + dictLimit;
+    const BYTE* const dictBase = ms->window.dictBase;
+    const BYTE* const dictEnd  = dictBase + dictLimit;
     const BYTE* const dictStart  = dictBase + ms->window.lowLimit;
     const U32 windowLog = ms->cParams.windowLog;
     const U32 rowLog = ms->cParams.searchLog < 5 ? 4 : 5;
- 
+
     searchMax_f const searchMax = ZSTD_selectLazyVTable(ms, searchMethod, ZSTD_extDict)->searchMax;
-    U32 offset_1 = rep[0], offset_2 = rep[1]; 
- 
+    U32 offset_1 = rep[0], offset_2 = rep[1];
+
     DEBUGLOG(5, "ZSTD_compressBlock_lazy_extDict_generic (searchFunc=%u)", (U32)searchMethod);
 
-    /* init */ 
-    ip += (ip == prefixStart); 
+    /* init */
+    ip += (ip == prefixStart);
     if (searchMethod == search_rowHash) {
         ZSTD_row_fillHashCache(ms, base, rowLog,
                                MIN(ms->cParams.minMatch, 6 /* mls caps out at 6 */),
                                ms->nextToUpdate, ilimit);
     }
- 
-    /* Match Loop */ 
+
+    /* Match Loop */
 #if defined(__GNUC__) && defined(__x86_64__)
     /* I've measured random a 5% speed loss on levels 5 & 6 (greedy) when the
      * code alignment is perturbed. To fix the instability align the loop on 32-bytes.
      */
     __asm__(".p2align 5");
 #endif
-    while (ip < ilimit) { 
-        size_t matchLength=0; 
+    while (ip < ilimit) {
+        size_t matchLength=0;
         size_t offcode=STORE_REPCODE_1;
-        const BYTE* start=ip+1; 
+        const BYTE* start=ip+1;
         U32 curr = (U32)(ip-base);
- 
-        /* check repCode */ 
+
+        /* check repCode */
         {   const U32 windowLow = ZSTD_getLowestMatchIndex(ms, curr+1, windowLog);
             const U32 repIndex = (U32)(curr+1 - offset_1);
-            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; 
-            const BYTE* const repMatch = repBase + repIndex; 
+            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
+            const BYTE* const repMatch = repBase + repIndex;
             if ( ((U32)((dictLimit-1) - repIndex) >= 3) /* intentional overflow */
                & (offset_1 <= curr+1 - windowLow) ) /* note: we are searching at curr+1 */
-            if (MEM_read32(ip+1) == MEM_read32(repMatch)) { 
-                /* repcode detected we should take it */ 
-                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; 
-                matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repEnd, prefixStart) + 4; 
-                if (depth==0) goto _storeSequence; 
-        }   } 
- 
-        /* first search (depth 0) */ 
+            if (MEM_read32(ip+1) == MEM_read32(repMatch)) {
+                /* repcode detected we should take it */
+                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
+                matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repEnd, prefixStart) + 4;
+                if (depth==0) goto _storeSequence;
+        }   }
+
+        /* first search (depth 0) */
         {   size_t offsetFound = 999999999;
             size_t const ml2 = searchMax(ms, ip, iend, &offsetFound);
-            if (ml2 > matchLength) 
+            if (ml2 > matchLength)
                 matchLength = ml2, start = ip, offcode=offsetFound;
-        } 
- 
+        }
+
         if (matchLength < 4) {
-            ip += ((ip-anchor) >> kSearchStrength) + 1;   /* jump faster over incompressible sections */ 
-            continue; 
-        } 
- 
-        /* let's try to find a better solution */ 
-        if (depth>=1) 
-        while (ip<ilimit) { 
-            ip ++; 
+            ip += ((ip-anchor) >> kSearchStrength) + 1;   /* jump faster over incompressible sections */
+            continue;
+        }
+
+        /* let's try to find a better solution */
+        if (depth>=1)
+        while (ip<ilimit) {
+            ip ++;
             curr++;
-            /* check repCode */ 
+            /* check repCode */
             if (offcode) {
                 const U32 windowLow = ZSTD_getLowestMatchIndex(ms, curr, windowLog);
                 const U32 repIndex = (U32)(curr - offset_1);
-                const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; 
-                const BYTE* const repMatch = repBase + repIndex; 
+                const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
+                const BYTE* const repMatch = repBase + repIndex;
                 if ( ((U32)((dictLimit-1) - repIndex) >= 3) /* intentional overflow : do not test positions overlapping 2 memory segments  */
                    & (offset_1 <= curr - windowLow) ) /* equivalent to `curr > repIndex >= windowLow` */
-                if (MEM_read32(ip) == MEM_read32(repMatch)) { 
-                    /* repcode detected */ 
-                    const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; 
-                    size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4; 
-                    int const gain2 = (int)(repLength * 3); 
+                if (MEM_read32(ip) == MEM_read32(repMatch)) {
+                    /* repcode detected */
+                    const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
+                    size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;
+                    int const gain2 = (int)(repLength * 3);
                     int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offcode)) + 1);
-                    if ((repLength >= 4) && (gain2 > gain1)) 
+                    if ((repLength >= 4) && (gain2 > gain1))
                         matchLength = repLength, offcode = STORE_REPCODE_1, start = ip;
-            }   } 
- 
-            /* search match, depth 1 */ 
+            }   }
+
+            /* search match, depth 1 */
             {   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)) { 
+                if ((ml2 >= 4) && (gain2 > gain1)) {
                     matchLength = ml2, offcode = offset2, start = ip;
-                    continue;   /* search a better one */ 
-            }   } 
- 
-            /* let's find an even better one */ 
-            if ((depth==2) && (ip<ilimit)) { 
-                ip ++; 
+                    continue;   /* search a better one */
+            }   }
+
+            /* let's find an even better one */
+            if ((depth==2) && (ip<ilimit)) {
+                ip ++;
                 curr++;
-                /* check repCode */ 
+                /* check repCode */
                 if (offcode) {
                     const U32 windowLow = ZSTD_getLowestMatchIndex(ms, curr, windowLog);
                     const U32 repIndex = (U32)(curr - offset_1);
-                    const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; 
-                    const BYTE* const repMatch = repBase + repIndex; 
+                    const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
+                    const BYTE* const repMatch = repBase + repIndex;
                     if ( ((U32)((dictLimit-1) - repIndex) >= 3) /* intentional overflow : do not test positions overlapping 2 memory segments  */
                        & (offset_1 <= curr - windowLow) ) /* equivalent to `curr > repIndex >= windowLow` */
-                    if (MEM_read32(ip) == MEM_read32(repMatch)) { 
-                        /* repcode detected */ 
-                        const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; 
-                        size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4; 
-                        int const gain2 = (int)(repLength * 4); 
+                    if (MEM_read32(ip) == MEM_read32(repMatch)) {
+                        /* repcode detected */
+                        const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
+                        size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;
+                        int const gain2 = (int)(repLength * 4);
                         int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)STORED_TO_OFFBASE(offcode)) + 1);
-                        if ((repLength >= 4) && (gain2 > gain1)) 
+                        if ((repLength >= 4) && (gain2 > gain1))
                             matchLength = repLength, offcode = STORE_REPCODE_1, start = ip;
-                }   } 
- 
-                /* search match, depth 2 */ 
+                }   }
+
+                /* search match, depth 2 */
                 {   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)) { 
+                    if ((ml2 >= 4) && (gain2 > gain1)) {
                         matchLength = ml2, offcode = offset2, start = ip;
-                        continue; 
-            }   }   } 
-            break;  /* nothing found : store previous solution */ 
-        } 
- 
-        /* catch up */ 
+                        continue;
+            }   }   }
+            break;  /* nothing found : store previous solution */
+        }
+
+        /* catch up */
         if (STORED_IS_OFFSET(offcode)) {
             U32 const matchIndex = (U32)((size_t)(start-base) - STORED_OFFSET(offcode));
-            const BYTE* match = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex; 
-            const BYTE* const mStart = (matchIndex < dictLimit) ? dictStart : prefixStart; 
-            while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; }  /* catch up */ 
+            const BYTE* match = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;
+            const BYTE* const mStart = (matchIndex < dictLimit) ? dictStart : prefixStart;
+            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 */ 
-_storeSequence: 
+        }
+
+        /* store sequence */
+_storeSequence:
         {   size_t const litLength = (size_t)(start - anchor);
             ZSTD_storeSeq(seqStore, litLength, anchor, iend, (U32)offcode, matchLength);
-            anchor = ip = start + matchLength; 
-        } 
- 
-        /* check immediate repcode */ 
-        while (ip <= ilimit) { 
+            anchor = ip = start + matchLength;
+        }
+
+        /* check immediate repcode */
+        while (ip <= ilimit) {
             const U32 repCurrent = (U32)(ip-base);
             const U32 windowLow = ZSTD_getLowestMatchIndex(ms, repCurrent, windowLog);
             const U32 repIndex = repCurrent - offset_2;
-            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; 
-            const BYTE* const repMatch = repBase + repIndex; 
+            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
+            const BYTE* const repMatch = repBase + repIndex;
             if ( ((U32)((dictLimit-1) - repIndex) >= 3) /* intentional overflow : do not test positions overlapping 2 memory segments  */
                & (offset_2 <= repCurrent - windowLow) ) /* equivalent to `curr > repIndex >= windowLow` */
-            if (MEM_read32(ip) == MEM_read32(repMatch)) { 
-                /* repcode detected we should take it */ 
-                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; 
-                matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4; 
+            if (MEM_read32(ip) == MEM_read32(repMatch)) {
+                /* repcode detected we should take it */
+                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
+                matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;
                 offcode = offset_2; offset_2 = offset_1; offset_1 = (U32)offcode;   /* swap offset history */
                 ZSTD_storeSeq(seqStore, 0, anchor, iend, STORE_REPCODE_1, matchLength);
-                ip += matchLength; 
-                anchor = ip; 
-                continue;   /* faster when present ... (?) */ 
-            } 
-            break; 
-    }   } 
- 
-    /* Save reps for next block */ 
-    rep[0] = offset_1; 
-    rep[1] = offset_2; 
- 
-    /* Return the last literals size */ 
+                ip += matchLength;
+                anchor = ip;
+                continue;   /* faster when present ... (?) */
+            }
+            break;
+    }   }
+
+    /* Save reps for next block */
+    rep[0] = offset_1;
+    rep[1] = offset_2;
+
+    /* Return the last literals size */
     return (size_t)(iend - anchor);
-} 
- 
- 
-size_t ZSTD_compressBlock_greedy_extDict( 
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+}
+
+
+size_t ZSTD_compressBlock_greedy_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         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], 
+}
+
+size_t ZSTD_compressBlock_lazy_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize)
- 
-{ 
+
+{
     return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1);
-} 
- 
-size_t ZSTD_compressBlock_lazy2_extDict( 
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+}
+
+size_t ZSTD_compressBlock_lazy2_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize)
- 
-{ 
+
+{
     return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2);
-} 
- 
-size_t ZSTD_compressBlock_btlazy2_extDict( 
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+}
+
+size_t ZSTD_compressBlock_btlazy2_extDict(
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize)
- 
-{ 
+
+{
     return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2);
-} 
+}
 
 size_t ZSTD_compressBlock_greedy_extDict_row(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],