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

1 files changed, 160 insertions, 160 deletions

diff --git a/contrib/libs/zstd/lib/compress/zstd_fast.c b/contrib/libs/zstd/lib/compress/zstd_fast.c
index 802fc315798..702fc6e91fa 100644
--- a/contrib/libs/zstd/lib/compress/zstd_fast.c
+++ b/contrib/libs/zstd/lib/compress/zstd_fast.c
@@ -16,10 +16,10 @@ void ZSTD_fillHashTable(ZSTD_matchState_t* ms,
                         const void* const end,
                         ZSTD_dictTableLoadMethod_e dtlm)
 {
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    const ZSTD_compressionParameters* const cParams = &ms->cParams; 
     U32* const hashTable = ms->hashTable;
     U32  const hBits = cParams->hashLog;
-    U32  const mls = cParams->minMatch;
+    U32  const mls = cParams->minMatch; 
     const BYTE* const base = ms->window.base;
     const BYTE* ip = base + ms->nextToUpdate;
     const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;
@@ -28,18 +28,18 @@ void ZSTD_fillHashTable(ZSTD_matchState_t* ms,
     /* Always insert every fastHashFillStep position into the hash table.
      * Insert the other positions if their hash entry is empty.
      */
-    for ( ; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) {
+    for ( ; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) { 
         U32 const curr = (U32)(ip - base);
-        size_t const hash0 = ZSTD_hashPtr(ip, hBits, mls);
+        size_t const hash0 = ZSTD_hashPtr(ip, hBits, mls); 
         hashTable[hash0] = curr;
-        if (dtlm == ZSTD_dtlm_fast) continue;
-        /* Only load extra positions for ZSTD_dtlm_full */
-        {   U32 p;
-            for (p = 1; p < fastHashFillStep; ++p) {
-                size_t const hash = ZSTD_hashPtr(ip + p, hBits, mls);
-                if (hashTable[hash] == 0) {  /* not yet filled */
+        if (dtlm == ZSTD_dtlm_fast) continue; 
+        /* Only load extra positions for ZSTD_dtlm_full */ 
+        {   U32 p; 
+            for (p = 1; p < fastHashFillStep; ++p) { 
+                size_t const hash = ZSTD_hashPtr(ip + p, hBits, mls); 
+                if (hashTable[hash] == 0) {  /* not yet filled */ 
                     hashTable[hash] = curr + p;
-    }   }   }   }
+    }   }   }   } 
 }
 
 
@@ -95,16 +95,16 @@ ZSTD_compressBlock_fast_noDict_generic(
         void const* src, size_t srcSize,
         U32 const mls, U32 const hasStep)
 {
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    const ZSTD_compressionParameters* const cParams = &ms->cParams; 
     U32* const hashTable = ms->hashTable;
-    U32 const hlog = cParams->hashLog;
-    /* support stepSize of 0 */
+    U32 const hlog = cParams->hashLog; 
+    /* support stepSize of 0 */ 
     size_t const stepSize = hasStep ? (cParams->targetLength + !(cParams->targetLength) + 1) : 2;
     const BYTE* const base = ms->window.base;
     const BYTE* const istart = (const BYTE*)src;
     const U32   endIndex = (U32)((size_t)(istart - base) + srcSize);
     const U32   prefixStartIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog);
-    const BYTE* const prefixStart = base + prefixStartIndex;
+    const BYTE* const prefixStart = base + prefixStartIndex; 
     const BYTE* const iend = istart + srcSize;
     const BYTE* const ilimit = iend - HASH_READ_SIZE;
 
@@ -137,7 +137,7 @@ ZSTD_compressBlock_fast_noDict_generic(
     const size_t kStepIncr = (1 << (kSearchStrength - 1));
 
     DEBUGLOG(5, "ZSTD_compressBlock_fast_generic");
-    ip0 += (ip0 == prefixStart);
+    ip0 += (ip0 == prefixStart); 
     {   U32 const curr = (U32)(ip0 - base);
         U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, curr, cParams->windowLog);
         U32 const maxRep = curr - windowLow;
@@ -155,11 +155,11 @@ _start: /* Requires: ip0 */
     ip1 = ip0 + 1;
     ip2 = ip0 + step;
     ip3 = ip2 + 1;
-
+ 
     if (ip3 >= ilimit) {
         goto _cleanup;
     }
-
+ 
     hash0 = ZSTD_hashPtr(ip0, hlog, mls);
     hash1 = ZSTD_hashPtr(ip1, hlog, mls);
 
@@ -182,8 +182,8 @@ _start: /* Requires: ip0 */
             match0 -= mLength;
             offcode = STORE_REPCODE_1;
             mLength += 4;
-            goto _match;
-        }
+            goto _match; 
+        } 
 
         /* load match for ip[0] */
         if (idx >= prefixStartIndex) {
@@ -195,8 +195,8 @@ _start: /* Requires: ip0 */
         /* check match at ip[0] */
         if (MEM_read32(ip0) == mval) {
             /* found a match! */
-            goto _offset;
-        }
+            goto _offset; 
+        } 
 
         /* lookup ip[1] */
         idx = hashTable[hash1];
@@ -224,8 +224,8 @@ _start: /* Requires: ip0 */
         /* check match at ip[0] */
         if (MEM_read32(ip0) == mval) {
             /* found a match! */
-            goto _offset;
-        }
+            goto _offset; 
+        } 
 
         /* lookup ip[1] */
         idx = hashTable[hash1];
@@ -246,9 +246,9 @@ _start: /* Requires: ip0 */
             PREFETCH_L1(ip1 + 64);
             PREFETCH_L1(ip1 + 128);
             nextStep += kStepIncr;
-        }
+        } 
     } while (ip3 < ilimit);
-
+ 
 _cleanup:
     /* Note that there are probably still a couple positions we could search.
      * However, it seems to be a meaningful performance hit to try to search
@@ -277,11 +277,11 @@ _offset: /* Requires: ip0, idx */
         mLength++;
     }
 
-_match: /* Requires: ip0, match0, offcode */
-
+_match: /* Requires: ip0, match0, offcode */ 
+ 
     /* Count the forward length. */
     mLength += ZSTD_count(ip0 + mLength, match0 + mLength, iend);
-
+ 
     ZSTD_storeSeq(seqStore, (size_t)(ip0 - anchor), anchor, iend, offcode, mLength);
 
     ip0 += mLength;
@@ -290,15 +290,15 @@ _match: /* Requires: ip0, match0, offcode */
     /* write next hash table entry */
     if (ip1 < ip0) {
         hashTable[hash1] = (U32)(ip1 - base);
-    }
-
+    } 
+ 
     /* Fill table and check for immediate repcode. */
     if (ip0 <= ilimit) {
         /* Fill Table */
         assert(base+current0+2 > istart);  /* check base overflow */
         hashTable[ZSTD_hashPtr(base+current0+2, hlog, mls)] = current0+2;  /* here because current+2 could be > iend-8 */
         hashTable[ZSTD_hashPtr(ip0-2, hlog, mls)] = (U32)(ip0-2-base);
-
+ 
         if (rep_offset2 > 0) { /* rep_offset2==0 means rep_offset2 is invalidated */
             while ( (ip0 <= ilimit) && (MEM_read32(ip0) == MEM_read32(ip0 - rep_offset2)) ) {
                 /* store sequence */
@@ -312,8 +312,8 @@ _match: /* Requires: ip0, match0, offcode */
     }   }   }
 
     goto _start;
-}
-
+} 
+ 
 #define ZSTD_GEN_FAST_FN(dictMode, mls, step)                                                            \
     static size_t ZSTD_compressBlock_fast_##dictMode##_##mls##_##step(                                      \
             ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],                    \
@@ -321,7 +321,7 @@ _match: /* Requires: ip0, match0, offcode */
     {                                                                                              \
         return ZSTD_compressBlock_fast_##dictMode##_generic(ms, seqStore, rep, src, srcSize, mls, step); \
     }
-
+ 
 ZSTD_GEN_FAST_FN(noDict, 4, 1)
 ZSTD_GEN_FAST_FN(noDict, 5, 1)
 ZSTD_GEN_FAST_FN(noDict, 6, 1)
@@ -332,12 +332,12 @@ ZSTD_GEN_FAST_FN(noDict, 5, 0)
 ZSTD_GEN_FAST_FN(noDict, 6, 0)
 ZSTD_GEN_FAST_FN(noDict, 7, 0)
 
-size_t ZSTD_compressBlock_fast(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
+size_t ZSTD_compressBlock_fast( 
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+        void const* src, size_t srcSize) 
+{ 
     U32 const mls = ms->cParams.minMatch;
-    assert(ms->dictMatchState == NULL);
+    assert(ms->dictMatchState == NULL); 
     if (ms->cParams.targetLength > 1) {
         switch(mls)
         {
@@ -365,41 +365,41 @@ size_t ZSTD_compressBlock_fast(
             return ZSTD_compressBlock_fast_noDict_7_0(ms, seqStore, rep, src, srcSize);
         }
 
-    }
-}
-
-FORCE_INLINE_TEMPLATE
-size_t ZSTD_compressBlock_fast_dictMatchState_generic(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
+    } 
+} 
+ 
+FORCE_INLINE_TEMPLATE 
+size_t ZSTD_compressBlock_fast_dictMatchState_generic( 
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
         void const* src, size_t srcSize, U32 const mls, U32 const hasStep)
-{
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const hashTable = ms->hashTable;
-    U32 const hlog = cParams->hashLog;
-    /* support stepSize of 0 */
-    U32 const stepSize = cParams->targetLength + !(cParams->targetLength);
-    const BYTE* const base = ms->window.base;
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const U32   prefixStartIndex = ms->window.dictLimit;
-    const BYTE* const prefixStart = base + prefixStartIndex;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - HASH_READ_SIZE;
-    U32 offset_1=rep[0], offset_2=rep[1];
-    U32 offsetSaved = 0;
-
-    const ZSTD_matchState_t* const dms = ms->dictMatchState;
-    const ZSTD_compressionParameters* const dictCParams = &dms->cParams ;
-    const U32* const dictHashTable = dms->hashTable;
-    const U32 dictStartIndex       = dms->window.dictLimit;
-    const BYTE* const dictBase     = dms->window.base;
-    const BYTE* const dictStart    = dictBase + dictStartIndex;
-    const BYTE* const dictEnd      = dms->window.nextSrc;
-    const U32 dictIndexDelta       = prefixStartIndex - (U32)(dictEnd - dictBase);
-    const U32 dictAndPrefixLength  = (U32)(ip - prefixStart + dictEnd - dictStart);
-    const U32 dictHLog             = dictCParams->hashLog;
-
+{ 
+    const ZSTD_compressionParameters* const cParams = &ms->cParams; 
+    U32* const hashTable = ms->hashTable; 
+    U32 const hlog = cParams->hashLog; 
+    /* support stepSize of 0 */ 
+    U32 const stepSize = cParams->targetLength + !(cParams->targetLength); 
+    const BYTE* const base = ms->window.base; 
+    const BYTE* const istart = (const BYTE*)src; 
+    const BYTE* ip = istart; 
+    const BYTE* anchor = istart; 
+    const U32   prefixStartIndex = ms->window.dictLimit; 
+    const BYTE* const prefixStart = base + prefixStartIndex; 
+    const BYTE* const iend = istart + srcSize; 
+    const BYTE* const ilimit = iend - HASH_READ_SIZE; 
+    U32 offset_1=rep[0], offset_2=rep[1]; 
+    U32 offsetSaved = 0; 
+ 
+    const ZSTD_matchState_t* const dms = ms->dictMatchState; 
+    const ZSTD_compressionParameters* const dictCParams = &dms->cParams ; 
+    const U32* const dictHashTable = dms->hashTable; 
+    const U32 dictStartIndex       = dms->window.dictLimit; 
+    const BYTE* const dictBase     = dms->window.base; 
+    const BYTE* const dictStart    = dictBase + dictStartIndex; 
+    const BYTE* const dictEnd      = dms->window.nextSrc; 
+    const U32 dictIndexDelta       = prefixStartIndex - (U32)(dictEnd - dictBase); 
+    const U32 dictAndPrefixLength  = (U32)(ip - prefixStart + dictEnd - dictStart); 
+    const U32 dictHLog             = dictCParams->hashLog; 
+ 
     /* if a dictionary is still attached, it necessarily means that
      * it is within window size. So we just check it. */
     const U32 maxDistance = 1U << cParams->windowLog;
@@ -411,17 +411,17 @@ size_t ZSTD_compressBlock_fast_dictMatchState_generic(
 
     /* ensure there will be no underflow
      * when translating a dict index into a local index */
-    assert(prefixStartIndex >= (U32)(dictEnd - dictBase));
-
-    /* init */
+    assert(prefixStartIndex >= (U32)(dictEnd - dictBase)); 
+ 
+    /* init */ 
     DEBUGLOG(5, "ZSTD_compressBlock_fast_dictMatchState_generic");
-    ip += (dictAndPrefixLength == 0);
-    /* dictMatchState repCode checks don't currently handle repCode == 0
-     * disabling. */
-    assert(offset_1 <= dictAndPrefixLength);
-    assert(offset_2 <= dictAndPrefixLength);
-
-    /* Main Search Loop */
+    ip += (dictAndPrefixLength == 0); 
+    /* dictMatchState repCode checks don't currently handle repCode == 0 
+     * disabling. */ 
+    assert(offset_1 <= dictAndPrefixLength); 
+    assert(offset_2 <= dictAndPrefixLength); 
+ 
+    /* Main Search Loop */ 
     while (ip < ilimit) {   /* < instead of <=, because repcode check at (ip+1) */
         size_t mLength;
         size_t const h = ZSTD_hashPtr(ip, hlog, mls);
@@ -429,53 +429,53 @@ size_t ZSTD_compressBlock_fast_dictMatchState_generic(
         U32 const matchIndex = hashTable[h];
         const BYTE* match = base + matchIndex;
         const U32 repIndex = curr + 1 - offset_1;
-        const BYTE* repMatch = (repIndex < prefixStartIndex) ?
-                               dictBase + (repIndex - dictIndexDelta) :
-                               base + repIndex;
+        const BYTE* repMatch = (repIndex < prefixStartIndex) ? 
+                               dictBase + (repIndex - dictIndexDelta) : 
+                               base + repIndex; 
         hashTable[h] = curr;   /* update hash table */
 
-        if ( ((U32)((prefixStartIndex-1) - repIndex) >= 3) /* intentional underflow : ensure repIndex isn't overlapping dict + prefix */
-          && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
-            const BYTE* const repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend;
-            mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixStart) + 4;
+        if ( ((U32)((prefixStartIndex-1) - repIndex) >= 3) /* intentional underflow : ensure repIndex isn't overlapping dict + prefix */ 
+          && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) { 
+            const BYTE* const repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend; 
+            mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixStart) + 4; 
             ip++;
             ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, STORE_REPCODE_1, mLength);
-        } else if ( (matchIndex <= prefixStartIndex) ) {
-            size_t const dictHash = ZSTD_hashPtr(ip, dictHLog, mls);
-            U32 const dictMatchIndex = dictHashTable[dictHash];
-            const BYTE* dictMatch = dictBase + dictMatchIndex;
-            if (dictMatchIndex <= dictStartIndex ||
-                MEM_read32(dictMatch) != MEM_read32(ip)) {
+        } else if ( (matchIndex <= prefixStartIndex) ) { 
+            size_t const dictHash = ZSTD_hashPtr(ip, dictHLog, mls); 
+            U32 const dictMatchIndex = dictHashTable[dictHash]; 
+            const BYTE* dictMatch = dictBase + dictMatchIndex; 
+            if (dictMatchIndex <= dictStartIndex || 
+                MEM_read32(dictMatch) != MEM_read32(ip)) { 
                 assert(stepSize >= 1);
                 ip += ((ip-anchor) >> kSearchStrength) + stepSize;
                 continue;
-            } else {
-                /* found a dict match */
+            } else { 
+                /* found a dict match */ 
                 U32 const offset = (U32)(curr-dictMatchIndex-dictIndexDelta);
-                mLength = ZSTD_count_2segments(ip+4, dictMatch+4, iend, dictEnd, prefixStart) + 4;
-                while (((ip>anchor) & (dictMatch>dictStart))
-                     && (ip[-1] == dictMatch[-1])) {
-                    ip--; dictMatch--; mLength++;
-                } /* catch up */
+                mLength = ZSTD_count_2segments(ip+4, dictMatch+4, iend, dictEnd, prefixStart) + 4; 
+                while (((ip>anchor) & (dictMatch>dictStart)) 
+                     && (ip[-1] == dictMatch[-1])) { 
+                    ip--; dictMatch--; mLength++; 
+                } /* catch up */ 
                 offset_2 = offset_1;
                 offset_1 = offset;
                 ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, STORE_OFFSET(offset), mLength);
-            }
-        } else if (MEM_read32(match) != MEM_read32(ip)) {
-            /* it's not a match, and we're not going to check the dictionary */
-            assert(stepSize >= 1);
-            ip += ((ip-anchor) >> kSearchStrength) + stepSize;
-            continue;
-        } else {
-            /* found a regular match */
-            U32 const offset = (U32)(ip-match);
-            mLength = ZSTD_count(ip+4, match+4, iend) + 4;
-            while (((ip>anchor) & (match>prefixStart))
-                 && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
-            offset_2 = offset_1;
-            offset_1 = offset;
+            } 
+        } else if (MEM_read32(match) != MEM_read32(ip)) { 
+            /* it's not a match, and we're not going to check the dictionary */ 
+            assert(stepSize >= 1); 
+            ip += ((ip-anchor) >> kSearchStrength) + stepSize; 
+            continue; 
+        } else { 
+            /* found a regular match */ 
+            U32 const offset = (U32)(ip-match); 
+            mLength = ZSTD_count(ip+4, match+4, iend) + 4; 
+            while (((ip>anchor) & (match>prefixStart)) 
+                 && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */ 
+            offset_2 = offset_1; 
+            offset_1 = offset; 
             ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, STORE_OFFSET(offset), mLength);
-        }
+        } 
 
         /* match found */
         ip += mLength;
@@ -486,29 +486,29 @@ size_t ZSTD_compressBlock_fast_dictMatchState_generic(
             assert(base+curr+2 > istart);  /* check base overflow */
             hashTable[ZSTD_hashPtr(base+curr+2, hlog, mls)] = curr+2;  /* here because curr+2 could be > iend-8 */
             hashTable[ZSTD_hashPtr(ip-2, hlog, mls)] = (U32)(ip-2-base);
-
+ 
             /* check immediate repcode */
-            while (ip <= ilimit) {
-                U32 const current2 = (U32)(ip-base);
-                U32 const repIndex2 = current2 - offset_2;
-                const BYTE* repMatch2 = repIndex2 < prefixStartIndex ?
-                        dictBase - dictIndexDelta + repIndex2 :
-                        base + repIndex2;
-                if ( ((U32)((prefixStartIndex-1) - (U32)repIndex2) >= 3 /* intentional overflow */)
-                   && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
-                    const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;
-                    size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;
-                    U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */
+            while (ip <= ilimit) { 
+                U32 const current2 = (U32)(ip-base); 
+                U32 const repIndex2 = current2 - offset_2; 
+                const BYTE* repMatch2 = repIndex2 < prefixStartIndex ? 
+                        dictBase - dictIndexDelta + repIndex2 : 
+                        base + repIndex2; 
+                if ( ((U32)((prefixStartIndex-1) - (U32)repIndex2) >= 3 /* intentional overflow */) 
+                   && (MEM_read32(repMatch2) == MEM_read32(ip)) ) { 
+                    const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend; 
+                    size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixStart) + 4; 
+                    U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */ 
                     ZSTD_storeSeq(seqStore, 0, anchor, iend, STORE_REPCODE_1, repLength2);
-                    hashTable[ZSTD_hashPtr(ip, hlog, mls)] = current2;
-                    ip += repLength2;
-                    anchor = ip;
-                    continue;
-                }
-                break;
-            }
-        }
-    }
+                    hashTable[ZSTD_hashPtr(ip, hlog, mls)] = current2; 
+                    ip += repLength2; 
+                    anchor = ip; 
+                    continue; 
+                } 
+                break; 
+            } 
+        } 
+    } 
 
     /* save reps for next block */
     rep[0] = offset_1 ? offset_1 : offsetSaved;
@@ -524,12 +524,12 @@ ZSTD_GEN_FAST_FN(dictMatchState, 5, 0)
 ZSTD_GEN_FAST_FN(dictMatchState, 6, 0)
 ZSTD_GEN_FAST_FN(dictMatchState, 7, 0)
 
-size_t ZSTD_compressBlock_fast_dictMatchState(
+size_t ZSTD_compressBlock_fast_dictMatchState( 
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
+        void const* src, size_t srcSize) 
 {
     U32 const mls = ms->cParams.minMatch;
-    assert(ms->dictMatchState != NULL);
+    assert(ms->dictMatchState != NULL); 
     switch(mls)
     {
     default: /* includes case 3 */
@@ -549,11 +549,11 @@ static size_t ZSTD_compressBlock_fast_extDict_generic(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize, U32 const mls, U32 const hasStep)
 {
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    U32* const hashTable = ms->hashTable;
-    U32 const hlog = cParams->hashLog;
-    /* support stepSize of 0 */
-    U32 const stepSize = cParams->targetLength + !(cParams->targetLength);
+    const ZSTD_compressionParameters* const cParams = &ms->cParams; 
+    U32* const hashTable = ms->hashTable; 
+    U32 const hlog = cParams->hashLog; 
+    /* support stepSize of 0 */ 
+    U32 const stepSize = cParams->targetLength + !(cParams->targetLength); 
     const BYTE* const base = ms->window.base;
     const BYTE* const dictBase = ms->window.dictBase;
     const BYTE* const istart = (const BYTE*)src;
@@ -562,11 +562,11 @@ static size_t ZSTD_compressBlock_fast_extDict_generic(
     const U32   endIndex = (U32)((size_t)(istart - base) + srcSize);
     const U32   lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog);
     const U32   dictStartIndex = lowLimit;
-    const BYTE* const dictStart = dictBase + dictStartIndex;
+    const BYTE* const dictStart = dictBase + dictStartIndex; 
     const U32   dictLimit = ms->window.dictLimit;
     const U32   prefixStartIndex = dictLimit < lowLimit ? lowLimit : dictLimit;
-    const BYTE* const prefixStart = base + prefixStartIndex;
-    const BYTE* const dictEnd = dictBase + prefixStartIndex;
+    const BYTE* const prefixStart = base + prefixStartIndex; 
+    const BYTE* const dictEnd = dictBase + prefixStartIndex; 
     const BYTE* const iend = istart + srcSize;
     const BYTE* const ilimit = iend - 8;
     U32 offset_1=rep[0], offset_2=rep[1];
@@ -582,13 +582,13 @@ static size_t ZSTD_compressBlock_fast_extDict_generic(
     /* Search Loop */
     while (ip < ilimit) {  /* < instead of <=, because (ip+1) */
         const size_t h = ZSTD_hashPtr(ip, hlog, mls);
-        const U32    matchIndex = hashTable[h];
-        const BYTE* const matchBase = matchIndex < prefixStartIndex ? dictBase : base;
-        const BYTE*  match = matchBase + matchIndex;
+        const U32    matchIndex = hashTable[h]; 
+        const BYTE* const matchBase = matchIndex < prefixStartIndex ? dictBase : base; 
+        const BYTE*  match = matchBase + matchIndex; 
         const U32    curr = (U32)(ip-base);
         const U32    repIndex = curr + 1 - offset_1;
-        const BYTE* const repBase = repIndex < prefixStartIndex ? dictBase : base;
-        const BYTE* const repMatch = repBase + repIndex;
+        const BYTE* const repBase = repIndex < prefixStartIndex ? dictBase : base; 
+        const BYTE* const repMatch = repBase + repIndex; 
         hashTable[h] = curr;   /* update hash table */
         DEBUGLOG(7, "offset_1 = %u , curr = %u", offset_1, curr);
 
@@ -602,7 +602,7 @@ static size_t ZSTD_compressBlock_fast_extDict_generic(
             ip += rLength;
             anchor = ip;
         } else {
-            if ( (matchIndex < dictStartIndex) ||
+            if ( (matchIndex < dictStartIndex) || 
                  (MEM_read32(match) != MEM_read32(ip)) ) {
                 assert(stepSize >= 1);
                 ip += ((ip-anchor) >> kSearchStrength) + stepSize;
@@ -630,8 +630,8 @@ static size_t ZSTD_compressBlock_fast_extDict_generic(
                 const BYTE* const repMatch2 = repIndex2 < prefixStartIndex ? dictBase + repIndex2 : base + repIndex2;
                 if ( (((U32)((prefixStartIndex-1) - repIndex2) >= 3) & (offset_2 <= curr - dictStartIndex))  /* intentional overflow */
                    && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
-                    const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;
-                    size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;
+                    const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend; 
+                    size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixStart) + 4; 
                     { U32 const tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset; }  /* swap offset_2 <=> offset_1 */
                     ZSTD_storeSeq(seqStore, 0 /*litlen*/, anchor, iend, STORE_REPCODE_1, repLength2);
                     hashTable[ZSTD_hashPtr(ip, hlog, mls)] = current2;
@@ -657,7 +657,7 @@ ZSTD_GEN_FAST_FN(extDict, 7, 0)
 
 size_t ZSTD_compressBlock_fast_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) 
 {
     U32 const mls = ms->cParams.minMatch;
     switch(mls)